Annotation of /xvidcore/src/decoder.c

Revision 1.75.2.1 - (view) (download)

1 :	edgomez	1.48	/*****************************************************************************
2 :	Isibaar	1.1	*
3 :	edgomez	1.12	* XVID MPEG-4 VIDEO CODEC
4 :	edgomez	1.48	* - Decoder Module -
5 :	Isibaar	1.1	*
6 :	edgomez	1.51	* Copyright(C) 2002 MinChen <chenm001@163.com>
7 :	suxen_drol	1.52	* 2002-2004 Peter Ross <pross@xvid.org>
8 :	edgomez	1.42	*
9 :	edgomez	1.51	* This program is free software ; you can redistribute it and/or modify
10 :	edgomez	1.47	* it under the terms of the GNU General Public License as published by
11 :	edgomez	1.51	* the Free Software Foundation ; either version 2 of the License, or
12 :	edgomez	1.12	* (at your option) any later version.
13 :			*
14 :			* This program is distributed in the hope that it will be useful,
15 :	edgomez	1.51	* but WITHOUT ANY WARRANTY ; without even the implied warranty of
16 :	edgomez	1.12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 :			* GNU General Public License for more details.
18 :			*
19 :			* You should have received a copy of the GNU General Public License
20 :	edgomez	1.51	* along with this program ; if not, write to the Free Software
21 :	edgomez	1.12	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 :	Isibaar	1.1	*
23 :	Isibaar	1.75.2.1	* $Id: decoder.c,v 1.75 2005/11/22 10:23:01 suxen_drol Exp $
24 :	edgomez	1.43	*
25 :	edgomez	1.48	****************************************************************************/
26 :	Isibaar	1.1
27 :	edgomez	1.47	#include <stdio.h>
28 :	Isibaar	1.1	#include <stdlib.h>
29 :	edgomez	1.12	#include <string.h>
30 :	Isibaar	1.1
31 :	chenm001	1.27	#ifdef BFRAMES_DEC_DEBUG
32 :	suxen_drol	1.73	#define BFRAMES_DEC
33 :	chenm001	1.27	#endif
34 :
35 :	Isibaar	1.1	#include "xvid.h"
36 :			#include "portab.h"
37 :	edgomez	1.47	#include "global.h"
38 :	Isibaar	1.1
39 :			#include "decoder.h"
40 :			#include "bitstream/bitstream.h"
41 :			#include "bitstream/mbcoding.h"
42 :
43 :	edgomez	1.51	#include "quant/quant.h"
44 :			#include "quant/quant_matrix.h"
45 :	Isibaar	1.1	#include "dct/idct.h"
46 :			#include "dct/fdct.h"
47 :			#include "utils/mem_transfer.h"
48 :			#include "image/interpolate8x8.h"
49 :	edgomez	1.47	#include "image/font.h"
50 :	edgomez	1.62	#include "image/qpel.h"
51 :	Isibaar	1.1
52 :			#include "bitstream/mbcoding.h"
53 :			#include "prediction/mbprediction.h"
54 :			#include "utils/timer.h"
55 :			#include "utils/emms.h"
56 :	edgomez	1.47	#include "motion/motion.h"
57 :	edgomez	1.51	#include "motion/gmc.h"
58 :	Isibaar	1.1
59 :			#include "image/image.h"
60 :			#include "image/colorspace.h"
61 :	edgomez	1.51	#include "image/postprocessing.h"
62 :	Isibaar	1.3	#include "utils/mem_align.h"
63 :	Isibaar	1.1
64 :	suxen_drol	1.73	#define DIV2ROUND(n) (((n)>>1)\|((n)&1))
65 :			#define DIV2(n) ((n)>>1)
66 :			#define DIVUVMOV(n) (((n) >> 1) + roundtab_79[(n) & 0x3]) //
67 :
68 :	edgomez	1.51	static int
69 :	edgomez	1.47	decoder_resize(DECODER * dec)
70 :	Isibaar	1.1	{
71 :	edgomez	1.47	/* free existing */
72 :			image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
73 :			image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
74 :			image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
75 :			image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
76 :			image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
77 :
78 :			image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
79 :	Isibaar	1.1
80 :	Skal	1.70	image_null(&dec->cur);
81 :			image_null(&dec->refn[0]);
82 :			image_null(&dec->refn[1]);
83 :			image_null(&dec->tmp);
84 :			image_null(&dec->qtmp);
85 :			image_null(&dec->gmc);
86 :
87 :
88 :			xvid_free(dec->last_mbs);
89 :			xvid_free(dec->mbs);
90 :			xvid_free(dec->qscale);
91 :			dec->last_mbs = NULL;
92 :			dec->mbs = NULL;
93 :			dec->qscale = NULL;
94 :	Isibaar	1.1
95 :	edgomez	1.47	/* realloc */
96 :	Isibaar	1.1	dec->mb_width = (dec->width + 15) / 16;
97 :			dec->mb_height = (dec->height + 15) / 16;
98 :
99 :			dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;
100 :			dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;
101 :	edgomez	1.19
102 :	Skal	1.70	if ( image_create(&dec->cur, dec->edged_width, dec->edged_height)
103 :			\|\| image_create(&dec->refn[0], dec->edged_width, dec->edged_height)
104 :			\|\| image_create(&dec->refn[1], dec->edged_width, dec->edged_height) /* Support B-frame to reference last 2 frame */
105 :			\|\| image_create(&dec->tmp, dec->edged_width, dec->edged_height)
106 :			\|\| image_create(&dec->qtmp, dec->edged_width, dec->edged_height)
107 :			\|\| image_create(&dec->gmc, dec->edged_width, dec->edged_height) )
108 :			goto memory_error;
109 :	Isibaar	1.1
110 :	edgomez	1.19	dec->mbs =
111 :			xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
112 :			CACHE_LINE);
113 :	Skal	1.70	if (dec->mbs == NULL)
114 :			goto memory_error;
115 :	Isibaar	1.20	memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
116 :
117 :	edgomez	1.48	/* For skip MB flag */
118 :	edgomez	1.19	dec->last_mbs =
119 :			xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
120 :			CACHE_LINE);
121 :	Skal	1.70	if (dec->last_mbs == NULL)
122 :			goto memory_error;
123 :	Isibaar	1.20	memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
124 :	Isibaar	1.1
125 :	edgomez	1.51	/* nothing happens if that fails */
126 :			dec->qscale =
127 :			xvid_malloc(sizeof(int) * dec->mb_width * dec->mb_height, CACHE_LINE);
128 :
129 :			if (dec->qscale)
130 :			memset(dec->qscale, 0, sizeof(int) * dec->mb_width * dec->mb_height);
131 :
132 :			return 0;
133 :	Skal	1.70
134 :			memory_error:
135 :			/* Most structures were deallocated / nullifieded, so it should be safe */
136 :			/* decoder_destroy(dec) minus the write_timer */
137 :			xvid_free(dec->mbs);
138 :			image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
139 :			image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
140 :			image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
141 :			image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
142 :			image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
143 :
144 :			xvid_free(dec);
145 :			return XVID_ERR_MEMORY;
146 :	edgomez	1.47	}
147 :
148 :
149 :			int
150 :	edgomez	1.51	decoder_create(xvid_dec_create_t * create)
151 :	edgomez	1.47	{
152 :	suxen_drol	1.73	DECODER *dec;
153 :
154 :			if (XVID_VERSION_MAJOR(create->version) != 1) /* v1.x.x */
155 :			return XVID_ERR_VERSION;
156 :
157 :			dec = xvid_malloc(sizeof(DECODER), CACHE_LINE);
158 :			if (dec == NULL) {
159 :			return XVID_ERR_MEMORY;
160 :			}
161 :
162 :			memset(dec, 0, sizeof(DECODER));
163 :
164 :			dec->mpeg_quant_matrices = xvid_malloc(sizeof(uint16_t) * 64 * 8, CACHE_LINE);
165 :			if (dec->mpeg_quant_matrices == NULL) {
166 :			xvid_free(dec);
167 :			return XVID_ERR_MEMORY;
168 :			}
169 :
170 :			create->handle = dec;
171 :
172 :			dec->width = create->width;
173 :			dec->height = create->height;
174 :
175 :			image_null(&dec->cur);
176 :			image_null(&dec->refn[0]);
177 :			image_null(&dec->refn[1]);
178 :			image_null(&dec->tmp);
179 :			image_null(&dec->qtmp);
180 :
181 :			/* image based GMC */
182 :			image_null(&dec->gmc);
183 :	edgomez	1.47
184 :	suxen_drol	1.73	dec->mbs = NULL;
185 :			dec->last_mbs = NULL;
186 :			dec->qscale = NULL;
187 :	edgomez	1.51
188 :	suxen_drol	1.73	init_timer();
189 :			init_postproc(&dec->postproc);
190 :			init_mpeg_matrix(dec->mpeg_quant_matrices);
191 :
192 :			/* For B-frame support (used to save reference frame's time */
193 :			dec->frames = 0;
194 :			dec->time = dec->time_base = dec->last_time_base = 0;
195 :			dec->low_delay = 0;
196 :			dec->packed_mode = 0;
197 :			dec->time_inc_resolution = 1; /* until VOL header says otherwise */
198 :
199 :	Isibaar	1.75.2.1	dec->bs_version = 0xffff; /* Initialize to very high value -> assume bugfree stream */
200 :
201 :	suxen_drol	1.73	dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
202 :
203 :			if (dec->fixed_dimensions)
204 :			return decoder_resize(dec);
205 :			else
206 :			return 0;
207 :	Isibaar	1.1	}
208 :
209 :
210 :	edgomez	1.19	int
211 :			decoder_destroy(DECODER * dec)
212 :	Isibaar	1.1	{
213 :	suxen_drol	1.73	xvid_free(dec->last_mbs);
214 :			xvid_free(dec->mbs);
215 :			xvid_free(dec->qscale);
216 :	edgomez	1.47
217 :	suxen_drol	1.73	/* image based GMC */
218 :			image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
219 :	edgomez	1.47
220 :	suxen_drol	1.73	image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
221 :			image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
222 :			image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
223 :			image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
224 :			image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
225 :			xvid_free(dec->mpeg_quant_matrices);
226 :			xvid_free(dec);
227 :	Isibaar	1.1
228 :	suxen_drol	1.73	write_timer();
229 :			return 0;
230 :	Isibaar	1.1	}
231 :
232 :	edgomez	1.19	static const int32_t dquant_table[4] = {
233 :	suxen_drol	1.73	-1, -2, 1, 2
234 :	Isibaar	1.1	};
235 :
236 :	edgomez	1.48	/* decode an intra macroblock */
237 :	edgomez	1.51	static void
238 :	edgomez	1.19	decoder_mbintra(DECODER * dec,
239 :	suxen_drol	1.73	MACROBLOCK * pMB,
240 :			const uint32_t x_pos,
241 :			const uint32_t y_pos,
242 :			const uint32_t acpred_flag,
243 :			const uint32_t cbp,
244 :			Bitstream * bs,
245 :			const uint32_t quant,
246 :			const uint32_t intra_dc_threshold,
247 :			const unsigned int bound)
248 :	Isibaar	1.1	{
249 :	edgomez	1.7
250 :	suxen_drol	1.73	DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
251 :			DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);
252 :	edgomez	1.7
253 :	suxen_drol	1.73	uint32_t stride = dec->edged_width;
254 :			uint32_t stride2 = stride / 2;
255 :			uint32_t next_block = stride * 8;
256 :			uint32_t i;
257 :			uint32_t iQuant = pMB->quant;
258 :			uint8_t pY_Cur, pU_Cur, *pV_Cur;
259 :
260 :			pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
261 :			pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
262 :			pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
263 :
264 :			memset(block, 0, 6 * 64 * sizeof(int16_t)); /* clear */
265 :
266 :			for (i = 0; i < 6; i++) {
267 :			uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
268 :			int16_t predictors[8];
269 :			int start_coeff;
270 :
271 :			start_timer();
272 :			predict_acdc(dec->mbs, x_pos, y_pos, dec->mb_width, i, &block[i * 64],
273 :			iQuant, iDcScaler, predictors, bound);
274 :			if (!acpred_flag) {
275 :			pMB->acpred_directions[i] = 0;
276 :			}
277 :			stop_prediction_timer();
278 :
279 :			if (quant < intra_dc_threshold) {
280 :			int dc_size;
281 :			int dc_dif;
282 :
283 :			dc_size = i < 4 ? get_dc_size_lum(bs) : get_dc_size_chrom(bs);
284 :			dc_dif = dc_size ? get_dc_dif(bs, dc_size) : 0;
285 :
286 :			if (dc_size > 8) {
287 :			BitstreamSkip(bs, 1); /* marker */
288 :			}
289 :	Isibaar	1.1
290 :	suxen_drol	1.73	block[i * 64 + 0] = dc_dif;
291 :			start_coeff = 1;
292 :	Isibaar	1.1
293 :	suxen_drol	1.73	DPRINTF(XVID_DEBUG_COEFF,"block[0] %i\n", dc_dif);
294 :			} else {
295 :			start_coeff = 0;
296 :			}
297 :	edgomez	1.19
298 :	suxen_drol	1.73	start_timer();
299 :			if (cbp & (1 << (5 - i))) /* coded */
300 :			{
301 :			int direction = dec->alternate_vertical_scan ?
302 :			2 : pMB->acpred_directions[i];
303 :
304 :			get_intra_block(bs, &block[i * 64], direction, start_coeff);
305 :			}
306 :			stop_coding_timer();
307 :
308 :			start_timer();
309 :			add_acdc(pMB, i, &block[i * 64], iDcScaler, predictors, dec->bs_version);
310 :			stop_prediction_timer();
311 :
312 :			start_timer();
313 :			if (dec->quant_type == 0) {
314 :			dequant_h263_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
315 :			} else {
316 :			dequant_mpeg_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
317 :			}
318 :			stop_iquant_timer();
319 :
320 :			start_timer();
321 :	suxen_drol	1.75	idct((short * const)&data[i * 64]);
322 :	suxen_drol	1.73	stop_idct_timer();
323 :
324 :			}
325 :
326 :			if (dec->interlacing && pMB->field_dct) {
327 :			next_block = stride;
328 :			stride *= 2;
329 :			}
330 :
331 :			start_timer();
332 :			transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
333 :			transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
334 :			transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
335 :			transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);
336 :			transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
337 :			transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
338 :			stop_transfer_timer();
339 :	Isibaar	1.1	}
340 :
341 :	edgomez	1.51	static void
342 :			decoder_mb_decode(DECODER * dec,
343 :	suxen_drol	1.73	const uint32_t cbp,
344 :			Bitstream * bs,
345 :			uint8_t * pY_Cur,
346 :			uint8_t * pU_Cur,
347 :			uint8_t * pV_Cur,
348 :			const MACROBLOCK * pMB)
349 :	edgomez	1.51	{
350 :	suxen_drol	1.73	DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
351 :	edgomez	1.51
352 :	suxen_drol	1.73	int stride = dec->edged_width;
353 :			int i;
354 :			const uint32_t iQuant = pMB->quant;
355 :			const int direction = dec->alternate_vertical_scan ? 2 : 0;
356 :			typedef void (*get_inter_block_function_t)(
357 :			Bitstream * bs,
358 :			int16_t * block,
359 :			int direction,
360 :			const int quant,
361 :			const uint16_t *matrix);
362 :			typedef void (*add_residual_function_t)(
363 :			uint8_t *predicted_block,
364 :			const int16_t *residual,
365 :			int stride);
366 :
367 :			const get_inter_block_function_t get_inter_block = (dec->quant_type == 0)
368 :			? (get_inter_block_function_t)get_inter_block_h263
369 :			: (get_inter_block_function_t)get_inter_block_mpeg;
370 :
371 :			uint8_t *dst[6];
372 :			int strides[6];
373 :
374 :
375 :			if (dec->interlacing && pMB->field_dct) {
376 :			dst[0] = pY_Cur;
377 :			dst[1] = pY_Cur + 8;
378 :			dst[2] = pY_Cur + stride;
379 :			dst[3] = dst[2] + 8;
380 :			dst[4] = pU_Cur;
381 :			dst[5] = pV_Cur;
382 :			strides[0] = strides[1] = strides[2] = strides[3] = stride*2;
383 :			strides[4] = stride/2;
384 :			strides[5] = stride/2;
385 :			} else {
386 :			dst[0] = pY_Cur;
387 :			dst[1] = pY_Cur + 8;
388 :			dst[2] = pY_Cur + 8*stride;
389 :			dst[3] = dst[2] + 8;
390 :			dst[4] = pU_Cur;
391 :			dst[5] = pV_Cur;
392 :			strides[0] = strides[1] = strides[2] = strides[3] = stride;
393 :			strides[4] = stride/2;
394 :			strides[5] = stride/2;
395 :			}
396 :
397 :			for (i = 0; i < 6; i++) {
398 :			/* Process only coded blocks */
399 :			if (cbp & (1 << (5 - i))) {
400 :
401 :			/* Clear the block */
402 :			memset(&data[0], 0, 64*sizeof(int16_t));
403 :
404 :			/* Decode coeffs and dequantize on the fly */
405 :			start_timer();
406 :			get_inter_block(bs, &data[0], direction, iQuant, get_inter_matrix(dec->mpeg_quant_matrices));
407 :			stop_coding_timer();
408 :
409 :			/* iDCT */
410 :			start_timer();
411 :	suxen_drol	1.75	idct((short * const)&data[0]);
412 :	suxen_drol	1.73	stop_idct_timer();
413 :
414 :			/* Add this residual to the predicted block */
415 :			start_timer();
416 :			transfer_16to8add(dst[i], &data[0], strides[i]);
417 :			stop_transfer_timer();
418 :			}
419 :			}
420 :	edgomez	1.51	}
421 :	Isibaar	1.1
422 :	edgomez	1.67	static void __inline
423 :	syskin	1.66	validate_vector(VECTOR * mv, unsigned int x_pos, unsigned int y_pos, const DECODER * dec)
424 :			{
425 :	suxen_drol	1.73	/* clip a vector to valid range
426 :			prevents crashes if bitstream is broken
427 :			*/
428 :			int shift = 5 + dec->quarterpel;
429 :			int xborder_high = (int)(dec->mb_width - x_pos) << shift;
430 :			int xborder_low = (-(int)x_pos-1) << shift;
431 :			int yborder_high = (int)(dec->mb_height - y_pos) << shift;
432 :			int yborder_low = (-(int)y_pos-1) << shift;
433 :	edgomez	1.67
434 :			#define CHECK_MV(mv) \
435 :	suxen_drol	1.73	do { \
436 :			if ((mv).x > xborder_high) { \
437 :			DPRINTF(XVID_DEBUG_MV, "mv.x > max -- %d > %d, MB %d, %d", (mv).x, xborder_high, x_pos, y_pos); \
438 :			(mv).x = xborder_high; \
439 :			} else if ((mv).x < xborder_low) { \
440 :			DPRINTF(XVID_DEBUG_MV, "mv.x < min -- %d < %d, MB %d, %d", (mv).x, xborder_low, x_pos, y_pos); \
441 :			(mv).x = xborder_low; \
442 :			} \
443 :			if ((mv).y > yborder_high) { \
444 :			DPRINTF(XVID_DEBUG_MV, "mv.y > max -- %d > %d, MB %d, %d", (mv).y, yborder_high, x_pos, y_pos); \
445 :			(mv).y = yborder_high; \
446 :			} else if ((mv).y < yborder_low) { \
447 :			DPRINTF(XVID_DEBUG_MV, "mv.y < min -- %d < %d, MB %d, %d", (mv).y, yborder_low, x_pos, y_pos); \
448 :			(mv).y = yborder_low; \
449 :			} \
450 :			} while (0)
451 :
452 :			CHECK_MV(mv[0]);
453 :			CHECK_MV(mv[1]);
454 :			CHECK_MV(mv[2]);
455 :			CHECK_MV(mv[3]);
456 :	syskin	1.66	}
457 :
458 :	Isibaar	1.72	/* Up to this version, chroma rounding was wrong with qpel.
459 :			* So we try to be backward compatible to avoid artifacts */
460 :			#define BS_VERSION_BUGGY_CHROMA_ROUNDING 1
461 :
462 :	edgomez	1.48	/* decode an inter macroblock */
463 :	edgomez	1.51	static void
464 :	edgomez	1.19	decoder_mbinter(DECODER * dec,
465 :	suxen_drol	1.73	const MACROBLOCK * pMB,
466 :			const uint32_t x_pos,
467 :			const uint32_t y_pos,
468 :			const uint32_t cbp,
469 :			Bitstream * bs,
470 :			const uint32_t rounding,
471 :	Isibaar	1.75.2.1	const int ref,
472 :			const int bvop)
473 :	Isibaar	1.1	{
474 :	suxen_drol	1.73	uint32_t stride = dec->edged_width;
475 :			uint32_t stride2 = stride / 2;
476 :			uint32_t i;
477 :	edgomez	1.51
478 :	suxen_drol	1.73	uint8_t pY_Cur, pU_Cur, *pV_Cur;
479 :	edgomez	1.47
480 :	suxen_drol	1.73	int uv_dx, uv_dy;
481 :			VECTOR mv[4]; /* local copy of mvs */
482 :	edgomez	1.47
483 :	suxen_drol	1.73	pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
484 :			pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
485 :			pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
486 :			for (i = 0; i < 4; i++)
487 :			mv[i] = pMB->mvs[i];
488 :	edgomez	1.47
489 :	suxen_drol	1.73	validate_vector(mv, x_pos, y_pos, dec);
490 :	syskin	1.54
491 :	suxen_drol	1.73	start_timer();
492 :	edgomez	1.51
493 :	Isibaar	1.75.2.1	if ((pMB->mode != MODE_INTER4V) \|\| (bvop)) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
494 :	edgomez	1.51
495 :	suxen_drol	1.73	uv_dx = mv[0].x;
496 :			uv_dy = mv[0].y;
497 :			if (dec->quarterpel) {
498 :	Isibaar	1.72	if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
499 :	Isibaar	1.75.2.1	uv_dx = (uv_dx>>1) \| (uv_dx&1);
500 :	Isibaar	1.72	uv_dy = (uv_dy>>1) \| (uv_dy&1);
501 :			}
502 :			else {
503 :	suxen_drol	1.73	uv_dx /= 2;
504 :			uv_dy /= 2;
505 :			}
506 :			}
507 :			uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
508 :			uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
509 :
510 :			if (dec->quarterpel)
511 :			interpolate16x16_quarterpel(dec->cur.y, dec->refn[ref].y, dec->qtmp.y, dec->qtmp.y + 64,
512 :			dec->qtmp.y + 128, 16x_pos, 16y_pos,
513 :			mv[0].x, mv[0].y, stride, rounding);
514 :			else
515 :			interpolate16x16_switch(dec->cur.y, dec->refn[ref].y, 16x_pos, 16y_pos,
516 :			mv[0].x, mv[0].y, stride, rounding);
517 :	Isibaar	1.1
518 :	suxen_drol	1.73	} else { /* MODE_INTER4V */
519 :	edgomez	1.47
520 :	suxen_drol	1.73	if(dec->quarterpel) {
521 :	Isibaar	1.72	if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
522 :			int z;
523 :			uv_dx = 0; uv_dy = 0;
524 :			for (z = 0; z < 4; z++) {
525 :			uv_dx += ((mv[z].x>>1) \| (mv[z].x&1));
526 :			uv_dy += ((mv[z].y>>1) \| (mv[z].y&1));
527 :			}
528 :			}
529 :			else {
530 :	suxen_drol	1.73	uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);
531 :			uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);
532 :			}
533 :			} else {
534 :			uv_dx = mv[0].x + mv[1].x + mv[2].x + mv[3].x;
535 :			uv_dy = mv[0].y + mv[1].y + mv[2].y + mv[3].y;
536 :			}
537 :
538 :			uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
539 :			uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
540 :
541 :			if (dec->quarterpel) {
542 :			interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
543 :			dec->qtmp.y + 128, 16x_pos, 16y_pos,
544 :			mv[0].x, mv[0].y, stride, rounding);
545 :			interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
546 :			dec->qtmp.y + 128, 16x_pos + 8, 16y_pos,
547 :			mv[1].x, mv[1].y, stride, rounding);
548 :			interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
549 :			dec->qtmp.y + 128, 16x_pos, 16y_pos + 8,
550 :			mv[2].x, mv[2].y, stride, rounding);
551 :			interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
552 :			dec->qtmp.y + 128, 16x_pos + 8, 16y_pos + 8,
553 :			mv[3].x, mv[3].y, stride, rounding);
554 :			} else {
555 :			interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16x_pos, 16y_pos,
556 :			mv[0].x, mv[0].y, stride, rounding);
557 :			interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16x_pos + 8, 16y_pos,
558 :			mv[1].x, mv[1].y, stride, rounding);
559 :			interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16x_pos, 16y_pos + 8,
560 :			mv[2].x, mv[2].y, stride, rounding);
561 :			interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16x_pos + 8, 16y_pos + 8,
562 :			mv[3].x, mv[3].y, stride, rounding);
563 :			}
564 :			}
565 :
566 :			/* chroma */
567 :			interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,
568 :			uv_dx, uv_dy, stride2, rounding);
569 :			interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,
570 :			uv_dx, uv_dy, stride2, rounding);
571 :
572 :			stop_comp_timer();
573 :
574 :			if (cbp)
575 :			decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
576 :			}
577 :
578 :			/* decode an inter macroblock in field mode */
579 :			static void
580 :			decoder_mbinter_field(DECODER * dec,
581 :			const MACROBLOCK * pMB,
582 :			const uint32_t x_pos,
583 :			const uint32_t y_pos,
584 :			const uint32_t cbp,
585 :			Bitstream * bs,
586 :			const uint32_t rounding,
587 :	Isibaar	1.75.2.1	const int ref,
588 :			const int bvop)
589 :	suxen_drol	1.73	{
590 :			uint32_t stride = dec->edged_width;
591 :			uint32_t stride2 = stride / 2;
592 :	Isibaar	1.1
593 :	suxen_drol	1.73	uint8_t pY_Cur, pU_Cur, *pV_Cur;
594 :	edgomez	1.47
595 :	suxen_drol	1.73	int uvtop_dx, uvtop_dy;
596 :			int uvbot_dx, uvbot_dy;
597 :			VECTOR mv[4]; /* local copy of mvs */
598 :
599 :			/* Get pointer to memory areas */
600 :			pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
601 :			pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
602 :			pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
603 :
604 :			mv[0] = pMB->mvs[0];
605 :			mv[1] = pMB->mvs[1];
606 :			memset(&mv[2],0,2*sizeof(VECTOR));
607 :
608 :			validate_vector(mv, x_pos, y_pos, dec);
609 :
610 :			start_timer();
611 :
612 :	Isibaar	1.75.2.1	if((pMB->mode!=MODE_INTER4V) \|\| (bvop)) /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
613 :	suxen_drol	1.73	{
614 :			/* Prepare top field vector */
615 :			uvtop_dx = DIV2ROUND(mv[0].x);
616 :			uvtop_dy = DIV2ROUND(mv[0].y);
617 :
618 :			/* Prepare bottom field vector */
619 :			uvbot_dx = DIV2ROUND(mv[1].x);
620 :			uvbot_dy = DIV2ROUND(mv[1].y);
621 :
622 :			if(dec->quarterpel)
623 :			{
624 :			/* NOT supported */
625 :			}
626 :			else
627 :			{
628 :			/* Interpolate top field left part(we use double stride for every 2nd line) */
629 :			interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
630 :			16x_pos,8y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
631 :			/* top field right part */
632 :			interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
633 :			16x_pos+8,8y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
634 :
635 :			/* Interpolate bottom field left part(we use double stride for every 2nd line) */
636 :			interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
637 :			16x_pos,8y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
638 :			/* Bottom field right part */
639 :			interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
640 :			16x_pos+8,8y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
641 :
642 :			/* Interpolate field1 U */
643 :			interpolate8x4_switch(dec->cur.u,dec->refn[ref].u+pMB->field_for_top*stride2,
644 :			8x_pos,4y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
645 :
646 :			/* Interpolate field1 V */
647 :			interpolate8x4_switch(dec->cur.v,dec->refn[ref].v+pMB->field_for_top*stride2,
648 :			8x_pos,4y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
649 :
650 :			/* Interpolate field2 U */
651 :			interpolate8x4_switch(dec->cur.u+stride2,dec->refn[ref].u+pMB->field_for_bot*stride2,
652 :			8x_pos,4y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
653 :
654 :			/* Interpolate field2 V */
655 :			interpolate8x4_switch(dec->cur.v+stride2,dec->refn[ref].v+pMB->field_for_bot*stride2,
656 :			8x_pos,4y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
657 :			}
658 :			}
659 :			else
660 :			{
661 :			/* We don't expect 4 motion vectors in interlaced mode */
662 :			}
663 :
664 :			stop_comp_timer();
665 :
666 :			/* Must add error correction? */
667 :			if(cbp)
668 :			decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
669 :	edgomez	1.47	}
670 :
671 :			static void
672 :			decoder_mbgmc(DECODER * dec,
673 :	suxen_drol	1.73	MACROBLOCK * const pMB,
674 :			const uint32_t x_pos,
675 :			const uint32_t y_pos,
676 :			const uint32_t fcode,
677 :			const uint32_t cbp,
678 :			Bitstream * bs,
679 :			const uint32_t rounding)
680 :	edgomez	1.47	{
681 :	suxen_drol	1.73	const uint32_t stride = dec->edged_width;
682 :			const uint32_t stride2 = stride / 2;
683 :	edgomez	1.51
684 :	suxen_drol	1.73	uint8_t const pY_Cur=dec->cur.y + (y_pos << 4) stride + (x_pos << 4);
685 :			uint8_t const pU_Cur=dec->cur.u + (y_pos << 3) stride2 + (x_pos << 3);
686 :			uint8_t const pV_Cur=dec->cur.v + (y_pos << 3) stride2 + (x_pos << 3);
687 :	edgomez	1.47
688 :	suxen_drol	1.73	NEW_GMC_DATA * gmc_data = &dec->new_gmc_data;
689 :	edgomez	1.51
690 :	suxen_drol	1.73	pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
691 :	Isibaar	1.1
692 :	suxen_drol	1.73	start_timer();
693 :	edgomez	1.51
694 :	edgomez	1.47	/* this is where the calculations are done */
695 :
696 :	suxen_drol	1.73	gmc_data->predict_16x16(gmc_data,
697 :			dec->cur.y + y_pos16stride + x_pos*16, dec->refn[0].y,
698 :			stride, stride, x_pos, y_pos, rounding);
699 :	edgomez	1.51
700 :	suxen_drol	1.73	gmc_data->predict_8x8(gmc_data,
701 :			dec->cur.u + y_pos8stride2 + x_pos*8, dec->refn[0].u,
702 :			dec->cur.v + y_pos8stride2 + x_pos*8, dec->refn[0].v,
703 :			stride2, stride2, x_pos, y_pos, rounding);
704 :	edgomez	1.47
705 :	suxen_drol	1.73	gmc_data->get_average_mv(gmc_data, &pMB->amv, x_pos, y_pos, dec->quarterpel);
706 :	Isibaar	1.1
707 :	suxen_drol	1.73	pMB->amv.x = gmc_sanitize(pMB->amv.x, dec->quarterpel, fcode);
708 :			pMB->amv.y = gmc_sanitize(pMB->amv.y, dec->quarterpel, fcode);
709 :	edgomez	1.47
710 :	suxen_drol	1.73	pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
711 :	Isibaar	1.1
712 :	suxen_drol	1.73	stop_transfer_timer();
713 :	Isibaar	1.1
714 :	suxen_drol	1.73	if (cbp)
715 :			decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
716 :	Isibaar	1.1
717 :			}
718 :
719 :
720 :	edgomez	1.51	static void
721 :	edgomez	1.19	decoder_iframe(DECODER * dec,
722 :	suxen_drol	1.73	Bitstream * bs,
723 :			int quant,
724 :			int intra_dc_threshold)
725 :	Isibaar	1.1	{
726 :	suxen_drol	1.73	uint32_t bound;
727 :			uint32_t x, y;
728 :			const uint32_t mb_width = dec->mb_width;
729 :			const uint32_t mb_height = dec->mb_height;
730 :
731 :			bound = 0;
732 :
733 :			for (y = 0; y < mb_height; y++) {
734 :			for (x = 0; x < mb_width; x++) {
735 :			MACROBLOCK *mb;
736 :			uint32_t mcbpc;
737 :			uint32_t cbpc;
738 :			uint32_t acpred_flag;
739 :			uint32_t cbpy;
740 :			uint32_t cbp;
741 :
742 :			while (BitstreamShowBits(bs, 9) == 1)
743 :			BitstreamSkip(bs, 9);
744 :
745 :			if (check_resync_marker(bs, 0))
746 :			{
747 :			bound = read_video_packet_header(bs, dec, 0,
748 :			&quant, NULL, NULL, &intra_dc_threshold);
749 :			x = bound % mb_width;
750 :			y = bound / mb_width;
751 :			}
752 :			mb = &dec->mbs[y * dec->mb_width + x];
753 :
754 :			DPRINTF(XVID_DEBUG_MB, "macroblock (%i,%i) %08x\n", x, y, BitstreamShowBits(bs, 32));
755 :
756 :			mcbpc = get_mcbpc_intra(bs);
757 :			mb->mode = mcbpc & 7;
758 :			cbpc = (mcbpc >> 4);
759 :
760 :			acpred_flag = BitstreamGetBit(bs);
761 :
762 :			cbpy = get_cbpy(bs, 1);
763 :			cbp = (cbpy << 2) \| cbpc;
764 :
765 :			if (mb->mode == MODE_INTRA_Q) {
766 :			quant += dquant_table[BitstreamGetBits(bs, 2)];
767 :			if (quant > 31) {
768 :			quant = 31;
769 :			} else if (quant < 1) {
770 :			quant = 1;
771 :			}
772 :			}
773 :			mb->quant = quant;
774 :			mb->mvs[0].x = mb->mvs[0].y =
775 :			mb->mvs[1].x = mb->mvs[1].y =
776 :			mb->mvs[2].x = mb->mvs[2].y =
777 :			mb->mvs[3].x = mb->mvs[3].y =0;
778 :
779 :			if (dec->interlacing) {
780 :			mb->field_dct = BitstreamGetBit(bs);
781 :			DPRINTF(XVID_DEBUG_MB,"deci: field_dct: %i\n", mb->field_dct);
782 :			}
783 :
784 :			decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
785 :			intra_dc_threshold, bound);
786 :
787 :			}
788 :			if(dec->out_frm)
789 :			output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,0,y,mb_width);
790 :			}
791 :	chenm001	1.26
792 :	suxen_drol	1.73	}
793 :	chenm001	1.26
794 :	Isibaar	1.1
795 :	suxen_drol	1.73	static void
796 :			get_motion_vector(DECODER * dec,
797 :			Bitstream * bs,
798 :			int x,
799 :			int y,
800 :			int k,
801 :			VECTOR * ret_mv,
802 :			int fcode,
803 :			const int bound)
804 :			{
805 :	Isibaar	1.1
806 :	suxen_drol	1.73	const int scale_fac = 1 << (fcode - 1);
807 :			const int high = (32 * scale_fac) - 1;
808 :			const int low = ((-32) * scale_fac);
809 :			const int range = (64 * scale_fac);
810 :
811 :			const VECTOR pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);
812 :			VECTOR mv;
813 :
814 :			mv.x = get_mv(bs, fcode);
815 :			mv.y = get_mv(bs, fcode);
816 :
817 :			DPRINTF(XVID_DEBUG_MV,"mv_diff (%i,%i) pred (%i,%i) result (%i,%i)\n", mv.x, mv.y, pmv.x, pmv.y, mv.x+pmv.x, mv.y+pmv.y);
818 :
819 :			mv.x += pmv.x;
820 :			mv.y += pmv.y;
821 :
822 :			if (mv.x < low) {
823 :			mv.x += range;
824 :			} else if (mv.x > high) {
825 :			mv.x -= range;
826 :			}
827 :
828 :			if (mv.y < low) {
829 :			mv.y += range;
830 :			} else if (mv.y > high) {
831 :			mv.y -= range;
832 :			}
833 :	edgomez	1.7
834 :	suxen_drol	1.73	ret_mv->x = mv.x;
835 :			ret_mv->y = mv.y;
836 :	Isibaar	1.1	}
837 :
838 :	suxen_drol	1.73	/* We use this when decoder runs interlaced -> different prediction */
839 :	Isibaar	1.1
840 :	suxen_drol	1.73	static void get_motion_vector_interlaced(DECODER * dec,
841 :			Bitstream * bs,
842 :			int x,
843 :			int y,
844 :			int k,
845 :			MACROBLOCK *pMB,
846 :			int fcode,
847 :			const int bound)
848 :	Isibaar	1.1	{
849 :	suxen_drol	1.73	const int scale_fac = 1 << (fcode - 1);
850 :			const int high = (32 * scale_fac) - 1;
851 :			const int low = ((-32) * scale_fac);
852 :			const int range = (64 * scale_fac);
853 :
854 :			/* Get interlaced prediction */
855 :			const VECTOR pmv=get_pmv2_interlaced(dec->mbs,dec->mb_width,bound,x,y,k);
856 :			VECTOR mv,mvf1,mvf2;
857 :
858 :			if(!pMB->field_pred)
859 :			{
860 :			mv.x = get_mv(bs,fcode);
861 :			mv.y = get_mv(bs,fcode);
862 :
863 :			mv.x += pmv.x;
864 :			mv.y += pmv.y;
865 :
866 :			if(mv.x<low) {
867 :			mv.x += range;
868 :			} else if (mv.x>high) {
869 :			mv.x-=range;
870 :			}
871 :
872 :			if (mv.y < low) {
873 :			mv.y += range;
874 :			} else if (mv.y > high) {
875 :			mv.y -= range;
876 :			}
877 :
878 :			pMB->mvs[0]=pMB->mvs[1]=pMB->mvs[2]=pMB->mvs[3]=mv;
879 :			}
880 :			else
881 :			{
882 :			mvf1.x = get_mv(bs, fcode);
883 :			mvf1.y = get_mv(bs, fcode);
884 :
885 :			mvf1.x += pmv.x;
886 :			mvf1.y = 2(mvf1.y+pmv.y/2); / It's multiple of 2 */
887 :
888 :			if (mvf1.x < low) {
889 :			mvf1.x += range;
890 :			} else if (mvf1.x > high) {
891 :			mvf1.x -= range;
892 :			}
893 :
894 :			if (mvf1.y < low) {
895 :			mvf1.y += range;
896 :			} else if (mvf1.y > high) {
897 :			mvf1.y -= range;
898 :			}
899 :
900 :			mvf2.x = get_mv(bs, fcode);
901 :			mvf2.y = get_mv(bs, fcode);
902 :
903 :			mvf2.x += pmv.x;
904 :			mvf2.y = 2(mvf2.y+pmv.y/2); / It's multiple of 2 */
905 :
906 :			if (mvf2.x < low) {
907 :			mvf2.x += range;
908 :			} else if (mvf2.x > high) {
909 :			mvf2.x -= range;
910 :			}
911 :
912 :			if (mvf2.y < low) {
913 :			mvf2.y += range;
914 :			} else if (mvf2.y > high) {
915 :			mvf2.y -= range;
916 :			}
917 :
918 :			pMB->mvs[0]=mvf1;
919 :			pMB->mvs[1]=mvf2;
920 :			pMB->mvs[2].x=pMB->mvs[3].x=0;
921 :			pMB->mvs[2].y=pMB->mvs[3].y=0;
922 :
923 :			/* Calculate average for as it is field predicted */
924 :			pMB->mvs_avg.x=DIV2ROUND(pMB->mvs[0].x+pMB->mvs[1].x);
925 :			pMB->mvs_avg.y=DIV2ROUND(pMB->mvs[0].y+pMB->mvs[1].y);
926 :			}
927 :	edgomez	1.51	}
928 :	Isibaar	1.1
929 :	edgomez	1.47	/* for P_VOP set gmc_warp to NULL */
930 :	edgomez	1.51	static void
931 :	edgomez	1.19	decoder_pframe(DECODER * dec,
932 :	suxen_drol	1.73	Bitstream * bs,
933 :			int rounding,
934 :			int quant,
935 :			int fcode,
936 :			int intra_dc_threshold,
937 :			const WARPPOINTS *const gmc_warp)
938 :	Isibaar	1.1	{
939 :	suxen_drol	1.73	uint32_t x, y;
940 :			uint32_t bound;
941 :			int cp_mb, st_mb;
942 :			const uint32_t mb_width = dec->mb_width;
943 :			const uint32_t mb_height = dec->mb_height;
944 :
945 :			if (!dec->is_edged[0]) {
946 :			start_timer();
947 :			image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
948 :			dec->width, dec->height, dec->bs_version);
949 :			dec->is_edged[0] = 1;
950 :			stop_edges_timer();
951 :			}
952 :
953 :			if (gmc_warp) {
954 :			/* accuracy: 0==1/2, 1=1/4, 2=1/8, 3=1/16 */
955 :			generate_GMCparameters( dec->sprite_warping_points,
956 :			dec->sprite_warping_accuracy, gmc_warp,
957 :			dec->width, dec->height, &dec->new_gmc_data);
958 :
959 :			/* image warping is done block-based in decoder_mbgmc(), now */
960 :			}
961 :
962 :			bound = 0;
963 :
964 :			for (y = 0; y < mb_height; y++) {
965 :			cp_mb = st_mb = 0;
966 :			for (x = 0; x < mb_width; x++) {
967 :			MACROBLOCK *mb;
968 :
969 :			/* skip stuffing */
970 :			while (BitstreamShowBits(bs, 10) == 1)
971 :			BitstreamSkip(bs, 10);
972 :
973 :			if (check_resync_marker(bs, fcode - 1)) {
974 :			bound = read_video_packet_header(bs, dec, fcode - 1,
975 :			&quant, &fcode, NULL, &intra_dc_threshold);
976 :			x = bound % mb_width;
977 :			y = bound / mb_width;
978 :			}
979 :			mb = &dec->mbs[y * dec->mb_width + x];
980 :
981 :			DPRINTF(XVID_DEBUG_MB, "macroblock (%i,%i) %08x\n", x, y, BitstreamShowBits(bs, 32));
982 :
983 :			if (!(BitstreamGetBit(bs))) { /* block _is_ coded */
984 :			uint32_t mcbpc, cbpc, cbpy, cbp;
985 :			uint32_t intra, acpred_flag = 0;
986 :			int mcsel = 0; /* mcsel: '0'=local motion, '1'=GMC */
987 :
988 :			cp_mb++;
989 :			mcbpc = get_mcbpc_inter(bs);
990 :			mb->mode = mcbpc & 7;
991 :			cbpc = (mcbpc >> 4);
992 :
993 :			DPRINTF(XVID_DEBUG_MB, "mode %i\n", mb->mode);
994 :			DPRINTF(XVID_DEBUG_MB, "cbpc %i\n", cbpc);
995 :
996 :			intra = (mb->mode == MODE_INTRA \|\| mb->mode == MODE_INTRA_Q);
997 :
998 :			if (gmc_warp && (mb->mode == MODE_INTER \|\| mb->mode == MODE_INTER_Q))
999 :			mcsel = BitstreamGetBit(bs);
1000 :			else if (intra)
1001 :			acpred_flag = BitstreamGetBit(bs);
1002 :
1003 :			cbpy = get_cbpy(bs, intra);
1004 :			DPRINTF(XVID_DEBUG_MB, "cbpy %i mcsel %i \n", cbpy,mcsel);
1005 :
1006 :			cbp = (cbpy << 2) \| cbpc;
1007 :
1008 :			if (mb->mode == MODE_INTER_Q \|\| mb->mode == MODE_INTRA_Q) {
1009 :			int dquant = dquant_table[BitstreamGetBits(bs, 2)];
1010 :			DPRINTF(XVID_DEBUG_MB, "dquant %i\n", dquant);
1011 :			quant += dquant;
1012 :			if (quant > 31) {
1013 :			quant = 31;
1014 :			} else if (quant < 1) {
1015 :			quant = 1;
1016 :			}
1017 :			DPRINTF(XVID_DEBUG_MB, "quant %i\n", quant);
1018 :			}
1019 :			mb->quant = quant;
1020 :
1021 :			mb->field_pred=0;
1022 :			if (dec->interlacing) {
1023 :			if (cbp \|\| intra) {
1024 :			mb->field_dct = BitstreamGetBit(bs);
1025 :			DPRINTF(XVID_DEBUG_MB,"decp: field_dct: %i\n", mb->field_dct);
1026 :			}
1027 :
1028 :			if ((mb->mode == MODE_INTER \|\| mb->mode == MODE_INTER_Q) && !mcsel) {
1029 :			mb->field_pred = BitstreamGetBit(bs);
1030 :			DPRINTF(XVID_DEBUG_MB, "decp: field_pred: %i\n", mb->field_pred);
1031 :
1032 :			if (mb->field_pred) {
1033 :			mb->field_for_top = BitstreamGetBit(bs);
1034 :			DPRINTF(XVID_DEBUG_MB,"decp: field_for_top: %i\n", mb->field_for_top);
1035 :			mb->field_for_bot = BitstreamGetBit(bs);
1036 :			DPRINTF(XVID_DEBUG_MB,"decp: field_for_bot: %i\n", mb->field_for_bot);
1037 :			}
1038 :			}
1039 :			}
1040 :
1041 :			if (mcsel) {
1042 :			decoder_mbgmc(dec, mb, x, y, fcode, cbp, bs, rounding);
1043 :			continue;
1044 :
1045 :			} else if (mb->mode == MODE_INTER \|\| mb->mode == MODE_INTER_Q) {
1046 :
1047 :			if(dec->interlacing) {
1048 :			/* Get motion vectors interlaced, field_pred is handled there */
1049 :			get_motion_vector_interlaced(dec, bs, x, y, 0, mb, fcode, bound);
1050 :			} else {
1051 :			get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1052 :			mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1053 :			}
1054 :			} else if (mb->mode == MODE_INTER4V ) {
1055 :			/* interlaced missing here */
1056 :			get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1057 :			get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);
1058 :			get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
1059 :			get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode, bound);
1060 :			} else { /* MODE_INTRA, MODE_INTRA_Q */
1061 :			mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
1062 :			mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
1063 :			decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
1064 :			intra_dc_threshold, bound);
1065 :			continue;
1066 :			}
1067 :
1068 :			/* See how to decode */
1069 :			if(!mb->field_pred)
1070 :	Isibaar	1.75.2.1	decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1071 :	suxen_drol	1.73	else
1072 :	Isibaar	1.75.2.1	decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1073 :	suxen_drol	1.73
1074 :			} else if (gmc_warp) { /* a not coded S(GMC)-VOP macroblock */
1075 :			mb->mode = MODE_NOT_CODED_GMC;
1076 :			mb->quant = quant;
1077 :			decoder_mbgmc(dec, mb, x, y, fcode, 0x00, bs, rounding);
1078 :
1079 :			if(dec->out_frm && cp_mb > 0) {
1080 :			output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1081 :			cp_mb = 0;
1082 :			}
1083 :			st_mb = x+1;
1084 :			} else { /* not coded P_VOP macroblock */
1085 :			mb->mode = MODE_NOT_CODED;
1086 :			mb->quant = quant;
1087 :
1088 :			mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
1089 :			mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
1090 :			mb->field_pred=0; /* (!) */
1091 :
1092 :			decoder_mbinter(dec, mb, x, y, 0, bs,
1093 :	Isibaar	1.75.2.1	rounding, 0, 0);
1094 :	suxen_drol	1.73
1095 :			if(dec->out_frm && cp_mb > 0) {
1096 :			output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1097 :			cp_mb = 0;
1098 :			}
1099 :			st_mb = x+1;
1100 :			}
1101 :			}
1102 :
1103 :			if(dec->out_frm && cp_mb > 0)
1104 :			output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1105 :			}
1106 :	Isibaar	1.1	}
1107 :
1108 :	edgomez	1.47
1109 :	edgomez	1.48	/* decode B-frame motion vector */
1110 :	edgomez	1.51	static void
1111 :			get_b_motion_vector(Bitstream * bs,
1112 :	suxen_drol	1.73	VECTOR * mv,
1113 :			int fcode,
1114 :			const VECTOR pmv,
1115 :			const DECODER * const dec,
1116 :			const int x, const int y)
1117 :	chenm001	1.14	{
1118 :	suxen_drol	1.73	const int scale_fac = 1 << (fcode - 1);
1119 :			const int high = (32 * scale_fac) - 1;
1120 :			const int low = ((-32) * scale_fac);
1121 :			const int range = (64 * scale_fac);
1122 :
1123 :			int mv_x = get_mv(bs, fcode);
1124 :			int mv_y = get_mv(bs, fcode);
1125 :
1126 :			mv_x += pmv.x;
1127 :			mv_y += pmv.y;
1128 :
1129 :			if (mv_x < low)
1130 :			mv_x += range;
1131 :			else if (mv_x > high)
1132 :			mv_x -= range;
1133 :
1134 :			if (mv_y < low)
1135 :			mv_y += range;
1136 :			else if (mv_y > high)
1137 :			mv_y -= range;
1138 :	edgomez	1.47
1139 :	suxen_drol	1.73	mv->x = mv_x;
1140 :			mv->y = mv_y;
1141 :	edgomez	1.47	}
1142 :
1143 :	edgomez	1.51	/* decode an B-frame direct & interpolate macroblock */
1144 :			static void
1145 :	edgomez	1.47	decoder_bf_interpolate_mbinter(DECODER * dec,
1146 :	suxen_drol	1.73	IMAGE forward,
1147 :			IMAGE backward,
1148 :			MACROBLOCK * pMB,
1149 :			const uint32_t x_pos,
1150 :			const uint32_t y_pos,
1151 :			Bitstream * bs,
1152 :			const int direct)
1153 :	edgomez	1.47	{
1154 :	suxen_drol	1.73	uint32_t stride = dec->edged_width;
1155 :			uint32_t stride2 = stride / 2;
1156 :			int uv_dx, uv_dy;
1157 :			int b_uv_dx, b_uv_dy;
1158 :			uint8_t pY_Cur, pU_Cur, *pV_Cur;
1159 :			const uint32_t cbp = pMB->cbp;
1160 :
1161 :			pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
1162 :			pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
1163 :			pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
1164 :
1165 :			validate_vector(pMB->mvs, x_pos, y_pos, dec);
1166 :			validate_vector(pMB->b_mvs, x_pos, y_pos, dec);
1167 :
1168 :			if (!direct) {
1169 :			uv_dx = pMB->mvs[0].x;
1170 :			uv_dy = pMB->mvs[0].y;
1171 :			b_uv_dx = pMB->b_mvs[0].x;
1172 :			b_uv_dy = pMB->b_mvs[0].y;
1173 :	edgomez	1.47
1174 :	suxen_drol	1.73	if (dec->quarterpel) {
1175 :	Isibaar	1.72	if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1176 :			uv_dx = (uv_dx>>1) \| (uv_dx&1);
1177 :			uv_dy = (uv_dy>>1) \| (uv_dy&1);
1178 :			b_uv_dx = (b_uv_dx>>1) \| (b_uv_dx&1);
1179 :			b_uv_dy = (b_uv_dy>>1) \| (b_uv_dy&1);
1180 :			}
1181 :			else {
1182 :	suxen_drol	1.73	uv_dx /= 2;
1183 :			uv_dy /= 2;
1184 :			b_uv_dx /= 2;
1185 :			b_uv_dy /= 2;
1186 :			}
1187 :			}
1188 :
1189 :			uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1190 :			uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
1191 :			b_uv_dx = (b_uv_dx >> 1) + roundtab_79[b_uv_dx & 0x3];
1192 :			b_uv_dy = (b_uv_dy >> 1) + roundtab_79[b_uv_dy & 0x3];
1193 :
1194 :			} else {
1195 :	Isibaar	1.75.2.1	if (dec->quarterpel) { /* for qpel the /2 shall be done before summation. We've done it right in the encoder in the past. */
1196 :			/* TODO: figure out if we ever did it wrong on the encoder side. If yes, add some workaround */
1197 :			if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1198 :			int z;
1199 :			uv_dx = 0; uv_dy = 0;
1200 :			b_uv_dx = 0; b_uv_dy = 0;
1201 :			for (z = 0; z < 4; z++) {
1202 :			uv_dx += ((pMB->mvs[z].x>>1) \| (pMB->mvs[z].x&1));
1203 :			uv_dy += ((pMB->mvs[z].y>>1) \| (pMB->mvs[z].y&1));
1204 :			b_uv_dx += ((pMB->b_mvs[z].x>>1) \| (pMB->b_mvs[z].x&1));
1205 :			b_uv_dy += ((pMB->b_mvs[z].y>>1) \| (pMB->b_mvs[z].y&1));
1206 :	Isibaar	1.72	}
1207 :	Isibaar	1.75.2.1	}
1208 :			else {
1209 :			uv_dx = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);
1210 :			uv_dy = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);
1211 :			b_uv_dx = (pMB->b_mvs[0].x / 2) + (pMB->b_mvs[1].x / 2) + (pMB->b_mvs[2].x / 2) + (pMB->b_mvs[3].x / 2);
1212 :			b_uv_dy = (pMB->b_mvs[0].y / 2) + (pMB->b_mvs[1].y / 2) + (pMB->b_mvs[2].y / 2) + (pMB->b_mvs[3].y / 2);
1213 :			}
1214 :			} else {
1215 :			uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
1216 :			uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
1217 :			b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;
1218 :			b_uv_dy = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;
1219 :	suxen_drol	1.73	}
1220 :
1221 :			uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
1222 :			uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
1223 :			b_uv_dx = (b_uv_dx >> 3) + roundtab_76[b_uv_dx & 0xf];
1224 :			b_uv_dy = (b_uv_dy >> 3) + roundtab_76[b_uv_dy & 0xf];
1225 :			}
1226 :
1227 :			start_timer();
1228 :			if(dec->quarterpel) {
1229 :			if(!direct) {
1230 :			interpolate16x16_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1231 :			dec->qtmp.y + 128, 16x_pos, 16y_pos,
1232 :			pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1233 :			} else {
1234 :			interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1235 :			dec->qtmp.y + 128, 16x_pos, 16y_pos,
1236 :			pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1237 :			interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1238 :			dec->qtmp.y + 128, 16x_pos + 8, 16y_pos,
1239 :			pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1240 :			interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1241 :			dec->qtmp.y + 128, 16x_pos, 16y_pos + 8,
1242 :			pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1243 :			interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1244 :			dec->qtmp.y + 128, 16x_pos + 8, 16y_pos + 8,
1245 :			pMB->mvs[3].x, pMB->mvs[3].y, stride, 0);
1246 :			}
1247 :			} else {
1248 :			interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos,
1249 :			pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1250 :			interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos,
1251 :			pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1252 :			interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos + 8,
1253 :			pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1254 :			interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos + 8,
1255 :			pMB->mvs[3].x, pMB->mvs[3].y, stride, 0);
1256 :			}
1257 :
1258 :			interpolate8x8_switch(dec->cur.u, forward.u, 8 * x_pos, 8 * y_pos, uv_dx,
1259 :			uv_dy, stride2, 0);
1260 :			interpolate8x8_switch(dec->cur.v, forward.v, 8 * x_pos, 8 * y_pos, uv_dx,
1261 :			uv_dy, stride2, 0);
1262 :
1263 :
1264 :			if(dec->quarterpel) {
1265 :			if(!direct) {
1266 :			interpolate16x16_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1267 :			dec->qtmp.y + 128, 16x_pos, 16y_pos,
1268 :			pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1269 :			} else {
1270 :			interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1271 :			dec->qtmp.y + 128, 16x_pos, 16y_pos,
1272 :			pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1273 :			interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1274 :			dec->qtmp.y + 128, 16x_pos + 8, 16y_pos,
1275 :			pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1276 :			interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1277 :			dec->qtmp.y + 128, 16x_pos, 16y_pos + 8,
1278 :			pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1279 :			interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1280 :			dec->qtmp.y + 128, 16x_pos + 8, 16y_pos + 8,
1281 :			pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1282 :			}
1283 :			} else {
1284 :			interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos, 16 * y_pos,
1285 :			pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1286 :			interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1287 :			16 * y_pos, pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1288 :			interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos,
1289 :			16 * y_pos + 8, pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1290 :			interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1291 :			16 * y_pos + 8, pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1292 :			}
1293 :
1294 :			interpolate8x8_add_switch(dec->cur.u, backward.u, 8 * x_pos, 8 * y_pos,
1295 :			b_uv_dx, b_uv_dy, stride2, 0);
1296 :			interpolate8x8_add_switch(dec->cur.v, backward.v, 8 * x_pos, 8 * y_pos,
1297 :			b_uv_dx, b_uv_dy, stride2, 0);
1298 :	edgomez	1.47
1299 :	suxen_drol	1.73	stop_comp_timer();
1300 :	edgomez	1.47
1301 :	suxen_drol	1.73	if (cbp)
1302 :			decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
1303 :	edgomez	1.47	}
1304 :
1305 :	edgomez	1.48	/* for decode B-frame dbquant */
1306 :	edgomez	1.51	static __inline int32_t
1307 :	edgomez	1.47	get_dbquant(Bitstream * bs)
1308 :			{
1309 :	suxen_drol	1.73	if (!BitstreamGetBit(bs)) /* '0' */
1310 :			return (0);
1311 :			else if (!BitstreamGetBit(bs)) /* '10' */
1312 :			return (-2);
1313 :			else /* '11' */
1314 :			return (2);
1315 :	edgomez	1.47	}
1316 :
1317 :	edgomez	1.48	/*
1318 :	edgomez	1.51	* decode B-frame mb_type
1319 :	suxen_drol	1.73	* bit ret_value
1320 :			* 1 0
1321 :			* 01 1
1322 :			* 001 2
1323 :			* 0001 3
1324 :	edgomez	1.48	*/
1325 :	edgomez	1.51	static int32_t __inline
1326 :	edgomez	1.47	get_mbtype(Bitstream * bs)
1327 :			{
1328 :	suxen_drol	1.73	int32_t mb_type;
1329 :	edgomez	1.47
1330 :	suxen_drol	1.73	for (mb_type = 0; mb_type <= 3; mb_type++)
1331 :			if (BitstreamGetBit(bs))
1332 :			return (mb_type);
1333 :	edgomez	1.47
1334 :	suxen_drol	1.73	return -1;
1335 :	edgomez	1.47	}
1336 :
1337 :	edgomez	1.51	static void
1338 :	edgomez	1.47	decoder_bframe(DECODER * dec,
1339 :	suxen_drol	1.73	Bitstream * bs,
1340 :			int quant,
1341 :			int fcode_forward,
1342 :			int fcode_backward)
1343 :	edgomez	1.47	{
1344 :	suxen_drol	1.73	uint32_t x, y;
1345 :			VECTOR mv;
1346 :			const VECTOR zeromv = {0,0};
1347 :			int i;
1348 :
1349 :			if (!dec->is_edged[0]) {
1350 :			start_timer();
1351 :			image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
1352 :			dec->width, dec->height, dec->bs_version);
1353 :			dec->is_edged[0] = 1;
1354 :			stop_edges_timer();
1355 :			}
1356 :
1357 :			if (!dec->is_edged[1]) {
1358 :			start_timer();
1359 :			image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
1360 :			dec->width, dec->height, dec->bs_version);
1361 :			dec->is_edged[1] = 1;
1362 :			stop_edges_timer();
1363 :			}
1364 :
1365 :			for (y = 0; y < dec->mb_height; y++) {
1366 :			/* Initialize Pred Motion Vector */
1367 :			dec->p_fmv = dec->p_bmv = zeromv;
1368 :			for (x = 0; x < dec->mb_width; x++) {
1369 :			MACROBLOCK mb = &dec->mbs[y dec->mb_width + x];
1370 :			MACROBLOCK last_mb = &dec->last_mbs[y dec->mb_width + x];
1371 :			const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;
1372 :	suxen_drol	1.74	int intra_dc_threshold; /* fake variable */
1373 :	suxen_drol	1.73
1374 :			if (check_resync_marker(bs, fcode_max - 1)) {
1375 :			int bound = read_video_packet_header(bs, dec, fcode_max - 1, &quant,
1376 :			&fcode_forward, &fcode_backward, &intra_dc_threshold);
1377 :			x = bound % dec->mb_width;
1378 :			y = bound / dec->mb_width;
1379 :			/* reset predicted macroblocks */
1380 :			dec->p_fmv = dec->p_bmv = zeromv;
1381 :			}
1382 :
1383 :			mv =
1384 :			mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =
1385 :			mb->mvs[0] = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = zeromv;
1386 :			mb->quant = quant;
1387 :
1388 :			/*
1389 :			* skip if the co-located P_VOP macroblock is not coded
1390 :			* if not codec in co-located S_VOP macroblock is _not_
1391 :			* automatically skipped
1392 :			*/
1393 :
1394 :			if (last_mb->mode == MODE_NOT_CODED) {
1395 :			mb->cbp = 0;
1396 :			mb->mode = MODE_FORWARD;
1397 :	Isibaar	1.75.2.1	decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1398 :	suxen_drol	1.73	continue;
1399 :			}
1400 :
1401 :			if (!BitstreamGetBit(bs)) { /* modb=='0' */
1402 :			const uint8_t modb2 = BitstreamGetBit(bs);
1403 :
1404 :			mb->mode = get_mbtype(bs);
1405 :
1406 :			if (!modb2) /* modb=='00' */
1407 :			mb->cbp = BitstreamGetBits(bs, 6);
1408 :			else
1409 :			mb->cbp = 0;
1410 :
1411 :			if (mb->mode && mb->cbp) {
1412 :			quant += get_dbquant(bs);
1413 :			if (quant > 31)
1414 :			quant = 31;
1415 :			else if (quant < 1)
1416 :			quant = 1;
1417 :			}
1418 :			mb->quant = quant;
1419 :
1420 :			if (dec->interlacing) {
1421 :			if (mb->cbp) {
1422 :			mb->field_dct = BitstreamGetBit(bs);
1423 :			DPRINTF(XVID_DEBUG_MB,"decp: field_dct: %i\n", mb->field_dct);
1424 :			}
1425 :
1426 :			if (mb->mode) {
1427 :			mb->field_pred = BitstreamGetBit(bs);
1428 :			DPRINTF(XVID_DEBUG_MB, "decp: field_pred: %i\n", mb->field_pred);
1429 :
1430 :			if (mb->field_pred) {
1431 :			mb->field_for_top = BitstreamGetBit(bs);
1432 :			DPRINTF(XVID_DEBUG_MB,"decp: field_for_top: %i\n", mb->field_for_top);
1433 :			mb->field_for_bot = BitstreamGetBit(bs);
1434 :			DPRINTF(XVID_DEBUG_MB,"decp: field_for_bot: %i\n", mb->field_for_bot);
1435 :			}
1436 :			}
1437 :			}
1438 :
1439 :			} else {
1440 :			mb->mode = MODE_DIRECT_NONE_MV;
1441 :			mb->cbp = 0;
1442 :			}
1443 :
1444 :			switch (mb->mode) {
1445 :			case MODE_DIRECT:
1446 :			get_b_motion_vector(bs, &mv, 1, zeromv, dec, x, y);
1447 :
1448 :			case MODE_DIRECT_NONE_MV:
1449 :			for (i = 0; i < 4; i++) {
1450 :			mb->mvs[i].x = last_mb->mvs[i].x*dec->time_bp/dec->time_pp + mv.x;
1451 :			mb->mvs[i].y = last_mb->mvs[i].y*dec->time_bp/dec->time_pp + mv.y;
1452 :
1453 :			mb->b_mvs[i].x = (mv.x)
1454 :			? mb->mvs[i].x - last_mb->mvs[i].x
1455 :			: last_mb->mvs[i].x*(dec->time_bp - dec->time_pp)/dec->time_pp;
1456 :			mb->b_mvs[i].y = (mv.y)
1457 :			? mb->mvs[i].y - last_mb->mvs[i].y
1458 :			: last_mb->mvs[i].y*(dec->time_bp - dec->time_pp)/dec->time_pp;
1459 :			}
1460 :
1461 :			decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1462 :			mb, x, y, bs, 1);
1463 :			break;
1464 :
1465 :			case MODE_INTERPOLATE:
1466 :			get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1467 :			dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1468 :
1469 :			get_b_motion_vector(bs, &mb->b_mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1470 :			dec->p_bmv = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] = mb->b_mvs[0];
1471 :
1472 :			decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1473 :			mb, x, y, bs, 0);
1474 :			break;
1475 :
1476 :			case MODE_BACKWARD:
1477 :			get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1478 :			dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1479 :
1480 :	Isibaar	1.75.2.1	decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1481 :	suxen_drol	1.73	break;
1482 :
1483 :			case MODE_FORWARD:
1484 :			get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1485 :			dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1486 :
1487 :	Isibaar	1.75.2.1	decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1488 :	suxen_drol	1.73	break;
1489 :
1490 :			default:
1491 :			DPRINTF(XVID_DEBUG_ERROR,"Not supported B-frame mb_type = %i\n", mb->mode);
1492 :			}
1493 :			} /* End of for */
1494 :			}
1495 :	edgomez	1.47	}
1496 :
1497 :			/* perform post processing if necessary, and output the image */
1498 :	suxen_drol	1.75	static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1499 :	suxen_drol	1.73	xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1500 :			int coding_type, int quant)
1501 :	edgomez	1.47	{
1502 :	suxen_drol	1.73	const int brightness = XVID_VERSION_MINOR(frame->version) >= 1 ? frame->brightness : 0;
1503 :	suxen_drol	1.55
1504 :	suxen_drol	1.73	if (dec->cartoon_mode)
1505 :			frame->general &= ~XVID_FILMEFFECT;
1506 :	edgomez	1.47
1507 :	suxen_drol	1.73	if ((frame->general & (XVID_DEBLOCKY\|XVID_DEBLOCKUV\|XVID_FILMEFFECT) \|\| brightness!=0)
1508 :			&& mbs != NULL) /* post process */
1509 :			{
1510 :			/* note: image is stored to tmp */
1511 :			image_copy(&dec->tmp, img, dec->edged_width, dec->height);
1512 :			image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,
1513 :			mbs, dec->mb_width, dec->mb_height, dec->mb_width,
1514 :			frame->general, brightness, dec->frames, (coding_type == B_VOP));
1515 :			img = &dec->tmp;
1516 :			}
1517 :
1518 :			image_output(img, dec->width, dec->height,
1519 :			dec->edged_width, (uint8_t**)frame->output.plane, frame->output.stride,
1520 :			frame->output.csp, dec->interlacing);
1521 :
1522 :			if (stats) {
1523 :			stats->type = coding2type(coding_type);
1524 :			stats->data.vop.time_base = (int)dec->time_base;
1525 :			stats->data.vop.time_increment = 0; /* XXX: todo */
1526 :			stats->data.vop.qscale_stride = dec->mb_width;
1527 :			stats->data.vop.qscale = dec->qscale;
1528 :			if (stats->data.vop.qscale != NULL && mbs != NULL) {
1529 :			unsigned int i;
1530 :			for (i = 0; i < dec->mb_width*dec->mb_height; i++)
1531 :			stats->data.vop.qscale[i] = mbs[i].quant;
1532 :			} else
1533 :			stats->data.vop.qscale = NULL;
1534 :			}
1535 :	edgomez	1.47	}
1536 :
1537 :			int
1538 :			decoder_decode(DECODER * dec,
1539 :	suxen_drol	1.73	xvid_dec_frame_t * frame, xvid_dec_stats_t * stats)
1540 :	edgomez	1.47	{
1541 :
1542 :	suxen_drol	1.73	Bitstream bs;
1543 :			uint32_t rounding;
1544 :			uint32_t quant = 2;
1545 :			uint32_t fcode_forward;
1546 :			uint32_t fcode_backward;
1547 :			uint32_t intra_dc_threshold;
1548 :			WARPPOINTS gmc_warp;
1549 :			int coding_type;
1550 :			int success, output, seen_something;
1551 :
1552 :			if (XVID_VERSION_MAJOR(frame->version) != 1 \|\| (stats && XVID_VERSION_MAJOR(stats->version) != 1)) /* v1.x.x */
1553 :			return XVID_ERR_VERSION;
1554 :
1555 :			start_global_timer();
1556 :
1557 :			dec->low_delay_default = (frame->general & XVID_LOWDELAY);
1558 :			if ((frame->general & XVID_DISCONTINUITY))
1559 :			dec->frames = 0;
1560 :			dec->out_frm = (frame->output.csp == XVID_CSP_SLICE) ? &frame->output : NULL;
1561 :
1562 :			if(frame->length<0) { /* decoder flush */
1563 :			int ret;
1564 :			/* if not decoding "low_delay/packed", and this isn't low_delay and
1565 :			we have a reference frame, then outout the reference frame */
1566 :			if (!(dec->low_delay_default && dec->packed_mode) && !dec->low_delay && dec->frames>0) {
1567 :			decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1568 :			dec->frames = 0;
1569 :			ret = 0;
1570 :			} else {
1571 :			if (stats) stats->type = XVID_TYPE_NOTHING;
1572 :			ret = XVID_ERR_END;
1573 :			}
1574 :
1575 :			emms();
1576 :			stop_global_timer();
1577 :			return ret;
1578 :			}
1579 :
1580 :			BitstreamInit(&bs, frame->bitstream, frame->length);
1581 :
1582 :			/* XXX: 0x7f is only valid whilst decoding vfw xvid/divx5 avi's */
1583 :			if(dec->low_delay_default && frame->length == 1 && BitstreamShowBits(&bs, 8) == 0x7f)
1584 :			{
1585 :			image_output(&dec->refn[0], dec->width, dec->height, dec->edged_width,
1586 :			(uint8_t**)frame->output.plane, frame->output.stride, frame->output.csp, dec->interlacing);
1587 :			if (stats) stats->type = XVID_TYPE_NOTHING;
1588 :			emms();
1589 :			return 1; /* one byte consumed */
1590 :			}
1591 :
1592 :			success = 0;
1593 :			output = 0;
1594 :			seen_something = 0;
1595 :	edgomez	1.51
1596 :	edgomez	1.47	repeat:
1597 :
1598 :	suxen_drol	1.73	coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1599 :			&quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1600 :	edgomez	1.47
1601 :	suxen_drol	1.73	DPRINTF(XVID_DEBUG_HEADER, "coding_type=%i, packed=%i, time=%"
1602 :	suxen_drol	1.69	#if defined(_MSC_VER)
1603 :			"I64"
1604 :			#else
1605 :			"ll"
1606 :			#endif
1607 :			"i, time_pp=%i, time_bp=%i\n",
1608 :	suxen_drol	1.73	coding_type, dec->packed_mode, dec->time, dec->time_pp, dec->time_bp);
1609 :	Isibaar	1.1
1610 :	suxen_drol	1.73	if (coding_type == -1) { /* nothing */
1611 :			if (success) goto done;
1612 :			if (stats) stats->type = XVID_TYPE_NOTHING;
1613 :			emms();
1614 :			return BitstreamPos(&bs)/8;
1615 :			}
1616 :
1617 :			if (coding_type == -2 \|\| coding_type == -3) { /* vol and/or resize */
1618 :
1619 :			if (coding_type == -3)
1620 :			decoder_resize(dec);
1621 :
1622 :			if(stats) {
1623 :			stats->type = XVID_TYPE_VOL;
1624 :			stats->data.vol.general = 0;
1625 :			/*XXX: if (dec->interlacing)
1626 :			stats->data.vol.general \|= ++INTERLACING; */
1627 :			stats->data.vol.width = dec->width;
1628 :			stats->data.vol.height = dec->height;
1629 :			stats->data.vol.par = dec->aspect_ratio;
1630 :			stats->data.vol.par_width = dec->par_width;
1631 :			stats->data.vol.par_height = dec->par_height;
1632 :			emms();
1633 :			return BitstreamPos(&bs)/8; /* number of bytes consumed */
1634 :			}
1635 :			goto repeat;
1636 :			}
1637 :
1638 :			if(dec->frames == 0 && coding_type != I_VOP) {
1639 :			/* 1st frame is not an i-vop */
1640 :			goto repeat;
1641 :			}
1642 :
1643 :			dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0; /* init pred vector to 0 */
1644 :
1645 :			/* packed_mode: special-N_VOP treament */
1646 :			if (dec->packed_mode && coding_type == N_VOP) {
1647 :			if (dec->low_delay_default && dec->frames > 0) {
1648 :			decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1649 :			output = 1;
1650 :			}
1651 :			/* ignore otherwise */
1652 :			} else if (coding_type != B_VOP) {
1653 :			switch(coding_type) {
1654 :			case I_VOP :
1655 :			decoder_iframe(dec, &bs, quant, intra_dc_threshold);
1656 :			break;
1657 :			case P_VOP :
1658 :			decoder_pframe(dec, &bs, rounding, quant,
1659 :			fcode_forward, intra_dc_threshold, NULL);
1660 :			break;
1661 :			case S_VOP :
1662 :			decoder_pframe(dec, &bs, rounding, quant,
1663 :			fcode_forward, intra_dc_threshold, &gmc_warp);
1664 :			break;
1665 :			case N_VOP :
1666 :			/* XXX: not_coded vops are not used for forward prediction */
1667 :			/* we should not swap(last_mbs,mbs) */
1668 :			image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);
1669 :			SWAP(MACROBLOCK , dec->mbs, dec->last_mbs); / it will be swapped back */
1670 :			break;
1671 :			}
1672 :
1673 :			/* note: for packed_mode, output is performed when the special-N_VOP is decoded */
1674 :			if (!(dec->low_delay_default && dec->packed_mode)) {
1675 :			if(dec->low_delay) {
1676 :			decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
1677 :			output = 1;
1678 :			} else if (dec->frames > 0) { /* is the reference frame valid? */
1679 :			/* output the reference frame */
1680 :			decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1681 :			output = 1;
1682 :			}
1683 :			}
1684 :
1685 :			image_swap(&dec->refn[0], &dec->refn[1]);
1686 :			dec->is_edged[1] = dec->is_edged[0];
1687 :			image_swap(&dec->cur, &dec->refn[0]);
1688 :			dec->is_edged[0] = 0;
1689 :			SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);
1690 :			dec->last_coding_type = coding_type;
1691 :
1692 :			dec->frames++;
1693 :			seen_something = 1;
1694 :
1695 :			} else { /* B_VOP */
1696 :
1697 :			if (dec->low_delay) {
1698 :			DPRINTF(XVID_DEBUG_ERROR, "warning: bvop found in low_delay==1 stream\n");
1699 :			dec->low_delay = 0;
1700 :			}
1701 :
1702 :			if (dec->frames < 2) {
1703 :			/* attemping to decode a bvop without atleast 2 reference frames */
1704 :			image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,
1705 :			"broken b-frame, mising ref frames");
1706 :			if (stats) stats->type = XVID_TYPE_NOTHING;
1707 :			} else if (dec->time_pp <= dec->time_bp) {
1708 :			/* this occurs when dx50_bvop_compatibility==0 sequences are
1709 :			decoded in vfw. */
1710 :			image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,
1711 :			"broken b-frame, tpp=%i tbp=%i", dec->time_pp, dec->time_bp);
1712 :			if (stats) stats->type = XVID_TYPE_NOTHING;
1713 :			} else {
1714 :			decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);
1715 :			decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
1716 :			}
1717 :
1718 :			output = 1;
1719 :			dec->frames++;
1720 :			}
1721 :	chenm001	1.14
1722 :	edgomez	1.51	#if 0 /* Avoids to read to much data because of 32bit reads in our BS functions */
1723 :	suxen_drol	1.73	BitstreamByteAlign(&bs);
1724 :	edgomez	1.51	#endif
1725 :	edgomez	1.47
1726 :	suxen_drol	1.73	/* low_delay_default mode: repeat in packed_mode */
1727 :			if (dec->low_delay_default && dec->packed_mode && output == 0 && success == 0) {
1728 :			success = 1;
1729 :			goto repeat;
1730 :			}
1731 :	edgomez	1.47
1732 :			done :
1733 :
1734 :	suxen_drol	1.69	/* if we reach here without outputing anything _and_
1735 :			the calling application has specified low_delay_default,
1736 :			we must output something.
1737 :			this always occurs on the first call to decode() call
1738 :			when bframes are present in the bitstream. it may also
1739 :			occur if no vops were seen in the bitstream
1740 :
1741 :			if packed_mode is enabled, then we output the recently
1742 :			decoded frame (the very first ivop). otherwise we have
1743 :			nothing to display, and therefore output a black screen.
1744 :			*/
1745 :			if (dec->low_delay_default && output == 0) {
1746 :			if (dec->packed_mode && seen_something) {
1747 :	suxen_drol	1.73	decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1748 :	suxen_drol	1.69	} else {
1749 :	suxen_drol	1.73	image_clear(&dec->cur, dec->width, dec->height, dec->edged_width, 0, 128, 128);
1750 :			decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);
1751 :			if (stats) stats->type = XVID_TYPE_NOTHING;
1752 :			}
1753 :			}
1754 :	Isibaar	1.50
1755 :	suxen_drol	1.73	emms();
1756 :			stop_global_timer();
1757 :	Isibaar	1.1
1758 :	suxen_drol	1.73	return (BitstreamPos(&bs)+7)/8; /* number of bytes consumed */
1759 :	Isibaar	1.1	}

No admin address has been configured	ViewVC Help
Powered by ViewVC 1.0.4