Annotation of /branches/dev-api-3/xvidcore/src/decoder.c

Revision 543 - (view) (download)

1 :	Isibaar	3	/**************************************************************************
2 :			*
3 :	edgomez	146	* XVID MPEG-4 VIDEO CODEC
4 :			* - Decoder main module -
5 :	Isibaar	3	*
6 :	edgomez	146	* This program is an implementation of a part of one or more MPEG-4
7 :			* Video tools as specified in ISO/IEC 14496-2 standard. Those intending
8 :			* to use this software module in hardware or software products are
9 :			* advised that its use may infringe existing patents or copyrights, and
10 :			* any such use would be at such party's own risk. The original
11 :			* developer of this software module and his/her company, and subsequent
12 :			* editors and their companies, will have no liability for use of this
13 :			* software or modifications or derivatives thereof.
14 :	Isibaar	3	*
15 :	edgomez	146	* This program is free software; you can redistribute it and/or modify
16 :			* it under the terms of the GNU General Public License as published by
17 :			* the Free Software Foundation; either version 2 of the License, or
18 :			* (at your option) any later version.
19 :	Isibaar	3	*
20 :	edgomez	146	* This program is distributed in the hope that it will be useful,
21 :			* but WITHOUT ANY WARRANTY; without even the implied warranty of
22 :			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 :			* GNU General Public License for more details.
24 :	Isibaar	3	*
25 :	edgomez	146	* You should have received a copy of the GNU General Public License
26 :			* along with this program; if not, write to the Free Software
27 :			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 :	Isibaar	3	*
29 :			*************************************************************************/
30 :
31 :			/**************************************************************************
32 :			*
33 :	edgomez	146	* History:
34 :	Isibaar	3	*
35 :	chenm001	297	* 15.07.2002 fix a bug in B-frame decode at DIRECT mode
36 :			* MinChen <chenm001@163.com>
37 :	chenm001	290	* 10.07.2002 added BFRAMES_DEC_DEBUG support
38 :			* Fix a little bug for low_delay flage
39 :			* MinChen <chenm001@163.com>
40 :	chenm001	272	* 28.06.2002 added basic resync support to iframe/pframe_decode()
41 :	chenm001	290	* 22.06.2002 added primative N_VOP support
42 :	chenm001	297	* #define BFRAMES_DEC now enables Minchen's bframe decoder
43 :	chenm001	168	* 08.05.2002 add low_delay support for B_VOP decode
44 :			* MinChen <chenm001@163.com>
45 :			* 05.05.2002 fix some B-frame decode problem
46 :	chenm001	156	* 02.05.2002 add B-frame decode support(have some problem);
47 :			* MinChen <chenm001@163.com>
48 :	chenm001	133	* 22.04.2002 add some B-frame decode support; chenm001 <chenm001@163.com>
49 :	h	81	* 29.03.2002 interlacing fix - compensated block wasn't being used when
50 :			* reconstructing blocks, thus artifacts
51 :			* interlacing speedup - used transfers to re-interlace
52 :			* interlaced decoding should be as fast as progressive now
53 :	h	69	* 26.03.2002 interlacing support - moved transfers outside decode loop
54 :	edgomez	146	* 26.12.2001 decoder_mbinter: dequant/idct moved within if(coded) block
55 :			* 22.12.2001 lock based interpolation
56 :			* 01.12.2001 inital version; (c)2001 peter ross <pross@cs.rmit.edu.au>
57 :	Isibaar	3	*
58 :	h	543	* $Id: decoder.c,v 1.37.2.1 2002-09-26 01:54:54 h Exp $
59 :	edgomez	146	*
60 :	Isibaar	3	*************************************************************************/
61 :
62 :			#include <stdlib.h>
63 :	edgomez	146	#include <string.h>
64 :	Isibaar	3
65 :	chenm001	290	#ifdef BFRAMES_DEC_DEBUG
66 :			#define BFRAMES_DEC
67 :			#endif
68 :
69 :	Isibaar	3	#include "xvid.h"
70 :			#include "portab.h"
71 :
72 :			#include "decoder.h"
73 :			#include "bitstream/bitstream.h"
74 :			#include "bitstream/mbcoding.h"
75 :
76 :			#include "quant/quant_h263.h"
77 :			#include "quant/quant_mpeg4.h"
78 :			#include "dct/idct.h"
79 :			#include "dct/fdct.h"
80 :			#include "utils/mem_transfer.h"
81 :			#include "image/interpolate8x8.h"
82 :
83 :			#include "bitstream/mbcoding.h"
84 :			#include "prediction/mbprediction.h"
85 :			#include "utils/timer.h"
86 :			#include "utils/emms.h"
87 :
88 :			#include "image/image.h"
89 :			#include "image/colorspace.h"
90 :	Isibaar	41	#include "utils/mem_align.h"
91 :	Isibaar	3
92 :	edgomez	195	int
93 :			decoder_create(XVID_DEC_PARAM * param)
94 :	Isibaar	3	{
95 :	edgomez	195	DECODER *dec;
96 :	Isibaar	3
97 :	Isibaar	42	dec = xvid_malloc(sizeof(DECODER), CACHE_LINE);
98 :	edgomez	195	if (dec == NULL) {
99 :	Isibaar	3	return XVID_ERR_MEMORY;
100 :			}
101 :			param->handle = dec;
102 :
103 :			dec->width = param->width;
104 :			dec->height = param->height;
105 :
106 :			dec->mb_width = (dec->width + 15) / 16;
107 :			dec->mb_height = (dec->height + 15) / 16;
108 :
109 :			dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;
110 :			dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;
111 :	Isibaar	208	dec->low_delay = 0;
112 :	edgomez	195
113 :			if (image_create(&dec->cur, dec->edged_width, dec->edged_height)) {
114 :	Isibaar	41	xvid_free(dec);
115 :	Isibaar	3	return XVID_ERR_MEMORY;
116 :			}
117 :
118 :	edgomez	195	if (image_create(&dec->refn[0], dec->edged_width, dec->edged_height)) {
119 :	Isibaar	3	image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
120 :	Isibaar	41	xvid_free(dec);
121 :	Isibaar	3	return XVID_ERR_MEMORY;
122 :			}
123 :	chenm001	133	// add by chenm001 <chenm001@163.com>
124 :			// for support B-frame to reference last 2 frame
125 :	edgomez	195	if (image_create(&dec->refn[1], dec->edged_width, dec->edged_height)) {
126 :	chenm001	133	image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
127 :			image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
128 :			xvid_free(dec);
129 :			return XVID_ERR_MEMORY;
130 :			}
131 :	edgomez	195	if (image_create(&dec->refn[2], dec->edged_width, dec->edged_height)) {
132 :	chenm001	156	image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
133 :			image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
134 :			image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
135 :			xvid_free(dec);
136 :			return XVID_ERR_MEMORY;
137 :			}
138 :	Isibaar	3
139 :	edgomez	195	dec->mbs =
140 :			xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
141 :			CACHE_LINE);
142 :			if (dec->mbs == NULL) {
143 :	Isibaar	3	image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
144 :	chenm001	156	image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
145 :			image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
146 :			image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);
147 :	Isibaar	41	xvid_free(dec);
148 :	Isibaar	3	return XVID_ERR_MEMORY;
149 :			}
150 :	Isibaar	208
151 :			memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
152 :
153 :	chenm001	156	// add by chenm001 <chenm001@163.com>
154 :			// for skip MB flag
155 :	edgomez	195	dec->last_mbs =
156 :			xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
157 :			CACHE_LINE);
158 :			if (dec->last_mbs == NULL) {
159 :	chenm001	156	xvid_free(dec->mbs);
160 :			image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
161 :			image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
162 :			image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
163 :			image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);
164 :			xvid_free(dec);
165 :			return XVID_ERR_MEMORY;
166 :			}
167 :	Isibaar	3
168 :	Isibaar	208	memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
169 :
170 :	Isibaar	3	init_timer();
171 :
172 :	chenm001	156	// add by chenm001 <chenm001@163.com>
173 :			// for support B-frame to save reference frame's time
174 :			dec->frames = -1;
175 :			dec->time = dec->time_base = dec->last_time_base = 0;
176 :	edgomez	195
177 :	Isibaar	3	return XVID_ERR_OK;
178 :			}
179 :
180 :
181 :	edgomez	195	int
182 :			decoder_destroy(DECODER * dec)
183 :	Isibaar	3	{
184 :	chenm001	156	xvid_free(dec->last_mbs);
185 :	Isibaar	41	xvid_free(dec->mbs);
186 :	chenm001	133	image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
187 :	chenm001	156	image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
188 :			image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);
189 :	Isibaar	3	image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
190 :	Isibaar	41	xvid_free(dec);
191 :	Isibaar	3
192 :			write_timer();
193 :			return XVID_ERR_OK;
194 :			}
195 :
196 :
197 :
198 :	edgomez	195	static const int32_t dquant_table[4] = {
199 :	Isibaar	3	-1, -2, 1, 2
200 :			};
201 :
202 :
203 :	chenm001	156
204 :
205 :	Isibaar	3	// decode an intra macroblock
206 :
207 :	edgomez	195	void
208 :			decoder_mbintra(DECODER * dec,
209 :			MACROBLOCK * pMB,
210 :			const uint32_t x_pos,
211 :			const uint32_t y_pos,
212 :			const uint32_t acpred_flag,
213 :			const uint32_t cbp,
214 :			Bitstream * bs,
215 :			const uint32_t quant,
216 :	chenm001	272	const uint32_t intra_dc_threshold,
217 :			const unsigned int bound)
218 :	Isibaar	3	{
219 :	edgomez	78
220 :			DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
221 :	edgomez	195	DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);
222 :	edgomez	78
223 :	h	81	uint32_t stride = dec->edged_width;
224 :			uint32_t stride2 = stride / 2;
225 :			uint32_t next_block = stride * 8;
226 :	h	69	uint32_t i;
227 :			uint32_t iQuant = pMB->quant;
228 :			uint8_t pY_Cur, pU_Cur, *pV_Cur;
229 :
230 :	edgomez	78	pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
231 :	h	81	pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
232 :			pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
233 :	h	69
234 :	edgomez	195	memset(block, 0, 6 * 64 * sizeof(int16_t)); // clear
235 :	h	69
236 :	edgomez	195	for (i = 0; i < 6; i++) {
237 :	h	69	uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
238 :	Isibaar	3	int16_t predictors[8];
239 :			int start_coeff;
240 :
241 :			start_timer();
242 :	edgomez	195	predict_acdc(dec->mbs, x_pos, y_pos, dec->mb_width, i, &block[i * 64],
243 :	chenm001	272	iQuant, iDcScaler, predictors, bound);
244 :	edgomez	195	if (!acpred_flag) {
245 :	h	69	pMB->acpred_directions[i] = 0;
246 :	Isibaar	3	}
247 :			stop_prediction_timer();
248 :
249 :	edgomez	195	if (quant < intra_dc_threshold) {
250 :	Isibaar	3	int dc_size;
251 :			int dc_dif;
252 :
253 :	edgomez	195	dc_size = i < 4 ? get_dc_size_lum(bs) : get_dc_size_chrom(bs);
254 :			dc_dif = dc_size ? get_dc_dif(bs, dc_size) : 0;
255 :	Isibaar	3
256 :	edgomez	195	if (dc_size > 8) {
257 :			BitstreamSkip(bs, 1); // marker
258 :	Isibaar	3	}
259 :	edgomez	195
260 :			block[i * 64 + 0] = dc_dif;
261 :	Isibaar	3	start_coeff = 1;
262 :	chenm001	272
263 :			DPRINTF(DPRINTF_COEFF,"block[0] %i", dc_dif);
264 :	edgomez	195	} else {
265 :	Isibaar	3	start_coeff = 0;
266 :			}
267 :
268 :			start_timer();
269 :	edgomez	195	if (cbp & (1 << (5 - i))) // coded
270 :	Isibaar	3	{
271 :	h	543	int direction = dec->alternate_vertical_scan ?
272 :			2 : pMB->acpred_directions[i];
273 :
274 :			get_intra_block(bs, &block[i * 64], direction, start_coeff);
275 :	Isibaar	3	}
276 :			stop_coding_timer();
277 :
278 :			start_timer();
279 :	edgomez	195	add_acdc(pMB, i, &block[i * 64], iDcScaler, predictors);
280 :	Isibaar	3	stop_prediction_timer();
281 :
282 :			start_timer();
283 :	edgomez	195	if (dec->quant_type == 0) {
284 :			dequant_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler);
285 :			} else {
286 :			dequant4_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler);
287 :	Isibaar	3	}
288 :			stop_iquant_timer();
289 :
290 :			start_timer();
291 :	edgomez	195	idct(&data[i * 64]);
292 :	Isibaar	3	stop_idct_timer();
293 :	h	69	}
294 :	Isibaar	3
295 :	edgomez	195	if (dec->interlacing && pMB->field_dct) {
296 :	h	81	next_block = stride;
297 :			stride *= 2;
298 :	Isibaar	3	}
299 :	h	69
300 :			start_timer();
301 :	edgomez	195	transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
302 :			transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
303 :			transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
304 :			transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);
305 :			transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
306 :			transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
307 :	h	69	stop_transfer_timer();
308 :	Isibaar	3	}
309 :
310 :
311 :
312 :
313 :
314 :			#define SIGN(X) (((X)>0)?1:-1)
315 :			#define ABS(X) (((X)>0)?(X):-(X))
316 :			static const uint32_t roundtab[16] =
317 :	edgomez	195	{ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };
318 :	Isibaar	3
319 :
320 :			// decode an inter macroblock
321 :
322 :	edgomez	195	void
323 :			decoder_mbinter(DECODER * dec,
324 :			const MACROBLOCK * pMB,
325 :			const uint32_t x_pos,
326 :			const uint32_t y_pos,
327 :			const uint32_t acpred_flag,
328 :			const uint32_t cbp,
329 :			Bitstream * bs,
330 :			const uint32_t quant,
331 :			const uint32_t rounding)
332 :	Isibaar	3	{
333 :	h	69
334 :	edgomez	195	DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
335 :	edgomez	78	DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);
336 :
337 :	h	81	uint32_t stride = dec->edged_width;
338 :			uint32_t stride2 = stride / 2;
339 :			uint32_t next_block = stride * 8;
340 :	edgomez	78	uint32_t i;
341 :			uint32_t iQuant = pMB->quant;
342 :	h	69	uint8_t pY_Cur, pU_Cur, *pV_Cur;
343 :	Isibaar	3	int uv_dx, uv_dy;
344 :
345 :	edgomez	78	pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
346 :	h	81	pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
347 :			pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
348 :	h	69
349 :	edgomez	195	if (pMB->mode == MODE_INTER \|\| pMB->mode == MODE_INTER_Q) {
350 :	h	69	uv_dx = pMB->mvs[0].x;
351 :			uv_dy = pMB->mvs[0].y;
352 :	Isibaar	3
353 :	Isibaar	333	if (dec->quarterpel)
354 :			{
355 :			uv_dx = (uv_dx >> 1) \| (uv_dx & 1);
356 :			uv_dy = (uv_dy >> 1) \| (uv_dy & 1);
357 :			}
358 :
359 :	Isibaar	3	uv_dx = (uv_dx & 3) ? (uv_dx >> 1) \| 1 : uv_dx / 2;
360 :			uv_dy = (uv_dy & 3) ? (uv_dy >> 1) \| 1 : uv_dy / 2;
361 :	edgomez	195	} else {
362 :	Isibaar	3	int sum;
363 :	h	69	sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
364 :	Isibaar	3
365 :	Isibaar	333	if (dec->quarterpel)
366 :			{
367 :			sum /= 2;
368 :			}
369 :
370 :			uv_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
371 :
372 :	h	69	sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
373 :	Isibaar	333
374 :			if (dec->quarterpel)
375 :			{
376 :			sum /= 2;
377 :			}
378 :
379 :			uv_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
380 :	Isibaar	3	}
381 :
382 :			start_timer();
383 :	Isibaar	333	if(dec->quarterpel) {
384 :			DEBUG("QUARTERPEL");
385 :			interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16x_pos, 16y_pos,
386 :			pMB->mvs[0].x, pMB->mvs[0].y, stride, rounding);
387 :			interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16x_pos + 8, 16y_pos,
388 :			pMB->mvs[1].x, pMB->mvs[1].y, stride, rounding);
389 :			interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16x_pos, 16y_pos + 8,
390 :			pMB->mvs[2].x, pMB->mvs[2].y, stride, rounding);
391 :			interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16x_pos + 8, 16y_pos + 8,
392 :			pMB->mvs[3].x, pMB->mvs[3].y, stride, rounding);
393 :			}
394 :			else {
395 :			interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16x_pos, 16y_pos,
396 :			pMB->mvs[0].x, pMB->mvs[0].y, stride, rounding);
397 :			interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16x_pos + 8, 16y_pos,
398 :			pMB->mvs[1].x, pMB->mvs[1].y, stride, rounding);
399 :			interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16x_pos, 16y_pos + 8,
400 :			pMB->mvs[2].x, pMB->mvs[2].y, stride, rounding);
401 :			interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16x_pos + 8, 16y_pos + 8,
402 :			pMB->mvs[3].x, pMB->mvs[3].y, stride, rounding);
403 :			}
404 :
405 :	edgomez	195	interpolate8x8_switch(dec->cur.u, dec->refn[0].u, 8 * x_pos, 8 * y_pos,
406 :			uv_dx, uv_dy, stride2, rounding);
407 :			interpolate8x8_switch(dec->cur.v, dec->refn[0].v, 8 * x_pos, 8 * y_pos,
408 :			uv_dx, uv_dy, stride2, rounding);
409 :	Isibaar	3	stop_comp_timer();
410 :
411 :	edgomez	195	for (i = 0; i < 6; i++) {
412 :	h	543	int direction = dec->alternate_vertical_scan ? 2 : 0;
413 :
414 :	edgomez	195	if (cbp & (1 << (5 - i))) // coded
415 :	Isibaar	3	{
416 :	edgomez	195	memset(&block[i * 64], 0, 64 * sizeof(int16_t)); // clear
417 :	Isibaar	3
418 :			start_timer();
419 :	h	543	get_inter_block(bs, &block[i * 64], direction);
420 :	Isibaar	3	stop_coding_timer();
421 :
422 :			start_timer();
423 :	edgomez	195	if (dec->quant_type == 0) {
424 :			dequant_inter(&data[i * 64], &block[i * 64], iQuant);
425 :			} else {
426 :			dequant4_inter(&data[i * 64], &block[i * 64], iQuant);
427 :	Isibaar	3	}
428 :			stop_iquant_timer();
429 :
430 :			start_timer();
431 :	edgomez	195	idct(&data[i * 64]);
432 :	Isibaar	3	stop_idct_timer();
433 :			}
434 :			}
435 :	h	69
436 :	edgomez	195	if (dec->interlacing && pMB->field_dct) {
437 :	h	81	next_block = stride;
438 :			stride *= 2;
439 :	h	69	}
440 :
441 :			start_timer();
442 :			if (cbp & 32)
443 :	edgomez	195	transfer_16to8add(pY_Cur, &data[0 * 64], stride);
444 :	h	69	if (cbp & 16)
445 :	edgomez	195	transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
446 :	h	69	if (cbp & 8)
447 :	edgomez	195	transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
448 :	h	69	if (cbp & 4)
449 :	edgomez	195	transfer_16to8add(pY_Cur + 8 + next_block, &data[3 * 64], stride);
450 :	h	69	if (cbp & 2)
451 :	edgomez	195	transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
452 :	h	69	if (cbp & 1)
453 :	edgomez	195	transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
454 :	h	69	stop_transfer_timer();
455 :	Isibaar	3	}
456 :
457 :
458 :	edgomez	195	void
459 :			decoder_iframe(DECODER * dec,
460 :			Bitstream * bs,
461 :			int quant,
462 :			int intra_dc_threshold)
463 :	Isibaar	3	{
464 :	chenm001	272	uint32_t bound;
465 :	Isibaar	3	uint32_t x, y;
466 :
467 :	chenm001	272	bound = 0;
468 :
469 :	edgomez	195	for (y = 0; y < dec->mb_height; y++) {
470 :			for (x = 0; x < dec->mb_width; x++) {
471 :	chenm001	272	MACROBLOCK *mb;
472 :	Isibaar	3	uint32_t mcbpc;
473 :			uint32_t cbpc;
474 :			uint32_t acpred_flag;
475 :			uint32_t cbpy;
476 :			uint32_t cbp;
477 :
478 :	chenm001	272	while (BitstreamShowBits(bs, 9) == 1)
479 :			BitstreamSkip(bs, 9);
480 :
481 :			if (check_resync_marker(bs, 0))
482 :			{
483 :			bound = read_video_packet_header(bs, 0, &quant);
484 :			x = bound % dec->mb_width;
485 :			y = bound / dec->mb_width;
486 :			}
487 :			mb = &dec->mbs[y * dec->mb_width + x];
488 :
489 :			DPRINTF(DPRINTF_MB, "macroblock (%i,%i) %08x", x, y, BitstreamShowBits(bs, 32));
490 :
491 :	Isibaar	3	mcbpc = get_mcbpc_intra(bs);
492 :			mb->mode = mcbpc & 7;
493 :			cbpc = (mcbpc >> 4);
494 :
495 :			acpred_flag = BitstreamGetBit(bs);
496 :
497 :			cbpy = get_cbpy(bs, 1);
498 :			cbp = (cbpy << 2) \| cbpc;
499 :
500 :	edgomez	195	if (mb->mode == MODE_INTRA_Q) {
501 :			quant += dquant_table[BitstreamGetBits(bs, 2)];
502 :			if (quant > 31) {
503 :	Isibaar	3	quant = 31;
504 :	edgomez	195	} else if (quant < 1) {
505 :	Isibaar	3	quant = 1;
506 :			}
507 :			}
508 :			mb->quant = quant;
509 :	chenm001	297	mb->mvs[0].x = mb->mvs[0].y =
510 :			mb->mvs[1].x = mb->mvs[1].y =
511 :			mb->mvs[2].x = mb->mvs[2].y =
512 :			mb->mvs[3].x = mb->mvs[3].y =0;
513 :	Isibaar	3
514 :	edgomez	195	if (dec->interlacing) {
515 :	h	69	mb->field_dct = BitstreamGetBit(bs);
516 :			DEBUG1("deci: field_dct: ", mb->field_dct);
517 :			}
518 :
519 :	edgomez	195	decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
520 :	chenm001	272	intra_dc_threshold, bound);
521 :	Isibaar	3	}
522 :	albeu	315	if(dec->out_frm)
523 :			output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,0,y,dec->mb_width);
524 :
525 :	Isibaar	3	}
526 :	edgomez	78
527 :	Isibaar	3	}
528 :
529 :
530 :	edgomez	195	void
531 :			get_motion_vector(DECODER * dec,
532 :			Bitstream * bs,
533 :			int x,
534 :			int y,
535 :			int k,
536 :			VECTOR * mv,
537 :	chenm001	272	int fcode,
538 :			const int bound)
539 :	Isibaar	3	{
540 :	edgomez	78
541 :	Isibaar	3	int scale_fac = 1 << (fcode - 1);
542 :			int high = (32 * scale_fac) - 1;
543 :			int low = ((-32) * scale_fac);
544 :			int range = (64 * scale_fac);
545 :
546 :	chenm001	272	VECTOR pmv;
547 :	Isibaar	3	int mv_x, mv_y;
548 :
549 :	chenm001	272	pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);
550 :	Isibaar	3
551 :			mv_x = get_mv(bs, fcode);
552 :			mv_y = get_mv(bs, fcode);
553 :	edgomez	195
554 :	chenm001	272	DPRINTF(DPRINTF_MV,"mv_diff (%i,%i) pred (%i,%i)", mv_x, mv_y, pmv.x, pmv.y);
555 :	suxen_drol	252
556 :	chenm001	272	mv_x += pmv.x;
557 :			mv_y += pmv.y;
558 :
559 :	edgomez	195	if (mv_x < low) {
560 :	Isibaar	3	mv_x += range;
561 :	edgomez	195	} else if (mv_x > high) {
562 :	Isibaar	3	mv_x -= range;
563 :			}
564 :
565 :	edgomez	195	if (mv_y < low) {
566 :	Isibaar	3	mv_y += range;
567 :	edgomez	195	} else if (mv_y > high) {
568 :	Isibaar	3	mv_y -= range;
569 :			}
570 :
571 :			mv->x = mv_x;
572 :			mv->y = mv_y;
573 :
574 :			}
575 :
576 :
577 :	edgomez	195	void
578 :			decoder_pframe(DECODER * dec,
579 :			Bitstream * bs,
580 :			int rounding,
581 :			int quant,
582 :			int fcode,
583 :			int intra_dc_threshold)
584 :	Isibaar	3	{
585 :	edgomez	78
586 :	Isibaar	3	uint32_t x, y;
587 :	chenm001	272	uint32_t bound;
588 :	albeu	315	int cp_mb, st_mb;
589 :	Isibaar	3
590 :			start_timer();
591 :	edgomez	195	image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
592 :	h	543	dec->width, dec->height);
593 :	Isibaar	3	stop_edges_timer();
594 :
595 :	chenm001	272	bound = 0;
596 :
597 :	edgomez	195	for (y = 0; y < dec->mb_height; y++) {
598 :	albeu	315	cp_mb = st_mb = 0;
599 :	edgomez	195	for (x = 0; x < dec->mb_width; x++) {
600 :	chenm001	272	MACROBLOCK *mb;
601 :	Isibaar	3
602 :	chenm001	272	// skip stuffing
603 :			while (BitstreamShowBits(bs, 10) == 1)
604 :			BitstreamSkip(bs, 10);
605 :
606 :			if (check_resync_marker(bs, fcode - 1))
607 :			{
608 :			bound = read_video_packet_header(bs, fcode - 1, &quant);
609 :			x = bound % dec->mb_width;
610 :			y = bound / dec->mb_width;
611 :			}
612 :			mb = &dec->mbs[y * dec->mb_width + x];
613 :
614 :			DPRINTF(DPRINTF_MB, "macroblock (%i,%i) %08x", x, y, BitstreamShowBits(bs, 32));
615 :
616 :	edgomez	195	//if (!(dec->mb_skip[y*dec->mb_width + x]=BitstreamGetBit(bs))) // not_coded
617 :			if (!(BitstreamGetBit(bs))) // not_coded
618 :	Isibaar	3	{
619 :			uint32_t mcbpc;
620 :			uint32_t cbpc;
621 :			uint32_t acpred_flag;
622 :			uint32_t cbpy;
623 :			uint32_t cbp;
624 :			uint32_t intra;
625 :
626 :	albeu	315	cp_mb++;
627 :	Isibaar	3	mcbpc = get_mcbpc_inter(bs);
628 :			mb->mode = mcbpc & 7;
629 :			cbpc = (mcbpc >> 4);
630 :	chenm001	272
631 :			DPRINTF(DPRINTF_MB, "mode %i", mb->mode);
632 :			DPRINTF(DPRINTF_MB, "cbpc %i", cbpc);
633 :	edgomez	12	acpred_flag = 0;
634 :	Isibaar	3
635 :			intra = (mb->mode == MODE_INTRA \|\| mb->mode == MODE_INTRA_Q);
636 :	edgomez	195
637 :			if (intra) {
638 :	Isibaar	3	acpred_flag = BitstreamGetBit(bs);
639 :			}
640 :
641 :			cbpy = get_cbpy(bs, intra);
642 :	chenm001	272	DPRINTF(DPRINTF_MB, "cbpy %i", cbpy);
643 :
644 :	Isibaar	3	cbp = (cbpy << 2) \| cbpc;
645 :
646 :	edgomez	195	if (mb->mode == MODE_INTER_Q \|\| mb->mode == MODE_INTRA_Q) {
647 :	chenm001	272	int dquant = dquant_table[BitstreamGetBits(bs, 2)];
648 :			DPRINTF(DPRINTF_MB, "dquant %i", dquant);
649 :			quant += dquant;
650 :	edgomez	195	if (quant > 31) {
651 :	Isibaar	3	quant = 31;
652 :	chenm001	272	} else if (quant < 1) {
653 :	Isibaar	3	quant = 1;
654 :			}
655 :	chenm001	272	DPRINTF(DPRINTF_MB, "quant %i", quant);
656 :	Isibaar	3	}
657 :			mb->quant = quant;
658 :	h	69
659 :	edgomez	195	if (dec->interlacing) {
660 :	h	388	if (cbp \|\| intra) {
661 :			mb->field_dct = BitstreamGetBit(bs);
662 :			DEBUG1("decp: field_dct: ", mb->field_dct);
663 :			}
664 :	Isibaar	3
665 :	edgomez	195	if (mb->mode == MODE_INTER \|\| mb->mode == MODE_INTER_Q) {
666 :	h	69	mb->field_pred = BitstreamGetBit(bs);
667 :			DEBUG1("decp: field_pred: ", mb->field_pred);
668 :
669 :	edgomez	195	if (mb->field_pred) {
670 :	h	69	mb->field_for_top = BitstreamGetBit(bs);
671 :			DEBUG1("decp: field_for_top: ", mb->field_for_top);
672 :			mb->field_for_bot = BitstreamGetBit(bs);
673 :			DEBUG1("decp: field_for_bot: ", mb->field_for_bot);
674 :			}
675 :			}
676 :	Isibaar	3	}
677 :	h	69
678 :	edgomez	195	if (mb->mode == MODE_INTER \|\| mb->mode == MODE_INTER_Q) {
679 :			if (dec->interlacing && mb->field_pred) {
680 :			get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],
681 :	chenm001	272	fcode, bound);
682 :	edgomez	195	get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1],
683 :	chenm001	272	fcode, bound);
684 :	edgomez	195	} else {
685 :			get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],
686 :	chenm001	272	fcode, bound);
687 :	edgomez	195	mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =
688 :			mb->mvs[0].x;
689 :			mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =
690 :			mb->mvs[0].y;
691 :	h	69	}
692 :	chl	339	} else if (mb->mode == MODE_INTER4V ) {
693 :
694 :	chenm001	272	get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
695 :			get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);
696 :			get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
697 :			get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode, bound);
698 :	edgomez	195	} else // MODE_INTRA, MODE_INTRA_Q
699 :	Isibaar	3	{
700 :	edgomez	195	mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =
701 :			0;
702 :			mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =
703 :			0;
704 :			decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
705 :	chenm001	272	intra_dc_threshold, bound);
706 :	Isibaar	3	continue;
707 :			}
708 :
709 :	edgomez	195	decoder_mbinter(dec, mb, x, y, acpred_flag, cbp, bs, quant,
710 :			rounding);
711 :			} else // not coded
712 :	Isibaar	3	{
713 :	chl	339	DEBUG2("P-frame MB at (X,Y)=",x,y);
714 :	chenm001	156	mb->mode = MODE_NOT_CODED;
715 :	Isibaar	3	mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
716 :			mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
717 :	edgomez	195
718 :	Isibaar	3	// copy macroblock directly from ref to cur
719 :
720 :			start_timer();
721 :
722 :	edgomez	195	transfer8x8_copy(dec->cur.y + (16 * y) * dec->edged_width +
723 :			(16 * x),
724 :			dec->refn[0].y + (16 * y) * dec->edged_width +
725 :			(16 * x), dec->edged_width);
726 :	Isibaar	3
727 :	edgomez	195	transfer8x8_copy(dec->cur.y + (16 * y) * dec->edged_width +
728 :			(16 * x + 8),
729 :			dec->refn[0].y + (16 * y) * dec->edged_width +
730 :			(16 * x + 8), dec->edged_width);
731 :	Isibaar	3
732 :	edgomez	195	transfer8x8_copy(dec->cur.y + (16 * y + 8) * dec->edged_width +
733 :			(16 * x),
734 :			dec->refn[0].y + (16 * y +
735 :			8) * dec->edged_width +
736 :			(16 * x), dec->edged_width);
737 :	Isibaar	3
738 :	edgomez	195	transfer8x8_copy(dec->cur.y + (16 * y + 8) * dec->edged_width +
739 :			(16 * x + 8),
740 :			dec->refn[0].y + (16 * y +
741 :			8) * dec->edged_width +
742 :			(16 * x + 8), dec->edged_width);
743 :	Isibaar	3
744 :	edgomez	195	transfer8x8_copy(dec->cur.u + (8 * y) * dec->edged_width / 2 +
745 :			(8 * x),
746 :			dec->refn[0].u +
747 :			(8 * y) * dec->edged_width / 2 + (8 * x),
748 :			dec->edged_width / 2);
749 :	Isibaar	3
750 :	edgomez	195	transfer8x8_copy(dec->cur.v + (8 * y) * dec->edged_width / 2 +
751 :			(8 * x),
752 :			dec->refn[0].v +
753 :			(8 * y) * dec->edged_width / 2 + (8 * x),
754 :			dec->edged_width / 2);
755 :	Isibaar	3	stop_transfer_timer();
756 :	albeu	315	if(dec->out_frm && cp_mb > 0) {
757 :			output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
758 :			cp_mb = 0;
759 :			}
760 :			st_mb = x+1;
761 :	Isibaar	3	}
762 :			}
763 :	albeu	315	if(dec->out_frm && cp_mb > 0)
764 :			output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
765 :	Isibaar	3	}
766 :			}
767 :
768 :	chenm001	156
769 :			// add by MinChen <chenm001@163.com>
770 :			// decode B-frame motion vector
771 :	edgomez	195	void
772 :			get_b_motion_vector(DECODER * dec,
773 :			Bitstream * bs,
774 :			int x,
775 :			int y,
776 :			VECTOR * mv,
777 :			int fcode,
778 :			const VECTOR pmv)
779 :	chenm001	156	{
780 :			int scale_fac = 1 << (fcode - 1);
781 :			int high = (32 * scale_fac) - 1;
782 :			int low = ((-32) * scale_fac);
783 :			int range = (64 * scale_fac);
784 :
785 :			int mv_x, mv_y;
786 :			int pmv_x, pmv_y;
787 :
788 :			pmv_x = pmv.x;
789 :			pmv_y = pmv.y;
790 :
791 :			mv_x = get_mv(bs, fcode);
792 :			mv_y = get_mv(bs, fcode);
793 :	edgomez	195
794 :	chenm001	156	mv_x += pmv_x;
795 :			mv_y += pmv_y;
796 :
797 :	edgomez	195	if (mv_x < low) {
798 :	chenm001	156	mv_x += range;
799 :	edgomez	195	} else if (mv_x > high) {
800 :	chenm001	156	mv_x -= range;
801 :			}
802 :
803 :	edgomez	195	if (mv_y < low) {
804 :	chenm001	156	mv_y += range;
805 :	edgomez	195	} else if (mv_y > high) {
806 :	chenm001	156	mv_y -= range;
807 :			}
808 :
809 :			mv->x = mv_x;
810 :			mv->y = mv_y;
811 :			}
812 :
813 :
814 :			// add by MinChen <chenm001@163.com>
815 :			// decode an B-frame forward & backward inter macroblock
816 :	edgomez	195	void
817 :			decoder_bf_mbinter(DECODER * dec,
818 :			const MACROBLOCK * pMB,
819 :			const uint32_t x_pos,
820 :			const uint32_t y_pos,
821 :			const uint32_t cbp,
822 :			Bitstream * bs,
823 :			const uint32_t quant,
824 :			const uint8_t ref)
825 :	chenm001	156	{
826 :
827 :	edgomez	195	DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
828 :	chenm001	156	DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);
829 :
830 :			uint32_t stride = dec->edged_width;
831 :			uint32_t stride2 = stride / 2;
832 :			uint32_t next_block = stride * 8;
833 :			uint32_t i;
834 :			uint32_t iQuant = pMB->quant;
835 :			uint8_t pY_Cur, pU_Cur, *pV_Cur;
836 :			int uv_dx, uv_dy;
837 :
838 :			pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
839 :			pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
840 :			pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
841 :
842 :	chenm001	297
843 :	edgomez	195	if (!(pMB->mode == MODE_INTER \|\| pMB->mode == MODE_INTER_Q)) {
844 :	chenm001	156	uv_dx = pMB->mvs[0].x;
845 :			uv_dy = pMB->mvs[0].y;
846 :
847 :			uv_dx = (uv_dx & 3) ? (uv_dx >> 1) \| 1 : uv_dx / 2;
848 :			uv_dy = (uv_dy & 3) ? (uv_dy >> 1) \| 1 : uv_dy / 2;
849 :	edgomez	195	} else {
850 :	chenm001	156	int sum;
851 :	edgomez	195
852 :	chenm001	156	sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
853 :	edgomez	195	uv_dx =
854 :			(sum ==
855 :			0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
856 :			(ABS(sum) / 16) * 2));
857 :	chenm001	156
858 :			sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
859 :	edgomez	195	uv_dy =
860 :			(sum ==
861 :			0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
862 :			(ABS(sum) / 16) * 2));
863 :	chenm001	156	}
864 :
865 :			start_timer();
866 :	edgomez	195	interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16 * x_pos, 16 * y_pos,
867 :			pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
868 :			interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16 * x_pos + 8,
869 :			16 * y_pos, pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
870 :			interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16 * x_pos,
871 :			16 * y_pos + 8, pMB->mvs[2].x, pMB->mvs[2].y, stride,
872 :			0);
873 :			interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16 * x_pos + 8,
874 :			16 * y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride,
875 :			0);
876 :			interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,
877 :			uv_dx, uv_dy, stride2, 0);
878 :			interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,
879 :			uv_dx, uv_dy, stride2, 0);
880 :	chenm001	156	stop_comp_timer();
881 :
882 :	edgomez	195	for (i = 0; i < 6; i++) {
883 :	h	543	int direction = dec->alternate_vertical_scan ? 2 : 0;
884 :
885 :	edgomez	195	if (cbp & (1 << (5 - i))) // coded
886 :	chenm001	156	{
887 :	edgomez	195	memset(&block[i * 64], 0, 64 * sizeof(int16_t)); // clear
888 :	chenm001	156
889 :			start_timer();
890 :	h	543	get_inter_block(bs, &block[i * 64], direction);
891 :	chenm001	156	stop_coding_timer();
892 :
893 :			start_timer();
894 :	edgomez	195	if (dec->quant_type == 0) {
895 :			dequant_inter(&data[i * 64], &block[i * 64], iQuant);
896 :			} else {
897 :			dequant4_inter(&data[i * 64], &block[i * 64], iQuant);
898 :	chenm001	156	}
899 :			stop_iquant_timer();
900 :
901 :			start_timer();
902 :	edgomez	195	idct(&data[i * 64]);
903 :	chenm001	156	stop_idct_timer();
904 :			}
905 :			}
906 :
907 :	edgomez	195	if (dec->interlacing && pMB->field_dct) {
908 :	chenm001	156	next_block = stride;
909 :			stride *= 2;
910 :			}
911 :
912 :			start_timer();
913 :			if (cbp & 32)
914 :	edgomez	195	transfer_16to8add(pY_Cur, &data[0 * 64], stride);
915 :	chenm001	156	if (cbp & 16)
916 :	edgomez	195	transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
917 :	chenm001	156	if (cbp & 8)
918 :	edgomez	195	transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
919 :	chenm001	156	if (cbp & 4)
920 :	edgomez	195	transfer_16to8add(pY_Cur + 8 + next_block, &data[3 * 64], stride);
921 :	chenm001	156	if (cbp & 2)
922 :	edgomez	195	transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
923 :	chenm001	156	if (cbp & 1)
924 :	edgomez	195	transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
925 :	chenm001	156	stop_transfer_timer();
926 :			}
927 :
928 :
929 :			// add by MinChen <chenm001@163.com>
930 :			// decode an B-frame direct & inter macroblock
931 :	edgomez	195	void
932 :			decoder_bf_interpolate_mbinter(DECODER * dec,
933 :			IMAGE forward,
934 :			IMAGE backward,
935 :			const MACROBLOCK * pMB,
936 :			const uint32_t x_pos,
937 :			const uint32_t y_pos,
938 :			Bitstream * bs)
939 :	chenm001	156	{
940 :
941 :	edgomez	195	DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
942 :	chenm001	156	DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);
943 :
944 :	edgomez	195	uint32_t stride = dec->edged_width;
945 :			uint32_t stride2 = stride / 2;
946 :			uint32_t next_block = stride * 8;
947 :			uint32_t iQuant = pMB->quant;
948 :			int uv_dx, uv_dy;
949 :			int b_uv_dx, b_uv_dy;
950 :			uint32_t i;
951 :			uint8_t pY_Cur, pU_Cur, *pV_Cur;
952 :	chenm001	297	const uint32_t cbp = pMB->cbp;
953 :	chenm001	156
954 :	chenm001	161	pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
955 :			pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
956 :			pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
957 :
958 :	chenm001	297
959 :	edgomez	195	if ((pMB->mode == MODE_INTER \|\| pMB->mode == MODE_INTER_Q)) {
960 :	chenm001	156	uv_dx = pMB->mvs[0].x;
961 :			uv_dy = pMB->mvs[0].y;
962 :
963 :			uv_dx = (uv_dx & 3) ? (uv_dx >> 1) \| 1 : uv_dx / 2;
964 :			uv_dy = (uv_dy & 3) ? (uv_dy >> 1) \| 1 : uv_dy / 2;
965 :
966 :			b_uv_dx = pMB->b_mvs[0].x;
967 :			b_uv_dy = pMB->b_mvs[0].y;
968 :
969 :			b_uv_dx = (uv_dx & 3) ? (uv_dx >> 1) \| 1 : uv_dx / 2;
970 :			b_uv_dy = (uv_dy & 3) ? (uv_dy >> 1) \| 1 : uv_dy / 2;
971 :	edgomez	195	} else {
972 :	chenm001	156	int sum;
973 :	edgomez	195
974 :	chenm001	156	sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
975 :	edgomez	195	uv_dx =
976 :			(sum ==
977 :			0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
978 :			(ABS(sum) / 16) * 2));
979 :	chenm001	156
980 :			sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
981 :	edgomez	195	uv_dy =
982 :			(sum ==
983 :			0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
984 :			(ABS(sum) / 16) * 2));
985 :	chenm001	156
986 :	edgomez	195	sum =
987 :			pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x +
988 :			pMB->b_mvs[3].x;
989 :			b_uv_dx =
990 :			(sum ==
991 :			0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
992 :			(ABS(sum) / 16) * 2));
993 :	chenm001	156
994 :	edgomez	195	sum =
995 :			pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y +
996 :			pMB->b_mvs[3].y;
997 :			b_uv_dy =
998 :			(sum ==
999 :			0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
1000 :			(ABS(sum) / 16) * 2));
1001 :	chenm001	156	}
1002 :
1003 :	edgomez	195
1004 :	chenm001	156	start_timer();
1005 :	edgomez	195	interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos,
1006 :			pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1007 :			interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos,
1008 :			pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1009 :			interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos + 8,
1010 :			pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1011 :			interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8,
1012 :			16 * y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride,
1013 :			0);
1014 :			interpolate8x8_switch(dec->cur.u, forward.u, 8 * x_pos, 8 * y_pos, uv_dx,
1015 :			uv_dy, stride2, 0);
1016 :			interpolate8x8_switch(dec->cur.v, forward.v, 8 * x_pos, 8 * y_pos, uv_dx,
1017 :			uv_dy, stride2, 0);
1018 :	chenm001	156
1019 :	chenm001	161
1020 :	edgomez	195	interpolate8x8_switch(dec->refn[2].y, backward.y, 16 * x_pos, 16 * y_pos,
1021 :			pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1022 :			interpolate8x8_switch(dec->refn[2].y, backward.y, 16 * x_pos + 8,
1023 :			16 * y_pos, pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride,
1024 :			0);
1025 :			interpolate8x8_switch(dec->refn[2].y, backward.y, 16 * x_pos,
1026 :			16 * y_pos + 8, pMB->b_mvs[2].x, pMB->b_mvs[2].y,
1027 :			stride, 0);
1028 :			interpolate8x8_switch(dec->refn[2].y, backward.y, 16 * x_pos + 8,
1029 :			16 * y_pos + 8, pMB->b_mvs[3].x, pMB->b_mvs[3].y,
1030 :			stride, 0);
1031 :			interpolate8x8_switch(dec->refn[2].u, backward.u, 8 * x_pos, 8 * y_pos,
1032 :			b_uv_dx, b_uv_dy, stride2, 0);
1033 :			interpolate8x8_switch(dec->refn[2].v, backward.v, 8 * x_pos, 8 * y_pos,
1034 :			b_uv_dx, b_uv_dy, stride2, 0);
1035 :	chenm001	156
1036 :	edgomez	195	interpolate8x8_c(dec->cur.y, dec->refn[2].y, 16 * x_pos, 16 * y_pos,
1037 :			stride);
1038 :			interpolate8x8_c(dec->cur.y, dec->refn[2].y, 16 * x_pos + 8, 16 * y_pos,
1039 :			stride);
1040 :			interpolate8x8_c(dec->cur.y, dec->refn[2].y, 16 * x_pos, 16 * y_pos + 8,
1041 :			stride);
1042 :			interpolate8x8_c(dec->cur.y, dec->refn[2].y, 16 * x_pos + 8,
1043 :			16 * y_pos + 8, stride);
1044 :			interpolate8x8_c(dec->cur.u, dec->refn[2].u, 8 * x_pos, 8 * y_pos,
1045 :			stride2);
1046 :			interpolate8x8_c(dec->cur.v, dec->refn[2].v, 8 * x_pos, 8 * y_pos,
1047 :			stride2);
1048 :	chenm001	156	stop_comp_timer();
1049 :	edgomez	195
1050 :			for (i = 0; i < 6; i++) {
1051 :	h	543	int direction = dec->alternate_vertical_scan ? 2 : 0;
1052 :
1053 :	edgomez	195	if (cbp & (1 << (5 - i))) // coded
1054 :	chenm001	161	{
1055 :	edgomez	195	memset(&block[i * 64], 0, 64 * sizeof(int16_t)); // clear
1056 :	chenm001	156
1057 :	chenm001	161	start_timer();
1058 :	h	543	get_inter_block(bs, &block[i * 64], direction);
1059 :	chenm001	161	stop_coding_timer();
1060 :
1061 :			start_timer();
1062 :	edgomez	195	if (dec->quant_type == 0) {
1063 :			dequant_inter(&data[i * 64], &block[i * 64], iQuant);
1064 :			} else {
1065 :			dequant4_inter(&data[i * 64], &block[i * 64], iQuant);
1066 :	chenm001	161	}
1067 :			stop_iquant_timer();
1068 :
1069 :			start_timer();
1070 :	edgomez	195	idct(&data[i * 64]);
1071 :	chenm001	161	stop_idct_timer();
1072 :			}
1073 :			}
1074 :
1075 :	edgomez	195	if (dec->interlacing && pMB->field_dct) {
1076 :	chenm001	161	next_block = stride;
1077 :			stride *= 2;
1078 :			}
1079 :
1080 :			start_timer();
1081 :			if (cbp & 32)
1082 :	edgomez	195	transfer_16to8add(pY_Cur, &data[0 * 64], stride);
1083 :	chenm001	161	if (cbp & 16)
1084 :	edgomez	195	transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
1085 :	chenm001	161	if (cbp & 8)
1086 :	edgomez	195	transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
1087 :	chenm001	161	if (cbp & 4)
1088 :	edgomez	195	transfer_16to8add(pY_Cur + 8 + next_block, &data[3 * 64], stride);
1089 :	chenm001	161	if (cbp & 2)
1090 :	edgomez	195	transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
1091 :	chenm001	161	if (cbp & 1)
1092 :	edgomez	195	transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
1093 :	chenm001	161	stop_transfer_timer();
1094 :	chenm001	156	}
1095 :
1096 :
1097 :			// add by MinChen <chenm001@163.com>
1098 :			// for decode B-frame dbquant
1099 :	edgomez	195	int32_t __inline
1100 :			get_dbquant(Bitstream * bs)
1101 :	chenm001	156	{
1102 :	edgomez	195	if (!BitstreamGetBit(bs)) // '0'
1103 :			return (0);
1104 :	chenm001	156	else if (!BitstreamGetBit(bs)) // '10'
1105 :	edgomez	195	return (-2);
1106 :	chenm001	156	else
1107 :	edgomez	195	return (2); // '11'
1108 :	chenm001	156	}
1109 :
1110 :			// add by MinChen <chenm001@163.com>
1111 :			// for decode B-frame mb_type
1112 :			// bit ret_value
1113 :			// 1 0
1114 :			// 01 1
1115 :			// 001 2
1116 :			// 0001 3
1117 :	edgomez	195	int32_t __inline
1118 :			get_mbtype(Bitstream * bs)
1119 :	chenm001	156	{
1120 :	chenm001	161	int32_t mb_type;
1121 :	edgomez	195
1122 :			for (mb_type = 0; mb_type <= 3; mb_type++) {
1123 :			if (BitstreamGetBit(bs))
1124 :	chenm001	161	break;
1125 :			}
1126 :
1127 :	edgomez	195	if (mb_type <= 3)
1128 :			return (mb_type);
1129 :	chenm001	156	else
1130 :	edgomez	195	return (-1);
1131 :	chenm001	156	}
1132 :
1133 :	edgomez	195	void
1134 :			decoder_bframe(DECODER * dec,
1135 :			Bitstream * bs,
1136 :			int quant,
1137 :			int fcode_forward,
1138 :			int fcode_backward)
1139 :	chenm001	156	{
1140 :	edgomez	195	uint32_t x, y;
1141 :	chenm001	297	VECTOR mv;
1142 :			const VECTOR zeromv = {0,0};
1143 :	chenm001	290	#ifdef BFRAMES_DEC_DEBUG
1144 :			FILE *fp;
1145 :			static char first=0;
1146 :			#define BFRAME_DEBUG if (!first && fp){ \
1147 :			fprintf(fp,"Y=%3d X=%3d MB=%2d CBP=%02X\n",y,x,mb->mb_type,mb->cbp); \
1148 :			}
1149 :			#endif
1150 :	chenm001	156
1151 :			start_timer();
1152 :	edgomez	195	image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
1153 :	h	543	dec->width, dec->height);
1154 :	chenm001	297	image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
1155 :	h	543	dec->width, dec->height);
1156 :	chenm001	156	stop_edges_timer();
1157 :
1158 :	chenm001	290	#ifdef BFRAMES_DEC_DEBUG
1159 :			if (!first){
1160 :			fp=fopen("C:\\XVIDDBG.TXT","w");
1161 :			}
1162 :			#endif
1163 :	chenm001	161
1164 :	edgomez	195	for (y = 0; y < dec->mb_height; y++) {
1165 :	chenm001	161	// Initialize Pred Motion Vector
1166 :	chenm001	297	dec->p_fmv = dec->p_bmv = zeromv;
1167 :	edgomez	195	for (x = 0; x < dec->mb_width; x++) {
1168 :			MACROBLOCK mb = &dec->mbs[y dec->mb_width + x];
1169 :			MACROBLOCK last_mb = &dec->last_mbs[y dec->mb_width + x];
1170 :	chenm001	156
1171 :	chenm001	297	mv =
1172 :			mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =
1173 :			mb->mvs[0] = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = zeromv;
1174 :	chenm001	161
1175 :	chenm001	156	// the last P_VOP is skip macroblock ?
1176 :	edgomez	195	if (last_mb->mode == MODE_NOT_CODED) {
1177 :	chenm001	161	//DEBUG2("Skip MB in B-frame at (X,Y)=!",x,y);
1178 :	chenm001	290	mb->cbp = 0;
1179 :			#ifdef BFRAMES_DEC_DEBUG
1180 :	chenm001	296	mb->mb_type = MODE_NOT_CODED;
1181 :	chenm001	290	BFRAME_DEBUG
1182 :			#endif
1183 :	chenm001	161	mb->mb_type = MODE_FORWARD;
1184 :	chenm001	297	mb->quant = last_mb->quant;
1185 :			//mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = mb->mvs[0].x;
1186 :			//mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = mb->mvs[0].y;
1187 :	chenm001	156
1188 :	chenm001	297	decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, mb->quant, 1);
1189 :	chenm001	156	continue;
1190 :			}
1191 :	chenm001	161
1192 :	edgomez	195	if (!BitstreamGetBit(bs)) { // modb=='0'
1193 :			const uint8_t modb2 = BitstreamGetBit(bs);
1194 :	chenm001	156
1195 :			mb->mb_type = get_mbtype(bs);
1196 :	edgomez	195
1197 :			if (!modb2) { // modb=='00'
1198 :			mb->cbp = BitstreamGetBits(bs, 6);
1199 :	chenm001	156	} else {
1200 :			mb->cbp = 0;
1201 :			}
1202 :	edgomez	195	if (mb->mb_type && mb->cbp) {
1203 :	chenm001	156	quant += get_dbquant(bs);
1204 :
1205 :	edgomez	195	if (quant > 31) {
1206 :	chenm001	156	quant = 31;
1207 :	chenm001	272	} else if (quant < 1) {
1208 :	chenm001	156	quant = 1;
1209 :			}
1210 :			}
1211 :			} else {
1212 :			mb->mb_type = MODE_DIRECT_NONE_MV;
1213 :	edgomez	195	mb->cbp = 0;
1214 :	chenm001	156	}
1215 :
1216 :	chenm001	297	mb->quant = quant;
1217 :			mb->mode = MODE_INTER4V;
1218 :	chenm001	156	//DEBUG1("Switch bm_type=",mb->mb_type);
1219 :
1220 :	chenm001	290	#ifdef BFRAMES_DEC_DEBUG
1221 :			BFRAME_DEBUG
1222 :			#endif
1223 :	chl	326
1224 :	edgomez	195	switch (mb->mb_type) {
1225 :	chenm001	156	case MODE_DIRECT:
1226 :	chenm001	297	get_b_motion_vector(dec, bs, x, y, &mv, 1, zeromv);
1227 :	chenm001	156
1228 :			case MODE_DIRECT_NONE_MV:
1229 :	chl	326	{
1230 :	chenm001	297	const int64_t TRB = dec->time_pp - dec->time_bp, TRD = dec->time_pp;
1231 :	chenm001	156	int i;
1232 :	edgomez	195
1233 :			for (i = 0; i < 4; i++) {
1234 :	chenm001	297	mb->mvs[i].x = (int32_t) ((TRB * last_mb->mvs[i].x)
1235 :			/ TRD + mv.x);
1236 :			mb->b_mvs[i].x = (int32_t) ((mv.x == 0)
1237 :			? ((TRB - TRD) * last_mb->mvs[i].x)
1238 :			/ TRD
1239 :			: mb->mvs[i].x - last_mb->mvs[i].x);
1240 :			mb->mvs[i].y = (int32_t) ((TRB * last_mb->mvs[i].y)
1241 :			/ TRD + mv.y);
1242 :			mb->b_mvs[i].y = (int32_t) ((mv.y == 0)
1243 :			? ((TRB - TRD) * last_mb->mvs[i].y)
1244 :			/ TRD
1245 :			: mb->mvs[i].y - last_mb->mvs[i].y);
1246 :	chenm001	156	}
1247 :			//DEBUG("B-frame Direct!\n");
1248 :			}
1249 :	edgomez	195	decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1250 :	chenm001	297	mb, x, y, bs);
1251 :	chenm001	156	break;
1252 :
1253 :			case MODE_INTERPOLATE:
1254 :	edgomez	195	get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_forward,
1255 :			dec->p_fmv);
1256 :	chenm001	297	dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1257 :	chenm001	156
1258 :	edgomez	195	get_b_motion_vector(dec, bs, x, y, &mb->b_mvs[0],
1259 :			fcode_backward, dec->p_bmv);
1260 :	chenm001	297	dec->p_bmv = mb->b_mvs[1] = mb->b_mvs[2] =
1261 :			mb->b_mvs[3] = mb->b_mvs[0];
1262 :	chenm001	156
1263 :	edgomez	195	decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1264 :	chenm001	297	mb, x, y, bs);
1265 :	chenm001	156	//DEBUG("B-frame Bidir!\n");
1266 :			break;
1267 :
1268 :			case MODE_BACKWARD:
1269 :	edgomez	195	get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_backward,
1270 :			dec->p_bmv);
1271 :	chenm001	297	dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1272 :	chenm001	161
1273 :	chenm001	297	mb->mode = MODE_INTER;
1274 :	chenm001	156	decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 0);
1275 :			//DEBUG("B-frame Backward!\n");
1276 :			break;
1277 :
1278 :			case MODE_FORWARD:
1279 :	edgomez	195	get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_forward,
1280 :			dec->p_fmv);
1281 :	chenm001	297	dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1282 :	chenm001	161
1283 :	chenm001	297	mb->mode = MODE_INTER;
1284 :	chenm001	156	decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 1);
1285 :	chenm001	161	//DEBUG("B-frame Forward!\n");
1286 :	chenm001	156	break;
1287 :
1288 :			default:
1289 :	chl	326	DEBUG1("Not support B-frame mb_type =", mb->mb_type);
1290 :	chenm001	156	}
1291 :
1292 :	edgomez	195	} // end of FOR
1293 :	chenm001	156	}
1294 :	chenm001	290	#ifdef BFRAMES_DEC_DEBUG
1295 :			if (!first){
1296 :			first=1;
1297 :			if (fp)
1298 :			fclose(fp);
1299 :			}
1300 :			#endif
1301 :	chenm001	156	}
1302 :
1303 :			// swap two MACROBLOCK array
1304 :	edgomez	195	void
1305 :			mb_swap(MACROBLOCK ** mb1,
1306 :			MACROBLOCK ** mb2)
1307 :	chenm001	156	{
1308 :	edgomez	195	MACROBLOCK temp = mb1;
1309 :
1310 :			mb1 = mb2;
1311 :			*mb2 = temp;
1312 :	chenm001	156	}
1313 :
1314 :	edgomez	195	int
1315 :			decoder_decode(DECODER * dec,
1316 :			XVID_DEC_FRAME * frame)
1317 :	Isibaar	3	{
1318 :	edgomez	78
1319 :	Isibaar	3	Bitstream bs;
1320 :			uint32_t rounding;
1321 :			uint32_t quant;
1322 :	chenm001	156	uint32_t fcode_forward;
1323 :			uint32_t fcode_backward;
1324 :	Isibaar	3	uint32_t intra_dc_threshold;
1325 :	chenm001	133	uint32_t vop_type;
1326 :	Isibaar	3
1327 :			start_global_timer();
1328 :	edgomez	195
1329 :	albeu	315	dec->out_frm = (frame->colorspace == XVID_CSP_EXTERN) ? frame->image : NULL;
1330 :
1331 :	Isibaar	3	BitstreamInit(&bs, frame->bitstream, frame->length);
1332 :
1333 :	chenm001	133	// add by chenm001 <chenm001@163.com>
1334 :			// for support B-frame to reference last 2 frame
1335 :	Isibaar	179	dec->frames++;
1336 :	edgomez	195	vop_type =
1337 :			BitstreamReadHeaders(&bs, dec, &rounding, &quant, &fcode_forward,
1338 :			&fcode_backward, &intra_dc_threshold);
1339 :	Isibaar	179
1340 :	edgomez	195	dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0; // init pred vector to 0
1341 :
1342 :			switch (vop_type) {
1343 :			case P_VOP:
1344 :			decoder_pframe(dec, &bs, rounding, quant, fcode_forward,
1345 :			intra_dc_threshold);
1346 :	chenm001	272	#ifdef BFRAMES_DEC
1347 :	edgomez	195	DEBUG1("P_VOP Time=", dec->time);
1348 :	chenm001	272	#endif
1349 :	Isibaar	3	break;
1350 :
1351 :	edgomez	195	case I_VOP:
1352 :	Isibaar	3	decoder_iframe(dec, &bs, quant, intra_dc_threshold);
1353 :	chenm001	272	#ifdef BFRAMES_DEC
1354 :	edgomez	195	DEBUG1("I_VOP Time=", dec->time);
1355 :	chenm001	272	#endif
1356 :	Isibaar	3	break;
1357 :
1358 :	edgomez	195	case B_VOP:
1359 :	suxen_drol	233	#ifdef BFRAMES_DEC
1360 :	edgomez	195	if (dec->time_pp > dec->time_bp) {
1361 :			DEBUG1("B_VOP Time=", dec->time);
1362 :	chenm001	156	decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);
1363 :			} else {
1364 :			DEBUG("broken B-frame!");
1365 :			}
1366 :	suxen_drol	233	#else
1367 :			image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);
1368 :	Isibaar	179	#endif
1369 :	Isibaar	3	break;
1370 :	edgomez	195
1371 :			case N_VOP: // vop not coded
1372 :	suxen_drol	233	// when low_delay==0, N_VOP's should interpolate between the past and future frames
1373 :			image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);
1374 :	Isibaar	3	break;
1375 :
1376 :	edgomez	195	default:
1377 :	Isibaar	3	return XVID_ERR_FAIL;
1378 :			}
1379 :
1380 :	chenm001	294	#ifdef BFRAMES_DEC_DEBUG
1381 :	chenm001	290	if (frame->length != BitstreamPos(&bs) / 8){
1382 :			DEBUG2("InLen/UseLen",frame->length, BitstreamPos(&bs) / 8);
1383 :			}
1384 :	chenm001	294	#endif
1385 :	Isibaar	3	frame->length = BitstreamPos(&bs) / 8;
1386 :
1387 :	chenm001	290
1388 :	suxen_drol	233	#ifdef BFRAMES_DEC
1389 :	chenm001	168	// test if no B_VOP
1390 :	chenm001	356	if (dec->low_delay \|\| dec->frames == 0) {
1391 :	Isibaar	179	#endif
1392 :	chenm001	290	image_output(&dec->cur, dec->width, dec->height, dec->edged_width,
1393 :	edgomez	195	frame->image, frame->stride, frame->colorspace);
1394 :	chenm001	290
1395 :	suxen_drol	233	#ifdef BFRAMES_DEC
1396 :	chenm001	168	} else {
1397 :	chenm001	356	if (dec->frames >= 1) {
1398 :	chenm001	168	start_timer();
1399 :	edgomez	195	if ((vop_type == I_VOP \|\| vop_type == P_VOP)) {
1400 :			image_output(&dec->refn[0], dec->width, dec->height,
1401 :			dec->edged_width, frame->image, frame->stride,
1402 :			frame->colorspace);
1403 :	chenm001	168	} else if (vop_type == B_VOP) {
1404 :	edgomez	195	image_output(&dec->cur, dec->width, dec->height,
1405 :			dec->edged_width, frame->image, frame->stride,
1406 :			frame->colorspace);
1407 :	chenm001	168	}
1408 :			stop_conv_timer();
1409 :	chenm001	156	}
1410 :			}
1411 :	Isibaar	179	#endif
1412 :
1413 :	edgomez	195	if (vop_type == I_VOP \|\| vop_type == P_VOP) {
1414 :	chenm001	156	image_swap(&dec->refn[0], &dec->refn[1]);
1415 :			image_swap(&dec->cur, &dec->refn[0]);
1416 :	chenm001	306
1417 :	chenm001	156	// swap MACROBLOCK
1418 :	chenm001	306	// the Divx will not set the low_delay flage some times
1419 :			// so follow code will wrong to not swap at that time
1420 :			// this will broken bitstream! so I'm change it,
1421 :			// But that is not the best way! can anyone tell me how
1422 :			// to do another way?
1423 :			// 18-07-2002 MinChen<chenm001@163.com>
1424 :			//if (!dec->low_delay && vop_type == P_VOP)
1425 :			if (vop_type == P_VOP)
1426 :	chenm001	161	mb_swap(&dec->mbs, &dec->last_mbs);
1427 :	chenm001	156	}
1428 :
1429 :	Isibaar	3	emms();
1430 :
1431 :			stop_global_timer();
1432 :
1433 :			return XVID_ERR_OK;
1434 :			}

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