WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/libavcodec/vc1dec.c

Rev	Author	Line No.	Line
4349	Serge	1	/*
		2	* VC-1 and WMV3 decoder
		3	* Copyright (c) 2011 Mashiat Sarker Shakkhar
		4	* Copyright (c) 2006-2007 Konstantin Shishkov
		5	* Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
		6	*
		7	* This file is part of FFmpeg.
		8	*
		9	* FFmpeg is free software; you can redistribute it and/or
		10	* modify it under the terms of the GNU Lesser General Public
		11	* License as published by the Free Software Foundation; either
		12	* version 2.1 of the License, or (at your option) any later version.
		13	*
		14	* FFmpeg is distributed in the hope that it will be useful,
		15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		17	* Lesser General Public License for more details.
		18	*
		19	* You should have received a copy of the GNU Lesser General Public
		20	* License along with FFmpeg; if not, write to the Free Software
		21	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		22	*/
		23
		24	/**
		25	* @file
		26	* VC-1 and WMV3 decoder
		27	*/
		28
		29	#include "internal.h"
		30	#include "avcodec.h"
		31	#include "error_resilience.h"
		32	#include "mpegvideo.h"
		33	#include "h263.h"
		34	#include "h264chroma.h"
		35	#include "vc1.h"
		36	#include "vc1data.h"
		37	#include "vc1acdata.h"
		38	#include "msmpeg4data.h"
		39	#include "unary.h"
		40	#include "mathops.h"
		41	#include "vdpau_internal.h"
		42	#include "libavutil/avassert.h"
		43
		44	#undef NDEBUG
		45	#include
		46
		47	#define MB_INTRA_VLC_BITS 9
		48	#define DC_VLC_BITS 9
		49
		50
		51	// offset tables for interlaced picture MVDATA decoding
		52	static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
		53	static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
		54
		55	/***********************************************************************/
		56	/**
		57	* @name VC-1 Bitplane decoding
		58	* @see 8.7, p56
		59	* @{
		60	*/
		61
		62	/**
		63	* Imode types
		64	* @{
		65	*/
		66	enum Imode {
		67	IMODE_RAW,
		68	IMODE_NORM2,
		69	IMODE_DIFF2,
		70	IMODE_NORM6,
		71	IMODE_DIFF6,
		72	IMODE_ROWSKIP,
		73	IMODE_COLSKIP
		74	};
		75	/** @} */ //imode defines
		76
		77	static void init_block_index(VC1Context *v)
		78	{
		79	MpegEncContext *s = &v->s;
		80	ff_init_block_index(s);
		81	if (v->field_mode && !(v->second_field ^ v->tff)) {
		82	s->dest[0] += s->current_picture_ptr->f.linesize[0];
		83	s->dest[1] += s->current_picture_ptr->f.linesize[1];
		84	s->dest[2] += s->current_picture_ptr->f.linesize[2];
		85	}
		86	}
		87
		88	/** @} */ //Bitplane group
		89
		90	static void vc1_put_signed_blocks_clamped(VC1Context *v)
		91	{
		92	MpegEncContext *s = &v->s;
		93	int topleft_mb_pos, top_mb_pos;
		94	int stride_y, fieldtx = 0;
		95	int v_dist;
		96
		97	/* The put pixels loop is always one MB row behind the decoding loop,
		98	* because we can only put pixels when overlap filtering is done, and
		99	* for filtering of the bottom edge of a MB, we need the next MB row
		100	* present as well.
		101	* Within the row, the put pixels loop is also one MB col behind the
		102	* decoding loop. The reason for this is again, because for filtering
		103	* of the right MB edge, we need the next MB present. */
		104	if (!s->first_slice_line) {
		105	if (s->mb_x) {
		106	topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
		107	if (v->fcm == ILACE_FRAME)
		108	fieldtx = v->fieldtx_plane[topleft_mb_pos];
		109	stride_y = s->linesize << fieldtx;
		110	v_dist = (16 - fieldtx) >> (fieldtx == 0);
		111	s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
		112	s->dest[0] - 16 * s->linesize - 16,
		113	stride_y);
		114	s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
		115	s->dest[0] - 16 * s->linesize - 8,
		116	stride_y);
		117	s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
		118	s->dest[0] - v_dist * s->linesize - 16,
		119	stride_y);
		120	s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
		121	s->dest[0] - v_dist * s->linesize - 8,
		122	stride_y);
		123	s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
		124	s->dest[1] - 8 * s->uvlinesize - 8,
		125	s->uvlinesize);
		126	s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
		127	s->dest[2] - 8 * s->uvlinesize - 8,
		128	s->uvlinesize);
		129	}
		130	if (s->mb_x == s->mb_width - 1) {
		131	top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
		132	if (v->fcm == ILACE_FRAME)
		133	fieldtx = v->fieldtx_plane[top_mb_pos];
		134	stride_y = s->linesize << fieldtx;
		135	v_dist = fieldtx ? 15 : 8;
		136	s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
		137	s->dest[0] - 16 * s->linesize,
		138	stride_y);
		139	s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
		140	s->dest[0] - 16 * s->linesize + 8,
		141	stride_y);
		142	s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
		143	s->dest[0] - v_dist * s->linesize,
		144	stride_y);
		145	s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
		146	s->dest[0] - v_dist * s->linesize + 8,
		147	stride_y);
		148	s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
		149	s->dest[1] - 8 * s->uvlinesize,
		150	s->uvlinesize);
		151	s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
		152	s->dest[2] - 8 * s->uvlinesize,
		153	s->uvlinesize);
		154	}
		155	}
		156
		157	#define inc_blk_idx(idx) do { \
		158	idx++; \
		159	if (idx >= v->n_allocated_blks) \
		160	idx = 0; \
		161	} while (0)
		162
		163	inc_blk_idx(v->topleft_blk_idx);
		164	inc_blk_idx(v->top_blk_idx);
		165	inc_blk_idx(v->left_blk_idx);
		166	inc_blk_idx(v->cur_blk_idx);
		167	}
		168
		169	static void vc1_loop_filter_iblk(VC1Context *v, int pq)
		170	{
		171	MpegEncContext *s = &v->s;
		172	int j;
		173	if (!s->first_slice_line) {
		174	v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
		175	if (s->mb_x)
		176	v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
		177	v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
		178	for (j = 0; j < 2; j++) {
		179	v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
		180	if (s->mb_x)
		181	v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
		182	}
		183	}
		184	v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
		185
		186	if (s->mb_y == s->end_mb_y - 1) {
		187	if (s->mb_x) {
		188	v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
		189	v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
		190	v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
		191	}
		192	v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
		193	}
		194	}
		195
		196	static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
		197	{
		198	MpegEncContext *s = &v->s;
		199	int j;
		200
		201	/* The loopfilter runs 1 row and 1 column behind the overlap filter, which
		202	* means it runs two rows/cols behind the decoding loop. */
		203	if (!s->first_slice_line) {
		204	if (s->mb_x) {
		205	if (s->mb_y >= s->start_mb_y + 2) {
		206	v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
		207
		208	if (s->mb_x >= 2)
		209	v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
		210	v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
		211	for (j = 0; j < 2; j++) {
		212	v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
		213	if (s->mb_x >= 2) {
		214	v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
		215	}
		216	}
		217	}
		218	v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
		219	}
		220
		221	if (s->mb_x == s->mb_width - 1) {
		222	if (s->mb_y >= s->start_mb_y + 2) {
		223	v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
		224
		225	if (s->mb_x)
		226	v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
		227	v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
		228	for (j = 0; j < 2; j++) {
		229	v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
		230	if (s->mb_x >= 2) {
		231	v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
		232	}
		233	}
		234	}
		235	v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
		236	}
		237
		238	if (s->mb_y == s->end_mb_y) {
		239	if (s->mb_x) {
		240	if (s->mb_x >= 2)
		241	v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
		242	v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
		243	if (s->mb_x >= 2) {
		244	for (j = 0; j < 2; j++) {
		245	v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
		246	}
		247	}
		248	}
		249
		250	if (s->mb_x == s->mb_width - 1) {
		251	if (s->mb_x)
		252	v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
		253	v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
		254	if (s->mb_x) {
		255	for (j = 0; j < 2; j++) {
		256	v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
		257	}
		258	}
		259	}
		260	}
		261	}
		262	}
		263
		264	static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
		265	{
		266	MpegEncContext *s = &v->s;
		267	int mb_pos;
		268
		269	if (v->condover == CONDOVER_NONE)
		270	return;
		271
		272	mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		273
		274	/* Within a MB, the horizontal overlap always runs before the vertical.
		275	* To accomplish that, we run the H on left and internal borders of the
		276	* currently decoded MB. Then, we wait for the next overlap iteration
		277	* to do H overlap on the right edge of this MB, before moving over and
		278	* running the V overlap. Therefore, the V overlap makes us trail by one
		279	* MB col and the H overlap filter makes us trail by one MB row. This
		280	* is reflected in the time at which we run the put_pixels loop. */
		281	if (v->condover == CONDOVER_ALL \|\| v->pq >= 9 \|\| v->over_flags_plane[mb_pos]) {
		282	if (s->mb_x && (v->condover == CONDOVER_ALL \|\| v->pq >= 9 \|\|
		283	v->over_flags_plane[mb_pos - 1])) {
		284	v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
		285	v->block[v->cur_blk_idx][0]);
		286	v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
		287	v->block[v->cur_blk_idx][2]);
		288	if (!(s->flags & CODEC_FLAG_GRAY)) {
		289	v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
		290	v->block[v->cur_blk_idx][4]);
		291	v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
		292	v->block[v->cur_blk_idx][5]);
		293	}
		294	}
		295	v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
		296	v->block[v->cur_blk_idx][1]);
		297	v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
		298	v->block[v->cur_blk_idx][3]);
		299
		300	if (s->mb_x == s->mb_width - 1) {
		301	if (!s->first_slice_line && (v->condover == CONDOVER_ALL \|\| v->pq >= 9 \|\|
		302	v->over_flags_plane[mb_pos - s->mb_stride])) {
		303	v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
		304	v->block[v->cur_blk_idx][0]);
		305	v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
		306	v->block[v->cur_blk_idx][1]);
		307	if (!(s->flags & CODEC_FLAG_GRAY)) {
		308	v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
		309	v->block[v->cur_blk_idx][4]);
		310	v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
		311	v->block[v->cur_blk_idx][5]);
		312	}
		313	}
		314	v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
		315	v->block[v->cur_blk_idx][2]);
		316	v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
		317	v->block[v->cur_blk_idx][3]);
		318	}
		319	}
		320	if (s->mb_x && (v->condover == CONDOVER_ALL \|\| v->over_flags_plane[mb_pos - 1])) {
		321	if (!s->first_slice_line && (v->condover == CONDOVER_ALL \|\| v->pq >= 9 \|\|
		322	v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
		323	v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
		324	v->block[v->left_blk_idx][0]);
		325	v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
		326	v->block[v->left_blk_idx][1]);
		327	if (!(s->flags & CODEC_FLAG_GRAY)) {
		328	v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
		329	v->block[v->left_blk_idx][4]);
		330	v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
		331	v->block[v->left_blk_idx][5]);
		332	}
		333	}
		334	v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
		335	v->block[v->left_blk_idx][2]);
		336	v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
		337	v->block[v->left_blk_idx][3]);
		338	}
		339	}
		340
		341	/** Do motion compensation over 1 macroblock
		342	* Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
		343	*/
		344	static void vc1_mc_1mv(VC1Context *v, int dir)
		345	{
		346	MpegEncContext *s = &v->s;
		347	H264ChromaContext *h264chroma = &v->h264chroma;
		348	uint8_t srcY, srcU, *srcV;
		349	int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
		350	int v_edge_pos = s->v_edge_pos >> v->field_mode;
		351	int i;
		352	uint8_t (luty)[256], (lutuv)[256];
		353	int use_ic;
		354
		355	if ((!v->field_mode \|\|
		356	(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
		357	!v->s.last_picture.f.data[0])
		358	return;
		359
		360	mx = s->mv[dir][0][0];
		361	my = s->mv[dir][0][1];
		362
		363	// store motion vectors for further use in B frames
		364	if (s->pict_type == AV_PICTURE_TYPE_P) {
		365	for (i = 0; i < 4; i++) {
		366	s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][0] = mx;
		367	s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][1] = my;
		368	}
		369	}
		370
		371	uvmx = (mx + ((mx & 3) == 3)) >> 1;
		372	uvmy = (my + ((my & 3) == 3)) >> 1;
		373	v->luma_mv[s->mb_x][0] = uvmx;
		374	v->luma_mv[s->mb_x][1] = uvmy;
		375
		376	if (v->field_mode &&
		377	v->cur_field_type != v->ref_field_type[dir]) {
		378	my = my - 2 + 4 * v->cur_field_type;
		379	uvmy = uvmy - 2 + 4 * v->cur_field_type;
		380	}
		381
		382	// fastuvmc shall be ignored for interlaced frame picture
		383	if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
		384	uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
		385	uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
		386	}
		387	if (!dir) {
		388	if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
		389	srcY = s->current_picture.f.data[0];
		390	srcU = s->current_picture.f.data[1];
		391	srcV = s->current_picture.f.data[2];
		392	luty = v->curr_luty;
		393	lutuv = v->curr_lutuv;
		394	use_ic = v->curr_use_ic;
		395	} else {
		396	srcY = s->last_picture.f.data[0];
		397	srcU = s->last_picture.f.data[1];
		398	srcV = s->last_picture.f.data[2];
		399	luty = v->last_luty;
		400	lutuv = v->last_lutuv;
		401	use_ic = v->last_use_ic;
		402	}
		403	} else {
		404	srcY = s->next_picture.f.data[0];
		405	srcU = s->next_picture.f.data[1];
		406	srcV = s->next_picture.f.data[2];
		407	luty = v->next_luty;
		408	lutuv = v->next_lutuv;
		409	use_ic = v->next_use_ic;
		410	}
		411
		412	if (!srcY \|\| !srcU) {
		413	av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
		414	return;
		415	}
		416
		417	src_x = s->mb_x * 16 + (mx >> 2);
		418	src_y = s->mb_y * 16 + (my >> 2);
		419	uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
		420	uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
		421
		422	if (v->profile != PROFILE_ADVANCED) {
		423	src_x = av_clip( src_x, -16, s->mb_width * 16);
		424	src_y = av_clip( src_y, -16, s->mb_height * 16);
		425	uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
		426	uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
		427	} else {
		428	src_x = av_clip( src_x, -17, s->avctx->coded_width);
		429	src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
		430	uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
		431	uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
		432	}
		433
		434	srcY += src_y * s->linesize + src_x;
		435	srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
		436	srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
		437
		438	if (v->field_mode && v->ref_field_type[dir]) {
		439	srcY += s->current_picture_ptr->f.linesize[0];
		440	srcU += s->current_picture_ptr->f.linesize[1];
		441	srcV += s->current_picture_ptr->f.linesize[2];
		442	}
		443
		444	/* for grayscale we should not try to read from unknown area */
		445	if (s->flags & CODEC_FLAG_GRAY) {
		446	srcU = s->edge_emu_buffer + 18 * s->linesize;
		447	srcV = s->edge_emu_buffer + 18 * s->linesize;
		448	}
		449
		450	if (v->rangeredfrm \|\| use_ic
		451	\|\| s->h_edge_pos < 22 \|\| v_edge_pos < 22
		452	\|\| (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
		453	\|\| (unsigned)(src_y - 1) > v_edge_pos - (my&3) - 16 - 3) {
		454	uint8_t uvbuf = s->edge_emu_buffer + 19 s->linesize;
		455
		456	srcY -= s->mspel * (1 + s->linesize);
		457	s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,
		458	srcY, s->linesize,
		459	17 + s->mspel * 2, 17 + s->mspel * 2,
		460	src_x - s->mspel, src_y - s->mspel,
		461	s->h_edge_pos, v_edge_pos);
		462	srcY = s->edge_emu_buffer;
		463	s->vdsp.emulated_edge_mc(uvbuf, s->uvlinesize, srcU, s->uvlinesize,
		464	8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
		465	s->h_edge_pos >> 1, v_edge_pos >> 1);
		466	s->vdsp.emulated_edge_mc(uvbuf + 16, s->uvlinesize, srcV, s->uvlinesize,
		467	8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
		468	s->h_edge_pos >> 1, v_edge_pos >> 1);
		469	srcU = uvbuf;
		470	srcV = uvbuf + 16;
		471	/* if we deal with range reduction we need to scale source blocks */
		472	if (v->rangeredfrm) {
		473	int i, j;
		474	uint8_t src, src2;
		475
		476	src = srcY;
		477	for (j = 0; j < 17 + s->mspel * 2; j++) {
		478	for (i = 0; i < 17 + s->mspel * 2; i++)
		479	src[i] = ((src[i] - 128) >> 1) + 128;
		480	src += s->linesize;
		481	}
		482	src = srcU;
		483	src2 = srcV;
		484	for (j = 0; j < 9; j++) {
		485	for (i = 0; i < 9; i++) {
		486	src[i] = ((src[i] - 128) >> 1) + 128;
		487	src2[i] = ((src2[i] - 128) >> 1) + 128;
		488	}
		489	src += s->uvlinesize;
		490	src2 += s->uvlinesize;
		491	}
		492	}
		493	/* if we deal with intensity compensation we need to scale source blocks */
		494	if (use_ic) {
		495	int i, j;
		496	uint8_t src, src2;
		497
		498	src = srcY;
		499	for (j = 0; j < 17 + s->mspel * 2; j++) {
		500	int f = v->field_mode ? v->ref_field_type[dir] : ((j + src_y - s->mspel) & 1) ;
		501	for (i = 0; i < 17 + s->mspel * 2; i++)
		502	src[i] = luty[f][src[i]];
		503	src += s->linesize;
		504	}
		505	src = srcU;
		506	src2 = srcV;
		507	for (j = 0; j < 9; j++) {
		508	int f = v->field_mode ? v->ref_field_type[dir] : ((j + uvsrc_y) & 1);
		509	for (i = 0; i < 9; i++) {
		510	src[i] = lutuv[f][src[i]];
		511	src2[i] = lutuv[f][src2[i]];
		512	}
		513	src += s->uvlinesize;
		514	src2 += s->uvlinesize;
		515	}
		516	}
		517	srcY += s->mspel * (1 + s->linesize);
		518	}
		519
		520	if (s->mspel) {
		521	dxy = ((my & 3) << 2) \| (mx & 3);
		522	v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
		523	v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
		524	srcY += s->linesize * 8;
		525	v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
		526	v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
		527	} else { // hpel mc - always used for luma
		528	dxy = (my & 2) \| ((mx & 2) >> 1);
		529	if (!v->rnd)
		530	s->hdsp.put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
		531	else
		532	s->hdsp.put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
		533	}
		534
		535	if (s->flags & CODEC_FLAG_GRAY) return;
		536	/* Chroma MC always uses qpel bilinear */
		537	uvmx = (uvmx & 3) << 1;
		538	uvmy = (uvmy & 3) << 1;
		539	if (!v->rnd) {
		540	h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
		541	h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
		542	} else {
		543	v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
		544	v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
		545	}
		546	}
		547
		548	static inline int median4(int a, int b, int c, int d)
		549	{
		550	if (a < b) {
		551	if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
		552	else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
		553	} else {
		554	if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
		555	else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
		556	}
		557	}
		558
		559	/** Do motion compensation for 4-MV macroblock - luminance block
		560	*/
		561	static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
		562	{
		563	MpegEncContext *s = &v->s;
		564	uint8_t *srcY;
		565	int dxy, mx, my, src_x, src_y;
		566	int off;
		567	int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
		568	int v_edge_pos = s->v_edge_pos >> v->field_mode;
		569	uint8_t (*luty)[256];
		570	int use_ic;
		571
		572	if ((!v->field_mode \|\|
		573	(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
		574	!v->s.last_picture.f.data[0])
		575	return;
		576
		577	mx = s->mv[dir][n][0];
		578	my = s->mv[dir][n][1];
		579
		580	if (!dir) {
		581	if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
		582	srcY = s->current_picture.f.data[0];
		583	luty = v->curr_luty;
		584	use_ic = v->curr_use_ic;
		585	} else {
		586	srcY = s->last_picture.f.data[0];
		587	luty = v->last_luty;
		588	use_ic = v->last_use_ic;
		589	}
		590	} else {
		591	srcY = s->next_picture.f.data[0];
		592	luty = v->next_luty;
		593	use_ic = v->next_use_ic;
		594	}
		595
		596	if (!srcY) {
		597	av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
		598	return;
		599	}
		600
		601	if (v->field_mode) {
		602	if (v->cur_field_type != v->ref_field_type[dir])
		603	my = my - 2 + 4 * v->cur_field_type;
		604	}
		605
		606	if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
		607	int same_count = 0, opp_count = 0, k;
		608	int chosen_mv[2][4][2], f;
		609	int tx, ty;
		610	for (k = 0; k < 4; k++) {
		611	f = v->mv_f[0][s->block_index[k] + v->blocks_off];
		612	chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
		613	chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
		614	opp_count += f;
		615	same_count += 1 - f;
		616	}
		617	f = opp_count > same_count;
		618	switch (f ? opp_count : same_count) {
		619	case 4:
		620	tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
		621	chosen_mv[f][2][0], chosen_mv[f][3][0]);
		622	ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
		623	chosen_mv[f][2][1], chosen_mv[f][3][1]);
		624	break;
		625	case 3:
		626	tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
		627	ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
		628	break;
		629	case 2:
		630	tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
		631	ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
		632	break;
		633	default:
		634	av_assert0(0);
		635	}
		636	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
		637	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
		638	for (k = 0; k < 4; k++)
		639	v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
		640	}
		641
		642	if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
		643	int qx, qy;
		644	int width = s->avctx->coded_width;
		645	int height = s->avctx->coded_height >> 1;
		646	if (s->pict_type == AV_PICTURE_TYPE_P) {
		647	s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][0] = mx;
		648	s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][1] = my;
		649	}
		650	qx = (s->mb_x * 16) + (mx >> 2);
		651	qy = (s->mb_y * 8) + (my >> 3);
		652
		653	if (qx < -17)
		654	mx -= 4 * (qx + 17);
		655	else if (qx > width)
		656	mx -= 4 * (qx - width);
		657	if (qy < -18)
		658	my -= 8 * (qy + 18);
		659	else if (qy > height + 1)
		660	my -= 8 * (qy - height - 1);
		661	}
		662
		663	if ((v->fcm == ILACE_FRAME) && fieldmv)
		664	off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
		665	else
		666	off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
		667
		668	src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
		669	if (!fieldmv)
		670	src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
		671	else
		672	src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
		673
		674	if (v->profile != PROFILE_ADVANCED) {
		675	src_x = av_clip(src_x, -16, s->mb_width * 16);
		676	src_y = av_clip(src_y, -16, s->mb_height * 16);
		677	} else {
		678	src_x = av_clip(src_x, -17, s->avctx->coded_width);
		679	if (v->fcm == ILACE_FRAME) {
		680	if (src_y & 1)
		681	src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
		682	else
		683	src_y = av_clip(src_y, -18, s->avctx->coded_height);
		684	} else {
		685	src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
		686	}
		687	}
		688
		689	srcY += src_y * s->linesize + src_x;
		690	if (v->field_mode && v->ref_field_type[dir])
		691	srcY += s->current_picture_ptr->f.linesize[0];
		692
		693	if (fieldmv && !(src_y & 1))
		694	v_edge_pos--;
		695	if (fieldmv && (src_y & 1) && src_y < 4)
		696	src_y--;
		697	if (v->rangeredfrm \|\| use_ic
		698	\|\| s->h_edge_pos < 13 \|\| v_edge_pos < 23
		699	\|\| (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
		700	\|\| (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
		701	srcY -= s->mspel * (1 + (s->linesize << fieldmv));
		702	/* check emulate edge stride and offset */
		703	s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize, srcY, s->linesize,
		704	9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
		705	src_x - s->mspel, src_y - (s->mspel << fieldmv),
		706	s->h_edge_pos, v_edge_pos);
		707	srcY = s->edge_emu_buffer;
		708	/* if we deal with range reduction we need to scale source blocks */
		709	if (v->rangeredfrm) {
		710	int i, j;
		711	uint8_t *src;
		712
		713	src = srcY;
		714	for (j = 0; j < 9 + s->mspel * 2; j++) {
		715	for (i = 0; i < 9 + s->mspel * 2; i++)
		716	src[i] = ((src[i] - 128) >> 1) + 128;
		717	src += s->linesize << fieldmv;
		718	}
		719	}
		720	/* if we deal with intensity compensation we need to scale source blocks */
		721	if (use_ic) {
		722	int i, j;
		723	uint8_t *src;
		724
		725	src = srcY;
		726	for (j = 0; j < 9 + s->mspel * 2; j++) {
		727	int f = v->field_mode ? v->ref_field_type[dir] : (((j<mspel << fieldmv)) & 1);
		728	for (i = 0; i < 9 + s->mspel * 2; i++)
		729	src[i] = luty[f][src[i]];
		730	src += s->linesize << fieldmv;
		731	}
		732	}
		733	srcY += s->mspel * (1 + (s->linesize << fieldmv));
		734	}
		735
		736	if (s->mspel) {
		737	dxy = ((my & 3) << 2) \| (mx & 3);
		738	if (avg)
		739	v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
		740	else
		741	v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
		742	} else { // hpel mc - always used for luma
		743	dxy = (my & 2) \| ((mx & 2) >> 1);
		744	if (!v->rnd)
		745	s->hdsp.put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
		746	else
		747	s->hdsp.put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
		748	}
		749	}
		750
		751	static av_always_inline int get_chroma_mv(int mvx, int mvy, int a, int flag, int tx, int *ty)
		752	{
		753	int idx, i;
		754	static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
		755
		756	idx = ((a[3] != flag) << 3)
		757	\| ((a[2] != flag) << 2)
		758	\| ((a[1] != flag) << 1)
		759	\| (a[0] != flag);
		760	if (!idx) {
		761	*tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
		762	*ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
		763	return 4;
		764	} else if (count[idx] == 1) {
		765	switch (idx) {
		766	case 0x1:
		767	*tx = mid_pred(mvx[1], mvx[2], mvx[3]);
		768	*ty = mid_pred(mvy[1], mvy[2], mvy[3]);
		769	return 3;
		770	case 0x2:
		771	*tx = mid_pred(mvx[0], mvx[2], mvx[3]);
		772	*ty = mid_pred(mvy[0], mvy[2], mvy[3]);
		773	return 3;
		774	case 0x4:
		775	*tx = mid_pred(mvx[0], mvx[1], mvx[3]);
		776	*ty = mid_pred(mvy[0], mvy[1], mvy[3]);
		777	return 3;
		778	case 0x8:
		779	*tx = mid_pred(mvx[0], mvx[1], mvx[2]);
		780	*ty = mid_pred(mvy[0], mvy[1], mvy[2]);
		781	return 3;
		782	}
		783	} else if (count[idx] == 2) {
		784	int t1 = 0, t2 = 0;
		785	for (i = 0; i < 3; i++)
		786	if (!a[i]) {
		787	t1 = i;
		788	break;
		789	}
		790	for (i = t1 + 1; i < 4; i++)
		791	if (!a[i]) {
		792	t2 = i;
		793	break;
		794	}
		795	*tx = (mvx[t1] + mvx[t2]) / 2;
		796	*ty = (mvy[t1] + mvy[t2]) / 2;
		797	return 2;
		798	} else {
		799	return 0;
		800	}
		801	return -1;
		802	}
		803
		804	/** Do motion compensation for 4-MV macroblock - both chroma blocks
		805	*/
		806	static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
		807	{
		808	MpegEncContext *s = &v->s;
		809	H264ChromaContext *h264chroma = &v->h264chroma;
		810	uint8_t srcU, srcV;
		811	int uvmx, uvmy, uvsrc_x, uvsrc_y;
		812	int k, tx = 0, ty = 0;
		813	int mvx[4], mvy[4], intra[4], mv_f[4];
		814	int valid_count;
		815	int chroma_ref_type = v->cur_field_type;
		816	int v_edge_pos = s->v_edge_pos >> v->field_mode;
		817	uint8_t (*lutuv)[256];
		818	int use_ic;
		819
		820	if (!v->field_mode && !v->s.last_picture.f.data[0])
		821	return;
		822	if (s->flags & CODEC_FLAG_GRAY)
		823	return;
		824
		825	for (k = 0; k < 4; k++) {
		826	mvx[k] = s->mv[dir][k][0];
		827	mvy[k] = s->mv[dir][k][1];
		828	intra[k] = v->mb_type[0][s->block_index[k]];
		829	if (v->field_mode)
		830	mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
		831	}
		832
		833	/* calculate chroma MV vector from four luma MVs */
		834	if (!v->field_mode \|\| (v->field_mode && !v->numref)) {
		835	valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
		836	chroma_ref_type = v->reffield;
		837	if (!valid_count) {
		838	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
		839	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
		840	v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
		841	return; //no need to do MC for intra blocks
		842	}
		843	} else {
		844	int dominant = 0;
		845	if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
		846	dominant = 1;
		847	valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
		848	if (dominant)
		849	chroma_ref_type = !v->cur_field_type;
		850	}
		851	if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
		852	return;
		853	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
		854	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
		855	uvmx = (tx + ((tx & 3) == 3)) >> 1;
		856	uvmy = (ty + ((ty & 3) == 3)) >> 1;
		857
		858	v->luma_mv[s->mb_x][0] = uvmx;
		859	v->luma_mv[s->mb_x][1] = uvmy;
		860
		861	if (v->fastuvmc) {
		862	uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
		863	uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
		864	}
		865	// Field conversion bias
		866	if (v->cur_field_type != chroma_ref_type)
		867	uvmy += 2 - 4 * chroma_ref_type;
		868
		869	uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
		870	uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
		871
		872	if (v->profile != PROFILE_ADVANCED) {
		873	uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
		874	uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
		875	} else {
		876	uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
		877	uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
		878	}
		879
		880	if (!dir) {
		881	if (v->field_mode && (v->cur_field_type != chroma_ref_type) && v->second_field) {
		882	srcU = s->current_picture.f.data[1];
		883	srcV = s->current_picture.f.data[2];
		884	lutuv = v->curr_lutuv;
		885	use_ic = v->curr_use_ic;
		886	} else {
		887	srcU = s->last_picture.f.data[1];
		888	srcV = s->last_picture.f.data[2];
		889	lutuv = v->last_lutuv;
		890	use_ic = v->last_use_ic;
		891	}
		892	} else {
		893	srcU = s->next_picture.f.data[1];
		894	srcV = s->next_picture.f.data[2];
		895	lutuv = v->next_lutuv;
		896	use_ic = v->next_use_ic;
		897	}
		898
		899	if (!srcU) {
		900	av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
		901	return;
		902	}
		903
		904	srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
		905	srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
		906
		907	if (v->field_mode) {
		908	if (chroma_ref_type) {
		909	srcU += s->current_picture_ptr->f.linesize[1];
		910	srcV += s->current_picture_ptr->f.linesize[2];
		911	}
		912	}
		913
		914	if (v->rangeredfrm \|\| use_ic
		915	\|\| s->h_edge_pos < 18 \|\| v_edge_pos < 18
		916	\|\| (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
		917	\|\| (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
		918	s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize, srcU,
		919	s->uvlinesize, 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
		920	s->h_edge_pos >> 1, v_edge_pos >> 1);
		921	s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, s->uvlinesize, srcV,
		922	s->uvlinesize, 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
		923	s->h_edge_pos >> 1, v_edge_pos >> 1);
		924	srcU = s->edge_emu_buffer;
		925	srcV = s->edge_emu_buffer + 16;
		926
		927	/* if we deal with range reduction we need to scale source blocks */
		928	if (v->rangeredfrm) {
		929	int i, j;
		930	uint8_t src, src2;
		931
		932	src = srcU;
		933	src2 = srcV;
		934	for (j = 0; j < 9; j++) {
		935	for (i = 0; i < 9; i++) {
		936	src[i] = ((src[i] - 128) >> 1) + 128;
		937	src2[i] = ((src2[i] - 128) >> 1) + 128;
		938	}
		939	src += s->uvlinesize;
		940	src2 += s->uvlinesize;
		941	}
		942	}
		943	/* if we deal with intensity compensation we need to scale source blocks */
		944	if (use_ic) {
		945	int i, j;
		946	uint8_t src, src2;
		947
		948	src = srcU;
		949	src2 = srcV;
		950	for (j = 0; j < 9; j++) {
		951	int f = v->field_mode ? chroma_ref_type : ((j + uvsrc_y) & 1);
		952	for (i = 0; i < 9; i++) {
		953	src[i] = lutuv[f][src[i]];
		954	src2[i] = lutuv[f][src2[i]];
		955	}
		956	src += s->uvlinesize;
		957	src2 += s->uvlinesize;
		958	}
		959	}
		960	}
		961
		962	/* Chroma MC always uses qpel bilinear */
		963	uvmx = (uvmx & 3) << 1;
		964	uvmy = (uvmy & 3) << 1;
		965	if (!v->rnd) {
		966	h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
		967	h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
		968	} else {
		969	v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
		970	v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
		971	}
		972	}
		973
		974	/** Do motion compensation for 4-MV interlaced frame chroma macroblock (both U and V)
		975	*/
		976	static void vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg)
		977	{
		978	MpegEncContext *s = &v->s;
		979	H264ChromaContext *h264chroma = &v->h264chroma;
		980	uint8_t srcU, srcV;
		981	int uvsrc_x, uvsrc_y;
		982	int uvmx_field[4], uvmy_field[4];
		983	int i, off, tx, ty;
		984	int fieldmv = v->blk_mv_type[s->block_index[0]];
		985	static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
		986	int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
		987	int v_edge_pos = s->v_edge_pos >> 1;
		988	int use_ic;
		989	uint8_t (*lutuv)[256];
		990
		991	if (s->flags & CODEC_FLAG_GRAY)
		992	return;
		993
		994	for (i = 0; i < 4; i++) {
		995	int d = i < 2 ? dir: dir2;
		996	tx = s->mv[d][i][0];
		997	uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
		998	ty = s->mv[d][i][1];
		999	if (fieldmv)
		1000	uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
		1001	else
		1002	uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
		1003	}
		1004
		1005	for (i = 0; i < 4; i++) {
		1006	off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
		1007	uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
		1008	uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
		1009	// FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
		1010	uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
		1011	uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
		1012	if (i < 2 ? dir : dir2) {
		1013	srcU = s->next_picture.f.data[1];
		1014	srcV = s->next_picture.f.data[2];
		1015	lutuv = v->next_lutuv;
		1016	use_ic = v->next_use_ic;
		1017	} else {
		1018	srcU = s->last_picture.f.data[1];
		1019	srcV = s->last_picture.f.data[2];
		1020	lutuv = v->last_lutuv;
		1021	use_ic = v->last_use_ic;
		1022	}
		1023	if (!srcU)
		1024	return;
		1025	srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
		1026	srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
		1027	uvmx_field[i] = (uvmx_field[i] & 3) << 1;
		1028	uvmy_field[i] = (uvmy_field[i] & 3) << 1;
		1029
		1030	if (fieldmv && !(uvsrc_y & 1))
		1031	v_edge_pos = (s->v_edge_pos >> 1) - 1;
		1032
		1033	if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
		1034	uvsrc_y--;
		1035	if (use_ic
		1036	\|\| s->h_edge_pos < 10 \|\| v_edge_pos < (5 << fieldmv)
		1037	\|\| (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
		1038	\|\| (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
		1039	s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize, srcU,
		1040	s->uvlinesize, 5, (5 << fieldmv), uvsrc_x,
		1041	uvsrc_y, s->h_edge_pos >> 1, v_edge_pos);
		1042	s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, s->uvlinesize, srcV,
		1043	s->uvlinesize, 5, (5 << fieldmv), uvsrc_x,
		1044	uvsrc_y, s->h_edge_pos >> 1, v_edge_pos);
		1045	srcU = s->edge_emu_buffer;
		1046	srcV = s->edge_emu_buffer + 16;
		1047
		1048	/* if we deal with intensity compensation we need to scale source blocks */
		1049	if (use_ic) {
		1050	int i, j;
		1051	uint8_t src, src2;
		1052
		1053	src = srcU;
		1054	src2 = srcV;
		1055	for (j = 0; j < 5; j++) {
		1056	int f = (uvsrc_y + (j << fieldmv)) & 1;
		1057	for (i = 0; i < 5; i++) {
		1058	src[i] = lutuv[f][src[i]];
		1059	src2[i] = lutuv[f][src2[i]];
		1060	}
		1061	src += s->uvlinesize << fieldmv;
		1062	src2 += s->uvlinesize << fieldmv;
		1063	}
		1064	}
		1065	}
		1066	if (avg) {
		1067	if (!v->rnd) {
		1068	h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
		1069	h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
		1070	} else {
		1071	v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
		1072	v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
		1073	}
		1074	} else {
		1075	if (!v->rnd) {
		1076	h264chroma->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
		1077	h264chroma->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
		1078	} else {
		1079	v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
		1080	v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
		1081	}
		1082	}
		1083	}
		1084	}
		1085
		1086	/***********************************************************************/
		1087	/**
		1088	* @name VC-1 Block-level functions
		1089	* @see 7.1.4, p91 and 8.1.1.7, p(1)04
		1090	* @{
		1091	*/
		1092
		1093	/**
		1094	* @def GET_MQUANT
		1095	* @brief Get macroblock-level quantizer scale
		1096	*/
		1097	#define GET_MQUANT() \
		1098	if (v->dquantfrm) { \
		1099	int edges = 0; \
		1100	if (v->dqprofile == DQPROFILE_ALL_MBS) { \
		1101	if (v->dqbilevel) { \
		1102	mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
		1103	} else { \
		1104	mqdiff = get_bits(gb, 3); \
		1105	if (mqdiff != 7) \
		1106	mquant = v->pq + mqdiff; \
		1107	else \
		1108	mquant = get_bits(gb, 5); \
		1109	} \
		1110	} \
		1111	if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
		1112	edges = 1 << v->dqsbedge; \
		1113	else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
		1114	edges = (3 << v->dqsbedge) % 15; \
		1115	else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
		1116	edges = 15; \
		1117	if ((edges&1) && !s->mb_x) \
		1118	mquant = v->altpq; \
		1119	if ((edges&2) && s->first_slice_line) \
		1120	mquant = v->altpq; \
		1121	if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
		1122	mquant = v->altpq; \
		1123	if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
		1124	mquant = v->altpq; \
		1125	if (!mquant \|\| mquant > 31) { \
		1126	av_log(v->s.avctx, AV_LOG_ERROR, \
		1127	"Overriding invalid mquant %d\n", mquant); \
		1128	mquant = 1; \
		1129	} \
		1130	}
		1131
		1132	/**
		1133	* @def GET_MVDATA(_dmv_x, _dmv_y)
		1134	* @brief Get MV differentials
		1135	* @see MVDATA decoding from 8.3.5.2, p(1)20
		1136	* @param _dmv_x Horizontal differential for decoded MV
		1137	* @param _dmv_y Vertical differential for decoded MV
		1138	*/
		1139	#define GET_MVDATA(_dmv_x, _dmv_y) \
		1140	index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
		1141	VC1_MV_DIFF_VLC_BITS, 2); \
		1142	if (index > 36) { \
		1143	mb_has_coeffs = 1; \
		1144	index -= 37; \
		1145	} else \
		1146	mb_has_coeffs = 0; \
		1147	s->mb_intra = 0; \
		1148	if (!index) { \
		1149	_dmv_x = _dmv_y = 0; \
		1150	} else if (index == 35) { \
		1151	_dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
		1152	_dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
		1153	} else if (index == 36) { \
		1154	_dmv_x = 0; \
		1155	_dmv_y = 0; \
		1156	s->mb_intra = 1; \
		1157	} else { \
		1158	index1 = index % 6; \
		1159	if (!s->quarter_sample && index1 == 5) val = 1; \
		1160	else val = 0; \
		1161	if (size_table[index1] - val > 0) \
		1162	val = get_bits(gb, size_table[index1] - val); \
		1163	else val = 0; \
		1164	sign = 0 - (val&1); \
		1165	_dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
		1166	\
		1167	index1 = index / 6; \
		1168	if (!s->quarter_sample && index1 == 5) val = 1; \
		1169	else val = 0; \
		1170	if (size_table[index1] - val > 0) \
		1171	val = get_bits(gb, size_table[index1] - val); \
		1172	else val = 0; \
		1173	sign = 0 - (val & 1); \
		1174	_dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
		1175	}
		1176
		1177	static av_always_inline void get_mvdata_interlaced(VC1Context v, int dmv_x,
		1178	int dmv_y, int pred_flag)
		1179	{
		1180	int index, index1;
		1181	int extend_x = 0, extend_y = 0;
		1182	GetBitContext *gb = &v->s.gb;
		1183	int bits, esc;
		1184	int val, sign;
		1185	const int* offs_tab;
		1186
		1187	if (v->numref) {
		1188	bits = VC1_2REF_MVDATA_VLC_BITS;
		1189	esc = 125;
		1190	} else {
		1191	bits = VC1_1REF_MVDATA_VLC_BITS;
		1192	esc = 71;
		1193	}
		1194	switch (v->dmvrange) {
		1195	case 1:
		1196	extend_x = 1;
		1197	break;
		1198	case 2:
		1199	extend_y = 1;
		1200	break;
		1201	case 3:
		1202	extend_x = extend_y = 1;
		1203	break;
		1204	}
		1205	index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
		1206	if (index == esc) {
		1207	*dmv_x = get_bits(gb, v->k_x);
		1208	*dmv_y = get_bits(gb, v->k_y);
		1209	if (v->numref) {
		1210	if (pred_flag) {
		1211	pred_flag = dmv_y & 1;
		1212	dmv_y = (dmv_y + *pred_flag) >> 1;
		1213	} else {
		1214	dmv_y = (dmv_y + (*dmv_y & 1)) >> 1;
		1215	}
		1216	}
		1217	}
		1218	else {
		1219	av_assert0(index < esc);
		1220	if (extend_x)
		1221	offs_tab = offset_table2;
		1222	else
		1223	offs_tab = offset_table1;
		1224	index1 = (index + 1) % 9;
		1225	if (index1 != 0) {
		1226	val = get_bits(gb, index1 + extend_x);
		1227	sign = 0 -(val & 1);
		1228	*dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
		1229	} else
		1230	*dmv_x = 0;
		1231	if (extend_y)
		1232	offs_tab = offset_table2;
		1233	else
		1234	offs_tab = offset_table1;
		1235	index1 = (index + 1) / 9;
		1236	if (index1 > v->numref) {
		1237	val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
		1238	sign = 0 - (val & 1);
		1239	*dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
		1240	} else
		1241	*dmv_y = 0;
		1242	if (v->numref && pred_flag)
		1243	*pred_flag = index1 & 1;
		1244	}
		1245	}
		1246
		1247	static av_always_inline int scaleforsame_x(VC1Context v, int n / MV */, int dir)
		1248	{
		1249	int scaledvalue, refdist;
		1250	int scalesame1, scalesame2;
		1251	int scalezone1_x, zone1offset_x;
		1252	int table_index = dir ^ v->second_field;
		1253
		1254	if (v->s.pict_type != AV_PICTURE_TYPE_B)
		1255	refdist = v->refdist;
		1256	else
		1257	refdist = dir ? v->brfd : v->frfd;
		1258	if (refdist > 3)
		1259	refdist = 3;
		1260	scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
		1261	scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
		1262	scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
		1263	zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
		1264
		1265	if (FFABS(n) > 255)
		1266	scaledvalue = n;
		1267	else {
		1268	if (FFABS(n) < scalezone1_x)
		1269	scaledvalue = (n * scalesame1) >> 8;
		1270	else {
		1271	if (n < 0)
		1272	scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
		1273	else
		1274	scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
		1275	}
		1276	}
		1277	return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
		1278	}
		1279
		1280	static av_always_inline int scaleforsame_y(VC1Context v, int i, int n / MV */, int dir)
		1281	{
		1282	int scaledvalue, refdist;
		1283	int scalesame1, scalesame2;
		1284	int scalezone1_y, zone1offset_y;
		1285	int table_index = dir ^ v->second_field;
		1286
		1287	if (v->s.pict_type != AV_PICTURE_TYPE_B)
		1288	refdist = v->refdist;
		1289	else
		1290	refdist = dir ? v->brfd : v->frfd;
		1291	if (refdist > 3)
		1292	refdist = 3;
		1293	scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
		1294	scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
		1295	scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
		1296	zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
		1297
		1298	if (FFABS(n) > 63)
		1299	scaledvalue = n;
		1300	else {
		1301	if (FFABS(n) < scalezone1_y)
		1302	scaledvalue = (n * scalesame1) >> 8;
		1303	else {
		1304	if (n < 0)
		1305	scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
		1306	else
		1307	scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
		1308	}
		1309	}
		1310
		1311	if (v->cur_field_type && !v->ref_field_type[dir])
		1312	return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
		1313	else
		1314	return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
		1315	}
		1316
		1317	static av_always_inline int scaleforopp_x(VC1Context v, int n / MV */)
		1318	{
		1319	int scalezone1_x, zone1offset_x;
		1320	int scaleopp1, scaleopp2, brfd;
		1321	int scaledvalue;
		1322
		1323	brfd = FFMIN(v->brfd, 3);
		1324	scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
		1325	zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
		1326	scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
		1327	scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
		1328
		1329	if (FFABS(n) > 255)
		1330	scaledvalue = n;
		1331	else {
		1332	if (FFABS(n) < scalezone1_x)
		1333	scaledvalue = (n * scaleopp1) >> 8;
		1334	else {
		1335	if (n < 0)
		1336	scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
		1337	else
		1338	scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
		1339	}
		1340	}
		1341	return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
		1342	}
		1343
		1344	static av_always_inline int scaleforopp_y(VC1Context v, int n / MV */, int dir)
		1345	{
		1346	int scalezone1_y, zone1offset_y;
		1347	int scaleopp1, scaleopp2, brfd;
		1348	int scaledvalue;
		1349
		1350	brfd = FFMIN(v->brfd, 3);
		1351	scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
		1352	zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
		1353	scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
		1354	scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
		1355
		1356	if (FFABS(n) > 63)
		1357	scaledvalue = n;
		1358	else {
		1359	if (FFABS(n) < scalezone1_y)
		1360	scaledvalue = (n * scaleopp1) >> 8;
		1361	else {
		1362	if (n < 0)
		1363	scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
		1364	else
		1365	scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
		1366	}
		1367	}
		1368	if (v->cur_field_type && !v->ref_field_type[dir]) {
		1369	return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
		1370	} else {
		1371	return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
		1372	}
		1373	}
		1374
		1375	static av_always_inline int scaleforsame(VC1Context v, int i, int n / MV */,
		1376	int dim, int dir)
		1377	{
		1378	int brfd, scalesame;
		1379	int hpel = 1 - v->s.quarter_sample;
		1380
		1381	n >>= hpel;
		1382	if (v->s.pict_type != AV_PICTURE_TYPE_B \|\| v->second_field \|\| !dir) {
		1383	if (dim)
		1384	n = scaleforsame_y(v, i, n, dir) << hpel;
		1385	else
		1386	n = scaleforsame_x(v, n, dir) << hpel;
		1387	return n;
		1388	}
		1389	brfd = FFMIN(v->brfd, 3);
		1390	scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
		1391
		1392	n = (n * scalesame >> 8) << hpel;
		1393	return n;
		1394	}
		1395
		1396	static av_always_inline int scaleforopp(VC1Context v, int n / MV */,
		1397	int dim, int dir)
		1398	{
		1399	int refdist, scaleopp;
		1400	int hpel = 1 - v->s.quarter_sample;
		1401
		1402	n >>= hpel;
		1403	if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
		1404	if (dim)
		1405	n = scaleforopp_y(v, n, dir) << hpel;
		1406	else
		1407	n = scaleforopp_x(v, n) << hpel;
		1408	return n;
		1409	}
		1410	if (v->s.pict_type != AV_PICTURE_TYPE_B)
		1411	refdist = FFMIN(v->refdist, 3);
		1412	else
		1413	refdist = dir ? v->brfd : v->frfd;
		1414	scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
		1415
		1416	n = (n * scaleopp >> 8) << hpel;
		1417	return n;
		1418	}
		1419
		1420	/** Predict and set motion vector
		1421	*/
		1422	static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
		1423	int mv1, int r_x, int r_y, uint8_t* is_intra,
		1424	int pred_flag, int dir)
		1425	{
		1426	MpegEncContext *s = &v->s;
		1427	int xy, wrap, off = 0;
		1428	int16_t A, B, *C;
		1429	int px, py;
		1430	int sum;
		1431	int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
		1432	int opposite, a_f, b_f, c_f;
		1433	int16_t field_predA[2];
		1434	int16_t field_predB[2];
		1435	int16_t field_predC[2];
		1436	int a_valid, b_valid, c_valid;
		1437	int hybridmv_thresh, y_bias = 0;
		1438
		1439	if (v->mv_mode == MV_PMODE_MIXED_MV \|\|
		1440	((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
		1441	mixedmv_pic = 1;
		1442	else
		1443	mixedmv_pic = 0;
		1444	/* scale MV difference to be quad-pel */
		1445	dmv_x <<= 1 - s->quarter_sample;
		1446	dmv_y <<= 1 - s->quarter_sample;
		1447
		1448	wrap = s->b8_stride;
		1449	xy = s->block_index[n];
		1450
		1451	if (s->mb_intra) {
		1452	s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;
		1453	s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;
		1454	s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;
		1455	s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
		1456	if (mv1) { /* duplicate motion data for 1-MV block */
		1457	s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
		1458	s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
		1459	s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
		1460	s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
		1461	s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
		1462	s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
		1463	v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
		1464	s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
		1465	s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
		1466	s->current_picture.motion_val[1][xy + wrap][0] = 0;
		1467	s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
		1468	s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
		1469	s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
		1470	}
		1471	return;
		1472	}
		1473
		1474	C = s->current_picture.motion_val[dir][xy - 1 + v->blocks_off];
		1475	A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];
		1476	if (mv1) {
		1477	if (v->field_mode && mixedmv_pic)
		1478	off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
		1479	else
		1480	off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
		1481	} else {
		1482	//in 4-MV mode different blocks have different B predictor position
		1483	switch (n) {
		1484	case 0:
		1485	off = (s->mb_x > 0) ? -1 : 1;
		1486	break;
		1487	case 1:
		1488	off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
		1489	break;
		1490	case 2:
		1491	off = 1;
		1492	break;
		1493	case 3:
		1494	off = -1;
		1495	}
		1496	}
		1497	B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];
		1498
		1499	a_valid = !s->first_slice_line \|\| (n == 2 \|\| n == 3);
		1500	b_valid = a_valid && (s->mb_width > 1);
		1501	c_valid = s->mb_x \|\| (n == 1 \|\| n == 3);
		1502	if (v->field_mode) {
		1503	a_valid = a_valid && !is_intra[xy - wrap];
		1504	b_valid = b_valid && !is_intra[xy - wrap + off];
		1505	c_valid = c_valid && !is_intra[xy - 1];
		1506	}
		1507
		1508	if (a_valid) {
		1509	a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
		1510	num_oppfield += a_f;
		1511	num_samefield += 1 - a_f;
		1512	field_predA[0] = A[0];
		1513	field_predA[1] = A[1];
		1514	} else {
		1515	field_predA[0] = field_predA[1] = 0;
		1516	a_f = 0;
		1517	}
		1518	if (b_valid) {
		1519	b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
		1520	num_oppfield += b_f;
		1521	num_samefield += 1 - b_f;
		1522	field_predB[0] = B[0];
		1523	field_predB[1] = B[1];
		1524	} else {
		1525	field_predB[0] = field_predB[1] = 0;
		1526	b_f = 0;
		1527	}
		1528	if (c_valid) {
		1529	c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
		1530	num_oppfield += c_f;
		1531	num_samefield += 1 - c_f;
		1532	field_predC[0] = C[0];
		1533	field_predC[1] = C[1];
		1534	} else {
		1535	field_predC[0] = field_predC[1] = 0;
		1536	c_f = 0;
		1537	}
		1538
		1539	if (v->field_mode) {
		1540	if (!v->numref)
		1541	// REFFIELD determines if the last field or the second-last field is
		1542	// to be used as reference
		1543	opposite = 1 - v->reffield;
		1544	else {
		1545	if (num_samefield <= num_oppfield)
		1546	opposite = 1 - pred_flag;
		1547	else
		1548	opposite = pred_flag;
		1549	}
		1550	} else
		1551	opposite = 0;
		1552	if (opposite) {
		1553	if (a_valid && !a_f) {
		1554	field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
		1555	field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
		1556	}
		1557	if (b_valid && !b_f) {
		1558	field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
		1559	field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
		1560	}
		1561	if (c_valid && !c_f) {
		1562	field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
		1563	field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
		1564	}
		1565	v->mv_f[dir][xy + v->blocks_off] = 1;
		1566	v->ref_field_type[dir] = !v->cur_field_type;
		1567	} else {
		1568	if (a_valid && a_f) {
		1569	field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
		1570	field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
		1571	}
		1572	if (b_valid && b_f) {
		1573	field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
		1574	field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
		1575	}
		1576	if (c_valid && c_f) {
		1577	field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
		1578	field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
		1579	}
		1580	v->mv_f[dir][xy + v->blocks_off] = 0;
		1581	v->ref_field_type[dir] = v->cur_field_type;
		1582	}
		1583
		1584	if (a_valid) {
		1585	px = field_predA[0];
		1586	py = field_predA[1];
		1587	} else if (c_valid) {
		1588	px = field_predC[0];
		1589	py = field_predC[1];
		1590	} else if (b_valid) {
		1591	px = field_predB[0];
		1592	py = field_predB[1];
		1593	} else {
		1594	px = 0;
		1595	py = 0;
		1596	}
		1597
		1598	if (num_samefield + num_oppfield > 1) {
		1599	px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
		1600	py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
		1601	}
		1602
		1603	/* Pullback MV as specified in 8.3.5.3.4 */
		1604	if (!v->field_mode) {
		1605	int qx, qy, X, Y;
		1606	qx = (s->mb_x << 6) + ((n == 1 \|\| n == 3) ? 32 : 0);
		1607	qy = (s->mb_y << 6) + ((n == 2 \|\| n == 3) ? 32 : 0);
		1608	X = (s->mb_width << 6) - 4;
		1609	Y = (s->mb_height << 6) - 4;
		1610	if (mv1) {
		1611	if (qx + px < -60) px = -60 - qx;
		1612	if (qy + py < -60) py = -60 - qy;
		1613	} else {
		1614	if (qx + px < -28) px = -28 - qx;
		1615	if (qy + py < -28) py = -28 - qy;
		1616	}
		1617	if (qx + px > X) px = X - qx;
		1618	if (qy + py > Y) py = Y - qy;
		1619	}
		1620
		1621	if (!v->field_mode \|\| s->pict_type != AV_PICTURE_TYPE_B) {
		1622	/* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
		1623	hybridmv_thresh = 32;
		1624	if (a_valid && c_valid) {
		1625	if (is_intra[xy - wrap])
		1626	sum = FFABS(px) + FFABS(py);
		1627	else
		1628	sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
		1629	if (sum > hybridmv_thresh) {
		1630	if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
		1631	px = field_predA[0];
		1632	py = field_predA[1];
		1633	} else {
		1634	px = field_predC[0];
		1635	py = field_predC[1];
		1636	}
		1637	} else {
		1638	if (is_intra[xy - 1])
		1639	sum = FFABS(px) + FFABS(py);
		1640	else
		1641	sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
		1642	if (sum > hybridmv_thresh) {
		1643	if (get_bits1(&s->gb)) {
		1644	px = field_predA[0];
		1645	py = field_predA[1];
		1646	} else {
		1647	px = field_predC[0];
		1648	py = field_predC[1];
		1649	}
		1650	}
		1651	}
		1652	}
		1653	}
		1654
		1655	if (v->field_mode && v->numref)
		1656	r_y >>= 1;
		1657	if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
		1658	y_bias = 1;
		1659	/* store MV using signed modulus of MV range defined in 4.11 */
		1660	s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
		1661	s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
		1662	if (mv1) { /* duplicate motion data for 1-MV block */
		1663	s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
		1664	s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
		1665	s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
		1666	s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
		1667	s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
		1668	s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
		1669	v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
		1670	v->mv_f[dir][xy + wrap + v->blocks_off] = v->mv_f[dir][xy + wrap + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
		1671	}
		1672	}
		1673
		1674	/** Predict and set motion vector for interlaced frame picture MBs
		1675	*/
		1676	static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
		1677	int mvn, int r_x, int r_y, uint8_t* is_intra, int dir)
		1678	{
		1679	MpegEncContext *s = &v->s;
		1680	int xy, wrap, off = 0;
		1681	int A[2], B[2], C[2];
		1682	int px = 0, py = 0;
		1683	int a_valid = 0, b_valid = 0, c_valid = 0;
		1684	int field_a, field_b, field_c; // 0: same, 1: opposit
		1685	int total_valid, num_samefield, num_oppfield;
		1686	int pos_c, pos_b, n_adj;
		1687
		1688	wrap = s->b8_stride;
		1689	xy = s->block_index[n];
		1690
		1691	if (s->mb_intra) {
		1692	s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
		1693	s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
		1694	s->current_picture.motion_val[1][xy][0] = 0;
		1695	s->current_picture.motion_val[1][xy][1] = 0;
		1696	if (mvn == 1) { /* duplicate motion data for 1-MV block */
		1697	s->current_picture.motion_val[0][xy + 1][0] = 0;
		1698	s->current_picture.motion_val[0][xy + 1][1] = 0;
		1699	s->current_picture.motion_val[0][xy + wrap][0] = 0;
		1700	s->current_picture.motion_val[0][xy + wrap][1] = 0;
		1701	s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
		1702	s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
		1703	v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
		1704	s->current_picture.motion_val[1][xy + 1][0] = 0;
		1705	s->current_picture.motion_val[1][xy + 1][1] = 0;
		1706	s->current_picture.motion_val[1][xy + wrap][0] = 0;
		1707	s->current_picture.motion_val[1][xy + wrap][1] = 0;
		1708	s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
		1709	s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
		1710	}
		1711	return;
		1712	}
		1713
		1714	off = ((n == 0) \|\| (n == 1)) ? 1 : -1;
		1715	/* predict A */
		1716	if (s->mb_x \|\| (n == 1) \|\| (n == 3)) {
		1717	if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
		1718	\|\| (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
		1719	A[0] = s->current_picture.motion_val[dir][xy - 1][0];
		1720	A[1] = s->current_picture.motion_val[dir][xy - 1][1];
		1721	a_valid = 1;
		1722	} else { // current block has frame mv and cand. has field MV (so average)
		1723	A[0] = (s->current_picture.motion_val[dir][xy - 1][0]
		1724	+ s->current_picture.motion_val[dir][xy - 1 + off * wrap][0] + 1) >> 1;
		1725	A[1] = (s->current_picture.motion_val[dir][xy - 1][1]
		1726	+ s->current_picture.motion_val[dir][xy - 1 + off * wrap][1] + 1) >> 1;
		1727	a_valid = 1;
		1728	}
		1729	if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
		1730	a_valid = 0;
		1731	A[0] = A[1] = 0;
		1732	}
		1733	} else
		1734	A[0] = A[1] = 0;
		1735	/* Predict B and C */
		1736	B[0] = B[1] = C[0] = C[1] = 0;
		1737	if (n == 0 \|\| n == 1 \|\| v->blk_mv_type[xy]) {
		1738	if (!s->first_slice_line) {
		1739	if (!v->is_intra[s->mb_x - s->mb_stride]) {
		1740	b_valid = 1;
		1741	n_adj = n \| 2;
		1742	pos_b = s->block_index[n_adj] - 2 * wrap;
		1743	if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
		1744	n_adj = (n & 2) \| (n & 1);
		1745	}
		1746	B[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][0];
		1747	B[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][1];
		1748	if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
		1749	B[0] = (B[0] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
		1750	B[1] = (B[1] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
		1751	}
		1752	}
		1753	if (s->mb_width > 1) {
		1754	if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
		1755	c_valid = 1;
		1756	n_adj = 2;
		1757	pos_c = s->block_index[2] - 2 * wrap + 2;
		1758	if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
		1759	n_adj = n & 2;
		1760	}
		1761	C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][0];
		1762	C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][1];
		1763	if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
		1764	C[0] = (1 + C[0] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
		1765	C[1] = (1 + C[1] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
		1766	}
		1767	if (s->mb_x == s->mb_width - 1) {
		1768	if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
		1769	c_valid = 1;
		1770	n_adj = 3;
		1771	pos_c = s->block_index[3] - 2 * wrap - 2;
		1772	if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
		1773	n_adj = n \| 1;
		1774	}
		1775	C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][0];
		1776	C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][1];
		1777	if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
		1778	C[0] = (1 + C[0] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
		1779	C[1] = (1 + C[1] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
		1780	}
		1781	} else
		1782	c_valid = 0;
		1783	}
		1784	}
		1785	}
		1786	}
		1787	} else {
		1788	pos_b = s->block_index[1];
		1789	b_valid = 1;
		1790	B[0] = s->current_picture.motion_val[dir][pos_b][0];
		1791	B[1] = s->current_picture.motion_val[dir][pos_b][1];
		1792	pos_c = s->block_index[0];
		1793	c_valid = 1;
		1794	C[0] = s->current_picture.motion_val[dir][pos_c][0];
		1795	C[1] = s->current_picture.motion_val[dir][pos_c][1];
		1796	}
		1797
		1798	total_valid = a_valid + b_valid + c_valid;
		1799	// check if predictor A is out of bounds
		1800	if (!s->mb_x && !(n == 1 \|\| n == 3)) {
		1801	A[0] = A[1] = 0;
		1802	}
		1803	// check if predictor B is out of bounds
		1804	if ((s->first_slice_line && v->blk_mv_type[xy]) \|\| (s->first_slice_line && !(n & 2))) {
		1805	B[0] = B[1] = C[0] = C[1] = 0;
		1806	}
		1807	if (!v->blk_mv_type[xy]) {
		1808	if (s->mb_width == 1) {
		1809	px = B[0];
		1810	py = B[1];
		1811	} else {
		1812	if (total_valid >= 2) {
		1813	px = mid_pred(A[0], B[0], C[0]);
		1814	py = mid_pred(A[1], B[1], C[1]);
		1815	} else if (total_valid) {
		1816	if (a_valid) { px = A[0]; py = A[1]; }
		1817	else if (b_valid) { px = B[0]; py = B[1]; }
		1818	else { px = C[0]; py = C[1]; }
		1819	}
		1820	}
		1821	} else {
		1822	if (a_valid)
		1823	field_a = (A[1] & 4) ? 1 : 0;
		1824	else
		1825	field_a = 0;
		1826	if (b_valid)
		1827	field_b = (B[1] & 4) ? 1 : 0;
		1828	else
		1829	field_b = 0;
		1830	if (c_valid)
		1831	field_c = (C[1] & 4) ? 1 : 0;
		1832	else
		1833	field_c = 0;
		1834
		1835	num_oppfield = field_a + field_b + field_c;
		1836	num_samefield = total_valid - num_oppfield;
		1837	if (total_valid == 3) {
		1838	if ((num_samefield == 3) \|\| (num_oppfield == 3)) {
		1839	px = mid_pred(A[0], B[0], C[0]);
		1840	py = mid_pred(A[1], B[1], C[1]);
		1841	} else if (num_samefield >= num_oppfield) {
		1842	/* take one MV from same field set depending on priority
		1843	the check for B may not be necessary */
		1844	px = !field_a ? A[0] : B[0];
		1845	py = !field_a ? A[1] : B[1];
		1846	} else {
		1847	px = field_a ? A[0] : B[0];
		1848	py = field_a ? A[1] : B[1];
		1849	}
		1850	} else if (total_valid == 2) {
		1851	if (num_samefield >= num_oppfield) {
		1852	if (!field_a && a_valid) {
		1853	px = A[0];
		1854	py = A[1];
		1855	} else if (!field_b && b_valid) {
		1856	px = B[0];
		1857	py = B[1];
		1858	} else /if (c_valid)/ {
		1859	av_assert1(c_valid);
		1860	px = C[0];
		1861	py = C[1];
		1862	} /else px = py = 0;/
		1863	} else {
		1864	if (field_a && a_valid) {
		1865	px = A[0];
		1866	py = A[1];
		1867	} else /if (field_b && b_valid)/ {
		1868	av_assert1(field_b && b_valid);
		1869	px = B[0];
		1870	py = B[1];
		1871	} /*else if (c_valid) {
		1872	px = C[0];
		1873	py = C[1];
		1874	}*/
		1875	}
		1876	} else if (total_valid == 1) {
		1877	px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
		1878	py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
		1879	}
		1880	}
		1881
		1882	/* store MV using signed modulus of MV range defined in 4.11 */
		1883	s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
		1884	s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
		1885	if (mvn == 1) { /* duplicate motion data for 1-MV block */
		1886	s->current_picture.motion_val[dir][xy + 1 ][0] = s->current_picture.motion_val[dir][xy][0];
		1887	s->current_picture.motion_val[dir][xy + 1 ][1] = s->current_picture.motion_val[dir][xy][1];
		1888	s->current_picture.motion_val[dir][xy + wrap ][0] = s->current_picture.motion_val[dir][xy][0];
		1889	s->current_picture.motion_val[dir][xy + wrap ][1] = s->current_picture.motion_val[dir][xy][1];
		1890	s->current_picture.motion_val[dir][xy + wrap + 1][0] = s->current_picture.motion_val[dir][xy][0];
		1891	s->current_picture.motion_val[dir][xy + wrap + 1][1] = s->current_picture.motion_val[dir][xy][1];
		1892	} else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
		1893	s->current_picture.motion_val[dir][xy + 1][0] = s->current_picture.motion_val[dir][xy][0];
		1894	s->current_picture.motion_val[dir][xy + 1][1] = s->current_picture.motion_val[dir][xy][1];
		1895	s->mv[dir][n + 1][0] = s->mv[dir][n][0];
		1896	s->mv[dir][n + 1][1] = s->mv[dir][n][1];
		1897	}
		1898	}
		1899
		1900	/** Motion compensation for direct or interpolated blocks in B-frames
		1901	*/
		1902	static void vc1_interp_mc(VC1Context *v)
		1903	{
		1904	MpegEncContext *s = &v->s;
		1905	H264ChromaContext *h264chroma = &v->h264chroma;
		1906	uint8_t srcY, srcU, *srcV;
		1907	int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
		1908	int off, off_uv;
		1909	int v_edge_pos = s->v_edge_pos >> v->field_mode;
		1910	int use_ic = v->next_use_ic;
		1911
		1912	if (!v->field_mode && !v->s.next_picture.f.data[0])
		1913	return;
		1914
		1915	mx = s->mv[1][0][0];
		1916	my = s->mv[1][0][1];
		1917	uvmx = (mx + ((mx & 3) == 3)) >> 1;
		1918	uvmy = (my + ((my & 3) == 3)) >> 1;
		1919	if (v->field_mode) {
		1920	if (v->cur_field_type != v->ref_field_type[1])
		1921	my = my - 2 + 4 * v->cur_field_type;
		1922	uvmy = uvmy - 2 + 4 * v->cur_field_type;
		1923	}
		1924	if (v->fastuvmc) {
		1925	uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
		1926	uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
		1927	}
		1928	srcY = s->next_picture.f.data[0];
		1929	srcU = s->next_picture.f.data[1];
		1930	srcV = s->next_picture.f.data[2];
		1931
		1932	src_x = s->mb_x * 16 + (mx >> 2);
		1933	src_y = s->mb_y * 16 + (my >> 2);
		1934	uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
		1935	uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
		1936
		1937	if (v->profile != PROFILE_ADVANCED) {
		1938	src_x = av_clip( src_x, -16, s->mb_width * 16);
		1939	src_y = av_clip( src_y, -16, s->mb_height * 16);
		1940	uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
		1941	uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
		1942	} else {
		1943	src_x = av_clip( src_x, -17, s->avctx->coded_width);
		1944	src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
		1945	uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
		1946	uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
		1947	}
		1948
		1949	srcY += src_y * s->linesize + src_x;
		1950	srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
		1951	srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
		1952
		1953	if (v->field_mode && v->ref_field_type[1]) {
		1954	srcY += s->current_picture_ptr->f.linesize[0];
		1955	srcU += s->current_picture_ptr->f.linesize[1];
		1956	srcV += s->current_picture_ptr->f.linesize[2];
		1957	}
		1958
		1959	/* for grayscale we should not try to read from unknown area */
		1960	if (s->flags & CODEC_FLAG_GRAY) {
		1961	srcU = s->edge_emu_buffer + 18 * s->linesize;
		1962	srcV = s->edge_emu_buffer + 18 * s->linesize;
		1963	}
		1964
		1965	if (v->rangeredfrm \|\| s->h_edge_pos < 22 \|\| v_edge_pos < 22 \|\| use_ic
		1966	\|\| (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
		1967	\|\| (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
		1968	uint8_t uvbuf = s->edge_emu_buffer + 19 s->linesize;
		1969
		1970	srcY -= s->mspel * (1 + s->linesize);
		1971	s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize, srcY, s->linesize,
		1972	17 + s->mspel * 2, 17 + s->mspel * 2,
		1973	src_x - s->mspel, src_y - s->mspel,
		1974	s->h_edge_pos, v_edge_pos);
		1975	srcY = s->edge_emu_buffer;
		1976	s->vdsp.emulated_edge_mc(uvbuf, s->uvlinesize, srcU, s->uvlinesize,
		1977	8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
		1978	s->h_edge_pos >> 1, v_edge_pos >> 1);
		1979	s->vdsp.emulated_edge_mc(uvbuf + 16, s->uvlinesize, srcV, s->uvlinesize,
		1980	8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
		1981	s->h_edge_pos >> 1, v_edge_pos >> 1);
		1982	srcU = uvbuf;
		1983	srcV = uvbuf + 16;
		1984	/* if we deal with range reduction we need to scale source blocks */
		1985	if (v->rangeredfrm) {
		1986	int i, j;
		1987	uint8_t src, src2;
		1988
		1989	src = srcY;
		1990	for (j = 0; j < 17 + s->mspel * 2; j++) {
		1991	for (i = 0; i < 17 + s->mspel * 2; i++)
		1992	src[i] = ((src[i] - 128) >> 1) + 128;
		1993	src += s->linesize;
		1994	}
		1995	src = srcU;
		1996	src2 = srcV;
		1997	for (j = 0; j < 9; j++) {
		1998	for (i = 0; i < 9; i++) {
		1999	src[i] = ((src[i] - 128) >> 1) + 128;
		2000	src2[i] = ((src2[i] - 128) >> 1) + 128;
		2001	}
		2002	src += s->uvlinesize;
		2003	src2 += s->uvlinesize;
		2004	}
		2005	}
		2006
		2007	if (use_ic) {
		2008	uint8_t (*luty )[256] = v->next_luty;
		2009	uint8_t (*lutuv)[256] = v->next_lutuv;
		2010	int i, j;
		2011	uint8_t src, src2;
		2012
		2013	src = srcY;
		2014	for (j = 0; j < 17 + s->mspel * 2; j++) {
		2015	int f = v->field_mode ? v->ref_field_type[1] : ((j+src_y - s->mspel) & 1);
		2016	for (i = 0; i < 17 + s->mspel * 2; i++)
		2017	src[i] = luty[f][src[i]];
		2018	src += s->linesize;
		2019	}
		2020	src = srcU;
		2021	src2 = srcV;
		2022	for (j = 0; j < 9; j++) {
		2023	int f = v->field_mode ? v->ref_field_type[1] : ((j+uvsrc_y) & 1);
		2024	for (i = 0; i < 9; i++) {
		2025	src[i] = lutuv[f][src[i]];
		2026	src2[i] = lutuv[f][src2[i]];
		2027	}
		2028	src += s->uvlinesize;
		2029	src2 += s->uvlinesize;
		2030	}
		2031	}
		2032	srcY += s->mspel * (1 + s->linesize);
		2033	}
		2034
		2035	off = 0;
		2036	off_uv = 0;
		2037
		2038	if (s->mspel) {
		2039	dxy = ((my & 3) << 2) \| (mx & 3);
		2040	v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
		2041	v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
		2042	srcY += s->linesize * 8;
		2043	v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
		2044	v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
		2045	} else { // hpel mc
		2046	dxy = (my & 2) \| ((mx & 2) >> 1);
		2047
		2048	if (!v->rnd)
		2049	s->hdsp.avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
		2050	else
		2051	s->hdsp.avg_no_rnd_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, 16);
		2052	}
		2053
		2054	if (s->flags & CODEC_FLAG_GRAY) return;
		2055	/* Chroma MC always uses qpel blilinear */
		2056	uvmx = (uvmx & 3) << 1;
		2057	uvmy = (uvmy & 3) << 1;
		2058	if (!v->rnd) {
		2059	h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
		2060	h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
		2061	} else {
		2062	v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
		2063	v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
		2064	}
		2065	}
		2066
		2067	static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
		2068	{
		2069	int n = bfrac;
		2070
		2071	#if B_FRACTION_DEN==256
		2072	if (inv)
		2073	n -= 256;
		2074	if (!qs)
		2075	return 2 * ((value * n + 255) >> 9);
		2076	return (value * n + 128) >> 8;
		2077	#else
		2078	if (inv)
		2079	n -= B_FRACTION_DEN;
		2080	if (!qs)
		2081	return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
		2082	return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
		2083	#endif
		2084	}
		2085
		2086	/** Reconstruct motion vector for B-frame and do motion compensation
		2087	*/
		2088	static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
		2089	int direct, int mode)
		2090	{
		2091	if (direct) {
		2092	vc1_mc_1mv(v, 0);
		2093	vc1_interp_mc(v);
		2094	return;
		2095	}
		2096	if (mode == BMV_TYPE_INTERPOLATED) {
		2097	vc1_mc_1mv(v, 0);
		2098	vc1_interp_mc(v);
		2099	return;
		2100	}
		2101
		2102	vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
		2103	}
		2104
		2105	static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
		2106	int direct, int mvtype)
		2107	{
		2108	MpegEncContext *s = &v->s;
		2109	int xy, wrap, off = 0;
		2110	int16_t A, B, *C;
		2111	int px, py;
		2112	int sum;
		2113	int r_x, r_y;
		2114	const uint8_t *is_intra = v->mb_type[0];
		2115
		2116	r_x = v->range_x;
		2117	r_y = v->range_y;
		2118	/* scale MV difference to be quad-pel */
		2119	dmv_x[0] <<= 1 - s->quarter_sample;
		2120	dmv_y[0] <<= 1 - s->quarter_sample;
		2121	dmv_x[1] <<= 1 - s->quarter_sample;
		2122	dmv_y[1] <<= 1 - s->quarter_sample;
		2123
		2124	wrap = s->b8_stride;
		2125	xy = s->block_index[0];
		2126
		2127	if (s->mb_intra) {
		2128	s->current_picture.motion_val[0][xy + v->blocks_off][0] =
		2129	s->current_picture.motion_val[0][xy + v->blocks_off][1] =
		2130	s->current_picture.motion_val[1][xy + v->blocks_off][0] =
		2131	s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
		2132	return;
		2133	}
		2134	if (!v->field_mode) {
		2135	s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
		2136	s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
		2137	s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
		2138	s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
		2139
		2140	/* Pullback predicted motion vectors as specified in 8.4.5.4 */
		2141	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));
		2142	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));
		2143	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));
		2144	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));
		2145	}
		2146	if (direct) {
		2147	s->current_picture.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
		2148	s->current_picture.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
		2149	s->current_picture.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
		2150	s->current_picture.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
		2151	return;
		2152	}
		2153
		2154	if ((mvtype == BMV_TYPE_FORWARD) \|\| (mvtype == BMV_TYPE_INTERPOLATED)) {
		2155	C = s->current_picture.motion_val[0][xy - 2];
		2156	A = s->current_picture.motion_val[0][xy - wrap * 2];
		2157	off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
		2158	B = s->current_picture.motion_val[0][xy - wrap * 2 + off];
		2159
		2160	if (!s->mb_x) C[0] = C[1] = 0;
		2161	if (!s->first_slice_line) { // predictor A is not out of bounds
		2162	if (s->mb_width == 1) {
		2163	px = A[0];
		2164	py = A[1];
		2165	} else {
		2166	px = mid_pred(A[0], B[0], C[0]);
		2167	py = mid_pred(A[1], B[1], C[1]);
		2168	}
		2169	} else if (s->mb_x) { // predictor C is not out of bounds
		2170	px = C[0];
		2171	py = C[1];
		2172	} else {
		2173	px = py = 0;
		2174	}
		2175	/* Pullback MV as specified in 8.3.5.3.4 */
		2176	{
		2177	int qx, qy, X, Y;
		2178	if (v->profile < PROFILE_ADVANCED) {
		2179	qx = (s->mb_x << 5);
		2180	qy = (s->mb_y << 5);
		2181	X = (s->mb_width << 5) - 4;
		2182	Y = (s->mb_height << 5) - 4;
		2183	if (qx + px < -28) px = -28 - qx;
		2184	if (qy + py < -28) py = -28 - qy;
		2185	if (qx + px > X) px = X - qx;
		2186	if (qy + py > Y) py = Y - qy;
		2187	} else {
		2188	qx = (s->mb_x << 6);
		2189	qy = (s->mb_y << 6);
		2190	X = (s->mb_width << 6) - 4;
		2191	Y = (s->mb_height << 6) - 4;
		2192	if (qx + px < -60) px = -60 - qx;
		2193	if (qy + py < -60) py = -60 - qy;
		2194	if (qx + px > X) px = X - qx;
		2195	if (qy + py > Y) py = Y - qy;
		2196	}
		2197	}
		2198	/* Calculate hybrid prediction as specified in 8.3.5.3.5 */
		2199	if (0 && !s->first_slice_line && s->mb_x) {
		2200	if (is_intra[xy - wrap])
		2201	sum = FFABS(px) + FFABS(py);
		2202	else
		2203	sum = FFABS(px - A[0]) + FFABS(py - A[1]);
		2204	if (sum > 32) {
		2205	if (get_bits1(&s->gb)) {
		2206	px = A[0];
		2207	py = A[1];
		2208	} else {
		2209	px = C[0];
		2210	py = C[1];
		2211	}
		2212	} else {
		2213	if (is_intra[xy - 2])
		2214	sum = FFABS(px) + FFABS(py);
		2215	else
		2216	sum = FFABS(px - C[0]) + FFABS(py - C[1]);
		2217	if (sum > 32) {
		2218	if (get_bits1(&s->gb)) {
		2219	px = A[0];
		2220	py = A[1];
		2221	} else {
		2222	px = C[0];
		2223	py = C[1];
		2224	}
		2225	}
		2226	}
		2227	}
		2228	/* store MV using signed modulus of MV range defined in 4.11 */
		2229	s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
		2230	s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
		2231	}
		2232	if ((mvtype == BMV_TYPE_BACKWARD) \|\| (mvtype == BMV_TYPE_INTERPOLATED)) {
		2233	C = s->current_picture.motion_val[1][xy - 2];
		2234	A = s->current_picture.motion_val[1][xy - wrap * 2];
		2235	off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
		2236	B = s->current_picture.motion_val[1][xy - wrap * 2 + off];
		2237
		2238	if (!s->mb_x)
		2239	C[0] = C[1] = 0;
		2240	if (!s->first_slice_line) { // predictor A is not out of bounds
		2241	if (s->mb_width == 1) {
		2242	px = A[0];
		2243	py = A[1];
		2244	} else {
		2245	px = mid_pred(A[0], B[0], C[0]);
		2246	py = mid_pred(A[1], B[1], C[1]);
		2247	}
		2248	} else if (s->mb_x) { // predictor C is not out of bounds
		2249	px = C[0];
		2250	py = C[1];
		2251	} else {
		2252	px = py = 0;
		2253	}
		2254	/* Pullback MV as specified in 8.3.5.3.4 */
		2255	{
		2256	int qx, qy, X, Y;
		2257	if (v->profile < PROFILE_ADVANCED) {
		2258	qx = (s->mb_x << 5);
		2259	qy = (s->mb_y << 5);
		2260	X = (s->mb_width << 5) - 4;
		2261	Y = (s->mb_height << 5) - 4;
		2262	if (qx + px < -28) px = -28 - qx;
		2263	if (qy + py < -28) py = -28 - qy;
		2264	if (qx + px > X) px = X - qx;
		2265	if (qy + py > Y) py = Y - qy;
		2266	} else {
		2267	qx = (s->mb_x << 6);
		2268	qy = (s->mb_y << 6);
		2269	X = (s->mb_width << 6) - 4;
		2270	Y = (s->mb_height << 6) - 4;
		2271	if (qx + px < -60) px = -60 - qx;
		2272	if (qy + py < -60) py = -60 - qy;
		2273	if (qx + px > X) px = X - qx;
		2274	if (qy + py > Y) py = Y - qy;
		2275	}
		2276	}
		2277	/* Calculate hybrid prediction as specified in 8.3.5.3.5 */
		2278	if (0 && !s->first_slice_line && s->mb_x) {
		2279	if (is_intra[xy - wrap])
		2280	sum = FFABS(px) + FFABS(py);
		2281	else
		2282	sum = FFABS(px - A[0]) + FFABS(py - A[1]);
		2283	if (sum > 32) {
		2284	if (get_bits1(&s->gb)) {
		2285	px = A[0];
		2286	py = A[1];
		2287	} else {
		2288	px = C[0];
		2289	py = C[1];
		2290	}
		2291	} else {
		2292	if (is_intra[xy - 2])
		2293	sum = FFABS(px) + FFABS(py);
		2294	else
		2295	sum = FFABS(px - C[0]) + FFABS(py - C[1]);
		2296	if (sum > 32) {
		2297	if (get_bits1(&s->gb)) {
		2298	px = A[0];
		2299	py = A[1];
		2300	} else {
		2301	px = C[0];
		2302	py = C[1];
		2303	}
		2304	}
		2305	}
		2306	}
		2307	/* store MV using signed modulus of MV range defined in 4.11 */
		2308
		2309	s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
		2310	s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
		2311	}
		2312	s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
		2313	s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
		2314	s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
		2315	s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
		2316	}
		2317
		2318	static inline void vc1_pred_b_mv_intfi(VC1Context v, int n, int dmv_x, int dmv_y, int mv1, int pred_flag)
		2319	{
		2320	int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
		2321	MpegEncContext *s = &v->s;
		2322	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		2323
		2324	if (v->bmvtype == BMV_TYPE_DIRECT) {
		2325	int total_opp, k, f;
		2326	if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
		2327	s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
		2328	v->bfraction, 0, s->quarter_sample);
		2329	s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
		2330	v->bfraction, 0, s->quarter_sample);
		2331	s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
		2332	v->bfraction, 1, s->quarter_sample);
		2333	s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
		2334	v->bfraction, 1, s->quarter_sample);
		2335
		2336	total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
		2337	+ v->mv_f_next[0][s->block_index[1] + v->blocks_off]
		2338	+ v->mv_f_next[0][s->block_index[2] + v->blocks_off]
		2339	+ v->mv_f_next[0][s->block_index[3] + v->blocks_off];
		2340	f = (total_opp > 2) ? 1 : 0;
		2341	} else {
		2342	s->mv[0][0][0] = s->mv[0][0][1] = 0;
		2343	s->mv[1][0][0] = s->mv[1][0][1] = 0;
		2344	f = 0;
		2345	}
		2346	v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
		2347	for (k = 0; k < 4; k++) {
		2348	s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
		2349	s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
		2350	s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
		2351	s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
		2352	v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
		2353	v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
		2354	}
		2355	return;
		2356	}
		2357	if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
		2358	vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], pred_flag[0], 0);
		2359	vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], pred_flag[1], 1);
		2360	return;
		2361	}
		2362	if (dir) { // backward
		2363	vc1_pred_mv(v, n, dmv_x[1], dmv_y[1], mv1, v->range_x, v->range_y, v->mb_type[0], pred_flag[1], 1);
		2364	if (n == 3 \|\| mv1) {
		2365	vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
		2366	}
		2367	} else { // forward
		2368	vc1_pred_mv(v, n, dmv_x[0], dmv_y[0], mv1, v->range_x, v->range_y, v->mb_type[0], pred_flag[0], 0);
		2369	if (n == 3 \|\| mv1) {
		2370	vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
		2371	}
		2372	}
		2373	}
		2374
		2375	/** Get predicted DC value for I-frames only
		2376	* prediction dir: left=0, top=1
		2377	* @param s MpegEncContext
		2378	* @param overlap flag indicating that overlap filtering is used
		2379	* @param pq integer part of picture quantizer
		2380	* @param[in] n block index in the current MB
		2381	* @param dc_val_ptr Pointer to DC predictor
		2382	* @param dir_ptr Prediction direction for use in AC prediction
		2383	*/
		2384	static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
		2385	int16_t *dc_val_ptr, int dir_ptr)
		2386	{
		2387	int a, b, c, wrap, pred, scale;
		2388	int16_t *dc_val;
		2389	static const uint16_t dcpred[32] = {
		2390	-1, 1024, 512, 341, 256, 205, 171, 146, 128,
		2391	114, 102, 93, 85, 79, 73, 68, 64,
		2392	60, 57, 54, 51, 49, 47, 45, 43,
		2393	41, 39, 38, 37, 35, 34, 33
		2394	};
		2395
		2396	/* find prediction - wmv3_dc_scale always used here in fact */
		2397	if (n < 4) scale = s->y_dc_scale;
		2398	else scale = s->c_dc_scale;
		2399
		2400	wrap = s->block_wrap[n];
		2401	dc_val = s->dc_val[0] + s->block_index[n];
		2402
		2403	/* B A
		2404	* C X
		2405	*/
		2406	c = dc_val[ - 1];
		2407	b = dc_val[ - 1 - wrap];
		2408	a = dc_val[ - wrap];
		2409
		2410	if (pq < 9 \|\| !overlap) {
		2411	/* Set outer values */
		2412	if (s->first_slice_line && (n != 2 && n != 3))
		2413	b = a = dcpred[scale];
		2414	if (s->mb_x == 0 && (n != 1 && n != 3))
		2415	b = c = dcpred[scale];
		2416	} else {
		2417	/* Set outer values */
		2418	if (s->first_slice_line && (n != 2 && n != 3))
		2419	b = a = 0;
		2420	if (s->mb_x == 0 && (n != 1 && n != 3))
		2421	b = c = 0;
		2422	}
		2423
		2424	if (abs(a - b) <= abs(b - c)) {
		2425	pred = c;
		2426	*dir_ptr = 1; // left
		2427	} else {
		2428	pred = a;
		2429	*dir_ptr = 0; // top
		2430	}
		2431
		2432	/* update predictor */
		2433	*dc_val_ptr = &dc_val[0];
		2434	return pred;
		2435	}
		2436
		2437
		2438	/** Get predicted DC value
		2439	* prediction dir: left=0, top=1
		2440	* @param s MpegEncContext
		2441	* @param overlap flag indicating that overlap filtering is used
		2442	* @param pq integer part of picture quantizer
		2443	* @param[in] n block index in the current MB
		2444	* @param a_avail flag indicating top block availability
		2445	* @param c_avail flag indicating left block availability
		2446	* @param dc_val_ptr Pointer to DC predictor
		2447	* @param dir_ptr Prediction direction for use in AC prediction
		2448	*/
		2449	static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
		2450	int a_avail, int c_avail,
		2451	int16_t *dc_val_ptr, int dir_ptr)
		2452	{
		2453	int a, b, c, wrap, pred;
		2454	int16_t *dc_val;
		2455	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		2456	int q1, q2 = 0;
		2457	int dqscale_index;
		2458
		2459	wrap = s->block_wrap[n];
		2460	dc_val = s->dc_val[0] + s->block_index[n];
		2461
		2462	/* B A
		2463	* C X
		2464	*/
		2465	c = dc_val[ - 1];
		2466	b = dc_val[ - 1 - wrap];
		2467	a = dc_val[ - wrap];
		2468	/* scale predictors if needed */
		2469	q1 = s->current_picture.qscale_table[mb_pos];
		2470	dqscale_index = s->y_dc_scale_table[q1] - 1;
		2471	if (dqscale_index < 0)
		2472	return 0;
		2473	if (c_avail && (n != 1 && n != 3)) {
		2474	q2 = s->current_picture.qscale_table[mb_pos - 1];
		2475	if (q2 && q2 != q1)
		2476	c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
		2477	}
		2478	if (a_avail && (n != 2 && n != 3)) {
		2479	q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
		2480	if (q2 && q2 != q1)
		2481	a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
		2482	}
		2483	if (a_avail && c_avail && (n != 3)) {
		2484	int off = mb_pos;
		2485	if (n != 1)
		2486	off--;
		2487	if (n != 2)
		2488	off -= s->mb_stride;
		2489	q2 = s->current_picture.qscale_table[off];
		2490	if (q2 && q2 != q1)
		2491	b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
		2492	}
		2493
		2494	if (a_avail && c_avail) {
		2495	if (abs(a - b) <= abs(b - c)) {
		2496	pred = c;
		2497	*dir_ptr = 1; // left
		2498	} else {
		2499	pred = a;
		2500	*dir_ptr = 0; // top
		2501	}
		2502	} else if (a_avail) {
		2503	pred = a;
		2504	*dir_ptr = 0; // top
		2505	} else if (c_avail) {
		2506	pred = c;
		2507	*dir_ptr = 1; // left
		2508	} else {
		2509	pred = 0;
		2510	*dir_ptr = 1; // left
		2511	}
		2512
		2513	/* update predictor */
		2514	*dc_val_ptr = &dc_val[0];
		2515	return pred;
		2516	}
		2517
		2518	/** @} */ // Block group
		2519
		2520	/**
		2521	* @name VC1 Macroblock-level functions in Simple/Main Profiles
		2522	* @see 7.1.4, p91 and 8.1.1.7, p(1)04
		2523	* @{
		2524	*/
		2525
		2526	static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
		2527	uint8_t **coded_block_ptr)
		2528	{
		2529	int xy, wrap, pred, a, b, c;
		2530
		2531	xy = s->block_index[n];
		2532	wrap = s->b8_stride;
		2533
		2534	/* B C
		2535	* A X
		2536	*/
		2537	a = s->coded_block[xy - 1 ];
		2538	b = s->coded_block[xy - 1 - wrap];
		2539	c = s->coded_block[xy - wrap];
		2540
		2541	if (b == c) {
		2542	pred = a;
		2543	} else {
		2544	pred = c;
		2545	}
		2546
		2547	/* store value */
		2548	*coded_block_ptr = &s->coded_block[xy];
		2549
		2550	return pred;
		2551	}
		2552
		2553	/**
		2554	* Decode one AC coefficient
		2555	* @param v The VC1 context
		2556	* @param last Last coefficient
		2557	* @param skip How much zero coefficients to skip
		2558	* @param value Decoded AC coefficient value
		2559	* @param codingset set of VLC to decode data
		2560	* @see 8.1.3.4
		2561	*/
		2562	static void vc1_decode_ac_coeff(VC1Context v, int last, int *skip,
		2563	int *value, int codingset)
		2564	{
		2565	GetBitContext *gb = &v->s.gb;
		2566	int index, escape, run = 0, level = 0, lst = 0;
		2567
		2568	index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
		2569	if (index != ff_vc1_ac_sizes[codingset] - 1) {
		2570	run = vc1_index_decode_table[codingset][index][0];
		2571	level = vc1_index_decode_table[codingset][index][1];
		2572	lst = index >= vc1_last_decode_table[codingset] \|\| get_bits_left(gb) < 0;
		2573	if (get_bits1(gb))
		2574	level = -level;
		2575	} else {
		2576	escape = decode210(gb);
		2577	if (escape != 2) {
		2578	index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
		2579	run = vc1_index_decode_table[codingset][index][0];
		2580	level = vc1_index_decode_table[codingset][index][1];
		2581	lst = index >= vc1_last_decode_table[codingset];
		2582	if (escape == 0) {
		2583	if (lst)
		2584	level += vc1_last_delta_level_table[codingset][run];
		2585	else
		2586	level += vc1_delta_level_table[codingset][run];
		2587	} else {
		2588	if (lst)
		2589	run += vc1_last_delta_run_table[codingset][level] + 1;
		2590	else
		2591	run += vc1_delta_run_table[codingset][level] + 1;
		2592	}
		2593	if (get_bits1(gb))
		2594	level = -level;
		2595	} else {
		2596	int sign;
		2597	lst = get_bits1(gb);
		2598	if (v->s.esc3_level_length == 0) {
		2599	if (v->pq < 8 \|\| v->dquantfrm) { // table 59
		2600	v->s.esc3_level_length = get_bits(gb, 3);
		2601	if (!v->s.esc3_level_length)
		2602	v->s.esc3_level_length = get_bits(gb, 2) + 8;
		2603	} else { // table 60
		2604	v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
		2605	}
		2606	v->s.esc3_run_length = 3 + get_bits(gb, 2);
		2607	}
		2608	run = get_bits(gb, v->s.esc3_run_length);
		2609	sign = get_bits1(gb);
		2610	level = get_bits(gb, v->s.esc3_level_length);
		2611	if (sign)
		2612	level = -level;
		2613	}
		2614	}
		2615
		2616	*last = lst;
		2617	*skip = run;
		2618	*value = level;
		2619	}
		2620
		2621	/** Decode intra block in intra frames - should be faster than decode_intra_block
		2622	* @param v VC1Context
		2623	* @param block block to decode
		2624	* @param[in] n subblock index
		2625	* @param coded are AC coeffs present or not
		2626	* @param codingset set of VLC to decode data
		2627	*/
		2628	static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
		2629	int coded, int codingset)
		2630	{
		2631	GetBitContext *gb = &v->s.gb;
		2632	MpegEncContext *s = &v->s;
		2633	int dc_pred_dir = 0; /* Direction of the DC prediction used */
		2634	int i;
		2635	int16_t *dc_val;
		2636	int16_t ac_val, ac_val2;
		2637	int dcdiff;
		2638
		2639	/* Get DC differential */
		2640	if (n < 4) {
		2641	dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
		2642	} else {
		2643	dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
		2644	}
		2645	if (dcdiff < 0) {
		2646	av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
		2647	return -1;
		2648	}
		2649	if (dcdiff) {
		2650	if (dcdiff == 119 /* ESC index value */) {
		2651	/* TODO: Optimize */
		2652	if (v->pq == 1) dcdiff = get_bits(gb, 10);
		2653	else if (v->pq == 2) dcdiff = get_bits(gb, 9);
		2654	else dcdiff = get_bits(gb, 8);
		2655	} else {
		2656	if (v->pq == 1)
		2657	dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
		2658	else if (v->pq == 2)
		2659	dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
		2660	}
		2661	if (get_bits1(gb))
		2662	dcdiff = -dcdiff;
		2663	}
		2664
		2665	/* Prediction */
		2666	dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
		2667	*dc_val = dcdiff;
		2668
		2669	/* Store the quantized DC coeff, used for prediction */
		2670	if (n < 4) {
		2671	block[0] = dcdiff * s->y_dc_scale;
		2672	} else {
		2673	block[0] = dcdiff * s->c_dc_scale;
		2674	}
		2675	/* Skip ? */
		2676	if (!coded) {
		2677	goto not_coded;
		2678	}
		2679
		2680	// AC Decoding
		2681	i = 1;
		2682
		2683	{
		2684	int last = 0, skip, value;
		2685	const uint8_t *zz_table;
		2686	int scale;
		2687	int k;
		2688
		2689	scale = v->pq * 2 + v->halfpq;
		2690
		2691	if (v->s.ac_pred) {
		2692	if (!dc_pred_dir)
		2693	zz_table = v->zz_8x8[2];
		2694	else
		2695	zz_table = v->zz_8x8[3];
		2696	} else
		2697	zz_table = v->zz_8x8[1];
		2698
		2699	ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
		2700	ac_val2 = ac_val;
		2701	if (dc_pred_dir) // left
		2702	ac_val -= 16;
		2703	else // top
		2704	ac_val -= 16 * s->block_wrap[n];
		2705
		2706	while (!last) {
		2707	vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
		2708	i += skip;
		2709	if (i > 63)
		2710	break;
		2711	block[zz_table[i++]] = value;
		2712	}
		2713
		2714	/* apply AC prediction if needed */
		2715	if (s->ac_pred) {
		2716	if (dc_pred_dir) { // left
		2717	for (k = 1; k < 8; k++)
		2718	block[k << v->left_blk_sh] += ac_val[k];
		2719	} else { // top
		2720	for (k = 1; k < 8; k++)
		2721	block[k << v->top_blk_sh] += ac_val[k + 8];
		2722	}
		2723	}
		2724	/* save AC coeffs for further prediction */
		2725	for (k = 1; k < 8; k++) {
		2726	ac_val2[k] = block[k << v->left_blk_sh];
		2727	ac_val2[k + 8] = block[k << v->top_blk_sh];
		2728	}
		2729
		2730	/* scale AC coeffs */
		2731	for (k = 1; k < 64; k++)
		2732	if (block[k]) {
		2733	block[k] *= scale;
		2734	if (!v->pquantizer)
		2735	block[k] += (block[k] < 0) ? -v->pq : v->pq;
		2736	}
		2737
		2738	if (s->ac_pred) i = 63;
		2739	}
		2740
		2741	not_coded:
		2742	if (!coded) {
		2743	int k, scale;
		2744	ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
		2745	ac_val2 = ac_val;
		2746
		2747	i = 0;
		2748	scale = v->pq * 2 + v->halfpq;
		2749	memset(ac_val2, 0, 16 * 2);
		2750	if (dc_pred_dir) { // left
		2751	ac_val -= 16;
		2752	if (s->ac_pred)
		2753	memcpy(ac_val2, ac_val, 8 * 2);
		2754	} else { // top
		2755	ac_val -= 16 * s->block_wrap[n];
		2756	if (s->ac_pred)
		2757	memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
		2758	}
		2759
		2760	/* apply AC prediction if needed */
		2761	if (s->ac_pred) {
		2762	if (dc_pred_dir) { //left
		2763	for (k = 1; k < 8; k++) {
		2764	block[k << v->left_blk_sh] = ac_val[k] * scale;
		2765	if (!v->pquantizer && block[k << v->left_blk_sh])
		2766	block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
		2767	}
		2768	} else { // top
		2769	for (k = 1; k < 8; k++) {
		2770	block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
		2771	if (!v->pquantizer && block[k << v->top_blk_sh])
		2772	block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
		2773	}
		2774	}
		2775	i = 63;
		2776	}
		2777	}
		2778	s->block_last_index[n] = i;
		2779
		2780	return 0;
		2781	}
		2782
		2783	/** Decode intra block in intra frames - should be faster than decode_intra_block
		2784	* @param v VC1Context
		2785	* @param block block to decode
		2786	* @param[in] n subblock number
		2787	* @param coded are AC coeffs present or not
		2788	* @param codingset set of VLC to decode data
		2789	* @param mquant quantizer value for this macroblock
		2790	*/
		2791	static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
		2792	int coded, int codingset, int mquant)
		2793	{
		2794	GetBitContext *gb = &v->s.gb;
		2795	MpegEncContext *s = &v->s;
		2796	int dc_pred_dir = 0; /* Direction of the DC prediction used */
		2797	int i;
		2798	int16_t *dc_val = NULL;
		2799	int16_t ac_val, ac_val2;
		2800	int dcdiff;
		2801	int a_avail = v->a_avail, c_avail = v->c_avail;
		2802	int use_pred = s->ac_pred;
		2803	int scale;
		2804	int q1, q2 = 0;
		2805	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		2806
		2807	/* Get DC differential */
		2808	if (n < 4) {
		2809	dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
		2810	} else {
		2811	dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
		2812	}
		2813	if (dcdiff < 0) {
		2814	av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
		2815	return -1;
		2816	}
		2817	if (dcdiff) {
		2818	if (dcdiff == 119 /* ESC index value */) {
		2819	/* TODO: Optimize */
		2820	if (mquant == 1) dcdiff = get_bits(gb, 10);
		2821	else if (mquant == 2) dcdiff = get_bits(gb, 9);
		2822	else dcdiff = get_bits(gb, 8);
		2823	} else {
		2824	if (mquant == 1)
		2825	dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
		2826	else if (mquant == 2)
		2827	dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
		2828	}
		2829	if (get_bits1(gb))
		2830	dcdiff = -dcdiff;
		2831	}
		2832
		2833	/* Prediction */
		2834	dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
		2835	*dc_val = dcdiff;
		2836
		2837	/* Store the quantized DC coeff, used for prediction */
		2838	if (n < 4) {
		2839	block[0] = dcdiff * s->y_dc_scale;
		2840	} else {
		2841	block[0] = dcdiff * s->c_dc_scale;
		2842	}
		2843
		2844	//AC Decoding
		2845	i = 1;
		2846
		2847	/* check if AC is needed at all */
		2848	if (!a_avail && !c_avail)
		2849	use_pred = 0;
		2850	ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
		2851	ac_val2 = ac_val;
		2852
		2853	scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
		2854
		2855	if (dc_pred_dir) // left
		2856	ac_val -= 16;
		2857	else // top
		2858	ac_val -= 16 * s->block_wrap[n];
		2859
		2860	q1 = s->current_picture.qscale_table[mb_pos];
		2861	if ( dc_pred_dir && c_avail && mb_pos)
		2862	q2 = s->current_picture.qscale_table[mb_pos - 1];
		2863	if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
		2864	q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
		2865	if ( dc_pred_dir && n == 1)
		2866	q2 = q1;
		2867	if (!dc_pred_dir && n == 2)
		2868	q2 = q1;
		2869	if (n == 3)
		2870	q2 = q1;
		2871
		2872	if (coded) {
		2873	int last = 0, skip, value;
		2874	const uint8_t *zz_table;
		2875	int k;
		2876
		2877	if (v->s.ac_pred) {
		2878	if (!use_pred && v->fcm == ILACE_FRAME) {
		2879	zz_table = v->zzi_8x8;
		2880	} else {
		2881	if (!dc_pred_dir) // top
		2882	zz_table = v->zz_8x8[2];
		2883	else // left
		2884	zz_table = v->zz_8x8[3];
		2885	}
		2886	} else {
		2887	if (v->fcm != ILACE_FRAME)
		2888	zz_table = v->zz_8x8[1];
		2889	else
		2890	zz_table = v->zzi_8x8;
		2891	}
		2892
		2893	while (!last) {
		2894	vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
		2895	i += skip;
		2896	if (i > 63)
		2897	break;
		2898	block[zz_table[i++]] = value;
		2899	}
		2900
		2901	/* apply AC prediction if needed */
		2902	if (use_pred) {
		2903	/* scale predictors if needed*/
		2904	if (q2 && q1 != q2) {
		2905	q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
		2906	q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
		2907
		2908	if (q1 < 1)
		2909	return AVERROR_INVALIDDATA;
		2910	if (dc_pred_dir) { // left
		2911	for (k = 1; k < 8; k++)
		2912	block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
		2913	} else { // top
		2914	for (k = 1; k < 8; k++)
		2915	block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
		2916	}
		2917	} else {
		2918	if (dc_pred_dir) { //left
		2919	for (k = 1; k < 8; k++)
		2920	block[k << v->left_blk_sh] += ac_val[k];
		2921	} else { //top
		2922	for (k = 1; k < 8; k++)
		2923	block[k << v->top_blk_sh] += ac_val[k + 8];
		2924	}
		2925	}
		2926	}
		2927	/* save AC coeffs for further prediction */
		2928	for (k = 1; k < 8; k++) {
		2929	ac_val2[k ] = block[k << v->left_blk_sh];
		2930	ac_val2[k + 8] = block[k << v->top_blk_sh];
		2931	}
		2932
		2933	/* scale AC coeffs */
		2934	for (k = 1; k < 64; k++)
		2935	if (block[k]) {
		2936	block[k] *= scale;
		2937	if (!v->pquantizer)
		2938	block[k] += (block[k] < 0) ? -mquant : mquant;
		2939	}
		2940
		2941	if (use_pred) i = 63;
		2942	} else { // no AC coeffs
		2943	int k;
		2944
		2945	memset(ac_val2, 0, 16 * 2);
		2946	if (dc_pred_dir) { // left
		2947	if (use_pred) {
		2948	memcpy(ac_val2, ac_val, 8 * 2);
		2949	if (q2 && q1 != q2) {
		2950	q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
		2951	q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
		2952	if (q1 < 1)
		2953	return AVERROR_INVALIDDATA;
		2954	for (k = 1; k < 8; k++)
		2955	ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
		2956	}
		2957	}
		2958	} else { // top
		2959	if (use_pred) {
		2960	memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
		2961	if (q2 && q1 != q2) {
		2962	q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
		2963	q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
		2964	if (q1 < 1)
		2965	return AVERROR_INVALIDDATA;
		2966	for (k = 1; k < 8; k++)
		2967	ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
		2968	}
		2969	}
		2970	}
		2971
		2972	/* apply AC prediction if needed */
		2973	if (use_pred) {
		2974	if (dc_pred_dir) { // left
		2975	for (k = 1; k < 8; k++) {
		2976	block[k << v->left_blk_sh] = ac_val2[k] * scale;
		2977	if (!v->pquantizer && block[k << v->left_blk_sh])
		2978	block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
		2979	}
		2980	} else { // top
		2981	for (k = 1; k < 8; k++) {
		2982	block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
		2983	if (!v->pquantizer && block[k << v->top_blk_sh])
		2984	block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
		2985	}
		2986	}
		2987	i = 63;
		2988	}
		2989	}
		2990	s->block_last_index[n] = i;
		2991
		2992	return 0;
		2993	}
		2994
		2995	/** Decode intra block in inter frames - more generic version than vc1_decode_i_block
		2996	* @param v VC1Context
		2997	* @param block block to decode
		2998	* @param[in] n subblock index
		2999	* @param coded are AC coeffs present or not
		3000	* @param mquant block quantizer
		3001	* @param codingset set of VLC to decode data
		3002	*/
		3003	static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
		3004	int coded, int mquant, int codingset)
		3005	{
		3006	GetBitContext *gb = &v->s.gb;
		3007	MpegEncContext *s = &v->s;
		3008	int dc_pred_dir = 0; /* Direction of the DC prediction used */
		3009	int i;
		3010	int16_t *dc_val = NULL;
		3011	int16_t ac_val, ac_val2;
		3012	int dcdiff;
		3013	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		3014	int a_avail = v->a_avail, c_avail = v->c_avail;
		3015	int use_pred = s->ac_pred;
		3016	int scale;
		3017	int q1, q2 = 0;
		3018
		3019	s->dsp.clear_block(block);
		3020
		3021	/* XXX: Guard against dumb values of mquant */
		3022	mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
		3023
		3024	/* Set DC scale - y and c use the same */
		3025	s->y_dc_scale = s->y_dc_scale_table[mquant];
		3026	s->c_dc_scale = s->c_dc_scale_table[mquant];
		3027
		3028	/* Get DC differential */
		3029	if (n < 4) {
		3030	dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
		3031	} else {
		3032	dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
		3033	}
		3034	if (dcdiff < 0) {
		3035	av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
		3036	return -1;
		3037	}
		3038	if (dcdiff) {
		3039	if (dcdiff == 119 /* ESC index value */) {
		3040	/* TODO: Optimize */
		3041	if (mquant == 1) dcdiff = get_bits(gb, 10);
		3042	else if (mquant == 2) dcdiff = get_bits(gb, 9);
		3043	else dcdiff = get_bits(gb, 8);
		3044	} else {
		3045	if (mquant == 1)
		3046	dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
		3047	else if (mquant == 2)
		3048	dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
		3049	}
		3050	if (get_bits1(gb))
		3051	dcdiff = -dcdiff;
		3052	}
		3053
		3054	/* Prediction */
		3055	dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
		3056	*dc_val = dcdiff;
		3057
		3058	/* Store the quantized DC coeff, used for prediction */
		3059
		3060	if (n < 4) {
		3061	block[0] = dcdiff * s->y_dc_scale;
		3062	} else {
		3063	block[0] = dcdiff * s->c_dc_scale;
		3064	}
		3065
		3066	//AC Decoding
		3067	i = 1;
		3068
		3069	/* check if AC is needed at all and adjust direction if needed */
		3070	if (!a_avail) dc_pred_dir = 1;
		3071	if (!c_avail) dc_pred_dir = 0;
		3072	if (!a_avail && !c_avail) use_pred = 0;
		3073	ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
		3074	ac_val2 = ac_val;
		3075
		3076	scale = mquant * 2 + v->halfpq;
		3077
		3078	if (dc_pred_dir) //left
		3079	ac_val -= 16;
		3080	else //top
		3081	ac_val -= 16 * s->block_wrap[n];
		3082
		3083	q1 = s->current_picture.qscale_table[mb_pos];
		3084	if (dc_pred_dir && c_avail && mb_pos)
		3085	q2 = s->current_picture.qscale_table[mb_pos - 1];
		3086	if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
		3087	q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
		3088	if ( dc_pred_dir && n == 1)
		3089	q2 = q1;
		3090	if (!dc_pred_dir && n == 2)
		3091	q2 = q1;
		3092	if (n == 3) q2 = q1;
		3093
		3094	if (coded) {
		3095	int last = 0, skip, value;
		3096	int k;
		3097
		3098	while (!last) {
		3099	vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
		3100	i += skip;
		3101	if (i > 63)
		3102	break;
		3103	if (v->fcm == PROGRESSIVE)
		3104	block[v->zz_8x8[0][i++]] = value;
		3105	else {
		3106	if (use_pred && (v->fcm == ILACE_FRAME)) {
		3107	if (!dc_pred_dir) // top
		3108	block[v->zz_8x8[2][i++]] = value;
		3109	else // left
		3110	block[v->zz_8x8[3][i++]] = value;
		3111	} else {
		3112	block[v->zzi_8x8[i++]] = value;
		3113	}
		3114	}
		3115	}
		3116
		3117	/* apply AC prediction if needed */
		3118	if (use_pred) {
		3119	/* scale predictors if needed*/
		3120	if (q2 && q1 != q2) {
		3121	q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
		3122	q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
		3123
		3124	if (q1 < 1)
		3125	return AVERROR_INVALIDDATA;
		3126	if (dc_pred_dir) { // left
		3127	for (k = 1; k < 8; k++)
		3128	block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
		3129	} else { //top
		3130	for (k = 1; k < 8; k++)
		3131	block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
		3132	}
		3133	} else {
		3134	if (dc_pred_dir) { // left
		3135	for (k = 1; k < 8; k++)
		3136	block[k << v->left_blk_sh] += ac_val[k];
		3137	} else { // top
		3138	for (k = 1; k < 8; k++)
		3139	block[k << v->top_blk_sh] += ac_val[k + 8];
		3140	}
		3141	}
		3142	}
		3143	/* save AC coeffs for further prediction */
		3144	for (k = 1; k < 8; k++) {
		3145	ac_val2[k ] = block[k << v->left_blk_sh];
		3146	ac_val2[k + 8] = block[k << v->top_blk_sh];
		3147	}
		3148
		3149	/* scale AC coeffs */
		3150	for (k = 1; k < 64; k++)
		3151	if (block[k]) {
		3152	block[k] *= scale;
		3153	if (!v->pquantizer)
		3154	block[k] += (block[k] < 0) ? -mquant : mquant;
		3155	}
		3156
		3157	if (use_pred) i = 63;
		3158	} else { // no AC coeffs
		3159	int k;
		3160
		3161	memset(ac_val2, 0, 16 * 2);
		3162	if (dc_pred_dir) { // left
		3163	if (use_pred) {
		3164	memcpy(ac_val2, ac_val, 8 * 2);
		3165	if (q2 && q1 != q2) {
		3166	q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
		3167	q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
		3168	if (q1 < 1)
		3169	return AVERROR_INVALIDDATA;
		3170	for (k = 1; k < 8; k++)
		3171	ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
		3172	}
		3173	}
		3174	} else { // top
		3175	if (use_pred) {
		3176	memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
		3177	if (q2 && q1 != q2) {
		3178	q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
		3179	q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
		3180	if (q1 < 1)
		3181	return AVERROR_INVALIDDATA;
		3182	for (k = 1; k < 8; k++)
		3183	ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
		3184	}
		3185	}
		3186	}
		3187
		3188	/* apply AC prediction if needed */
		3189	if (use_pred) {
		3190	if (dc_pred_dir) { // left
		3191	for (k = 1; k < 8; k++) {
		3192	block[k << v->left_blk_sh] = ac_val2[k] * scale;
		3193	if (!v->pquantizer && block[k << v->left_blk_sh])
		3194	block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
		3195	}
		3196	} else { // top
		3197	for (k = 1; k < 8; k++) {
		3198	block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
		3199	if (!v->pquantizer && block[k << v->top_blk_sh])
		3200	block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
		3201	}
		3202	}
		3203	i = 63;
		3204	}
		3205	}
		3206	s->block_last_index[n] = i;
		3207
		3208	return 0;
		3209	}
		3210
		3211	/** Decode P block
		3212	*/
		3213	static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
		3214	int mquant, int ttmb, int first_block,
		3215	uint8_t *dst, int linesize, int skip_block,
		3216	int *ttmb_out)
		3217	{
		3218	MpegEncContext *s = &v->s;
		3219	GetBitContext *gb = &s->gb;
		3220	int i, j;
		3221	int subblkpat = 0;
		3222	int scale, off, idx, last, skip, value;
		3223	int ttblk = ttmb & 7;
		3224	int pat = 0;
		3225
		3226	s->dsp.clear_block(block);
		3227
		3228	if (ttmb == -1) {
		3229	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)];
		3230	}
		3231	if (ttblk == TT_4X4) {
		3232	subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
		3233	}
		3234	if ((ttblk != TT_8X8 && ttblk != TT_4X4)
		3235	&& ((v->ttmbf \|\| (ttmb != -1 && (ttmb & 8) && !first_block))
		3236	\|\| (!v->res_rtm_flag && !first_block))) {
		3237	subblkpat = decode012(gb);
		3238	if (subblkpat)
		3239	subblkpat ^= 3; // swap decoded pattern bits
		3240	if (ttblk == TT_8X4_TOP \|\| ttblk == TT_8X4_BOTTOM)
		3241	ttblk = TT_8X4;
		3242	if (ttblk == TT_4X8_RIGHT \|\| ttblk == TT_4X8_LEFT)
		3243	ttblk = TT_4X8;
		3244	}
		3245	scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
		3246
		3247	// convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
		3248	if (ttblk == TT_8X4_TOP \|\| ttblk == TT_8X4_BOTTOM) {
		3249	subblkpat = 2 - (ttblk == TT_8X4_TOP);
		3250	ttblk = TT_8X4;
		3251	}
		3252	if (ttblk == TT_4X8_RIGHT \|\| ttblk == TT_4X8_LEFT) {
		3253	subblkpat = 2 - (ttblk == TT_4X8_LEFT);
		3254	ttblk = TT_4X8;
		3255	}
		3256	switch (ttblk) {
		3257	case TT_8X8:
		3258	pat = 0xF;
		3259	i = 0;
		3260	last = 0;
		3261	while (!last) {
		3262	vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
		3263	i += skip;
		3264	if (i > 63)
		3265	break;
		3266	if (!v->fcm)
		3267	idx = v->zz_8x8[0][i++];
		3268	else
		3269	idx = v->zzi_8x8[i++];
		3270	block[idx] = value * scale;
		3271	if (!v->pquantizer)
		3272	block[idx] += (block[idx] < 0) ? -mquant : mquant;
		3273	}
		3274	if (!skip_block) {
		3275	if (i == 1)
		3276	v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
		3277	else {
		3278	v->vc1dsp.vc1_inv_trans_8x8(block);
		3279	s->dsp.add_pixels_clamped(block, dst, linesize);
		3280	}
		3281	}
		3282	break;
		3283	case TT_4X4:
		3284	pat = ~subblkpat & 0xF;
		3285	for (j = 0; j < 4; j++) {
		3286	last = subblkpat & (1 << (3 - j));
		3287	i = 0;
		3288	off = (j & 1) * 4 + (j & 2) * 16;
		3289	while (!last) {
		3290	vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
		3291	i += skip;
		3292	if (i > 15)
		3293	break;
		3294	if (!v->fcm)
		3295	idx = ff_vc1_simple_progressive_4x4_zz[i++];
		3296	else
		3297	idx = ff_vc1_adv_interlaced_4x4_zz[i++];
		3298	block[idx + off] = value * scale;
		3299	if (!v->pquantizer)
		3300	block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
		3301	}
		3302	if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
		3303	if (i == 1)
		3304	v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
		3305	else
		3306	v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
		3307	}
		3308	}
		3309	break;
		3310	case TT_8X4:
		3311	pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
		3312	for (j = 0; j < 2; j++) {
		3313	last = subblkpat & (1 << (1 - j));
		3314	i = 0;
		3315	off = j * 32;
		3316	while (!last) {
		3317	vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
		3318	i += skip;
		3319	if (i > 31)
		3320	break;
		3321	if (!v->fcm)
		3322	idx = v->zz_8x4[i++] + off;
		3323	else
		3324	idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
		3325	block[idx] = value * scale;
		3326	if (!v->pquantizer)
		3327	block[idx] += (block[idx] < 0) ? -mquant : mquant;
		3328	}
		3329	if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
		3330	if (i == 1)
		3331	v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
		3332	else
		3333	v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
		3334	}
		3335	}
		3336	break;
		3337	case TT_4X8:
		3338	pat = ~(subblkpat * 5) & 0xF;
		3339	for (j = 0; j < 2; j++) {
		3340	last = subblkpat & (1 << (1 - j));
		3341	i = 0;
		3342	off = j * 4;
		3343	while (!last) {
		3344	vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
		3345	i += skip;
		3346	if (i > 31)
		3347	break;
		3348	if (!v->fcm)
		3349	idx = v->zz_4x8[i++] + off;
		3350	else
		3351	idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
		3352	block[idx] = value * scale;
		3353	if (!v->pquantizer)
		3354	block[idx] += (block[idx] < 0) ? -mquant : mquant;
		3355	}
		3356	if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
		3357	if (i == 1)
		3358	v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
		3359	else
		3360	v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
		3361	}
		3362	}
		3363	break;
		3364	}
		3365	if (ttmb_out)
		3366	ttmb_out \|= ttblk << (n 4);
		3367	return pat;
		3368	}
		3369
		3370	/** @} */ // Macroblock group
		3371
		3372	static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
		3373	static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
		3374
		3375	static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
		3376	{
		3377	MpegEncContext *s = &v->s;
		3378	int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
		3379	block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
		3380	mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
		3381	block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
		3382	int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
		3383	uint8_t *dst;
		3384
		3385	if (block_num > 3) {
		3386	dst = s->dest[block_num - 3];
		3387	} else {
		3388	dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
		3389	}
		3390	if (s->mb_y != s->end_mb_y \|\| block_num < 2) {
		3391	int16_t (*mv)[2];
		3392	int mv_stride;
		3393
		3394	if (block_num > 3) {
		3395	bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
		3396	bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
		3397	mv = &v->luma_mv[s->mb_x - s->mb_stride];
		3398	mv_stride = s->mb_stride;
		3399	} else {
		3400	bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
		3401	: (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
		3402	bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
		3403	: (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
		3404	mv_stride = s->b8_stride;
		3405	mv = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
		3406	}
		3407
		3408	if (bottom_is_intra & 1 \|\| block_is_intra & 1 \|\|
		3409	mv[0][0] != mv[mv_stride][0] \|\| mv[0][1] != mv[mv_stride][1]) {
		3410	v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
		3411	} else {
		3412	idx = ((bottom_cbp >> 2) \| block_cbp) & 3;
		3413	if (idx == 3) {
		3414	v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
		3415	} else if (idx) {
		3416	if (idx == 1)
		3417	v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
		3418	else
		3419	v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
		3420	}
		3421	}
		3422	}
		3423
		3424	dst -= 4 * linesize;
		3425	ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
		3426	if (ttblk == TT_4X4 \|\| ttblk == TT_8X4) {
		3427	idx = (block_cbp \| (block_cbp >> 2)) & 3;
		3428	if (idx == 3) {
		3429	v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
		3430	} else if (idx) {
		3431	if (idx == 1)
		3432	v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
		3433	else
		3434	v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
		3435	}
		3436	}
		3437	}
		3438
		3439	static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
		3440	{
		3441	MpegEncContext *s = &v->s;
		3442	int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
		3443	block_cbp = mb_cbp >> (block_num * 4), right_cbp,
		3444	mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
		3445	block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
		3446	int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
		3447	uint8_t *dst;
		3448
		3449	if (block_num > 3) {
		3450	dst = s->dest[block_num - 3] - 8 * linesize;
		3451	} else {
		3452	dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
		3453	}
		3454
		3455	if (s->mb_x != s->mb_width \|\| !(block_num & 5)) {
		3456	int16_t (*mv)[2];
		3457
		3458	if (block_num > 3) {
		3459	right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
		3460	right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
		3461	mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
		3462	} else {
		3463	right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
		3464	: (mb_cbp >> ((block_num + 1) * 4));
		3465	right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
		3466	: (mb_is_intra >> ((block_num + 1) * 4));
		3467	mv = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
		3468	}
		3469	if (block_is_intra & 1 \|\| right_is_intra & 1 \|\| mv[0][0] != mv[1][0] \|\| mv[0][1] != mv[1][1]) {
		3470	v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
		3471	} else {
		3472	idx = ((right_cbp >> 1) \| block_cbp) & 5; // FIXME check
		3473	if (idx == 5) {
		3474	v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
		3475	} else if (idx) {
		3476	if (idx == 1)
		3477	v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
		3478	else
		3479	v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
		3480	}
		3481	}
		3482	}
		3483
		3484	dst -= 4;
		3485	ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
		3486	if (ttblk == TT_4X4 \|\| ttblk == TT_4X8) {
		3487	idx = (block_cbp \| (block_cbp >> 1)) & 5;
		3488	if (idx == 5) {
		3489	v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
		3490	} else if (idx) {
		3491	if (idx == 1)
		3492	v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
		3493	else
		3494	v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
		3495	}
		3496	}
		3497	}
		3498
		3499	static void vc1_apply_p_loop_filter(VC1Context *v)
		3500	{
		3501	MpegEncContext *s = &v->s;
		3502	int i;
		3503
		3504	for (i = 0; i < 6; i++) {
		3505	vc1_apply_p_v_loop_filter(v, i);
		3506	}
		3507
		3508	/* V always precedes H, therefore we run H one MB before V;
		3509	* at the end of a row, we catch up to complete the row */
		3510	if (s->mb_x) {
		3511	for (i = 0; i < 6; i++) {
		3512	vc1_apply_p_h_loop_filter(v, i);
		3513	}
		3514	if (s->mb_x == s->mb_width - 1) {
		3515	s->mb_x++;
		3516	ff_update_block_index(s);
		3517	for (i = 0; i < 6; i++) {
		3518	vc1_apply_p_h_loop_filter(v, i);
		3519	}
		3520	}
		3521	}
		3522	}
		3523
		3524	/** Decode one P-frame MB
		3525	*/
		3526	static int vc1_decode_p_mb(VC1Context *v)
		3527	{
		3528	MpegEncContext *s = &v->s;
		3529	GetBitContext *gb = &s->gb;
		3530	int i, j;
		3531	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		3532	int cbp; /* cbp decoding stuff */
		3533	int mqdiff, mquant; /* MB quantization */
		3534	int ttmb = v->ttfrm; /* MB Transform type */
		3535
		3536	int mb_has_coeffs = 1; /* last_flag */
		3537	int dmv_x, dmv_y; /* Differential MV components */
		3538	int index, index1; /* LUT indexes */
		3539	int val, sign; /* temp values */
		3540	int first_block = 1;
		3541	int dst_idx, off;
		3542	int skipped, fourmv;
		3543	int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
		3544
		3545	mquant = v->pq; /* lossy initialization */
		3546
		3547	if (v->mv_type_is_raw)
		3548	fourmv = get_bits1(gb);
		3549	else
		3550	fourmv = v->mv_type_mb_plane[mb_pos];
		3551	if (v->skip_is_raw)
		3552	skipped = get_bits1(gb);
		3553	else
		3554	skipped = v->s.mbskip_table[mb_pos];
		3555
		3556	if (!fourmv) { /* 1MV mode */
		3557	if (!skipped) {
		3558	GET_MVDATA(dmv_x, dmv_y);
		3559
		3560	if (s->mb_intra) {
		3561	s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
		3562	s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
		3563	}
		3564	s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
		3565	vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
		3566
		3567	/* FIXME Set DC val for inter block ? */
		3568	if (s->mb_intra && !mb_has_coeffs) {
		3569	GET_MQUANT();
		3570	s->ac_pred = get_bits1(gb);
		3571	cbp = 0;
		3572	} else if (mb_has_coeffs) {
		3573	if (s->mb_intra)
		3574	s->ac_pred = get_bits1(gb);
		3575	cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
		3576	GET_MQUANT();
		3577	} else {
		3578	mquant = v->pq;
		3579	cbp = 0;
		3580	}
		3581	s->current_picture.qscale_table[mb_pos] = mquant;
		3582
		3583	if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
		3584	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
		3585	VC1_TTMB_VLC_BITS, 2);
		3586	if (!s->mb_intra) vc1_mc_1mv(v, 0);
		3587	dst_idx = 0;
		3588	for (i = 0; i < 6; i++) {
		3589	s->dc_val[0][s->block_index[i]] = 0;
		3590	dst_idx += i >> 2;
		3591	val = ((cbp >> (5 - i)) & 1);
		3592	off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
		3593	v->mb_type[0][s->block_index[i]] = s->mb_intra;
		3594	if (s->mb_intra) {
		3595	/* check if prediction blocks A and C are available */
		3596	v->a_avail = v->c_avail = 0;
		3597	if (i == 2 \|\| i == 3 \|\| !s->first_slice_line)
		3598	v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
		3599	if (i == 1 \|\| i == 3 \|\| s->mb_x)
		3600	v->c_avail = v->mb_type[0][s->block_index[i] - 1];
		3601
		3602	vc1_decode_intra_block(v, s->block[i], i, val, mquant,
		3603	(i & 4) ? v->codingset2 : v->codingset);
		3604	if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
		3605	continue;
		3606	v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
		3607	if (v->rangeredfrm)
		3608	for (j = 0; j < 64; j++)
		3609	s->block[i][j] <<= 1;
		3610	s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
		3611	if (v->pq >= 9 && v->overlap) {
		3612	if (v->c_avail)
		3613	v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
		3614	if (v->a_avail)
		3615	v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
		3616	}
		3617	block_cbp \|= 0xF << (i << 2);
		3618	block_intra \|= 1 << i;
		3619	} else if (val) {
		3620	pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
		3621	s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
		3622	(i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
		3623	block_cbp \|= pat << (i << 2);
		3624	if (!v->ttmbf && ttmb < 8)
		3625	ttmb = -1;
		3626	first_block = 0;
		3627	}
		3628	}
		3629	} else { // skipped
		3630	s->mb_intra = 0;
		3631	for (i = 0; i < 6; i++) {
		3632	v->mb_type[0][s->block_index[i]] = 0;
		3633	s->dc_val[0][s->block_index[i]] = 0;
		3634	}
		3635	s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
		3636	s->current_picture.qscale_table[mb_pos] = 0;
		3637	vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
		3638	vc1_mc_1mv(v, 0);
		3639	}
		3640	} else { // 4MV mode
		3641	if (!skipped /* unskipped MB */) {
		3642	int intra_count = 0, coded_inter = 0;
		3643	int is_intra[6], is_coded[6];
		3644	/* Get CBPCY */
		3645	cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
		3646	for (i = 0; i < 6; i++) {
		3647	val = ((cbp >> (5 - i)) & 1);
		3648	s->dc_val[0][s->block_index[i]] = 0;
		3649	s->mb_intra = 0;
		3650	if (i < 4) {
		3651	dmv_x = dmv_y = 0;
		3652	s->mb_intra = 0;
		3653	mb_has_coeffs = 0;
		3654	if (val) {
		3655	GET_MVDATA(dmv_x, dmv_y);
		3656	}
		3657	vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
		3658	if (!s->mb_intra)
		3659	vc1_mc_4mv_luma(v, i, 0, 0);
		3660	intra_count += s->mb_intra;
		3661	is_intra[i] = s->mb_intra;
		3662	is_coded[i] = mb_has_coeffs;
		3663	}
		3664	if (i & 4) {
		3665	is_intra[i] = (intra_count >= 3);
		3666	is_coded[i] = val;
		3667	}
		3668	if (i == 4)
		3669	vc1_mc_4mv_chroma(v, 0);
		3670	v->mb_type[0][s->block_index[i]] = is_intra[i];
		3671	if (!coded_inter)
		3672	coded_inter = !is_intra[i] & is_coded[i];
		3673	}
		3674	// if there are no coded blocks then don't do anything more
		3675	dst_idx = 0;
		3676	if (!intra_count && !coded_inter)
		3677	goto end;
		3678	GET_MQUANT();
		3679	s->current_picture.qscale_table[mb_pos] = mquant;
		3680	/* test if block is intra and has pred */
		3681	{
		3682	int intrapred = 0;
		3683	for (i = 0; i < 6; i++)
		3684	if (is_intra[i]) {
		3685	if (((!s->first_slice_line \|\| (i == 2 \|\| i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
		3686	\|\| ((s->mb_x \|\| (i == 1 \|\| i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
		3687	intrapred = 1;
		3688	break;
		3689	}
		3690	}
		3691	if (intrapred)
		3692	s->ac_pred = get_bits1(gb);
		3693	else
		3694	s->ac_pred = 0;
		3695	}
		3696	if (!v->ttmbf && coded_inter)
		3697	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
		3698	for (i = 0; i < 6; i++) {
		3699	dst_idx += i >> 2;
		3700	off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
		3701	s->mb_intra = is_intra[i];
		3702	if (is_intra[i]) {
		3703	/* check if prediction blocks A and C are available */
		3704	v->a_avail = v->c_avail = 0;
		3705	if (i == 2 \|\| i == 3 \|\| !s->first_slice_line)
		3706	v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
		3707	if (i == 1 \|\| i == 3 \|\| s->mb_x)
		3708	v->c_avail = v->mb_type[0][s->block_index[i] - 1];
		3709
		3710	vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
		3711	(i & 4) ? v->codingset2 : v->codingset);
		3712	if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
		3713	continue;
		3714	v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
		3715	if (v->rangeredfrm)
		3716	for (j = 0; j < 64; j++)
		3717	s->block[i][j] <<= 1;
		3718	s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
		3719	(i & 4) ? s->uvlinesize : s->linesize);
		3720	if (v->pq >= 9 && v->overlap) {
		3721	if (v->c_avail)
		3722	v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
		3723	if (v->a_avail)
		3724	v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
		3725	}
		3726	block_cbp \|= 0xF << (i << 2);
		3727	block_intra \|= 1 << i;
		3728	} else if (is_coded[i]) {
		3729	pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
		3730	first_block, s->dest[dst_idx] + off,
		3731	(i & 4) ? s->uvlinesize : s->linesize,
		3732	(i & 4) && (s->flags & CODEC_FLAG_GRAY),
		3733	&block_tt);
		3734	block_cbp \|= pat << (i << 2);
		3735	if (!v->ttmbf && ttmb < 8)
		3736	ttmb = -1;
		3737	first_block = 0;
		3738	}
		3739	}
		3740	} else { // skipped MB
		3741	s->mb_intra = 0;
		3742	s->current_picture.qscale_table[mb_pos] = 0;
		3743	for (i = 0; i < 6; i++) {
		3744	v->mb_type[0][s->block_index[i]] = 0;
		3745	s->dc_val[0][s->block_index[i]] = 0;
		3746	}
		3747	for (i = 0; i < 4; i++) {
		3748	vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
		3749	vc1_mc_4mv_luma(v, i, 0, 0);
		3750	}
		3751	vc1_mc_4mv_chroma(v, 0);
		3752	s->current_picture.qscale_table[mb_pos] = 0;
		3753	}
		3754	}
		3755	end:
		3756	v->cbp[s->mb_x] = block_cbp;
		3757	v->ttblk[s->mb_x] = block_tt;
		3758	v->is_intra[s->mb_x] = block_intra;
		3759
		3760	return 0;
		3761	}
		3762
		3763	/* Decode one macroblock in an interlaced frame p picture */
		3764
		3765	static int vc1_decode_p_mb_intfr(VC1Context *v)
		3766	{
		3767	MpegEncContext *s = &v->s;
		3768	GetBitContext *gb = &s->gb;
		3769	int i;
		3770	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		3771	int cbp = 0; /* cbp decoding stuff */
		3772	int mqdiff, mquant; /* MB quantization */
		3773	int ttmb = v->ttfrm; /* MB Transform type */
		3774
		3775	int mb_has_coeffs = 1; /* last_flag */
		3776	int dmv_x, dmv_y; /* Differential MV components */
		3777	int val; /* temp value */
		3778	int first_block = 1;
		3779	int dst_idx, off;
		3780	int skipped, fourmv = 0, twomv = 0;
		3781	int block_cbp = 0, pat, block_tt = 0;
		3782	int idx_mbmode = 0, mvbp;
		3783	int stride_y, fieldtx;
		3784
		3785	mquant = v->pq; /* Lossy initialization */
		3786
		3787	if (v->skip_is_raw)
		3788	skipped = get_bits1(gb);
		3789	else
		3790	skipped = v->s.mbskip_table[mb_pos];
		3791	if (!skipped) {
		3792	if (v->fourmvswitch)
		3793	idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
		3794	else
		3795	idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
		3796	switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
		3797	/* store the motion vector type in a flag (useful later) */
		3798	case MV_PMODE_INTFR_4MV:
		3799	fourmv = 1;
		3800	v->blk_mv_type[s->block_index[0]] = 0;
		3801	v->blk_mv_type[s->block_index[1]] = 0;
		3802	v->blk_mv_type[s->block_index[2]] = 0;
		3803	v->blk_mv_type[s->block_index[3]] = 0;
		3804	break;
		3805	case MV_PMODE_INTFR_4MV_FIELD:
		3806	fourmv = 1;
		3807	v->blk_mv_type[s->block_index[0]] = 1;
		3808	v->blk_mv_type[s->block_index[1]] = 1;
		3809	v->blk_mv_type[s->block_index[2]] = 1;
		3810	v->blk_mv_type[s->block_index[3]] = 1;
		3811	break;
		3812	case MV_PMODE_INTFR_2MV_FIELD:
		3813	twomv = 1;
		3814	v->blk_mv_type[s->block_index[0]] = 1;
		3815	v->blk_mv_type[s->block_index[1]] = 1;
		3816	v->blk_mv_type[s->block_index[2]] = 1;
		3817	v->blk_mv_type[s->block_index[3]] = 1;
		3818	break;
		3819	case MV_PMODE_INTFR_1MV:
		3820	v->blk_mv_type[s->block_index[0]] = 0;
		3821	v->blk_mv_type[s->block_index[1]] = 0;
		3822	v->blk_mv_type[s->block_index[2]] = 0;
		3823	v->blk_mv_type[s->block_index[3]] = 0;
		3824	break;
		3825	}
		3826	if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
		3827	for (i = 0; i < 4; i++) {
		3828	s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
		3829	s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
		3830	}
		3831	s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
		3832	s->mb_intra = v->is_intra[s->mb_x] = 1;
		3833	for (i = 0; i < 6; i++)
		3834	v->mb_type[0][s->block_index[i]] = 1;
		3835	fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
		3836	mb_has_coeffs = get_bits1(gb);
		3837	if (mb_has_coeffs)
		3838	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
		3839	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
		3840	GET_MQUANT();
		3841	s->current_picture.qscale_table[mb_pos] = mquant;
		3842	/* Set DC scale - y and c use the same (not sure if necessary here) */
		3843	s->y_dc_scale = s->y_dc_scale_table[mquant];
		3844	s->c_dc_scale = s->c_dc_scale_table[mquant];
		3845	dst_idx = 0;
		3846	for (i = 0; i < 6; i++) {
		3847	s->dc_val[0][s->block_index[i]] = 0;
		3848	dst_idx += i >> 2;
		3849	val = ((cbp >> (5 - i)) & 1);
		3850	v->mb_type[0][s->block_index[i]] = s->mb_intra;
		3851	v->a_avail = v->c_avail = 0;
		3852	if (i == 2 \|\| i == 3 \|\| !s->first_slice_line)
		3853	v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
		3854	if (i == 1 \|\| i == 3 \|\| s->mb_x)
		3855	v->c_avail = v->mb_type[0][s->block_index[i] - 1];
		3856
		3857	vc1_decode_intra_block(v, s->block[i], i, val, mquant,
		3858	(i & 4) ? v->codingset2 : v->codingset);
		3859	if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
		3860	v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
		3861	if (i < 4) {
		3862	stride_y = s->linesize << fieldtx;
		3863	off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
		3864	} else {
		3865	stride_y = s->uvlinesize;
		3866	off = 0;
		3867	}
		3868	s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
		3869	//TODO: loop filter
		3870	}
		3871
		3872	} else { // inter MB
		3873	mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
		3874	if (mb_has_coeffs)
		3875	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
		3876	if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
		3877	v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
		3878	} else {
		3879	if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
		3880	\|\| (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
		3881	v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
		3882	}
		3883	}
		3884	s->mb_intra = v->is_intra[s->mb_x] = 0;
		3885	for (i = 0; i < 6; i++)
		3886	v->mb_type[0][s->block_index[i]] = 0;
		3887	fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
		3888	/* for all motion vector read MVDATA and motion compensate each block */
		3889	dst_idx = 0;
		3890	if (fourmv) {
		3891	mvbp = v->fourmvbp;
		3892	for (i = 0; i < 6; i++) {
		3893	if (i < 4) {
		3894	dmv_x = dmv_y = 0;
		3895	val = ((mvbp >> (3 - i)) & 1);
		3896	if (val) {
		3897	get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
		3898	}
		3899	vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0);
		3900	vc1_mc_4mv_luma(v, i, 0, 0);
		3901	} else if (i == 4) {
		3902	vc1_mc_4mv_chroma4(v, 0, 0, 0);
		3903	}
		3904	}
		3905	} else if (twomv) {
		3906	mvbp = v->twomvbp;
		3907	dmv_x = dmv_y = 0;
		3908	if (mvbp & 2) {
		3909	get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
		3910	}
		3911	vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
		3912	vc1_mc_4mv_luma(v, 0, 0, 0);
		3913	vc1_mc_4mv_luma(v, 1, 0, 0);
		3914	dmv_x = dmv_y = 0;
		3915	if (mvbp & 1) {
		3916	get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
		3917	}
		3918	vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
		3919	vc1_mc_4mv_luma(v, 2, 0, 0);
		3920	vc1_mc_4mv_luma(v, 3, 0, 0);
		3921	vc1_mc_4mv_chroma4(v, 0, 0, 0);
		3922	} else {
		3923	mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
		3924	dmv_x = dmv_y = 0;
		3925	if (mvbp) {
		3926	get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
		3927	}
		3928	vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
		3929	vc1_mc_1mv(v, 0);
		3930	}
		3931	if (cbp)
		3932	GET_MQUANT(); // p. 227
		3933	s->current_picture.qscale_table[mb_pos] = mquant;
		3934	if (!v->ttmbf && cbp)
		3935	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
		3936	for (i = 0; i < 6; i++) {
		3937	s->dc_val[0][s->block_index[i]] = 0;
		3938	dst_idx += i >> 2;
		3939	val = ((cbp >> (5 - i)) & 1);
		3940	if (!fieldtx)
		3941	off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
		3942	else
		3943	off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
		3944	if (val) {
		3945	pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
		3946	first_block, s->dest[dst_idx] + off,
		3947	(i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
		3948	(i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
		3949	block_cbp \|= pat << (i << 2);
		3950	if (!v->ttmbf && ttmb < 8)
		3951	ttmb = -1;
		3952	first_block = 0;
		3953	}
		3954	}
		3955	}
		3956	} else { // skipped
		3957	s->mb_intra = v->is_intra[s->mb_x] = 0;
		3958	for (i = 0; i < 6; i++) {
		3959	v->mb_type[0][s->block_index[i]] = 0;
		3960	s->dc_val[0][s->block_index[i]] = 0;
		3961	}
		3962	s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
		3963	s->current_picture.qscale_table[mb_pos] = 0;
		3964	v->blk_mv_type[s->block_index[0]] = 0;
		3965	v->blk_mv_type[s->block_index[1]] = 0;
		3966	v->blk_mv_type[s->block_index[2]] = 0;
		3967	v->blk_mv_type[s->block_index[3]] = 0;
		3968	vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
		3969	vc1_mc_1mv(v, 0);
		3970	}
		3971	if (s->mb_x == s->mb_width - 1)
		3972	memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
		3973	return 0;
		3974	}
		3975
		3976	static int vc1_decode_p_mb_intfi(VC1Context *v)
		3977	{
		3978	MpegEncContext *s = &v->s;
		3979	GetBitContext *gb = &s->gb;
		3980	int i;
		3981	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		3982	int cbp = 0; /* cbp decoding stuff */
		3983	int mqdiff, mquant; /* MB quantization */
		3984	int ttmb = v->ttfrm; /* MB Transform type */
		3985
		3986	int mb_has_coeffs = 1; /* last_flag */
		3987	int dmv_x, dmv_y; /* Differential MV components */
		3988	int val; /* temp values */
		3989	int first_block = 1;
		3990	int dst_idx, off;
		3991	int pred_flag = 0;
		3992	int block_cbp = 0, pat, block_tt = 0;
		3993	int idx_mbmode = 0;
		3994
		3995	mquant = v->pq; /* Lossy initialization */
		3996
		3997	idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
		3998	if (idx_mbmode <= 1) { // intra MB
		3999	s->mb_intra = v->is_intra[s->mb_x] = 1;
		4000	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
		4001	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
		4002	s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
		4003	GET_MQUANT();
		4004	s->current_picture.qscale_table[mb_pos] = mquant;
		4005	/* Set DC scale - y and c use the same (not sure if necessary here) */
		4006	s->y_dc_scale = s->y_dc_scale_table[mquant];
		4007	s->c_dc_scale = s->c_dc_scale_table[mquant];
		4008	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
		4009	mb_has_coeffs = idx_mbmode & 1;
		4010	if (mb_has_coeffs)
		4011	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
		4012	dst_idx = 0;
		4013	for (i = 0; i < 6; i++) {
		4014	s->dc_val[0][s->block_index[i]] = 0;
		4015	v->mb_type[0][s->block_index[i]] = 1;
		4016	dst_idx += i >> 2;
		4017	val = ((cbp >> (5 - i)) & 1);
		4018	v->a_avail = v->c_avail = 0;
		4019	if (i == 2 \|\| i == 3 \|\| !s->first_slice_line)
		4020	v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
		4021	if (i == 1 \|\| i == 3 \|\| s->mb_x)
		4022	v->c_avail = v->mb_type[0][s->block_index[i] - 1];
		4023
		4024	vc1_decode_intra_block(v, s->block[i], i, val, mquant,
		4025	(i & 4) ? v->codingset2 : v->codingset);
		4026	if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
		4027	continue;
		4028	v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
		4029	off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
		4030	s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
		4031	// TODO: loop filter
		4032	}
		4033	} else {
		4034	s->mb_intra = v->is_intra[s->mb_x] = 0;
		4035	s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
		4036	for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
		4037	if (idx_mbmode <= 5) { // 1-MV
		4038	dmv_x = dmv_y = pred_flag = 0;
		4039	if (idx_mbmode & 1) {
		4040	get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
		4041	}
		4042	vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
		4043	vc1_mc_1mv(v, 0);
		4044	mb_has_coeffs = !(idx_mbmode & 2);
		4045	} else { // 4-MV
		4046	v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
		4047	for (i = 0; i < 6; i++) {
		4048	if (i < 4) {
		4049	dmv_x = dmv_y = pred_flag = 0;
		4050	val = ((v->fourmvbp >> (3 - i)) & 1);
		4051	if (val) {
		4052	get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
		4053	}
		4054	vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
		4055	vc1_mc_4mv_luma(v, i, 0, 0);
		4056	} else if (i == 4)
		4057	vc1_mc_4mv_chroma(v, 0);
		4058	}
		4059	mb_has_coeffs = idx_mbmode & 1;
		4060	}
		4061	if (mb_has_coeffs)
		4062	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
		4063	if (cbp) {
		4064	GET_MQUANT();
		4065	}
		4066	s->current_picture.qscale_table[mb_pos] = mquant;
		4067	if (!v->ttmbf && cbp) {
		4068	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
		4069	}
		4070	dst_idx = 0;
		4071	for (i = 0; i < 6; i++) {
		4072	s->dc_val[0][s->block_index[i]] = 0;
		4073	dst_idx += i >> 2;
		4074	val = ((cbp >> (5 - i)) & 1);
		4075	off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
		4076	if (val) {
		4077	pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
		4078	first_block, s->dest[dst_idx] + off,
		4079	(i & 4) ? s->uvlinesize : s->linesize,
		4080	(i & 4) && (s->flags & CODEC_FLAG_GRAY),
		4081	&block_tt);
		4082	block_cbp \|= pat << (i << 2);
		4083	if (!v->ttmbf && ttmb < 8) ttmb = -1;
		4084	first_block = 0;
		4085	}
		4086	}
		4087	}
		4088	if (s->mb_x == s->mb_width - 1)
		4089	memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
		4090	return 0;
		4091	}
		4092
		4093	/** Decode one B-frame MB (in Main profile)
		4094	*/
		4095	static void vc1_decode_b_mb(VC1Context *v)
		4096	{
		4097	MpegEncContext *s = &v->s;
		4098	GetBitContext *gb = &s->gb;
		4099	int i, j;
		4100	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		4101	int cbp = 0; /* cbp decoding stuff */
		4102	int mqdiff, mquant; /* MB quantization */
		4103	int ttmb = v->ttfrm; /* MB Transform type */
		4104	int mb_has_coeffs = 0; /* last_flag */
		4105	int index, index1; /* LUT indexes */
		4106	int val, sign; /* temp values */
		4107	int first_block = 1;
		4108	int dst_idx, off;
		4109	int skipped, direct;
		4110	int dmv_x[2], dmv_y[2];
		4111	int bmvtype = BMV_TYPE_BACKWARD;
		4112
		4113	mquant = v->pq; /* lossy initialization */
		4114	s->mb_intra = 0;
		4115
		4116	if (v->dmb_is_raw)
		4117	direct = get_bits1(gb);
		4118	else
		4119	direct = v->direct_mb_plane[mb_pos];
		4120	if (v->skip_is_raw)
		4121	skipped = get_bits1(gb);
		4122	else
		4123	skipped = v->s.mbskip_table[mb_pos];
		4124
		4125	dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
		4126	for (i = 0; i < 6; i++) {
		4127	v->mb_type[0][s->block_index[i]] = 0;
		4128	s->dc_val[0][s->block_index[i]] = 0;
		4129	}
		4130	s->current_picture.qscale_table[mb_pos] = 0;
		4131
		4132	if (!direct) {
		4133	if (!skipped) {
		4134	GET_MVDATA(dmv_x[0], dmv_y[0]);
		4135	dmv_x[1] = dmv_x[0];
		4136	dmv_y[1] = dmv_y[0];
		4137	}
		4138	if (skipped \|\| !s->mb_intra) {
		4139	bmvtype = decode012(gb);
		4140	switch (bmvtype) {
		4141	case 0:
		4142	bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
		4143	break;
		4144	case 1:
		4145	bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
		4146	break;
		4147	case 2:
		4148	bmvtype = BMV_TYPE_INTERPOLATED;
		4149	dmv_x[0] = dmv_y[0] = 0;
		4150	}
		4151	}
		4152	}
		4153	for (i = 0; i < 6; i++)
		4154	v->mb_type[0][s->block_index[i]] = s->mb_intra;
		4155
		4156	if (skipped) {
		4157	if (direct)
		4158	bmvtype = BMV_TYPE_INTERPOLATED;
		4159	vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
		4160	vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
		4161	return;
		4162	}
		4163	if (direct) {
		4164	cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
		4165	GET_MQUANT();
		4166	s->mb_intra = 0;
		4167	s->current_picture.qscale_table[mb_pos] = mquant;
		4168	if (!v->ttmbf)
		4169	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
		4170	dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
		4171	vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
		4172	vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
		4173	} else {
		4174	if (!mb_has_coeffs && !s->mb_intra) {
		4175	/* no coded blocks - effectively skipped */
		4176	vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
		4177	vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
		4178	return;
		4179	}
		4180	if (s->mb_intra && !mb_has_coeffs) {
		4181	GET_MQUANT();
		4182	s->current_picture.qscale_table[mb_pos] = mquant;
		4183	s->ac_pred = get_bits1(gb);
		4184	cbp = 0;
		4185	vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
		4186	} else {
		4187	if (bmvtype == BMV_TYPE_INTERPOLATED) {
		4188	GET_MVDATA(dmv_x[0], dmv_y[0]);
		4189	if (!mb_has_coeffs) {
		4190	/* interpolated skipped block */
		4191	vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
		4192	vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
		4193	return;
		4194	}
		4195	}
		4196	vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
		4197	if (!s->mb_intra) {
		4198	vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
		4199	}
		4200	if (s->mb_intra)
		4201	s->ac_pred = get_bits1(gb);
		4202	cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
		4203	GET_MQUANT();
		4204	s->current_picture.qscale_table[mb_pos] = mquant;
		4205	if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
		4206	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
		4207	}
		4208	}
		4209	dst_idx = 0;
		4210	for (i = 0; i < 6; i++) {
		4211	s->dc_val[0][s->block_index[i]] = 0;
		4212	dst_idx += i >> 2;
		4213	val = ((cbp >> (5 - i)) & 1);
		4214	off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
		4215	v->mb_type[0][s->block_index[i]] = s->mb_intra;
		4216	if (s->mb_intra) {
		4217	/* check if prediction blocks A and C are available */
		4218	v->a_avail = v->c_avail = 0;
		4219	if (i == 2 \|\| i == 3 \|\| !s->first_slice_line)
		4220	v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
		4221	if (i == 1 \|\| i == 3 \|\| s->mb_x)
		4222	v->c_avail = v->mb_type[0][s->block_index[i] - 1];
		4223
		4224	vc1_decode_intra_block(v, s->block[i], i, val, mquant,
		4225	(i & 4) ? v->codingset2 : v->codingset);
		4226	if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
		4227	continue;
		4228	v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
		4229	if (v->rangeredfrm)
		4230	for (j = 0; j < 64; j++)
		4231	s->block[i][j] <<= 1;
		4232	s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
		4233	} else if (val) {
		4234	vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
		4235	first_block, s->dest[dst_idx] + off,
		4236	(i & 4) ? s->uvlinesize : s->linesize,
		4237	(i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
		4238	if (!v->ttmbf && ttmb < 8)
		4239	ttmb = -1;
		4240	first_block = 0;
		4241	}
		4242	}
		4243	}
		4244
		4245	/** Decode one B-frame MB (in interlaced field B picture)
		4246	*/
		4247	static void vc1_decode_b_mb_intfi(VC1Context *v)
		4248	{
		4249	MpegEncContext *s = &v->s;
		4250	GetBitContext *gb = &s->gb;
		4251	int i, j;
		4252	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		4253	int cbp = 0; /* cbp decoding stuff */
		4254	int mqdiff, mquant; /* MB quantization */
		4255	int ttmb = v->ttfrm; /* MB Transform type */
		4256	int mb_has_coeffs = 0; /* last_flag */
		4257	int val; /* temp value */
		4258	int first_block = 1;
		4259	int dst_idx, off;
		4260	int fwd;
		4261	int dmv_x[2], dmv_y[2], pred_flag[2];
		4262	int bmvtype = BMV_TYPE_BACKWARD;
		4263	int idx_mbmode;
		4264
		4265	mquant = v->pq; /* Lossy initialization */
		4266	s->mb_intra = 0;
		4267
		4268	idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
		4269	if (idx_mbmode <= 1) { // intra MB
		4270	s->mb_intra = v->is_intra[s->mb_x] = 1;
		4271	s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
		4272	s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
		4273	s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
		4274	GET_MQUANT();
		4275	s->current_picture.qscale_table[mb_pos] = mquant;
		4276	/* Set DC scale - y and c use the same (not sure if necessary here) */
		4277	s->y_dc_scale = s->y_dc_scale_table[mquant];
		4278	s->c_dc_scale = s->c_dc_scale_table[mquant];
		4279	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
		4280	mb_has_coeffs = idx_mbmode & 1;
		4281	if (mb_has_coeffs)
		4282	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
		4283	dst_idx = 0;
		4284	for (i = 0; i < 6; i++) {
		4285	s->dc_val[0][s->block_index[i]] = 0;
		4286	dst_idx += i >> 2;
		4287	val = ((cbp >> (5 - i)) & 1);
		4288	v->mb_type[0][s->block_index[i]] = s->mb_intra;
		4289	v->a_avail = v->c_avail = 0;
		4290	if (i == 2 \|\| i == 3 \|\| !s->first_slice_line)
		4291	v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
		4292	if (i == 1 \|\| i == 3 \|\| s->mb_x)
		4293	v->c_avail = v->mb_type[0][s->block_index[i] - 1];
		4294
		4295	vc1_decode_intra_block(v, s->block[i], i, val, mquant,
		4296	(i & 4) ? v->codingset2 : v->codingset);
		4297	if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
		4298	continue;
		4299	v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
		4300	if (v->rangeredfrm)
		4301	for (j = 0; j < 64; j++)
		4302	s->block[i][j] <<= 1;
		4303	off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
		4304	s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
		4305	// TODO: yet to perform loop filter
		4306	}
		4307	} else {
		4308	s->mb_intra = v->is_intra[s->mb_x] = 0;
		4309	s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
		4310	for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
		4311	if (v->fmb_is_raw)
		4312	fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
		4313	else
		4314	fwd = v->forward_mb_plane[mb_pos];
		4315	if (idx_mbmode <= 5) { // 1-MV
		4316	int interpmvp = 0;
		4317	dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
		4318	pred_flag[0] = pred_flag[1] = 0;
		4319	if (fwd)
		4320	bmvtype = BMV_TYPE_FORWARD;
		4321	else {
		4322	bmvtype = decode012(gb);
		4323	switch (bmvtype) {
		4324	case 0:
		4325	bmvtype = BMV_TYPE_BACKWARD;
		4326	break;
		4327	case 1:
		4328	bmvtype = BMV_TYPE_DIRECT;
		4329	break;
		4330	case 2:
		4331	bmvtype = BMV_TYPE_INTERPOLATED;
		4332	interpmvp = get_bits1(gb);
		4333	}
		4334	}
		4335	v->bmvtype = bmvtype;
		4336	if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
		4337	get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
		4338	}
		4339	if (interpmvp) {
		4340	get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
		4341	}
		4342	if (bmvtype == BMV_TYPE_DIRECT) {
		4343	dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
		4344	dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
		4345	}
		4346	vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
		4347	vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
		4348	mb_has_coeffs = !(idx_mbmode & 2);
		4349	} else { // 4-MV
		4350	if (fwd)
		4351	bmvtype = BMV_TYPE_FORWARD;
		4352	v->bmvtype = bmvtype;
		4353	v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
		4354	for (i = 0; i < 6; i++) {
		4355	if (i < 4) {
		4356	dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
		4357	dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
		4358	val = ((v->fourmvbp >> (3 - i)) & 1);
		4359	if (val) {
		4360	get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
		4361	&dmv_y[bmvtype == BMV_TYPE_BACKWARD],
		4362	&pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
		4363	}
		4364	vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
		4365	vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD, 0);
		4366	} else if (i == 4)
		4367	vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
		4368	}
		4369	mb_has_coeffs = idx_mbmode & 1;
		4370	}
		4371	if (mb_has_coeffs)
		4372	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
		4373	if (cbp) {
		4374	GET_MQUANT();
		4375	}
		4376	s->current_picture.qscale_table[mb_pos] = mquant;
		4377	if (!v->ttmbf && cbp) {
		4378	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
		4379	}
		4380	dst_idx = 0;
		4381	for (i = 0; i < 6; i++) {
		4382	s->dc_val[0][s->block_index[i]] = 0;
		4383	dst_idx += i >> 2;
		4384	val = ((cbp >> (5 - i)) & 1);
		4385	off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
		4386	if (val) {
		4387	vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
		4388	first_block, s->dest[dst_idx] + off,
		4389	(i & 4) ? s->uvlinesize : s->linesize,
		4390	(i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
		4391	if (!v->ttmbf && ttmb < 8)
		4392	ttmb = -1;
		4393	first_block = 0;
		4394	}
		4395	}
		4396	}
		4397	}
		4398
		4399	/** Decode one B-frame MB (in interlaced frame B picture)
		4400	*/
		4401	static int vc1_decode_b_mb_intfr(VC1Context *v)
		4402	{
		4403	MpegEncContext *s = &v->s;
		4404	GetBitContext *gb = &s->gb;
		4405	int i, j;
		4406	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		4407	int cbp = 0; /* cbp decoding stuff */
		4408	int mqdiff, mquant; /* MB quantization */
		4409	int ttmb = v->ttfrm; /* MB Transform type */
		4410	int mvsw = 0; /* motion vector switch */
		4411	int mb_has_coeffs = 1; /* last_flag */
		4412	int dmv_x, dmv_y; /* Differential MV components */
		4413	int val; /* temp value */
		4414	int first_block = 1;
		4415	int dst_idx, off;
		4416	int skipped, direct, twomv = 0;
		4417	int block_cbp = 0, pat, block_tt = 0;
		4418	int idx_mbmode = 0, mvbp;
		4419	int stride_y, fieldtx;
		4420	int bmvtype = BMV_TYPE_BACKWARD;
		4421	int dir, dir2;
		4422
		4423	mquant = v->pq; /* Lossy initialization */
		4424	s->mb_intra = 0;
		4425	if (v->skip_is_raw)
		4426	skipped = get_bits1(gb);
		4427	else
		4428	skipped = v->s.mbskip_table[mb_pos];
		4429
		4430	if (!skipped) {
		4431	idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
		4432	if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
		4433	twomv = 1;
		4434	v->blk_mv_type[s->block_index[0]] = 1;
		4435	v->blk_mv_type[s->block_index[1]] = 1;
		4436	v->blk_mv_type[s->block_index[2]] = 1;
		4437	v->blk_mv_type[s->block_index[3]] = 1;
		4438	} else {
		4439	v->blk_mv_type[s->block_index[0]] = 0;
		4440	v->blk_mv_type[s->block_index[1]] = 0;
		4441	v->blk_mv_type[s->block_index[2]] = 0;
		4442	v->blk_mv_type[s->block_index[3]] = 0;
		4443	}
		4444	}
		4445
		4446	if (v->dmb_is_raw)
		4447	direct = get_bits1(gb);
		4448	else
		4449	direct = v->direct_mb_plane[mb_pos];
		4450
		4451	if (direct) {
		4452	s->mv[0][0][0] = s->current_picture.motion_val[0][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 0, s->quarter_sample);
		4453	s->mv[0][0][1] = s->current_picture.motion_val[0][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 0, s->quarter_sample);
		4454	s->mv[1][0][0] = s->current_picture.motion_val[1][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 1, s->quarter_sample);
		4455	s->mv[1][0][1] = s->current_picture.motion_val[1][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 1, s->quarter_sample);
		4456
		4457	if (twomv) {
		4458	s->mv[0][2][0] = s->current_picture.motion_val[0][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 0, s->quarter_sample);
		4459	s->mv[0][2][1] = s->current_picture.motion_val[0][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 0, s->quarter_sample);
		4460	s->mv[1][2][0] = s->current_picture.motion_val[1][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 1, s->quarter_sample);
		4461	s->mv[1][2][1] = s->current_picture.motion_val[1][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 1, s->quarter_sample);
		4462
		4463	for (i = 1; i < 4; i += 2) {
		4464	s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];
		4465	s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];
		4466	s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];
		4467	s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];
		4468	}
		4469	} else {
		4470	for (i = 1; i < 4; i++) {
		4471	s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];
		4472	s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];
		4473	s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];
		4474	s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];
		4475	}
		4476	}
		4477	}
		4478
		4479	if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
		4480	for (i = 0; i < 4; i++) {
		4481	s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = 0;
		4482	s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = 0;
		4483	s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
		4484	s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
		4485	}
		4486	s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
		4487	s->mb_intra = v->is_intra[s->mb_x] = 1;
		4488	for (i = 0; i < 6; i++)
		4489	v->mb_type[0][s->block_index[i]] = 1;
		4490	fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
		4491	mb_has_coeffs = get_bits1(gb);
		4492	if (mb_has_coeffs)
		4493	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
		4494	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
		4495	GET_MQUANT();
		4496	s->current_picture.qscale_table[mb_pos] = mquant;
		4497	/* Set DC scale - y and c use the same (not sure if necessary here) */
		4498	s->y_dc_scale = s->y_dc_scale_table[mquant];
		4499	s->c_dc_scale = s->c_dc_scale_table[mquant];
		4500	dst_idx = 0;
		4501	for (i = 0; i < 6; i++) {
		4502	s->dc_val[0][s->block_index[i]] = 0;
		4503	dst_idx += i >> 2;
		4504	val = ((cbp >> (5 - i)) & 1);
		4505	v->mb_type[0][s->block_index[i]] = s->mb_intra;
		4506	v->a_avail = v->c_avail = 0;
		4507	if (i == 2 \|\| i == 3 \|\| !s->first_slice_line)
		4508	v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
		4509	if (i == 1 \|\| i == 3 \|\| s->mb_x)
		4510	v->c_avail = v->mb_type[0][s->block_index[i] - 1];
		4511
		4512	vc1_decode_intra_block(v, s->block[i], i, val, mquant,
		4513	(i & 4) ? v->codingset2 : v->codingset);
		4514	if (i > 3 && (s->flags & CODEC_FLAG_GRAY))
		4515	continue;
		4516	v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
		4517	if (i < 4) {
		4518	stride_y = s->linesize << fieldtx;
		4519	off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
		4520	} else {
		4521	stride_y = s->uvlinesize;
		4522	off = 0;
		4523	}
		4524	s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
		4525	}
		4526	} else {
		4527	s->mb_intra = v->is_intra[s->mb_x] = 0;
		4528	if (!direct) {
		4529	if (skipped \|\| !s->mb_intra) {
		4530	bmvtype = decode012(gb);
		4531	switch (bmvtype) {
		4532	case 0:
		4533	bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
		4534	break;
		4535	case 1:
		4536	bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
		4537	break;
		4538	case 2:
		4539	bmvtype = BMV_TYPE_INTERPOLATED;
		4540	}
		4541	}
		4542
		4543	if (twomv && bmvtype != BMV_TYPE_INTERPOLATED)
		4544	mvsw = get_bits1(gb);
		4545	}
		4546
		4547	if (!skipped) { // inter MB
		4548	mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
		4549	if (mb_has_coeffs)
		4550	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
		4551	if (!direct) {
		4552	if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
		4553	v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
		4554	} else if (bmvtype == BMV_TYPE_INTERPOLATED \|\| twomv) {
		4555	v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
		4556	}
		4557	}
		4558
		4559	for (i = 0; i < 6; i++)
		4560	v->mb_type[0][s->block_index[i]] = 0;
		4561	fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[0][idx_mbmode][1];
		4562	/* for all motion vector read MVDATA and motion compensate each block */
		4563	dst_idx = 0;
		4564	if (direct) {
		4565	if (twomv) {
		4566	for (i = 0; i < 4; i++) {
		4567	vc1_mc_4mv_luma(v, i, 0, 0);
		4568	vc1_mc_4mv_luma(v, i, 1, 1);
		4569	}
		4570	vc1_mc_4mv_chroma4(v, 0, 0, 0);
		4571	vc1_mc_4mv_chroma4(v, 1, 1, 1);
		4572	} else {
		4573	vc1_mc_1mv(v, 0);
		4574	vc1_interp_mc(v);
		4575	}
		4576	} else if (twomv && bmvtype == BMV_TYPE_INTERPOLATED) {
		4577	mvbp = v->fourmvbp;
		4578	for (i = 0; i < 4; i++) {
		4579	dir = i==1 \|\| i==3;
		4580	dmv_x = dmv_y = 0;
		4581	val = ((mvbp >> (3 - i)) & 1);
		4582	if (val)
		4583	get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
		4584	j = i > 1 ? 2 : 0;
		4585	vc1_pred_mv_intfr(v, j, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
		4586	vc1_mc_4mv_luma(v, j, dir, dir);
		4587	vc1_mc_4mv_luma(v, j+1, dir, dir);
		4588	}
		4589
		4590	vc1_mc_4mv_chroma4(v, 0, 0, 0);
		4591	vc1_mc_4mv_chroma4(v, 1, 1, 1);
		4592	} else if (bmvtype == BMV_TYPE_INTERPOLATED) {
		4593	mvbp = v->twomvbp;
		4594	dmv_x = dmv_y = 0;
		4595	if (mvbp & 2)
		4596	get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
		4597
		4598	vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
		4599	vc1_mc_1mv(v, 0);
		4600
		4601	dmv_x = dmv_y = 0;
		4602	if (mvbp & 1)
		4603	get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
		4604
		4605	vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 1);
		4606	vc1_interp_mc(v);
		4607	} else if (twomv) {
		4608	dir = bmvtype == BMV_TYPE_BACKWARD;
		4609	dir2 = dir;
		4610	if (mvsw)
		4611	dir2 = !dir;
		4612	mvbp = v->twomvbp;
		4613	dmv_x = dmv_y = 0;
		4614	if (mvbp & 2)
		4615	get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
		4616	vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
		4617
		4618	dmv_x = dmv_y = 0;
		4619	if (mvbp & 1)
		4620	get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
		4621	vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir2);
		4622
		4623	if (mvsw) {
		4624	for (i = 0; i < 2; i++) {
		4625	s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];
		4626	s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];
		4627	s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];
		4628	s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];
		4629	}
		4630	} else {
		4631	vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
		4632	vc1_pred_mv_intfr(v, 2, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
		4633	}
		4634
		4635	vc1_mc_4mv_luma(v, 0, dir, 0);
		4636	vc1_mc_4mv_luma(v, 1, dir, 0);
		4637	vc1_mc_4mv_luma(v, 2, dir2, 0);
		4638	vc1_mc_4mv_luma(v, 3, dir2, 0);
		4639	vc1_mc_4mv_chroma4(v, dir, dir2, 0);
		4640	} else {
		4641	dir = bmvtype == BMV_TYPE_BACKWARD;
		4642
		4643	mvbp = ff_vc1_mbmode_intfrp[0][idx_mbmode][2];
		4644	dmv_x = dmv_y = 0;
		4645	if (mvbp)
		4646	get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
		4647
		4648	vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], dir);
		4649	v->blk_mv_type[s->block_index[0]] = 1;
		4650	v->blk_mv_type[s->block_index[1]] = 1;
		4651	v->blk_mv_type[s->block_index[2]] = 1;
		4652	v->blk_mv_type[s->block_index[3]] = 1;
		4653	vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
		4654	for (i = 0; i < 2; i++) {
		4655	s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];
		4656	s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];
		4657	}
		4658	vc1_mc_1mv(v, dir);
		4659	}
		4660
		4661	if (cbp)
		4662	GET_MQUANT(); // p. 227
		4663	s->current_picture.qscale_table[mb_pos] = mquant;
		4664	if (!v->ttmbf && cbp)
		4665	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
		4666	for (i = 0; i < 6; i++) {
		4667	s->dc_val[0][s->block_index[i]] = 0;
		4668	dst_idx += i >> 2;
		4669	val = ((cbp >> (5 - i)) & 1);
		4670	if (!fieldtx)
		4671	off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
		4672	else
		4673	off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
		4674	if (val) {
		4675	pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
		4676	first_block, s->dest[dst_idx] + off,
		4677	(i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
		4678	(i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
		4679	block_cbp \|= pat << (i << 2);
		4680	if (!v->ttmbf && ttmb < 8)
		4681	ttmb = -1;
		4682	first_block = 0;
		4683	}
		4684	}
		4685
		4686	} else { // skipped
		4687	dir = 0;
		4688	for (i = 0; i < 6; i++) {
		4689	v->mb_type[0][s->block_index[i]] = 0;
		4690	s->dc_val[0][s->block_index[i]] = 0;
		4691	}
		4692	s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
		4693	s->current_picture.qscale_table[mb_pos] = 0;
		4694	v->blk_mv_type[s->block_index[0]] = 0;
		4695	v->blk_mv_type[s->block_index[1]] = 0;
		4696	v->blk_mv_type[s->block_index[2]] = 0;
		4697	v->blk_mv_type[s->block_index[3]] = 0;
		4698
		4699	if (!direct) {
		4700	if (bmvtype == BMV_TYPE_INTERPOLATED) {
		4701	vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
		4702	vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 1);
		4703	} else {
		4704	dir = bmvtype == BMV_TYPE_BACKWARD;
		4705	vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], dir);
		4706	if (mvsw) {
		4707	int dir2 = dir;
		4708	if (mvsw)
		4709	dir2 = !dir;
		4710	for (i = 0; i < 2; i++) {
		4711	s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];
		4712	s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];
		4713	s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];
		4714	s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];
		4715	}
		4716	} else {
		4717	v->blk_mv_type[s->block_index[0]] = 1;
		4718	v->blk_mv_type[s->block_index[1]] = 1;
		4719	v->blk_mv_type[s->block_index[2]] = 1;
		4720	v->blk_mv_type[s->block_index[3]] = 1;
		4721	vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
		4722	for (i = 0; i < 2; i++) {
		4723	s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];
		4724	s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];
		4725	}
		4726	}
		4727	}
		4728	}
		4729
		4730	vc1_mc_1mv(v, dir);
		4731	if (direct \|\| bmvtype == BMV_TYPE_INTERPOLATED) {
		4732	vc1_interp_mc(v);
		4733	}
		4734	}
		4735	}
		4736	if (s->mb_x == s->mb_width - 1)
		4737	memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
		4738	v->cbp[s->mb_x] = block_cbp;
		4739	v->ttblk[s->mb_x] = block_tt;
		4740	return 0;
		4741	}
		4742
		4743	/** Decode blocks of I-frame
		4744	*/
		4745	static void vc1_decode_i_blocks(VC1Context *v)
		4746	{
		4747	int k, j;
		4748	MpegEncContext *s = &v->s;
		4749	int cbp, val;
		4750	uint8_t *coded_val;
		4751	int mb_pos;
		4752
		4753	/* select codingmode used for VLC tables selection */
		4754	switch (v->y_ac_table_index) {
		4755	case 0:
		4756	v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
		4757	break;
		4758	case 1:
		4759	v->codingset = CS_HIGH_MOT_INTRA;
		4760	break;
		4761	case 2:
		4762	v->codingset = CS_MID_RATE_INTRA;
		4763	break;
		4764	}
		4765
		4766	switch (v->c_ac_table_index) {
		4767	case 0:
		4768	v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
		4769	break;
		4770	case 1:
		4771	v->codingset2 = CS_HIGH_MOT_INTER;
		4772	break;
		4773	case 2:
		4774	v->codingset2 = CS_MID_RATE_INTER;
		4775	break;
		4776	}
		4777
		4778	/* Set DC scale - y and c use the same */
		4779	s->y_dc_scale = s->y_dc_scale_table[v->pq];
		4780	s->c_dc_scale = s->c_dc_scale_table[v->pq];
		4781
		4782	//do frame decode
		4783	s->mb_x = s->mb_y = 0;
		4784	s->mb_intra = 1;
		4785	s->first_slice_line = 1;
		4786	for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
		4787	s->mb_x = 0;
		4788	init_block_index(v);
		4789	for (; s->mb_x < v->end_mb_x; s->mb_x++) {
		4790	uint8_t *dst[6];
		4791	ff_update_block_index(s);
		4792	dst[0] = s->dest[0];
		4793	dst[1] = dst[0] + 8;
		4794	dst[2] = s->dest[0] + s->linesize * 8;
		4795	dst[3] = dst[2] + 8;
		4796	dst[4] = s->dest[1];
		4797	dst[5] = s->dest[2];
		4798	s->dsp.clear_blocks(s->block[0]);
		4799	mb_pos = s->mb_x + s->mb_y * s->mb_width;
		4800	s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
		4801	s->current_picture.qscale_table[mb_pos] = v->pq;
		4802	s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
		4803	s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
		4804
		4805	// do actual MB decoding and displaying
		4806	cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
		4807	v->s.ac_pred = get_bits1(&v->s.gb);
		4808
		4809	for (k = 0; k < 6; k++) {
		4810	val = ((cbp >> (5 - k)) & 1);
		4811
		4812	if (k < 4) {
		4813	int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
		4814	val = val ^ pred;
		4815	*coded_val = val;
		4816	}
		4817	cbp \|= val << (5 - k);
		4818
		4819	vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
		4820
		4821	if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
		4822	continue;
		4823	v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
		4824	if (v->pq >= 9 && v->overlap) {
		4825	if (v->rangeredfrm)
		4826	for (j = 0; j < 64; j++)
		4827	s->block[k][j] <<= 1;
		4828	s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
		4829	} else {
		4830	if (v->rangeredfrm)
		4831	for (j = 0; j < 64; j++)
		4832	s->block[k][j] = (s->block[k][j] - 64) << 1;
		4833	s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
		4834	}
		4835	}
		4836
		4837	if (v->pq >= 9 && v->overlap) {
		4838	if (s->mb_x) {
		4839	v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
		4840	v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
		4841	if (!(s->flags & CODEC_FLAG_GRAY)) {
		4842	v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
		4843	v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
		4844	}
		4845	}
		4846	v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
		4847	v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
		4848	if (!s->first_slice_line) {
		4849	v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
		4850	v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
		4851	if (!(s->flags & CODEC_FLAG_GRAY)) {
		4852	v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
		4853	v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
		4854	}
		4855	}
		4856	v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
		4857	v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
		4858	}
		4859	if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
		4860
		4861	if (get_bits_count(&s->gb) > v->bits) {
		4862	ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
		4863	av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
		4864	get_bits_count(&s->gb), v->bits);
		4865	return;
		4866	}
		4867	}
		4868	if (!v->s.loop_filter)
		4869	ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
		4870	else if (s->mb_y)
		4871	ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
		4872
		4873	s->first_slice_line = 0;
		4874	}
		4875	if (v->s.loop_filter)
		4876	ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
		4877
		4878	/* This is intentionally mb_height and not end_mb_y - unlike in advanced
		4879	* profile, these only differ are when decoding MSS2 rectangles. */
		4880	ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
		4881	}
		4882
		4883	/** Decode blocks of I-frame for advanced profile
		4884	*/
		4885	static void vc1_decode_i_blocks_adv(VC1Context *v)
		4886	{
		4887	int k;
		4888	MpegEncContext *s = &v->s;
		4889	int cbp, val;
		4890	uint8_t *coded_val;
		4891	int mb_pos;
		4892	int mquant = v->pq;
		4893	int mqdiff;
		4894	GetBitContext *gb = &s->gb;
		4895
		4896	/* select codingmode used for VLC tables selection */
		4897	switch (v->y_ac_table_index) {
		4898	case 0:
		4899	v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
		4900	break;
		4901	case 1:
		4902	v->codingset = CS_HIGH_MOT_INTRA;
		4903	break;
		4904	case 2:
		4905	v->codingset = CS_MID_RATE_INTRA;
		4906	break;
		4907	}
		4908
		4909	switch (v->c_ac_table_index) {
		4910	case 0:
		4911	v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
		4912	break;
		4913	case 1:
		4914	v->codingset2 = CS_HIGH_MOT_INTER;
		4915	break;
		4916	case 2:
		4917	v->codingset2 = CS_MID_RATE_INTER;
		4918	break;
		4919	}
		4920
		4921	// do frame decode
		4922	s->mb_x = s->mb_y = 0;
		4923	s->mb_intra = 1;
		4924	s->first_slice_line = 1;
		4925	s->mb_y = s->start_mb_y;
		4926	if (s->start_mb_y) {
		4927	s->mb_x = 0;
		4928	init_block_index(v);
		4929	memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
		4930	(1 + s->b8_stride) * sizeof(*s->coded_block));
		4931	}
		4932	for (; s->mb_y < s->end_mb_y; s->mb_y++) {
		4933	s->mb_x = 0;
		4934	init_block_index(v);
		4935	for (;s->mb_x < s->mb_width; s->mb_x++) {
		4936	int16_t (*block)[64] = v->block[v->cur_blk_idx];
		4937	ff_update_block_index(s);
		4938	s->dsp.clear_blocks(block[0]);
		4939	mb_pos = s->mb_x + s->mb_y * s->mb_stride;
		4940	s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
		4941	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
		4942	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
		4943
		4944	// do actual MB decoding and displaying
		4945	if (v->fieldtx_is_raw)
		4946	v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
		4947	cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
		4948	if ( v->acpred_is_raw)
		4949	v->s.ac_pred = get_bits1(&v->s.gb);
		4950	else
		4951	v->s.ac_pred = v->acpred_plane[mb_pos];
		4952
		4953	if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
		4954	v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
		4955
		4956	GET_MQUANT();
		4957
		4958	s->current_picture.qscale_table[mb_pos] = mquant;
		4959	/* Set DC scale - y and c use the same */
		4960	s->y_dc_scale = s->y_dc_scale_table[mquant];
		4961	s->c_dc_scale = s->c_dc_scale_table[mquant];
		4962
		4963	for (k = 0; k < 6; k++) {
		4964	val = ((cbp >> (5 - k)) & 1);
		4965
		4966	if (k < 4) {
		4967	int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
		4968	val = val ^ pred;
		4969	*coded_val = val;
		4970	}
		4971	cbp \|= val << (5 - k);
		4972
		4973	v->a_avail = !s->first_slice_line \|\| (k == 2 \|\| k == 3);
		4974	v->c_avail = !!s->mb_x \|\| (k == 1 \|\| k == 3);
		4975
		4976	vc1_decode_i_block_adv(v, block[k], k, val,
		4977	(k < 4) ? v->codingset : v->codingset2, mquant);
		4978
		4979	if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
		4980	continue;
		4981	v->vc1dsp.vc1_inv_trans_8x8(block[k]);
		4982	}
		4983
		4984	vc1_smooth_overlap_filter_iblk(v);
		4985	vc1_put_signed_blocks_clamped(v);
		4986	if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
		4987
		4988	if (get_bits_count(&s->gb) > v->bits) {
		4989	// TODO: may need modification to handle slice coding
		4990	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
		4991	av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
		4992	get_bits_count(&s->gb), v->bits);
		4993	return;
		4994	}
		4995	}
		4996	if (!v->s.loop_filter)
		4997	ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
		4998	else if (s->mb_y)
		4999	ff_mpeg_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
		5000	s->first_slice_line = 0;
		5001	}
		5002
		5003	/* raw bottom MB row */
		5004	s->mb_x = 0;
		5005	init_block_index(v);
		5006
		5007	for (;s->mb_x < s->mb_width; s->mb_x++) {
		5008	ff_update_block_index(s);
		5009	vc1_put_signed_blocks_clamped(v);
		5010	if (v->s.loop_filter)
		5011	vc1_loop_filter_iblk_delayed(v, v->pq);
		5012	}
		5013	if (v->s.loop_filter)
		5014	ff_mpeg_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
		5015	ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
		5016	(s->end_mb_y << v->field_mode) - 1, ER_MB_END);
		5017	}
		5018
		5019	static void vc1_decode_p_blocks(VC1Context *v)
		5020	{
		5021	MpegEncContext *s = &v->s;
		5022	int apply_loop_filter;
		5023
		5024	/* select codingmode used for VLC tables selection */
		5025	switch (v->c_ac_table_index) {
		5026	case 0:
		5027	v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
		5028	break;
		5029	case 1:
		5030	v->codingset = CS_HIGH_MOT_INTRA;
		5031	break;
		5032	case 2:
		5033	v->codingset = CS_MID_RATE_INTRA;
		5034	break;
		5035	}
		5036
		5037	switch (v->c_ac_table_index) {
		5038	case 0:
		5039	v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
		5040	break;
		5041	case 1:
		5042	v->codingset2 = CS_HIGH_MOT_INTER;
		5043	break;
		5044	case 2:
		5045	v->codingset2 = CS_MID_RATE_INTER;
		5046	break;
		5047	}
		5048
		5049	apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY) &&
		5050	v->fcm == PROGRESSIVE;
		5051	s->first_slice_line = 1;
		5052	memset(v->cbp_base, 0, sizeof(v->cbp_base[0])2s->mb_stride);
		5053	for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
		5054	s->mb_x = 0;
		5055	init_block_index(v);
		5056	for (; s->mb_x < s->mb_width; s->mb_x++) {
		5057	ff_update_block_index(s);
		5058
		5059	if (v->fcm == ILACE_FIELD)
		5060	vc1_decode_p_mb_intfi(v);
		5061	else if (v->fcm == ILACE_FRAME)
		5062	vc1_decode_p_mb_intfr(v);
		5063	else vc1_decode_p_mb(v);
		5064	if (s->mb_y != s->start_mb_y && apply_loop_filter)
		5065	vc1_apply_p_loop_filter(v);
		5066	if (get_bits_count(&s->gb) > v->bits \|\| get_bits_count(&s->gb) < 0) {
		5067	// TODO: may need modification to handle slice coding
		5068	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
		5069	av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
		5070	get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
		5071	return;
		5072	}
		5073	}
		5074	memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
		5075	memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
		5076	memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
		5077	memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
		5078	if (s->mb_y != s->start_mb_y) ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
		5079	s->first_slice_line = 0;
		5080	}
		5081	if (apply_loop_filter) {
		5082	s->mb_x = 0;
		5083	init_block_index(v);
		5084	for (; s->mb_x < s->mb_width; s->mb_x++) {
		5085	ff_update_block_index(s);
		5086	vc1_apply_p_loop_filter(v);
		5087	}
		5088	}
		5089	if (s->end_mb_y >= s->start_mb_y)
		5090	ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
		5091	ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
		5092	(s->end_mb_y << v->field_mode) - 1, ER_MB_END);
		5093	}
		5094
		5095	static void vc1_decode_b_blocks(VC1Context *v)
		5096	{
		5097	MpegEncContext *s = &v->s;
		5098
		5099	/* select codingmode used for VLC tables selection */
		5100	switch (v->c_ac_table_index) {
		5101	case 0:
		5102	v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
		5103	break;
		5104	case 1:
		5105	v->codingset = CS_HIGH_MOT_INTRA;
		5106	break;
		5107	case 2:
		5108	v->codingset = CS_MID_RATE_INTRA;
		5109	break;
		5110	}
		5111
		5112	switch (v->c_ac_table_index) {
		5113	case 0:
		5114	v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
		5115	break;
		5116	case 1:
		5117	v->codingset2 = CS_HIGH_MOT_INTER;
		5118	break;
		5119	case 2:
		5120	v->codingset2 = CS_MID_RATE_INTER;
		5121	break;
		5122	}
		5123
		5124	s->first_slice_line = 1;
		5125	for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
		5126	s->mb_x = 0;
		5127	init_block_index(v);
		5128	for (; s->mb_x < s->mb_width; s->mb_x++) {
		5129	ff_update_block_index(s);
		5130
		5131	if (v->fcm == ILACE_FIELD)
		5132	vc1_decode_b_mb_intfi(v);
		5133	else if (v->fcm == ILACE_FRAME)
		5134	vc1_decode_b_mb_intfr(v);
		5135	else
		5136	vc1_decode_b_mb(v);
		5137	if (get_bits_count(&s->gb) > v->bits \|\| get_bits_count(&s->gb) < 0) {
		5138	// TODO: may need modification to handle slice coding
		5139	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
		5140	av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
		5141	get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
		5142	return;
		5143	}
		5144	if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
		5145	}
		5146	if (!v->s.loop_filter)
		5147	ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
		5148	else if (s->mb_y)
		5149	ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
		5150	s->first_slice_line = 0;
		5151	}
		5152	if (v->s.loop_filter)
		5153	ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
		5154	ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
		5155	(s->end_mb_y << v->field_mode) - 1, ER_MB_END);
		5156	}
		5157
		5158	static void vc1_decode_skip_blocks(VC1Context *v)
		5159	{
		5160	MpegEncContext *s = &v->s;
		5161
		5162	if (!v->s.last_picture.f.data[0])
		5163	return;
		5164
		5165	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
		5166	s->first_slice_line = 1;
		5167	for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
		5168	s->mb_x = 0;
		5169	init_block_index(v);
		5170	ff_update_block_index(s);
		5171	memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
		5172	memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
		5173	memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
		5174	ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
		5175	s->first_slice_line = 0;
		5176	}
		5177	s->pict_type = AV_PICTURE_TYPE_P;
		5178	}
		5179
		5180	void ff_vc1_decode_blocks(VC1Context *v)
		5181	{
		5182
		5183	v->s.esc3_level_length = 0;
		5184	if (v->x8_type) {
		5185	ff_intrax8_decode_picture(&v->x8, 2v->pq + v->halfpq, v->pq !v->pquantizer);
		5186	} else {
		5187	v->cur_blk_idx = 0;
		5188	v->left_blk_idx = -1;
		5189	v->topleft_blk_idx = 1;
		5190	v->top_blk_idx = 2;
		5191	switch (v->s.pict_type) {
		5192	case AV_PICTURE_TYPE_I:
		5193	if (v->profile == PROFILE_ADVANCED)
		5194	vc1_decode_i_blocks_adv(v);
		5195	else
		5196	vc1_decode_i_blocks(v);
		5197	break;
		5198	case AV_PICTURE_TYPE_P:
		5199	if (v->p_frame_skipped)
		5200	vc1_decode_skip_blocks(v);
		5201	else
		5202	vc1_decode_p_blocks(v);
		5203	break;
		5204	case AV_PICTURE_TYPE_B:
		5205	if (v->bi_type) {
		5206	if (v->profile == PROFILE_ADVANCED)
		5207	vc1_decode_i_blocks_adv(v);
		5208	else
		5209	vc1_decode_i_blocks(v);
		5210	} else
		5211	vc1_decode_b_blocks(v);
		5212	break;
		5213	}
		5214	}
		5215	}
		5216
		5217	#if CONFIG_WMV3IMAGE_DECODER \|\| CONFIG_VC1IMAGE_DECODER
		5218
		5219	typedef struct {
		5220	/**
		5221	* Transform coefficients for both sprites in 16.16 fixed point format,
		5222	* in the order they appear in the bitstream:
		5223	* x scale
		5224	* rotation 1 (unused)
		5225	* x offset
		5226	* rotation 2 (unused)
		5227	* y scale
		5228	* y offset
		5229	* alpha
		5230	*/
		5231	int coefs[2][7];
		5232
		5233	int effect_type, effect_flag;
		5234	int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
		5235	int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
		5236	} SpriteData;
		5237
		5238	static inline int get_fp_val(GetBitContext* gb)
		5239	{
		5240	return (get_bits_long(gb, 30) - (1 << 29)) << 1;
		5241	}
		5242
		5243	static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
		5244	{
		5245	c[1] = c[3] = 0;
		5246
		5247	switch (get_bits(gb, 2)) {
		5248	case 0:
		5249	c[0] = 1 << 16;
		5250	c[2] = get_fp_val(gb);
		5251	c[4] = 1 << 16;
		5252	break;
		5253	case 1:
		5254	c[0] = c[4] = get_fp_val(gb);
		5255	c[2] = get_fp_val(gb);
		5256	break;
		5257	case 2:
		5258	c[0] = get_fp_val(gb);
		5259	c[2] = get_fp_val(gb);
		5260	c[4] = get_fp_val(gb);
		5261	break;
		5262	case 3:
		5263	c[0] = get_fp_val(gb);
		5264	c[1] = get_fp_val(gb);
		5265	c[2] = get_fp_val(gb);
		5266	c[3] = get_fp_val(gb);
		5267	c[4] = get_fp_val(gb);
		5268	break;
		5269	}
		5270	c[5] = get_fp_val(gb);
		5271	if (get_bits1(gb))
		5272	c[6] = get_fp_val(gb);
		5273	else
		5274	c[6] = 1 << 16;
		5275	}
		5276
		5277	static void vc1_parse_sprites(VC1Context v, GetBitContext gb, SpriteData* sd)
		5278	{
		5279	AVCodecContext *avctx = v->s.avctx;
		5280	int sprite, i;
		5281
		5282	for (sprite = 0; sprite <= v->two_sprites; sprite++) {
		5283	vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
		5284	if (sd->coefs[sprite][1] \|\| sd->coefs[sprite][3])
		5285	avpriv_request_sample(avctx, "Non-zero rotation coefficients");
		5286	av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
		5287	for (i = 0; i < 7; i++)
		5288	av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
		5289	sd->coefs[sprite][i] / (1<<16),
		5290	(abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
		5291	av_log(avctx, AV_LOG_DEBUG, "\n");
		5292	}
		5293
		5294	skip_bits(gb, 2);
		5295	if (sd->effect_type = get_bits_long(gb, 30)) {
		5296	switch (sd->effect_pcount1 = get_bits(gb, 4)) {
		5297	case 7:
		5298	vc1_sprite_parse_transform(gb, sd->effect_params1);
		5299	break;
		5300	case 14:
		5301	vc1_sprite_parse_transform(gb, sd->effect_params1);
		5302	vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
		5303	break;
		5304	default:
		5305	for (i = 0; i < sd->effect_pcount1; i++)
		5306	sd->effect_params1[i] = get_fp_val(gb);
		5307	}
		5308	if (sd->effect_type != 13 \|\| sd->effect_params1[0] != sd->coefs[0][6]) {
		5309	// effect 13 is simple alpha blending and matches the opacity above
		5310	av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
		5311	for (i = 0; i < sd->effect_pcount1; i++)
		5312	av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
		5313	sd->effect_params1[i] / (1 << 16),
		5314	(abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
		5315	av_log(avctx, AV_LOG_DEBUG, "\n");
		5316	}
		5317
		5318	sd->effect_pcount2 = get_bits(gb, 16);
		5319	if (sd->effect_pcount2 > 10) {
		5320	av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
		5321	return;
		5322	} else if (sd->effect_pcount2) {
		5323	i = -1;
		5324	av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
		5325	while (++i < sd->effect_pcount2) {
		5326	sd->effect_params2[i] = get_fp_val(gb);
		5327	av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
		5328	sd->effect_params2[i] / (1 << 16),
		5329	(abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
		5330	}
		5331	av_log(avctx, AV_LOG_DEBUG, "\n");
		5332	}
		5333	}
		5334	if (sd->effect_flag = get_bits1(gb))
		5335	av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
		5336
		5337	if (get_bits_count(gb) >= gb->size_in_bits +
		5338	(avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
		5339	av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
		5340	if (get_bits_count(gb) < gb->size_in_bits - 8)
		5341	av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
		5342	}
		5343
		5344	static void vc1_draw_sprites(VC1Context v, SpriteData sd)
		5345	{
		5346	int i, plane, row, sprite;
		5347	int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
		5348	uint8_t* src_h[2][2];
		5349	int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
		5350	int ysub[2];
		5351	MpegEncContext *s = &v->s;
		5352
		5353	for (i = 0; i < 2; i++) {
		5354	xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
		5355	xadv[i] = sd->coefs[i][0];
		5356	if (xadv[i] != 1<<16 \|\| (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
		5357	xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
		5358
		5359	yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
		5360	yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
		5361	}
		5362	alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
		5363
		5364	for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
		5365	int width = v->output_width>>!!plane;
		5366
		5367	for (row = 0; row < v->output_height>>!!plane; row++) {
		5368	uint8_t *dst = v->sprite_output_frame.data[plane] +
		5369	v->sprite_output_frame.linesize[plane] * row;
		5370
		5371	for (sprite = 0; sprite <= v->two_sprites; sprite++) {
		5372	uint8_t *iplane = s->current_picture.f.data[plane];
		5373	int iline = s->current_picture.f.linesize[plane];
		5374	int ycoord = yoff[sprite] + yadv[sprite] * row;
		5375	int yline = ycoord >> 16;
		5376	int next_line;
		5377	ysub[sprite] = ycoord & 0xFFFF;
		5378	if (sprite) {
		5379	iplane = s->last_picture.f.data[plane];
		5380	iline = s->last_picture.f.linesize[plane];
		5381	}
		5382	next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
		5383	if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
		5384	src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
		5385	if (ysub[sprite])
		5386	src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
		5387	} else {
		5388	if (sr_cache[sprite][0] != yline) {
		5389	if (sr_cache[sprite][1] == yline) {
		5390	FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
		5391	FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
		5392	} else {
		5393	v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
		5394	sr_cache[sprite][0] = yline;
		5395	}
		5396	}
		5397	if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
		5398	v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
		5399	iplane + next_line, xoff[sprite],
		5400	xadv[sprite], width);
		5401	sr_cache[sprite][1] = yline + 1;
		5402	}
		5403	src_h[sprite][0] = v->sr_rows[sprite][0];
		5404	src_h[sprite][1] = v->sr_rows[sprite][1];
		5405	}
		5406	}
		5407
		5408	if (!v->two_sprites) {
		5409	if (ysub[0]) {
		5410	v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
		5411	} else {
		5412	memcpy(dst, src_h[0][0], width);
		5413	}
		5414	} else {
		5415	if (ysub[0] && ysub[1]) {
		5416	v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
		5417	src_h[1][0], src_h[1][1], ysub[1], alpha, width);
		5418	} else if (ysub[0]) {
		5419	v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
		5420	src_h[1][0], alpha, width);
		5421	} else if (ysub[1]) {
		5422	v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
		5423	src_h[0][0], (1<<16)-1-alpha, width);
		5424	} else {
		5425	v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
		5426	}
		5427	}
		5428	}
		5429
		5430	if (!plane) {
		5431	for (i = 0; i < 2; i++) {
		5432	xoff[i] >>= 1;
		5433	yoff[i] >>= 1;
		5434	}
		5435	}
		5436
		5437	}
		5438	}
		5439
		5440
		5441	static int vc1_decode_sprites(VC1Context v, GetBitContext gb)
		5442	{
		5443	int ret;
		5444	MpegEncContext *s = &v->s;
		5445	AVCodecContext *avctx = s->avctx;
		5446	SpriteData sd;
		5447
		5448	vc1_parse_sprites(v, gb, &sd);
		5449
		5450	if (!s->current_picture.f.data[0]) {
		5451	av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
		5452	return -1;
		5453	}
		5454
		5455	if (v->two_sprites && (!s->last_picture_ptr \|\| !s->last_picture.f.data[0])) {
		5456	av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
		5457	v->two_sprites = 0;
		5458	}
		5459
		5460	av_frame_unref(&v->sprite_output_frame);
		5461	if ((ret = ff_get_buffer(avctx, &v->sprite_output_frame, 0)) < 0)
		5462	return ret;
		5463
		5464	vc1_draw_sprites(v, &sd);
		5465
		5466	return 0;
		5467	}
		5468
		5469	static void vc1_sprite_flush(AVCodecContext *avctx)
		5470	{
		5471	VC1Context *v = avctx->priv_data;
		5472	MpegEncContext *s = &v->s;
		5473	AVFrame *f = &s->current_picture.f;
		5474	int plane, i;
		5475
		5476	/* Windows Media Image codecs have a convergence interval of two keyframes.
		5477	Since we can't enforce it, clear to black the missing sprite. This is
		5478	wrong but it looks better than doing nothing. */
		5479
		5480	if (f->data[0])
		5481	for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
		5482	for (i = 0; i < v->sprite_height>>!!plane; i++)
		5483	memset(f->data[plane] + i * f->linesize[plane],
		5484	plane ? 128 : 0, f->linesize[plane]);
		5485	}
		5486
		5487	#endif
		5488
		5489	av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
		5490	{
		5491	MpegEncContext *s = &v->s;
		5492	int i;
		5493
		5494	/* Allocate mb bitplanes */
		5495	v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
		5496	v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
		5497	v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
		5498	v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
		5499	v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
		5500	v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
		5501
		5502	v->n_allocated_blks = s->mb_width + 2;
		5503	v->block = av_malloc(sizeof(v->block) v->n_allocated_blks);
		5504	v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
		5505	v->cbp = v->cbp_base + s->mb_stride;
		5506	v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
		5507	v->ttblk = v->ttblk_base + s->mb_stride;
		5508	v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
		5509	v->is_intra = v->is_intra_base + s->mb_stride;
		5510	v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
		5511	v->luma_mv = v->luma_mv_base + s->mb_stride;
		5512
		5513	/* allocate block type info in that way so it could be used with s->block_index[] */
		5514	v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
		5515	v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
		5516	v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
		5517	v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
		5518
		5519	/* allocate memory to store block level MV info */
		5520	v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
		5521	v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
		5522	v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
		5523	v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
		5524	v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
		5525	v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
		5526	v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
		5527	v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
		5528
		5529	/* Init coded blocks info */
		5530	if (v->profile == PROFILE_ADVANCED) {
		5531	// if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
		5532	// return -1;
		5533	// if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
		5534	// return -1;
		5535	}
		5536
		5537	ff_intrax8_common_init(&v->x8,s);
		5538
		5539	if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE \|\| s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
		5540	for (i = 0; i < 4; i++)
		5541	if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
		5542	return AVERROR(ENOMEM);
		5543	}
		5544
		5545	if (!v->mv_type_mb_plane \|\| !v->direct_mb_plane \|\| !v->acpred_plane \|\| !v->over_flags_plane \|\|
		5546	!v->block \|\| !v->cbp_base \|\| !v->ttblk_base \|\| !v->is_intra_base \|\| !v->luma_mv_base \|\|
		5547	!v->mb_type_base) {
		5548	av_freep(&v->mv_type_mb_plane);
		5549	av_freep(&v->direct_mb_plane);
		5550	av_freep(&v->acpred_plane);
		5551	av_freep(&v->over_flags_plane);
		5552	av_freep(&v->block);
		5553	av_freep(&v->cbp_base);
		5554	av_freep(&v->ttblk_base);
		5555	av_freep(&v->is_intra_base);
		5556	av_freep(&v->luma_mv_base);
		5557	av_freep(&v->mb_type_base);
		5558	return AVERROR(ENOMEM);
		5559	}
		5560
		5561	return 0;
		5562	}
		5563
		5564	av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
		5565	{
		5566	int i;
		5567	for (i = 0; i < 64; i++) {
		5568	#define transpose(x) ((x >> 3) \| ((x & 7) << 3))
		5569	v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
		5570	v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
		5571	v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
		5572	v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
		5573	v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
		5574	}
		5575	v->left_blk_sh = 0;
		5576	v->top_blk_sh = 3;
		5577	}
		5578
		5579	/** Initialize a VC1/WMV3 decoder
		5580	* @todo TODO: Handle VC-1 IDUs (Transport level?)
		5581	* @todo TODO: Decypher remaining bits in extra_data
		5582	*/
		5583	static av_cold int vc1_decode_init(AVCodecContext *avctx)
		5584	{
		5585	VC1Context *v = avctx->priv_data;
		5586	MpegEncContext *s = &v->s;
		5587	GetBitContext gb;
		5588	int ret;
		5589
		5590	/* save the container output size for WMImage */
		5591	v->output_width = avctx->width;
		5592	v->output_height = avctx->height;
		5593
		5594	if (!avctx->extradata_size \|\| !avctx->extradata)
		5595	return -1;
		5596	if (!(avctx->flags & CODEC_FLAG_GRAY))
		5597	avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
		5598	else
		5599	avctx->pix_fmt = AV_PIX_FMT_GRAY8;
		5600	avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
		5601	v->s.avctx = avctx;
		5602	avctx->flags \|= CODEC_FLAG_EMU_EDGE;
		5603	v->s.flags \|= CODEC_FLAG_EMU_EDGE;
		5604
		5605	if ((ret = ff_vc1_init_common(v)) < 0)
		5606	return ret;
		5607	// ensure static VLC tables are initialized
		5608	if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
		5609	return ret;
		5610	if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
		5611	return ret;
		5612	// Hack to ensure the above functions will be called
		5613	// again once we know all necessary settings.
		5614	// That this is necessary might indicate a bug.
		5615	ff_vc1_decode_end(avctx);
		5616
		5617	ff_h264chroma_init(&v->h264chroma, 8);
		5618	ff_vc1dsp_init(&v->vc1dsp);
		5619
		5620	if (avctx->codec_id == AV_CODEC_ID_WMV3 \|\| avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
		5621	int count = 0;
		5622
		5623	// looks like WMV3 has a sequence header stored in the extradata
		5624	// advanced sequence header may be before the first frame
		5625	// the last byte of the extradata is a version number, 1 for the
		5626	// samples we can decode
		5627
		5628	init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
		5629
		5630	if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
		5631	return ret;
		5632
		5633	count = avctx->extradata_size*8 - get_bits_count(&gb);
		5634	if (count > 0) {
		5635	av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
		5636	count, get_bits(&gb, count));
		5637	} else if (count < 0) {
		5638	av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
		5639	}
		5640	} else { // VC1/WVC1/WVP2
		5641	const uint8_t *start = avctx->extradata;
		5642	uint8_t *end = avctx->extradata + avctx->extradata_size;
		5643	const uint8_t *next;
		5644	int size, buf2_size;
		5645	uint8_t *buf2 = NULL;
		5646	int seq_initialized = 0, ep_initialized = 0;
		5647
		5648	if (avctx->extradata_size < 16) {
		5649	av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
		5650	return -1;
		5651	}
		5652
		5653	buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
		5654	start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
		5655	next = start;
		5656	for (; next < end; start = next) {
		5657	next = find_next_marker(start + 4, end);
		5658	size = next - start - 4;
		5659	if (size <= 0)
		5660	continue;
		5661	buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
		5662	init_get_bits(&gb, buf2, buf2_size * 8);
		5663	switch (AV_RB32(start)) {
		5664	case VC1_CODE_SEQHDR:
		5665	if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
		5666	av_free(buf2);
		5667	return ret;
		5668	}
		5669	seq_initialized = 1;
		5670	break;
		5671	case VC1_CODE_ENTRYPOINT:
		5672	if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
		5673	av_free(buf2);
		5674	return ret;
		5675	}
		5676	ep_initialized = 1;
		5677	break;
		5678	}
		5679	}
		5680	av_free(buf2);
		5681	if (!seq_initialized \|\| !ep_initialized) {
		5682	av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
		5683	return -1;
		5684	}
		5685	v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
		5686	}
		5687
		5688	avctx->profile = v->profile;
		5689	if (v->profile == PROFILE_ADVANCED)
		5690	avctx->level = v->level;
		5691
		5692	avctx->has_b_frames = !!avctx->max_b_frames;
		5693
		5694	s->mb_width = (avctx->coded_width + 15) >> 4;
		5695	s->mb_height = (avctx->coded_height + 15) >> 4;
		5696
		5697	if (v->profile == PROFILE_ADVANCED \|\| v->res_fasttx) {
		5698	ff_vc1_init_transposed_scantables(v);
		5699	} else {
		5700	memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
		5701	v->left_blk_sh = 3;
		5702	v->top_blk_sh = 0;
		5703	}
		5704
		5705	if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
		5706	v->sprite_width = avctx->coded_width;
		5707	v->sprite_height = avctx->coded_height;
		5708
		5709	avctx->coded_width = avctx->width = v->output_width;
		5710	avctx->coded_height = avctx->height = v->output_height;
		5711
		5712	// prevent 16.16 overflows
		5713	if (v->sprite_width > 1 << 14 \|\|
		5714	v->sprite_height > 1 << 14 \|\|
		5715	v->output_width > 1 << 14 \|\|
		5716	v->output_height > 1 << 14) return -1;
		5717
		5718	if ((v->sprite_width&1) \|\| (v->sprite_height&1)) {
		5719	avpriv_request_sample(avctx, "odd sprites support");
		5720	return AVERROR_PATCHWELCOME;
		5721	}
		5722	}
		5723	return 0;
		5724	}
		5725
		5726	/** Close a VC1/WMV3 decoder
		5727	* @warning Initial try at using MpegEncContext stuff
		5728	*/
		5729	av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
		5730	{
		5731	VC1Context *v = avctx->priv_data;
		5732	int i;
		5733
		5734	av_frame_unref(&v->sprite_output_frame);
		5735
		5736	for (i = 0; i < 4; i++)
		5737	av_freep(&v->sr_rows[i >> 1][i & 1]);
		5738	av_freep(&v->hrd_rate);
		5739	av_freep(&v->hrd_buffer);
		5740	ff_MPV_common_end(&v->s);
		5741	av_freep(&v->mv_type_mb_plane);
		5742	av_freep(&v->direct_mb_plane);
		5743	av_freep(&v->forward_mb_plane);
		5744	av_freep(&v->fieldtx_plane);
		5745	av_freep(&v->acpred_plane);
		5746	av_freep(&v->over_flags_plane);
		5747	av_freep(&v->mb_type_base);
		5748	av_freep(&v->blk_mv_type_base);
		5749	av_freep(&v->mv_f_base);
		5750	av_freep(&v->mv_f_next_base);
		5751	av_freep(&v->block);
		5752	av_freep(&v->cbp_base);
		5753	av_freep(&v->ttblk_base);
		5754	av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
		5755	av_freep(&v->luma_mv_base);
		5756	ff_intrax8_common_end(&v->x8);
		5757	return 0;
		5758	}
		5759
		5760
		5761	/** Decode a VC1/WMV3 frame
		5762	* @todo TODO: Handle VC-1 IDUs (Transport level?)
		5763	*/
		5764	static int vc1_decode_frame(AVCodecContext avctx, void data,
		5765	int got_frame, AVPacket avpkt)
		5766	{
		5767	const uint8_t *buf = avpkt->data;
		5768	int buf_size = avpkt->size, n_slices = 0, i, ret;
		5769	VC1Context *v = avctx->priv_data;
		5770	MpegEncContext *s = &v->s;
		5771	AVFrame *pict = data;
		5772	uint8_t *buf2 = NULL;
		5773	const uint8_t buf_start = buf, buf_start_second_field = NULL;
		5774	int mb_height, n_slices1=-1;
		5775	struct {
		5776	uint8_t *buf;
		5777	GetBitContext gb;
		5778	int mby_start;
		5779	} slices = NULL, tmp;
		5780
		5781	v->second_field = 0;
		5782
		5783	if(s->flags & CODEC_FLAG_LOW_DELAY)
		5784	s->low_delay = 1;
		5785
		5786	/* no supplementary picture */
		5787	if (buf_size == 0 \|\| (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
		5788	/* special case for last picture */
		5789	if (s->low_delay == 0 && s->next_picture_ptr) {
		5790	if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
		5791	return ret;
		5792	s->next_picture_ptr = NULL;
		5793
		5794	*got_frame = 1;
		5795	}
		5796
		5797	return buf_size;
		5798	}
		5799
		5800	if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
		5801	if (v->profile < PROFILE_ADVANCED)
		5802	avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
		5803	else
		5804	avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
		5805	}
		5806
		5807	//for advanced profile we may need to parse and unescape data
		5808	if (avctx->codec_id == AV_CODEC_ID_VC1 \|\| avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
		5809	int buf_size2 = 0;
		5810	buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
		5811	if (!buf2)
		5812	return AVERROR(ENOMEM);
		5813
		5814	if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
		5815	const uint8_t start, end, *next;
		5816	int size;
		5817
		5818	next = buf;
		5819	for (start = buf, end = buf + buf_size; next < end; start = next) {
		5820	next = find_next_marker(start + 4, end);
		5821	size = next - start - 4;
		5822	if (size <= 0) continue;
		5823	switch (AV_RB32(start)) {
		5824	case VC1_CODE_FRAME:
		5825	if (avctx->hwaccel \|\|
		5826	s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
		5827	buf_start = start;
		5828	buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
		5829	break;
		5830	case VC1_CODE_FIELD: {
		5831	int buf_size3;
		5832	if (avctx->hwaccel \|\|
		5833	s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
		5834	buf_start_second_field = start;
		5835	tmp = av_realloc(slices, sizeof(slices) (n_slices+1));
		5836	if (!tmp)
		5837	goto err;
		5838	slices = tmp;
		5839	slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
		5840	if (!slices[n_slices].buf)
		5841	goto err;
		5842	buf_size3 = vc1_unescape_buffer(start + 4, size,
		5843	slices[n_slices].buf);
		5844	init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
		5845	buf_size3 << 3);
		5846	/* assuming that the field marker is at the exact middle,
		5847	hope it's correct */
		5848	slices[n_slices].mby_start = s->mb_height >> 1;
		5849	n_slices1 = n_slices - 1; // index of the last slice of the first field
		5850	n_slices++;
		5851	break;
		5852	}
		5853	case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
		5854	buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
		5855	init_get_bits(&s->gb, buf2, buf_size2 * 8);
		5856	ff_vc1_decode_entry_point(avctx, v, &s->gb);
		5857	break;
		5858	case VC1_CODE_SLICE: {
		5859	int buf_size3;
		5860	tmp = av_realloc(slices, sizeof(slices) (n_slices+1));
		5861	if (!tmp)
		5862	goto err;
		5863	slices = tmp;
		5864	slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
		5865	if (!slices[n_slices].buf)
		5866	goto err;
		5867	buf_size3 = vc1_unescape_buffer(start + 4, size,
		5868	slices[n_slices].buf);
		5869	init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
		5870	buf_size3 << 3);
		5871	slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
		5872	n_slices++;
		5873	break;
		5874	}
		5875	}
		5876	}
		5877	} else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
		5878	const uint8_t *divider;
		5879	int buf_size3;
		5880
		5881	divider = find_next_marker(buf, buf + buf_size);
		5882	if ((divider == (buf + buf_size)) \|\| AV_RB32(divider) != VC1_CODE_FIELD) {
		5883	av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
		5884	goto err;
		5885	} else { // found field marker, unescape second field
		5886	if (avctx->hwaccel \|\|
		5887	s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
		5888	buf_start_second_field = divider;
		5889	tmp = av_realloc(slices, sizeof(slices) (n_slices+1));
		5890	if (!tmp)
		5891	goto err;
		5892	slices = tmp;
		5893	slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
		5894	if (!slices[n_slices].buf)
		5895	goto err;
		5896	buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
		5897	init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
		5898	buf_size3 << 3);
		5899	slices[n_slices].mby_start = s->mb_height >> 1;
		5900	n_slices1 = n_slices - 1;
		5901	n_slices++;
		5902	}
		5903	buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
		5904	} else {
		5905	buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
		5906	}
		5907	init_get_bits(&s->gb, buf2, buf_size2*8);
		5908	} else
		5909	init_get_bits(&s->gb, buf, buf_size*8);
		5910
		5911	if (v->res_sprite) {
		5912	v->new_sprite = !get_bits1(&s->gb);
		5913	v->two_sprites = get_bits1(&s->gb);
		5914	/* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
		5915	we're using the sprite compositor. These are intentionally kept separate
		5916	so you can get the raw sprites by using the wmv3 decoder for WMVP or
		5917	the vc1 one for WVP2 */
		5918	if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
		5919	if (v->new_sprite) {
		5920	// switch AVCodecContext parameters to those of the sprites
		5921	avctx->width = avctx->coded_width = v->sprite_width;
		5922	avctx->height = avctx->coded_height = v->sprite_height;
		5923	} else {
		5924	goto image;
		5925	}
		5926	}
		5927	}
		5928
		5929	if (s->context_initialized &&
		5930	(s->width != avctx->coded_width \|\|
		5931	s->height != avctx->coded_height)) {
		5932	ff_vc1_decode_end(avctx);
		5933	}
		5934
		5935	if (!s->context_initialized) {
		5936	if (ff_msmpeg4_decode_init(avctx) < 0)
		5937	goto err;
		5938	if (ff_vc1_decode_init_alloc_tables(v) < 0) {
		5939	ff_MPV_common_end(s);
		5940	goto err;
		5941	}
		5942
		5943	s->low_delay = !avctx->has_b_frames \|\| v->res_sprite;
		5944
		5945	if (v->profile == PROFILE_ADVANCED) {
		5946	if(avctx->coded_width<=1 \|\| avctx->coded_height<=1)
		5947	goto err;
		5948	s->h_edge_pos = avctx->coded_width;
		5949	s->v_edge_pos = avctx->coded_height;
		5950	}
		5951	}
		5952
		5953	/* We need to set current_picture_ptr before reading the header,
		5954	* otherwise we cannot store anything in there. */
		5955	if (s->current_picture_ptr == NULL \|\| s->current_picture_ptr->f.data[0]) {
		5956	int i = ff_find_unused_picture(s, 0);
		5957	if (i < 0)
		5958	goto err;
		5959	s->current_picture_ptr = &s->picture[i];
		5960	}
		5961
		5962	// do parse frame header
		5963	v->pic_header_flag = 0;
		5964	v->first_pic_header_flag = 1;
		5965	if (v->profile < PROFILE_ADVANCED) {
		5966	if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
		5967	goto err;
		5968	}
		5969	} else {
		5970	if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
		5971	goto err;
		5972	}
		5973	}
		5974	v->first_pic_header_flag = 0;
		5975
		5976	if (avctx->debug & FF_DEBUG_PICT_INFO)
		5977	av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
		5978
		5979	if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
		5980	&& s->pict_type != AV_PICTURE_TYPE_I) {
		5981	av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
		5982	goto err;
		5983	}
		5984
		5985	if ((s->mb_height >> v->field_mode) == 0) {
		5986	av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
		5987	goto err;
		5988	}
		5989
		5990	// process pulldown flags
		5991	s->current_picture_ptr->f.repeat_pict = 0;
		5992	// Pulldown flags are only valid when 'broadcast' has been set.
		5993	// So ticks_per_frame will be 2
		5994	if (v->rff) {
		5995	// repeat field
		5996	s->current_picture_ptr->f.repeat_pict = 1;
		5997	} else if (v->rptfrm) {
		5998	// repeat frames
		5999	s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
		6000	}
		6001
		6002	// for skipping the frame
		6003	s->current_picture.f.pict_type = s->pict_type;
		6004	s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
		6005
		6006	/* skip B-frames if we don't have reference frames */
		6007	if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B \|\| s->droppable)) {
		6008	goto err;
		6009	}
		6010	if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) \|\|
		6011	(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) \|\|
		6012	avctx->skip_frame >= AVDISCARD_ALL) {
		6013	goto end;
		6014	}
		6015
		6016	if (s->next_p_frame_damaged) {
		6017	if (s->pict_type == AV_PICTURE_TYPE_B)
		6018	goto end;
		6019	else
		6020	s->next_p_frame_damaged = 0;
		6021	}
		6022
		6023	if (ff_MPV_frame_start(s, avctx) < 0) {
		6024	goto err;
		6025	}
		6026
		6027	v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE);
		6028	v->s.current_picture_ptr->f.top_field_first = v->tff;
		6029
		6030	s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
		6031	s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
		6032
		6033	if ((CONFIG_VC1_VDPAU_DECODER)
		6034	&&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
		6035	if (v->field_mode && buf_start_second_field) {
		6036	ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
		6037	ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
		6038	} else {
		6039	ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
		6040	}
		6041	} else if (avctx->hwaccel) {
		6042	if (v->field_mode && buf_start_second_field) {
		6043	// decode first field
		6044	s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
		6045	if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
		6046	goto err;
		6047	if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
		6048	goto err;
		6049	if (avctx->hwaccel->end_frame(avctx) < 0)
		6050	goto err;
		6051
		6052	// decode second field
		6053	s->gb = slices[n_slices1 + 1].gb;
		6054	s->picture_structure = PICT_TOP_FIELD + v->tff;
		6055	v->second_field = 1;
		6056	v->pic_header_flag = 0;
		6057	if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
		6058	av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
		6059	goto err;
		6060	}
		6061	v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
		6062
		6063	if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
		6064	goto err;
		6065	if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
		6066	goto err;
		6067	if (avctx->hwaccel->end_frame(avctx) < 0)
		6068	goto err;
		6069	} else {
		6070	s->picture_structure = PICT_FRAME;
		6071	if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
		6072	goto err;
		6073	if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
		6074	goto err;
		6075	if (avctx->hwaccel->end_frame(avctx) < 0)
		6076	goto err;
		6077	}
		6078	} else {
		6079	int header_ret = 0;
		6080
		6081	ff_mpeg_er_frame_start(s);
		6082
		6083	v->bits = buf_size * 8;
		6084	v->end_mb_x = s->mb_width;
		6085	if (v->field_mode) {
		6086	s->current_picture.f.linesize[0] <<= 1;
		6087	s->current_picture.f.linesize[1] <<= 1;
		6088	s->current_picture.f.linesize[2] <<= 1;
		6089	s->linesize <<= 1;
		6090	s->uvlinesize <<= 1;
		6091	}
		6092	mb_height = s->mb_height >> v->field_mode;
		6093
		6094	av_assert0 (mb_height > 0);
		6095
		6096	for (i = 0; i <= n_slices; i++) {
		6097	if (i > 0 && slices[i - 1].mby_start >= mb_height) {
		6098	if (v->field_mode <= 0) {
		6099	av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
		6100	"picture boundary (%d >= %d)\n", i,
		6101	slices[i - 1].mby_start, mb_height);
		6102	continue;
		6103	}
		6104	v->second_field = 1;
		6105	v->blocks_off = s->b8_stride * (s->mb_height&~1);
		6106	v->mb_off = s->mb_stride * s->mb_height >> 1;
		6107	} else {
		6108	v->second_field = 0;
		6109	v->blocks_off = 0;
		6110	v->mb_off = 0;
		6111	}
		6112	if (i) {
		6113	v->pic_header_flag = 0;
		6114	if (v->field_mode && i == n_slices1 + 2) {
		6115	if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
		6116	av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
		6117	if (avctx->err_recognition & AV_EF_EXPLODE)
		6118	goto err;
		6119	continue;
		6120	}
		6121	} else if (get_bits1(&s->gb)) {
		6122	v->pic_header_flag = 1;
		6123	if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
		6124	av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
		6125	if (avctx->err_recognition & AV_EF_EXPLODE)
		6126	goto err;
		6127	continue;
		6128	}
		6129	}
		6130	}
		6131	if (header_ret < 0)
		6132	continue;
		6133	s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
		6134	if (!v->field_mode \|\| v->second_field)
		6135	s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
		6136	else {
		6137	if (i >= n_slices) {
		6138	av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
		6139	continue;
		6140	}
		6141	s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
		6142	}
		6143	if (s->end_mb_y <= s->start_mb_y) {
		6144	av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
		6145	continue;
		6146	}
		6147	if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
		6148	av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
		6149	continue;
		6150	}
		6151	ff_vc1_decode_blocks(v);
		6152	if (i != n_slices)
		6153	s->gb = slices[i].gb;
		6154	}
		6155	if (v->field_mode) {
		6156	v->second_field = 0;
		6157	s->current_picture.f.linesize[0] >>= 1;
		6158	s->current_picture.f.linesize[1] >>= 1;
		6159	s->current_picture.f.linesize[2] >>= 1;
		6160	s->linesize >>= 1;
		6161	s->uvlinesize >>= 1;
		6162	if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
		6163	FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
		6164	FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
		6165	}
		6166	}
		6167	av_dlog(s->avctx, "Consumed %i/%i bits\n",
		6168	get_bits_count(&s->gb), s->gb.size_in_bits);
		6169	// if (get_bits_count(&s->gb) > buf_size * 8)
		6170	// return -1;
		6171	if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
		6172	goto err;
		6173	if (!v->field_mode)
		6174	ff_er_frame_end(&s->er);
		6175	}
		6176
		6177	ff_MPV_frame_end(s);
		6178
		6179	if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE \|\| avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
		6180	image:
		6181	avctx->width = avctx->coded_width = v->output_width;
		6182	avctx->height = avctx->coded_height = v->output_height;
		6183	if (avctx->skip_frame >= AVDISCARD_NONREF)
		6184	goto end;
		6185	#if CONFIG_WMV3IMAGE_DECODER \|\| CONFIG_VC1IMAGE_DECODER
		6186	if (vc1_decode_sprites(v, &s->gb))
		6187	goto err;
		6188	#endif
		6189	if ((ret = av_frame_ref(pict, &v->sprite_output_frame)) < 0)
		6190	goto err;
		6191	*got_frame = 1;
		6192	} else {
		6193	if (s->pict_type == AV_PICTURE_TYPE_B \|\| s->low_delay) {
		6194	if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
		6195	goto err;
		6196	ff_print_debug_info(s, s->current_picture_ptr, pict);
		6197	} else if (s->last_picture_ptr != NULL) {
		6198	if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
		6199	goto err;
		6200	ff_print_debug_info(s, s->last_picture_ptr, pict);
		6201	}
		6202	if (s->last_picture_ptr \|\| s->low_delay) {
		6203	*got_frame = 1;
		6204	}
		6205	}
		6206
		6207	end:
		6208	av_free(buf2);
		6209	for (i = 0; i < n_slices; i++)
		6210	av_free(slices[i].buf);
		6211	av_free(slices);
		6212	return buf_size;
		6213
		6214	err:
		6215	av_free(buf2);
		6216	for (i = 0; i < n_slices; i++)
		6217	av_free(slices[i].buf);
		6218	av_free(slices);
		6219	return -1;
		6220	}
		6221
		6222
		6223	static const AVProfile profiles[] = {
		6224	{ FF_PROFILE_VC1_SIMPLE, "Simple" },
		6225	{ FF_PROFILE_VC1_MAIN, "Main" },
		6226	{ FF_PROFILE_VC1_COMPLEX, "Complex" },
		6227	{ FF_PROFILE_VC1_ADVANCED, "Advanced" },
		6228	{ FF_PROFILE_UNKNOWN },
		6229	};
		6230
		6231	static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
		6232	#if CONFIG_DXVA2
		6233	AV_PIX_FMT_DXVA2_VLD,
		6234	#endif
		6235	#if CONFIG_VAAPI
		6236	AV_PIX_FMT_VAAPI_VLD,
		6237	#endif
		6238	#if CONFIG_VDPAU
		6239	AV_PIX_FMT_VDPAU,
		6240	#endif
		6241	AV_PIX_FMT_YUV420P,
		6242	AV_PIX_FMT_NONE
		6243	};
		6244
		6245	AVCodec ff_vc1_decoder = {
		6246	.name = "vc1",
		6247	.long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
		6248	.type = AVMEDIA_TYPE_VIDEO,
		6249	.id = AV_CODEC_ID_VC1,
		6250	.priv_data_size = sizeof(VC1Context),
		6251	.init = vc1_decode_init,
		6252	.close = ff_vc1_decode_end,
		6253	.decode = vc1_decode_frame,
		6254	.flush = ff_mpeg_flush,
		6255	.capabilities = CODEC_CAP_DR1 \| CODEC_CAP_DELAY,
		6256	.pix_fmts = vc1_hwaccel_pixfmt_list_420,
		6257	.profiles = NULL_IF_CONFIG_SMALL(profiles)
		6258	};
		6259
		6260	#if CONFIG_WMV3_DECODER
		6261	AVCodec ff_wmv3_decoder = {
		6262	.name = "wmv3",
		6263	.long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
		6264	.type = AVMEDIA_TYPE_VIDEO,
		6265	.id = AV_CODEC_ID_WMV3,
		6266	.priv_data_size = sizeof(VC1Context),
		6267	.init = vc1_decode_init,
		6268	.close = ff_vc1_decode_end,
		6269	.decode = vc1_decode_frame,
		6270	.flush = ff_mpeg_flush,
		6271	.capabilities = CODEC_CAP_DR1 \| CODEC_CAP_DELAY,
		6272	.pix_fmts = vc1_hwaccel_pixfmt_list_420,
		6273	.profiles = NULL_IF_CONFIG_SMALL(profiles)
		6274	};
		6275	#endif
		6276
		6277	#if CONFIG_WMV3_VDPAU_DECODER
		6278	AVCodec ff_wmv3_vdpau_decoder = {
		6279	.name = "wmv3_vdpau",
		6280	.long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
		6281	.type = AVMEDIA_TYPE_VIDEO,
		6282	.id = AV_CODEC_ID_WMV3,
		6283	.priv_data_size = sizeof(VC1Context),
		6284	.init = vc1_decode_init,
		6285	.close = ff_vc1_decode_end,
		6286	.decode = vc1_decode_frame,
		6287	.capabilities = CODEC_CAP_DR1 \| CODEC_CAP_DELAY \| CODEC_CAP_HWACCEL_VDPAU,
		6288	.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
		6289	.profiles = NULL_IF_CONFIG_SMALL(profiles)
		6290	};
		6291	#endif
		6292
		6293	#if CONFIG_VC1_VDPAU_DECODER
		6294	AVCodec ff_vc1_vdpau_decoder = {
		6295	.name = "vc1_vdpau",
		6296	.long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
		6297	.type = AVMEDIA_TYPE_VIDEO,
		6298	.id = AV_CODEC_ID_VC1,
		6299	.priv_data_size = sizeof(VC1Context),
		6300	.init = vc1_decode_init,
		6301	.close = ff_vc1_decode_end,
		6302	.decode = vc1_decode_frame,
		6303	.capabilities = CODEC_CAP_DR1 \| CODEC_CAP_DELAY \| CODEC_CAP_HWACCEL_VDPAU,
		6304	.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
		6305	.profiles = NULL_IF_CONFIG_SMALL(profiles)
		6306	};
		6307	#endif
		6308
		6309	#if CONFIG_WMV3IMAGE_DECODER
		6310	AVCodec ff_wmv3image_decoder = {
		6311	.name = "wmv3image",
		6312	.long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
		6313	.type = AVMEDIA_TYPE_VIDEO,
		6314	.id = AV_CODEC_ID_WMV3IMAGE,
		6315	.priv_data_size = sizeof(VC1Context),
		6316	.init = vc1_decode_init,
		6317	.close = ff_vc1_decode_end,
		6318	.decode = vc1_decode_frame,
		6319	.capabilities = CODEC_CAP_DR1,
		6320	.flush = vc1_sprite_flush,
		6321	.pix_fmts = ff_pixfmt_list_420
		6322	};
		6323	#endif
		6324
		6325	#if CONFIG_VC1IMAGE_DECODER
		6326	AVCodec ff_vc1image_decoder = {
		6327	.name = "vc1image",
		6328	.long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
		6329	.type = AVMEDIA_TYPE_VIDEO,
		6330	.id = AV_CODEC_ID_VC1IMAGE,
		6331	.priv_data_size = sizeof(VC1Context),
		6332	.init = vc1_decode_init,
		6333	.close = ff_vc1_decode_end,
		6334	.decode = vc1_decode_frame,
		6335	.capabilities = CODEC_CAP_DR1,
		6336	.flush = vc1_sprite_flush,
		6337	.pix_fmts = ff_pixfmt_list_420
		6338	};
		6339	#endif

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/libavcodec/vc1dec.c @ 4930 – Rev