[cvs] / xvidcore / src / decoder.c Repository:
ViewVC logotype

Annotation of /xvidcore/src/decoder.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1.37.2.9 - (view) (download)

1 : Isibaar 1.1 /**************************************************************************
2 :     *
3 : edgomez 1.12 * XVID MPEG-4 VIDEO CODEC
4 :     * - Decoder main module -
5 : Isibaar 1.1 *
6 : edgomez 1.12 * 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 :     *
15 :     * 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 :     *
20 :     * 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 :     *
25 :     * 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 1.1 *
29 :     *************************************************************************/
30 :    
31 :     /**************************************************************************
32 :     *
33 : edgomez 1.12 * History:
34 : Isibaar 1.1 *
35 : chenm001 1.30 * 15.07.2002 fix a bug in B-frame decode at DIRECT mode
36 :     * MinChen <chenm001@163.com>
37 : chenm001 1.27 * 10.07.2002 added BFRAMES_DEC_DEBUG support
38 :     * Fix a little bug for low_delay flage
39 :     * MinChen <chenm001@163.com>
40 : chenm001 1.26 * 28.06.2002 added basic resync support to iframe/pframe_decode()
41 : chenm001 1.27 * 22.06.2002 added primative N_VOP support
42 : chenm001 1.30 * #define BFRAMES_DEC now enables Minchen's bframe decoder
43 : chenm001 1.17 * 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 1.14 * 02.05.2002 add B-frame decode support(have some problem);
47 :     * MinChen <chenm001@163.com>
48 : chenm001 1.11 * 22.04.2002 add some B-frame decode support; chenm001 <chenm001@163.com>
49 : h 1.8 * 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 1.5 * 26.03.2002 interlacing support - moved transfers outside decode loop
54 : edgomez 1.12 * 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 :     *
58 : suxen_drol 1.37.2.9 * $Id: decoder.c,v 1.37.2.8 2002/11/07 10:28:15 suxen_drol Exp $
59 : Isibaar 1.1 *
60 :     *************************************************************************/
61 :    
62 :     #include <stdlib.h>
63 : edgomez 1.12 #include <string.h>
64 : Isibaar 1.1
65 : chenm001 1.27 #ifdef BFRAMES_DEC_DEBUG
66 :     #define BFRAMES_DEC
67 :     #endif
68 :    
69 : Isibaar 1.1 #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 : Isibaar 1.37.2.6 #include "motion/motion.h"
88 : Isibaar 1.1
89 :     #include "image/image.h"
90 :     #include "image/colorspace.h"
91 : Isibaar 1.3 #include "utils/mem_align.h"
92 : Isibaar 1.1
93 : edgomez 1.19 int
94 : suxen_drol 1.37.2.8 decoder_resize(DECODER * dec)
95 : Isibaar 1.1 {
96 : suxen_drol 1.37.2.8 /* free existing */
97 : Isibaar 1.1
98 : suxen_drol 1.37.2.8 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
99 :     image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
100 :     image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);
101 :     image_destroy(&dec->refh, dec->edged_width, dec->edged_height);
102 :     image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
103 : Isibaar 1.1
104 : suxen_drol 1.37.2.8 if (dec->last_mbs)
105 :     xvid_free(dec->last_mbs);
106 :     if (dec->mbs)
107 :     xvid_free(dec->mbs);
108 :    
109 :     /* realloc */
110 : Isibaar 1.1
111 :     dec->mb_width = (dec->width + 15) / 16;
112 :     dec->mb_height = (dec->height + 15) / 16;
113 :    
114 :     dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;
115 :     dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;
116 : edgomez 1.19
117 :     if (image_create(&dec->cur, dec->edged_width, dec->edged_height)) {
118 : Isibaar 1.3 xvid_free(dec);
119 : Isibaar 1.1 return XVID_ERR_MEMORY;
120 :     }
121 :    
122 : edgomez 1.19 if (image_create(&dec->refn[0], dec->edged_width, dec->edged_height)) {
123 : Isibaar 1.1 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
124 : Isibaar 1.3 xvid_free(dec);
125 : Isibaar 1.1 return XVID_ERR_MEMORY;
126 :     }
127 : suxen_drol 1.37.2.8
128 : chenm001 1.11 // add by chenm001 <chenm001@163.com>
129 :     // for support B-frame to reference last 2 frame
130 : edgomez 1.19 if (image_create(&dec->refn[1], dec->edged_width, dec->edged_height)) {
131 : chenm001 1.11 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
132 :     image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
133 :     xvid_free(dec);
134 :     return XVID_ERR_MEMORY;
135 :     }
136 : edgomez 1.19 if (image_create(&dec->refn[2], dec->edged_width, dec->edged_height)) {
137 : chenm001 1.14 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
138 :     image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
139 :     image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
140 :     xvid_free(dec);
141 :     return XVID_ERR_MEMORY;
142 :     }
143 : Isibaar 1.1
144 : Isibaar 1.37.2.2 if (image_create(&dec->refh, dec->edged_width, dec->edged_height)) {
145 :     image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
146 :     image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
147 :     image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
148 :     image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);
149 :     xvid_free(dec);
150 :     return XVID_ERR_MEMORY;
151 :     }
152 :    
153 : edgomez 1.19 dec->mbs =
154 :     xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
155 :     CACHE_LINE);
156 :     if (dec->mbs == NULL) {
157 : Isibaar 1.1 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
158 : chenm001 1.14 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
159 :     image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
160 :     image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);
161 : Isibaar 1.37.2.2 image_destroy(&dec->refh, dec->edged_width, dec->edged_height);
162 : chenm001 1.14 xvid_free(dec);
163 :     return XVID_ERR_MEMORY;
164 :     }
165 : Isibaar 1.20 memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
166 :    
167 : chenm001 1.14 // add by chenm001 <chenm001@163.com>
168 :     // for skip MB flag
169 : edgomez 1.19 dec->last_mbs =
170 :     xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
171 :     CACHE_LINE);
172 :     if (dec->last_mbs == NULL) {
173 : chenm001 1.14 xvid_free(dec->mbs);
174 :     image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
175 :     image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
176 :     image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
177 :     image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);
178 : Isibaar 1.37.2.2 image_destroy(&dec->refh, dec->edged_width, dec->edged_height);
179 : Isibaar 1.3 xvid_free(dec);
180 : Isibaar 1.1 return XVID_ERR_MEMORY;
181 :     }
182 : Isibaar 1.20
183 :     memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
184 : Isibaar 1.1
185 : suxen_drol 1.37.2.8 return XVID_ERR_OK;
186 :     }
187 :    
188 :    
189 :     int
190 :     decoder_create(XVID_DEC_PARAM * param)
191 :     {
192 :     DECODER *dec;
193 :    
194 :     dec = xvid_malloc(sizeof(DECODER), CACHE_LINE);
195 :     if (dec == NULL) {
196 :     return XVID_ERR_MEMORY;
197 :     }
198 :     memset(dec, 0, sizeof(DECODER));
199 :    
200 :     param->handle = dec;
201 :    
202 :     dec->width = param->width;
203 :     dec->height = param->height;
204 :    
205 :     image_null(&dec->cur);
206 :     image_null(&dec->refn[0]);
207 :     image_null(&dec->refn[1]);
208 :     image_null(&dec->refn[2]);
209 :     image_null(&dec->refh);
210 :    
211 :     dec->mbs = NULL;
212 :     dec->last_mbs = NULL;
213 :    
214 : Isibaar 1.1 init_timer();
215 :    
216 : chenm001 1.14 // add by chenm001 <chenm001@163.com>
217 :     // for support B-frame to save reference frame's time
218 :     dec->frames = -1;
219 :     dec->time = dec->time_base = dec->last_time_base = 0;
220 : suxen_drol 1.37.2.8 dec->low_delay = 0;
221 : edgomez 1.19
222 : suxen_drol 1.37.2.8 dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
223 :    
224 :     if (dec->fixed_dimensions)
225 :     return decoder_resize(dec);
226 :     else
227 :     return XVID_ERR_OK;
228 : Isibaar 1.1 }
229 :    
230 :    
231 : edgomez 1.19 int
232 :     decoder_destroy(DECODER * dec)
233 : Isibaar 1.1 {
234 : chenm001 1.14 xvid_free(dec->last_mbs);
235 : Isibaar 1.3 xvid_free(dec->mbs);
236 : chenm001 1.11 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
237 : chenm001 1.14 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
238 :     image_destroy(&dec->refn[2], dec->edged_width, dec->edged_height);
239 : Isibaar 1.37.2.2 image_destroy(&dec->refh, dec->edged_width, dec->edged_height);
240 : Isibaar 1.1 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
241 : Isibaar 1.3 xvid_free(dec);
242 : Isibaar 1.1
243 :     write_timer();
244 :     return XVID_ERR_OK;
245 :     }
246 :    
247 :    
248 :    
249 : edgomez 1.19 static const int32_t dquant_table[4] = {
250 : Isibaar 1.1 -1, -2, 1, 2
251 :     };
252 :    
253 :    
254 : chenm001 1.14
255 :    
256 : Isibaar 1.1 // decode an intra macroblock
257 :    
258 : edgomez 1.19 void
259 :     decoder_mbintra(DECODER * dec,
260 :     MACROBLOCK * pMB,
261 :     const uint32_t x_pos,
262 :     const uint32_t y_pos,
263 :     const uint32_t acpred_flag,
264 :     const uint32_t cbp,
265 :     Bitstream * bs,
266 :     const uint32_t quant,
267 : chenm001 1.26 const uint32_t intra_dc_threshold,
268 :     const unsigned int bound)
269 : Isibaar 1.1 {
270 : edgomez 1.7
271 :     DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
272 : edgomez 1.19 DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);
273 : edgomez 1.7
274 : h 1.8 uint32_t stride = dec->edged_width;
275 :     uint32_t stride2 = stride / 2;
276 :     uint32_t next_block = stride * 8;
277 : h 1.5 uint32_t i;
278 :     uint32_t iQuant = pMB->quant;
279 :     uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
280 :    
281 : edgomez 1.7 pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
282 : h 1.8 pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
283 :     pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
284 : edgomez 1.7
285 : edgomez 1.19 memset(block, 0, 6 * 64 * sizeof(int16_t)); // clear
286 : h 1.5
287 : edgomez 1.19 for (i = 0; i < 6; i++) {
288 : h 1.5 uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
289 : Isibaar 1.1 int16_t predictors[8];
290 :     int start_coeff;
291 :    
292 :     start_timer();
293 : edgomez 1.19 predict_acdc(dec->mbs, x_pos, y_pos, dec->mb_width, i, &block[i * 64],
294 : chenm001 1.26 iQuant, iDcScaler, predictors, bound);
295 : edgomez 1.19 if (!acpred_flag) {
296 : h 1.5 pMB->acpred_directions[i] = 0;
297 : Isibaar 1.1 }
298 :     stop_prediction_timer();
299 :    
300 : edgomez 1.19 if (quant < intra_dc_threshold) {
301 : Isibaar 1.1 int dc_size;
302 :     int dc_dif;
303 :    
304 : edgomez 1.19 dc_size = i < 4 ? get_dc_size_lum(bs) : get_dc_size_chrom(bs);
305 :     dc_dif = dc_size ? get_dc_dif(bs, dc_size) : 0;
306 : Isibaar 1.1
307 : edgomez 1.19 if (dc_size > 8) {
308 :     BitstreamSkip(bs, 1); // marker
309 : Isibaar 1.1 }
310 : edgomez 1.19
311 :     block[i * 64 + 0] = dc_dif;
312 : Isibaar 1.1 start_coeff = 1;
313 : chenm001 1.26
314 :     DPRINTF(DPRINTF_COEFF,"block[0] %i", dc_dif);
315 : edgomez 1.19 } else {
316 : Isibaar 1.1 start_coeff = 0;
317 :     }
318 :    
319 :     start_timer();
320 : edgomez 1.19 if (cbp & (1 << (5 - i))) // coded
321 : Isibaar 1.1 {
322 : h 1.37.2.1 int direction = dec->alternate_vertical_scan ?
323 :     2 : pMB->acpred_directions[i];
324 :    
325 :     get_intra_block(bs, &block[i * 64], direction, start_coeff);
326 : Isibaar 1.1 }
327 :     stop_coding_timer();
328 :    
329 :     start_timer();
330 : edgomez 1.19 add_acdc(pMB, i, &block[i * 64], iDcScaler, predictors);
331 : Isibaar 1.1 stop_prediction_timer();
332 :    
333 :     start_timer();
334 : edgomez 1.19 if (dec->quant_type == 0) {
335 :     dequant_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler);
336 :     } else {
337 :     dequant4_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler);
338 : Isibaar 1.1 }
339 :     stop_iquant_timer();
340 :    
341 :     start_timer();
342 : edgomez 1.19 idct(&data[i * 64]);
343 : Isibaar 1.1 stop_idct_timer();
344 : h 1.5 }
345 : Isibaar 1.1
346 : edgomez 1.19 if (dec->interlacing && pMB->field_dct) {
347 : h 1.8 next_block = stride;
348 :     stride *= 2;
349 : Isibaar 1.1 }
350 : h 1.5
351 :     start_timer();
352 : edgomez 1.19 transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
353 :     transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
354 :     transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
355 :     transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);
356 :     transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
357 :     transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
358 : h 1.5 stop_transfer_timer();
359 : Isibaar 1.1 }
360 :    
361 :    
362 :    
363 :    
364 :    
365 :     #define SIGN(X) (((X)>0)?1:-1)
366 :     #define ABS(X) (((X)>0)?(X):-(X))
367 :    
368 :     // decode an inter macroblock
369 :    
370 : edgomez 1.19 void
371 :     decoder_mbinter(DECODER * dec,
372 :     const MACROBLOCK * pMB,
373 :     const uint32_t x_pos,
374 :     const uint32_t y_pos,
375 :     const uint32_t acpred_flag,
376 :     const uint32_t cbp,
377 :     Bitstream * bs,
378 :     const uint32_t quant,
379 :     const uint32_t rounding)
380 : Isibaar 1.1 {
381 : edgomez 1.7
382 : edgomez 1.19 DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
383 : edgomez 1.7 DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);
384 : h 1.5
385 : h 1.8 uint32_t stride = dec->edged_width;
386 :     uint32_t stride2 = stride / 2;
387 :     uint32_t next_block = stride * 8;
388 : edgomez 1.7 uint32_t i;
389 :     uint32_t iQuant = pMB->quant;
390 : h 1.5 uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
391 : Isibaar 1.1 int uv_dx, uv_dy;
392 :    
393 : edgomez 1.7 pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
394 : h 1.8 pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
395 :     pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
396 : h 1.5
397 : edgomez 1.19 if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
398 : h 1.5 uv_dx = pMB->mvs[0].x;
399 :     uv_dy = pMB->mvs[0].y;
400 : Isibaar 1.1
401 : Isibaar 1.34 if (dec->quarterpel)
402 :     {
403 : Isibaar 1.37.2.7 uv_dx /= 2;
404 :     uv_dy /= 2;
405 : Isibaar 1.34 }
406 : Isibaar 1.37.2.7
407 :     uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
408 :     uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
409 : Isibaar 1.37.2.3
410 :     start_timer();
411 :     if(dec->quarterpel) {
412 :     interpolate16x16_quarterpel(dec->cur.y, dec->refn[0].y, dec->refh.y, dec->refh.y + 64,
413 :     dec->refh.y + 128, 16*x_pos, 16*y_pos,
414 :     pMB->mvs[0].x, pMB->mvs[0].y, stride, rounding);
415 :     }
416 :     else {
417 :     interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos,
418 :     pMB->mvs[0].x, pMB->mvs[0].y, stride, rounding);
419 :     interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos,
420 :     pMB->mvs[1].x, pMB->mvs[1].y, stride, rounding);
421 :     interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos + 8,
422 :     pMB->mvs[2].x, pMB->mvs[2].y, stride, rounding);
423 :     interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos + 8,
424 :     pMB->mvs[3].x, pMB->mvs[3].y, stride, rounding);
425 :     }
426 :    
427 :     interpolate8x8_switch(dec->cur.u, dec->refn[0].u, 8 * x_pos, 8 * y_pos,
428 :     uv_dx, uv_dy, stride2, rounding);
429 :     interpolate8x8_switch(dec->cur.v, dec->refn[0].v, 8 * x_pos, 8 * y_pos,
430 :     uv_dx, uv_dy, stride2, rounding);
431 :     stop_comp_timer();
432 :    
433 : edgomez 1.19 } else {
434 : Isibaar 1.1 int sum;
435 : Isibaar 1.37.2.6
436 :     if(dec->quarterpel)
437 :     sum = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);
438 :     else
439 :     sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
440 :    
441 :     uv_dx = (sum >> 3) + roundtab_76[sum & 0xf];
442 :    
443 :     if(dec->quarterpel)
444 :     sum = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);
445 :     else
446 :     sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
447 : Isibaar 1.34
448 : Isibaar 1.37.2.6 uv_dy = (sum >> 3) + roundtab_76[sum & 0xf];
449 : Isibaar 1.1
450 : Isibaar 1.37.2.3 start_timer();
451 :     if(dec->quarterpel) {
452 :     interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, dec->refh.y, dec->refh.y + 64,
453 :     dec->refh.y + 128, 16*x_pos, 16*y_pos,
454 :     pMB->mvs[0].x, pMB->mvs[0].y, stride, rounding);
455 :     interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, dec->refh.y, dec->refh.y + 64,
456 :     dec->refh.y + 128, 16*x_pos + 8, 16*y_pos,
457 :     pMB->mvs[1].x, pMB->mvs[1].y, stride, rounding);
458 :     interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, dec->refh.y, dec->refh.y + 64,
459 :     dec->refh.y + 128, 16*x_pos, 16*y_pos + 8,
460 :     pMB->mvs[2].x, pMB->mvs[2].y, stride, rounding);
461 :     interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, dec->refh.y, dec->refh.y + 64,
462 :     dec->refh.y + 128, 16*x_pos + 8, 16*y_pos + 8,
463 :     pMB->mvs[3].x, pMB->mvs[3].y, stride, rounding);
464 :     }
465 :     else {
466 :     interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos,
467 : Isibaar 1.34 pMB->mvs[0].x, pMB->mvs[0].y, stride, rounding);
468 : Isibaar 1.37.2.3 interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos,
469 : Isibaar 1.34 pMB->mvs[1].x, pMB->mvs[1].y, stride, rounding);
470 : Isibaar 1.37.2.3 interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos + 8,
471 : Isibaar 1.34 pMB->mvs[2].x, pMB->mvs[2].y, stride, rounding);
472 : Isibaar 1.37.2.3 interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos + 8,
473 : Isibaar 1.34 pMB->mvs[3].x, pMB->mvs[3].y, stride, rounding);
474 : Isibaar 1.37.2.3 }
475 :    
476 :     interpolate8x8_switch(dec->cur.u, dec->refn[0].u, 8 * x_pos, 8 * y_pos,
477 :     uv_dx, uv_dy, stride2, rounding);
478 :     interpolate8x8_switch(dec->cur.v, dec->refn[0].v, 8 * x_pos, 8 * y_pos,
479 :     uv_dx, uv_dy, stride2, rounding);
480 :     stop_comp_timer();
481 : Isibaar 1.34 }
482 : Isibaar 1.1
483 : edgomez 1.19 for (i = 0; i < 6; i++) {
484 : h 1.37.2.1 int direction = dec->alternate_vertical_scan ? 2 : 0;
485 :    
486 : edgomez 1.19 if (cbp & (1 << (5 - i))) // coded
487 : Isibaar 1.1 {
488 : edgomez 1.19 memset(&block[i * 64], 0, 64 * sizeof(int16_t)); // clear
489 : Isibaar 1.1
490 :     start_timer();
491 : h 1.37.2.1 get_inter_block(bs, &block[i * 64], direction);
492 : Isibaar 1.1 stop_coding_timer();
493 :    
494 :     start_timer();
495 : edgomez 1.19 if (dec->quant_type == 0) {
496 :     dequant_inter(&data[i * 64], &block[i * 64], iQuant);
497 :     } else {
498 :     dequant4_inter(&data[i * 64], &block[i * 64], iQuant);
499 : Isibaar 1.1 }
500 :     stop_iquant_timer();
501 :    
502 :     start_timer();
503 : edgomez 1.19 idct(&data[i * 64]);
504 : Isibaar 1.1 stop_idct_timer();
505 : h 1.5 }
506 :     }
507 : Isibaar 1.1
508 : edgomez 1.19 if (dec->interlacing && pMB->field_dct) {
509 : h 1.8 next_block = stride;
510 :     stride *= 2;
511 : Isibaar 1.1 }
512 : h 1.5
513 :     start_timer();
514 :     if (cbp & 32)
515 : edgomez 1.19 transfer_16to8add(pY_Cur, &data[0 * 64], stride);
516 : h 1.5 if (cbp & 16)
517 : edgomez 1.19 transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
518 : h 1.5 if (cbp & 8)
519 : edgomez 1.19 transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
520 : h 1.5 if (cbp & 4)
521 : edgomez 1.19 transfer_16to8add(pY_Cur + 8 + next_block, &data[3 * 64], stride);
522 : h 1.5 if (cbp & 2)
523 : edgomez 1.19 transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
524 : h 1.5 if (cbp & 1)
525 : edgomez 1.19 transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
526 : h 1.5 stop_transfer_timer();
527 : Isibaar 1.1 }
528 :    
529 :    
530 : edgomez 1.19 void
531 :     decoder_iframe(DECODER * dec,
532 :     Bitstream * bs,
533 : suxen_drol 1.37.2.8 int reduced_resolution,
534 : edgomez 1.19 int quant,
535 :     int intra_dc_threshold)
536 : Isibaar 1.1 {
537 : chenm001 1.26 uint32_t bound;
538 :     uint32_t x, y;
539 : suxen_drol 1.37.2.8 int mb_width = dec->mb_width;
540 :     int mb_height = dec->mb_height;
541 :    
542 :     if (reduced_resolution)
543 :     {
544 :     mb_width /= 2;
545 :     mb_height /= 2;
546 :     }
547 : chenm001 1.25
548 : chenm001 1.26 bound = 0;
549 : edgomez 1.7
550 : suxen_drol 1.37.2.8 for (y = 0; y < mb_height; y++) {
551 :     for (x = 0; x < mb_width; x++) {
552 : chenm001 1.26 MACROBLOCK *mb;
553 : Isibaar 1.1 uint32_t mcbpc;
554 :     uint32_t cbpc;
555 :     uint32_t acpred_flag;
556 :     uint32_t cbpy;
557 :     uint32_t cbp;
558 :    
559 : chenm001 1.26 while (BitstreamShowBits(bs, 9) == 1)
560 :     BitstreamSkip(bs, 9);
561 :    
562 :     if (check_resync_marker(bs, 0))
563 :     {
564 : suxen_drol 1.37.2.8 bound = read_video_packet_header(bs, dec, 0,
565 :     &quant, NULL, NULL, &intra_dc_threshold);
566 : chenm001 1.26 x = bound % dec->mb_width;
567 :     y = bound / dec->mb_width;
568 :     }
569 :     mb = &dec->mbs[y * dec->mb_width + x];
570 :    
571 :     DPRINTF(DPRINTF_MB, "macroblock (%i,%i) %08x", x, y, BitstreamShowBits(bs, 32));
572 :    
573 : Isibaar 1.1 mcbpc = get_mcbpc_intra(bs);
574 :     mb->mode = mcbpc & 7;
575 :     cbpc = (mcbpc >> 4);
576 :    
577 :     acpred_flag = BitstreamGetBit(bs);
578 :    
579 :     cbpy = get_cbpy(bs, 1);
580 :     cbp = (cbpy << 2) | cbpc;
581 :    
582 : edgomez 1.19 if (mb->mode == MODE_INTRA_Q) {
583 :     quant += dquant_table[BitstreamGetBits(bs, 2)];
584 :     if (quant > 31) {
585 : Isibaar 1.1 quant = 31;
586 : edgomez 1.19 } else if (quant < 1) {
587 : Isibaar 1.1 quant = 1;
588 :     }
589 :     }
590 :     mb->quant = quant;
591 : chenm001 1.30 mb->mvs[0].x = mb->mvs[0].y =
592 :     mb->mvs[1].x = mb->mvs[1].y =
593 :     mb->mvs[2].x = mb->mvs[2].y =
594 :     mb->mvs[3].x = mb->mvs[3].y =0;
595 : h 1.5
596 : edgomez 1.19 if (dec->interlacing) {
597 : h 1.5 mb->field_dct = BitstreamGetBit(bs);
598 :     DEBUG1("deci: field_dct: ", mb->field_dct);
599 :     }
600 : Isibaar 1.1
601 : edgomez 1.19 decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
602 : chenm001 1.26 intra_dc_threshold, bound);
603 : suxen_drol 1.37.2.8
604 : Isibaar 1.1 }
605 : albeu 1.32 if(dec->out_frm)
606 :     output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,0,y,dec->mb_width);
607 : Isibaar 1.1 }
608 : edgomez 1.7
609 : Isibaar 1.1 }
610 :    
611 :    
612 : edgomez 1.19 void
613 :     get_motion_vector(DECODER * dec,
614 :     Bitstream * bs,
615 :     int x,
616 :     int y,
617 :     int k,
618 :     VECTOR * mv,
619 : chenm001 1.26 int fcode,
620 :     const int bound)
621 : Isibaar 1.1 {
622 : edgomez 1.7
623 : Isibaar 1.1 int scale_fac = 1 << (fcode - 1);
624 :     int high = (32 * scale_fac) - 1;
625 :     int low = ((-32) * scale_fac);
626 :     int range = (64 * scale_fac);
627 :    
628 : chenm001 1.26 VECTOR pmv;
629 : Isibaar 1.1 int mv_x, mv_y;
630 :    
631 : chenm001 1.26 pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);
632 : Isibaar 1.1
633 :     mv_x = get_mv(bs, fcode);
634 :     mv_y = get_mv(bs, fcode);
635 : edgomez 1.19
636 : chenm001 1.26 DPRINTF(DPRINTF_MV,"mv_diff (%i,%i) pred (%i,%i)", mv_x, mv_y, pmv.x, pmv.y);
637 :    
638 :     mv_x += pmv.x;
639 :     mv_y += pmv.y;
640 : Isibaar 1.1
641 : edgomez 1.19 if (mv_x < low) {
642 : Isibaar 1.1 mv_x += range;
643 : edgomez 1.19 } else if (mv_x > high) {
644 : Isibaar 1.1 mv_x -= range;
645 :     }
646 :    
647 : edgomez 1.19 if (mv_y < low) {
648 : Isibaar 1.1 mv_y += range;
649 : edgomez 1.19 } else if (mv_y > high) {
650 : Isibaar 1.1 mv_y -= range;
651 :     }
652 :    
653 :     mv->x = mv_x;
654 :     mv->y = mv_y;
655 : suxen_drol 1.37.2.8 }
656 : Isibaar 1.1
657 : suxen_drol 1.37.2.8
658 :    
659 :     static __inline int gmc_sanitize(int value, int quarterpel, int fcode)
660 :     {
661 :     int length = 1 << (fcode+4);
662 :    
663 :     if (quarterpel) value *= 2;
664 :    
665 :     if (value < -length)
666 :     return -length;
667 :     else if (value >= length)
668 :     return length-1;
669 :     else return value;
670 : Isibaar 1.1 }
671 :    
672 :    
673 : suxen_drol 1.37.2.8 /* for P_VOP set gmc_mv to NULL */
674 : edgomez 1.19 void
675 :     decoder_pframe(DECODER * dec,
676 :     Bitstream * bs,
677 :     int rounding,
678 : suxen_drol 1.37.2.8 int reduced_resolution,
679 : edgomez 1.19 int quant,
680 :     int fcode,
681 : suxen_drol 1.37.2.8 int intra_dc_threshold,
682 :     VECTOR * gmc_mv)
683 : Isibaar 1.1 {
684 : edgomez 1.7
685 : Isibaar 1.1 uint32_t x, y;
686 : chenm001 1.26 uint32_t bound;
687 : albeu 1.32 int cp_mb, st_mb;
688 : Isibaar 1.1
689 :     start_timer();
690 : edgomez 1.19 image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
691 : h 1.37.2.1 dec->width, dec->height);
692 : Isibaar 1.1 stop_edges_timer();
693 :    
694 : chenm001 1.26 bound = 0;
695 :    
696 : edgomez 1.19 for (y = 0; y < dec->mb_height; y++) {
697 : albeu 1.32 cp_mb = st_mb = 0;
698 : edgomez 1.19 for (x = 0; x < dec->mb_width; x++) {
699 : chenm001 1.26 MACROBLOCK *mb;
700 :    
701 :     // skip stuffing
702 :     while (BitstreamShowBits(bs, 10) == 1)
703 :     BitstreamSkip(bs, 10);
704 :    
705 :     if (check_resync_marker(bs, fcode - 1))
706 :     {
707 : suxen_drol 1.37.2.8 bound = read_video_packet_header(bs, dec, fcode - 1,
708 :     &quant, &fcode, NULL, &intra_dc_threshold);
709 : chenm001 1.26 x = bound % dec->mb_width;
710 :     y = bound / dec->mb_width;
711 :     }
712 :     mb = &dec->mbs[y * dec->mb_width + x];
713 :    
714 :     DPRINTF(DPRINTF_MB, "macroblock (%i,%i) %08x", x, y, BitstreamShowBits(bs, 32));
715 : suxen_drol 1.23
716 : edgomez 1.19 //if (!(dec->mb_skip[y*dec->mb_width + x]=BitstreamGetBit(bs))) // not_coded
717 :     if (!(BitstreamGetBit(bs))) // not_coded
718 : Isibaar 1.1 {
719 :     uint32_t mcbpc;
720 :     uint32_t cbpc;
721 :     uint32_t acpred_flag;
722 :     uint32_t cbpy;
723 :     uint32_t cbp;
724 :     uint32_t intra;
725 : suxen_drol 1.37.2.8 int mcsel = 0; // mcsel: '0'=local motion, '1'=GMC
726 : Isibaar 1.1
727 : albeu 1.32 cp_mb++;
728 : Isibaar 1.1 mcbpc = get_mcbpc_inter(bs);
729 :     mb->mode = mcbpc & 7;
730 :     cbpc = (mcbpc >> 4);
731 : chenm001 1.26
732 :     DPRINTF(DPRINTF_MB, "mode %i", mb->mode);
733 :     DPRINTF(DPRINTF_MB, "cbpc %i", cbpc);
734 : edgomez 1.2 acpred_flag = 0;
735 : Isibaar 1.1
736 :     intra = (mb->mode == MODE_INTRA || mb->mode == MODE_INTRA_Q);
737 : edgomez 1.19
738 :     if (intra) {
739 : Isibaar 1.1 acpred_flag = BitstreamGetBit(bs);
740 :     }
741 :    
742 : suxen_drol 1.37.2.8 if (gmc_mv && (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q))
743 :     {
744 :     mcsel = BitstreamGetBit(bs);
745 :     }
746 :    
747 : chenm001 1.26 cbpy = get_cbpy(bs, intra);
748 :     DPRINTF(DPRINTF_MB, "cbpy %i", cbpy);
749 : chenm001 1.25
750 : Isibaar 1.1 cbp = (cbpy << 2) | cbpc;
751 :    
752 : edgomez 1.19 if (mb->mode == MODE_INTER_Q || mb->mode == MODE_INTRA_Q) {
753 : chenm001 1.26 int dquant = dquant_table[BitstreamGetBits(bs, 2)];
754 :     DPRINTF(DPRINTF_MB, "dquant %i", dquant);
755 :     quant += dquant;
756 : edgomez 1.19 if (quant > 31) {
757 : Isibaar 1.1 quant = 31;
758 : chenm001 1.26 } else if (quant < 1) {
759 : Isibaar 1.1 quant = 1;
760 :     }
761 : chenm001 1.26 DPRINTF(DPRINTF_MB, "quant %i", quant);
762 : Isibaar 1.1 }
763 :     mb->quant = quant;
764 : h 1.5
765 : edgomez 1.19 if (dec->interlacing) {
766 : h 1.37 if (cbp || intra) {
767 :     mb->field_dct = BitstreamGetBit(bs);
768 :     DEBUG1("decp: field_dct: ", mb->field_dct);
769 :     }
770 : h 1.5
771 : edgomez 1.19 if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
772 : h 1.5 mb->field_pred = BitstreamGetBit(bs);
773 :     DEBUG1("decp: field_pred: ", mb->field_pred);
774 :    
775 : edgomez 1.19 if (mb->field_pred) {
776 : h 1.5 mb->field_for_top = BitstreamGetBit(bs);
777 :     DEBUG1("decp: field_for_top: ", mb->field_for_top);
778 :     mb->field_for_bot = BitstreamGetBit(bs);
779 :     DEBUG1("decp: field_for_bot: ", mb->field_for_bot);
780 :     }
781 :     }
782 :     }
783 :    
784 : edgomez 1.19 if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
785 : suxen_drol 1.37.2.8
786 :     if (mcsel)
787 :     {
788 :     mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = gmc_sanitize(gmc_mv[0].x, dec->quarterpel, fcode);
789 :     mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = gmc_sanitize(gmc_mv[0].y, dec->quarterpel, fcode);
790 :    
791 :     } else if (dec->interlacing && mb->field_pred) {
792 : edgomez 1.19 get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],
793 : chenm001 1.26 fcode, bound);
794 : edgomez 1.19 get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1],
795 : chenm001 1.26 fcode, bound);
796 : edgomez 1.19 } else {
797 :     get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],
798 : chenm001 1.26 fcode, bound);
799 : edgomez 1.19 mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =
800 :     mb->mvs[0].x;
801 :     mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =
802 :     mb->mvs[0].y;
803 : h 1.5 }
804 : chl 1.35 } else if (mb->mode == MODE_INTER4V ) {
805 :    
806 : chenm001 1.26 get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
807 :     get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);
808 :     get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
809 :     get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode, bound);
810 : edgomez 1.19 } else // MODE_INTRA, MODE_INTRA_Q
811 : Isibaar 1.1 {
812 : edgomez 1.19 mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =
813 :     0;
814 :     mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =
815 :     0;
816 :     decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
817 : chenm001 1.26 intra_dc_threshold, bound);
818 : Isibaar 1.1 continue;
819 :     }
820 :    
821 : edgomez 1.19 decoder_mbinter(dec, mb, x, y, acpred_flag, cbp, bs, quant,
822 :     rounding);
823 : suxen_drol 1.37.2.8
824 :     }
825 :     else if (gmc_mv) /* not coded S_VOP macroblock */
826 :     {
827 :     mb->mode = MODE_NOT_CODED;
828 :     mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = gmc_sanitize(gmc_mv[0].x, dec->quarterpel, fcode);
829 :     mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = gmc_sanitize(gmc_mv[0].y, dec->quarterpel, fcode);
830 :     decoder_mbinter(dec, mb, x, y, 0, 0, bs, quant, rounding);
831 :     }
832 :     else /* not coded P_VOP macroblock */
833 : Isibaar 1.1 {
834 : chenm001 1.14 mb->mode = MODE_NOT_CODED;
835 : Isibaar 1.1 mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
836 :     mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
837 :     // copy macroblock directly from ref to cur
838 :    
839 :     start_timer();
840 :    
841 : edgomez 1.19 transfer8x8_copy(dec->cur.y + (16 * y) * dec->edged_width +
842 :     (16 * x),
843 :     dec->refn[0].y + (16 * y) * dec->edged_width +
844 :     (16 * x), dec->edged_width);
845 :    
846 :     transfer8x8_copy(dec->cur.y + (16 * y) * dec->edged_width +
847 :     (16 * x + 8),
848 :     dec->refn[0].y + (16 * y) * dec->edged_width +
849 :     (16 * x + 8), dec->edged_width);
850 :    
851 :     transfer8x8_copy(dec->cur.y + (16 * y + 8) * dec->edged_width +
852 :     (16 * x),
853 :     dec->refn[0].y + (16 * y +
854 :     8) * dec->edged_width +
855 :     (16 * x), dec->edged_width);
856 :    
857 :     transfer8x8_copy(dec->cur.y + (16 * y + 8) * dec->edged_width +
858 :     (16 * x + 8),
859 :     dec->refn[0].y + (16 * y +
860 :     8) * dec->edged_width +
861 :     (16 * x + 8), dec->edged_width);
862 :    
863 :     transfer8x8_copy(dec->cur.u + (8 * y) * dec->edged_width / 2 +
864 :     (8 * x),
865 :     dec->refn[0].u +
866 :     (8 * y) * dec->edged_width / 2 + (8 * x),
867 :     dec->edged_width / 2);
868 :    
869 :     transfer8x8_copy(dec->cur.v + (8 * y) * dec->edged_width / 2 +
870 :     (8 * x),
871 :     dec->refn[0].v +
872 :     (8 * y) * dec->edged_width / 2 + (8 * x),
873 :     dec->edged_width / 2);
874 : suxen_drol 1.37.2.8
875 : Isibaar 1.1 stop_transfer_timer();
876 : suxen_drol 1.37.2.8
877 : albeu 1.32 if(dec->out_frm && cp_mb > 0) {
878 :     output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
879 :     cp_mb = 0;
880 :     }
881 :     st_mb = x+1;
882 : Isibaar 1.1 }
883 :     }
884 : albeu 1.32 if(dec->out_frm && cp_mb > 0)
885 :     output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
886 : Isibaar 1.1 }
887 :     }
888 :    
889 : chenm001 1.14
890 :     // add by MinChen <chenm001@163.com>
891 :     // decode B-frame motion vector
892 : edgomez 1.19 void
893 :     get_b_motion_vector(DECODER * dec,
894 :     Bitstream * bs,
895 :     int x,
896 :     int y,
897 :     VECTOR * mv,
898 :     int fcode,
899 :     const VECTOR pmv)
900 : chenm001 1.14 {
901 :     int scale_fac = 1 << (fcode - 1);
902 :     int high = (32 * scale_fac) - 1;
903 :     int low = ((-32) * scale_fac);
904 :     int range = (64 * scale_fac);
905 :    
906 :     int mv_x, mv_y;
907 :     int pmv_x, pmv_y;
908 :    
909 :     pmv_x = pmv.x;
910 :     pmv_y = pmv.y;
911 :    
912 :     mv_x = get_mv(bs, fcode);
913 :     mv_y = get_mv(bs, fcode);
914 : edgomez 1.19
915 : chenm001 1.14 mv_x += pmv_x;
916 :     mv_y += pmv_y;
917 :    
918 : edgomez 1.19 if (mv_x < low) {
919 : chenm001 1.14 mv_x += range;
920 : edgomez 1.19 } else if (mv_x > high) {
921 : chenm001 1.14 mv_x -= range;
922 :     }
923 :    
924 : edgomez 1.19 if (mv_y < low) {
925 : chenm001 1.14 mv_y += range;
926 : edgomez 1.19 } else if (mv_y > high) {
927 : chenm001 1.14 mv_y -= range;
928 :     }
929 :    
930 :     mv->x = mv_x;
931 :     mv->y = mv_y;
932 :     }
933 :    
934 :    
935 :     // add by MinChen <chenm001@163.com>
936 :     // decode an B-frame forward & backward inter macroblock
937 : edgomez 1.19 void
938 :     decoder_bf_mbinter(DECODER * dec,
939 :     const MACROBLOCK * pMB,
940 :     const uint32_t x_pos,
941 :     const uint32_t y_pos,
942 :     const uint32_t cbp,
943 :     Bitstream * bs,
944 :     const uint32_t quant,
945 :     const uint8_t ref)
946 : chenm001 1.14 {
947 :    
948 : edgomez 1.19 DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
949 : chenm001 1.14 DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);
950 :    
951 :     uint32_t stride = dec->edged_width;
952 :     uint32_t stride2 = stride / 2;
953 :     uint32_t next_block = stride * 8;
954 :     uint32_t i;
955 :     uint32_t iQuant = pMB->quant;
956 :     uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
957 :     int uv_dx, uv_dy;
958 :    
959 :     pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
960 :     pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
961 :     pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
962 :    
963 : chenm001 1.30
964 : edgomez 1.19 if (!(pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)) {
965 : chenm001 1.14 uv_dx = pMB->mvs[0].x;
966 :     uv_dy = pMB->mvs[0].y;
967 :    
968 :     uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;
969 :     uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;
970 : edgomez 1.19 } else {
971 : chenm001 1.14 int sum;
972 : edgomez 1.19
973 : chenm001 1.14 sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
974 : edgomez 1.19 uv_dx =
975 :     (sum ==
976 :     0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
977 :     (ABS(sum) / 16) * 2));
978 : chenm001 1.14
979 :     sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
980 : edgomez 1.19 uv_dy =
981 :     (sum ==
982 :     0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
983 :     (ABS(sum) / 16) * 2));
984 : chenm001 1.14 }
985 :    
986 :     start_timer();
987 : edgomez 1.19 interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16 * x_pos, 16 * y_pos,
988 :     pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
989 :     interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16 * x_pos + 8,
990 :     16 * y_pos, pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
991 :     interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16 * x_pos,
992 :     16 * y_pos + 8, pMB->mvs[2].x, pMB->mvs[2].y, stride,
993 :     0);
994 :     interpolate8x8_switch(dec->cur.y, dec->refn[ref].y, 16 * x_pos + 8,
995 :     16 * y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride,
996 :     0);
997 :     interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,
998 :     uv_dx, uv_dy, stride2, 0);
999 :     interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,
1000 :     uv_dx, uv_dy, stride2, 0);
1001 : chenm001 1.14 stop_comp_timer();
1002 :    
1003 : edgomez 1.19 for (i = 0; i < 6; i++) {
1004 : h 1.37.2.1 int direction = dec->alternate_vertical_scan ? 2 : 0;
1005 :    
1006 : edgomez 1.19 if (cbp & (1 << (5 - i))) // coded
1007 : chenm001 1.14 {
1008 : edgomez 1.19 memset(&block[i * 64], 0, 64 * sizeof(int16_t)); // clear
1009 : chenm001 1.14
1010 :     start_timer();
1011 : h 1.37.2.1 get_inter_block(bs, &block[i * 64], direction);
1012 : chenm001 1.14 stop_coding_timer();
1013 :    
1014 :     start_timer();
1015 : edgomez 1.19 if (dec->quant_type == 0) {
1016 :     dequant_inter(&data[i * 64], &block[i * 64], iQuant);
1017 :     } else {
1018 :     dequant4_inter(&data[i * 64], &block[i * 64], iQuant);
1019 : chenm001 1.14 }
1020 :     stop_iquant_timer();
1021 :    
1022 :     start_timer();
1023 : edgomez 1.19 idct(&data[i * 64]);
1024 : chenm001 1.14 stop_idct_timer();
1025 :     }
1026 :     }
1027 :    
1028 : edgomez 1.19 if (dec->interlacing && pMB->field_dct) {
1029 : chenm001 1.14 next_block = stride;
1030 :     stride *= 2;
1031 :     }
1032 :    
1033 :     start_timer();
1034 :     if (cbp & 32)
1035 : edgomez 1.19 transfer_16to8add(pY_Cur, &data[0 * 64], stride);
1036 : chenm001 1.14 if (cbp & 16)
1037 : edgomez 1.19 transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
1038 : chenm001 1.14 if (cbp & 8)
1039 : edgomez 1.19 transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
1040 : chenm001 1.14 if (cbp & 4)
1041 : edgomez 1.19 transfer_16to8add(pY_Cur + 8 + next_block, &data[3 * 64], stride);
1042 : chenm001 1.14 if (cbp & 2)
1043 : edgomez 1.19 transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
1044 : chenm001 1.14 if (cbp & 1)
1045 : edgomez 1.19 transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
1046 : chenm001 1.14 stop_transfer_timer();
1047 :     }
1048 :    
1049 :     // add by MinChen <chenm001@163.com>
1050 :     // decode an B-frame direct & inter macroblock
1051 : edgomez 1.19 void
1052 :     decoder_bf_interpolate_mbinter(DECODER * dec,
1053 :     IMAGE forward,
1054 :     IMAGE backward,
1055 :     const MACROBLOCK * pMB,
1056 :     const uint32_t x_pos,
1057 :     const uint32_t y_pos,
1058 :     Bitstream * bs)
1059 : chenm001 1.14 {
1060 :    
1061 : edgomez 1.19 DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
1062 : chenm001 1.14 DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);
1063 :    
1064 : edgomez 1.19 uint32_t stride = dec->edged_width;
1065 :     uint32_t stride2 = stride / 2;
1066 :     uint32_t next_block = stride * 8;
1067 :     uint32_t iQuant = pMB->quant;
1068 :     int uv_dx, uv_dy;
1069 :     int b_uv_dx, b_uv_dy;
1070 :     uint32_t i;
1071 :     uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
1072 : chenm001 1.30 const uint32_t cbp = pMB->cbp;
1073 : chenm001 1.15
1074 :     pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
1075 :     pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
1076 :     pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
1077 : chenm001 1.14
1078 : chenm001 1.30
1079 : edgomez 1.19 if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)) {
1080 : chenm001 1.14 uv_dx = pMB->mvs[0].x;
1081 :     uv_dy = pMB->mvs[0].y;
1082 :    
1083 :     uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;
1084 :     uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;
1085 :    
1086 :     b_uv_dx = pMB->b_mvs[0].x;
1087 :     b_uv_dy = pMB->b_mvs[0].y;
1088 :    
1089 :     b_uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;
1090 :     b_uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;
1091 : edgomez 1.19 } else {
1092 : chenm001 1.14 int sum;
1093 : edgomez 1.19
1094 : chenm001 1.14 sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
1095 : edgomez 1.19 uv_dx =
1096 :     (sum ==
1097 :     0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
1098 :     (ABS(sum) / 16) * 2));
1099 : chenm001 1.14
1100 :     sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
1101 : edgomez 1.19 uv_dy =
1102 :     (sum ==
1103 :     0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
1104 :     (ABS(sum) / 16) * 2));
1105 :    
1106 :     sum =
1107 :     pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x +
1108 :     pMB->b_mvs[3].x;
1109 :     b_uv_dx =
1110 :     (sum ==
1111 :     0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
1112 :     (ABS(sum) / 16) * 2));
1113 :    
1114 :     sum =
1115 :     pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y +
1116 :     pMB->b_mvs[3].y;
1117 :     b_uv_dy =
1118 :     (sum ==
1119 :     0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +
1120 :     (ABS(sum) / 16) * 2));
1121 :     }
1122 : chenm001 1.14
1123 :    
1124 :     start_timer();
1125 : edgomez 1.19 interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos,
1126 :     pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1127 :     interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos,
1128 :     pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1129 :     interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos + 8,
1130 :     pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1131 :     interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8,
1132 :     16 * y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride,
1133 :     0);
1134 :     interpolate8x8_switch(dec->cur.u, forward.u, 8 * x_pos, 8 * y_pos, uv_dx,
1135 :     uv_dy, stride2, 0);
1136 :     interpolate8x8_switch(dec->cur.v, forward.v, 8 * x_pos, 8 * y_pos, uv_dx,
1137 :     uv_dy, stride2, 0);
1138 :    
1139 :    
1140 :     interpolate8x8_switch(dec->refn[2].y, backward.y, 16 * x_pos, 16 * y_pos,
1141 :     pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1142 :     interpolate8x8_switch(dec->refn[2].y, backward.y, 16 * x_pos + 8,
1143 :     16 * y_pos, pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride,
1144 :     0);
1145 :     interpolate8x8_switch(dec->refn[2].y, backward.y, 16 * x_pos,
1146 :     16 * y_pos + 8, pMB->b_mvs[2].x, pMB->b_mvs[2].y,
1147 :     stride, 0);
1148 :     interpolate8x8_switch(dec->refn[2].y, backward.y, 16 * x_pos + 8,
1149 :     16 * y_pos + 8, pMB->b_mvs[3].x, pMB->b_mvs[3].y,
1150 :     stride, 0);
1151 :     interpolate8x8_switch(dec->refn[2].u, backward.u, 8 * x_pos, 8 * y_pos,
1152 :     b_uv_dx, b_uv_dy, stride2, 0);
1153 :     interpolate8x8_switch(dec->refn[2].v, backward.v, 8 * x_pos, 8 * y_pos,
1154 :     b_uv_dx, b_uv_dy, stride2, 0);
1155 :    
1156 : Isibaar 1.37.2.2 interpolate8x8_avg2(dec->cur.y + (16 * y_pos * stride) + 16 * x_pos,
1157 :     dec->cur.y + (16 * y_pos * stride) + 16 * x_pos,
1158 :     dec->refn[2].y + (16 * y_pos * stride) + 16 * x_pos,
1159 :     stride, 0);
1160 :    
1161 :     interpolate8x8_avg2(dec->cur.y + (16 * y_pos * stride) + 16 * x_pos + 8,
1162 :     dec->cur.y + (16 * y_pos * stride) + 16 * x_pos + 8,
1163 :     dec->refn[2].y + (16 * y_pos * stride) + 16 * x_pos + 8,
1164 :     stride, 0);
1165 :    
1166 : Isibaar 1.37.2.4 interpolate8x8_avg2(dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos,
1167 :     dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos,
1168 :     dec->refn[2].y + ((16 * y_pos + 8) * stride) + 16 * x_pos,
1169 : Isibaar 1.37.2.2 stride, 0);
1170 :    
1171 : Isibaar 1.37.2.4 interpolate8x8_avg2(dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos + 8,
1172 :     dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos + 8,
1173 :     dec->refn[2].y + ((16 * y_pos + 8) * stride) + 16 * x_pos + 8,
1174 : Isibaar 1.37.2.2 stride, 0);
1175 :    
1176 : Isibaar 1.37.2.4 interpolate8x8_avg2(dec->cur.u + (8 * y_pos * stride2) + 8 * x_pos,
1177 :     dec->cur.u + (8 * y_pos * stride2) + 8 * x_pos,
1178 :     dec->refn[2].u + (8 * y_pos * stride2) + 8 * x_pos,
1179 : Isibaar 1.37.2.2 stride2, 0);
1180 :    
1181 : Isibaar 1.37.2.4 interpolate8x8_avg2(dec->cur.v + (8 * y_pos * stride2) + 8 * x_pos,
1182 :     dec->cur.v + (8 * y_pos * stride2) + 8 * x_pos,
1183 :     dec->refn[2].v + (8 * y_pos * stride2) + 8 * x_pos,
1184 : Isibaar 1.37.2.2 stride2, 0);
1185 :    
1186 : chenm001 1.14 stop_comp_timer();
1187 : edgomez 1.19
1188 :     for (i = 0; i < 6; i++) {
1189 : h 1.37.2.1 int direction = dec->alternate_vertical_scan ? 2 : 0;
1190 :    
1191 : edgomez 1.19 if (cbp & (1 << (5 - i))) // coded
1192 : chenm001 1.15 {
1193 : edgomez 1.19 memset(&block[i * 64], 0, 64 * sizeof(int16_t)); // clear
1194 : chenm001 1.14
1195 : chenm001 1.15 start_timer();
1196 : h 1.37.2.1 get_inter_block(bs, &block[i * 64], direction);
1197 : chenm001 1.15 stop_coding_timer();
1198 :    
1199 :     start_timer();
1200 : edgomez 1.19 if (dec->quant_type == 0) {
1201 :     dequant_inter(&data[i * 64], &block[i * 64], iQuant);
1202 :     } else {
1203 :     dequant4_inter(&data[i * 64], &block[i * 64], iQuant);
1204 : chenm001 1.15 }
1205 :     stop_iquant_timer();
1206 :    
1207 :     start_timer();
1208 : edgomez 1.19 idct(&data[i * 64]);
1209 : chenm001 1.15 stop_idct_timer();
1210 :     }
1211 :     }
1212 :    
1213 : edgomez 1.19 if (dec->interlacing && pMB->field_dct) {
1214 : chenm001 1.15 next_block = stride;
1215 :     stride *= 2;
1216 :     }
1217 :    
1218 :     start_timer();
1219 :     if (cbp & 32)
1220 : edgomez 1.19 transfer_16to8add(pY_Cur, &data[0 * 64], stride);
1221 : chenm001 1.15 if (cbp & 16)
1222 : edgomez 1.19 transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
1223 : chenm001 1.15 if (cbp & 8)
1224 : edgomez 1.19 transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
1225 : chenm001 1.15 if (cbp & 4)
1226 : edgomez 1.19 transfer_16to8add(pY_Cur + 8 + next_block, &data[3 * 64], stride);
1227 : chenm001 1.15 if (cbp & 2)
1228 : edgomez 1.19 transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
1229 : chenm001 1.15 if (cbp & 1)
1230 : edgomez 1.19 transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
1231 : chenm001 1.15 stop_transfer_timer();
1232 : chenm001 1.14 }
1233 :    
1234 :    
1235 :     // add by MinChen <chenm001@163.com>
1236 :     // for decode B-frame dbquant
1237 : edgomez 1.19 int32_t __inline
1238 :     get_dbquant(Bitstream * bs)
1239 : chenm001 1.14 {
1240 : edgomez 1.19 if (!BitstreamGetBit(bs)) // '0'
1241 :     return (0);
1242 : chenm001 1.14 else if (!BitstreamGetBit(bs)) // '10'
1243 : edgomez 1.19 return (-2);
1244 : chenm001 1.14 else
1245 : edgomez 1.19 return (2); // '11'
1246 : chenm001 1.14 }
1247 :    
1248 :     // add by MinChen <chenm001@163.com>
1249 :     // for decode B-frame mb_type
1250 :     // bit ret_value
1251 :     // 1 0
1252 :     // 01 1
1253 :     // 001 2
1254 :     // 0001 3
1255 : edgomez 1.19 int32_t __inline
1256 :     get_mbtype(Bitstream * bs)
1257 : chenm001 1.14 {
1258 : chenm001 1.15 int32_t mb_type;
1259 : edgomez 1.19
1260 :     for (mb_type = 0; mb_type <= 3; mb_type++) {
1261 :     if (BitstreamGetBit(bs))
1262 : chenm001 1.15 break;
1263 :     }
1264 :    
1265 : edgomez 1.19 if (mb_type <= 3)
1266 :     return (mb_type);
1267 : chenm001 1.14 else
1268 : edgomez 1.19 return (-1);
1269 : chenm001 1.14 }
1270 :    
1271 : edgomez 1.19 void
1272 :     decoder_bframe(DECODER * dec,
1273 :     Bitstream * bs,
1274 :     int quant,
1275 :     int fcode_forward,
1276 :     int fcode_backward)
1277 : chenm001 1.14 {
1278 : edgomez 1.19 uint32_t x, y;
1279 : chenm001 1.30 VECTOR mv;
1280 :     const VECTOR zeromv = {0,0};
1281 : chenm001 1.27 #ifdef BFRAMES_DEC_DEBUG
1282 :     FILE *fp;
1283 :     static char first=0;
1284 :     #define BFRAME_DEBUG if (!first && fp){ \
1285 :     fprintf(fp,"Y=%3d X=%3d MB=%2d CBP=%02X\n",y,x,mb->mb_type,mb->cbp); \
1286 :     }
1287 :     #endif
1288 : chenm001 1.14
1289 :     start_timer();
1290 : edgomez 1.19 image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
1291 : h 1.37.2.1 dec->width, dec->height);
1292 : chenm001 1.30 image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
1293 : h 1.37.2.1 dec->width, dec->height);
1294 : chenm001 1.14 stop_edges_timer();
1295 :    
1296 : chenm001 1.27 #ifdef BFRAMES_DEC_DEBUG
1297 :     if (!first){
1298 :     fp=fopen("C:\\XVIDDBG.TXT","w");
1299 :     }
1300 :     #endif
1301 : chenm001 1.15
1302 : edgomez 1.19 for (y = 0; y < dec->mb_height; y++) {
1303 : chenm001 1.15 // Initialize Pred Motion Vector
1304 : chenm001 1.30 dec->p_fmv = dec->p_bmv = zeromv;
1305 : edgomez 1.19 for (x = 0; x < dec->mb_width; x++) {
1306 :     MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1307 :     MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1308 : chenm001 1.14
1309 : chenm001 1.30 mv =
1310 :     mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =
1311 :     mb->mvs[0] = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = zeromv;
1312 : chenm001 1.15
1313 : chenm001 1.14 // the last P_VOP is skip macroblock ?
1314 : edgomez 1.19 if (last_mb->mode == MODE_NOT_CODED) {
1315 : chenm001 1.15 //DEBUG2("Skip MB in B-frame at (X,Y)=!",x,y);
1316 : chenm001 1.27 mb->cbp = 0;
1317 :     #ifdef BFRAMES_DEC_DEBUG
1318 : chenm001 1.29 mb->mb_type = MODE_NOT_CODED;
1319 : chenm001 1.27 BFRAME_DEBUG
1320 :     #endif
1321 : chenm001 1.15 mb->mb_type = MODE_FORWARD;
1322 : chenm001 1.30 mb->quant = last_mb->quant;
1323 :     //mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = mb->mvs[0].x;
1324 :     //mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = mb->mvs[0].y;
1325 : chenm001 1.14
1326 : chenm001 1.30 decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, mb->quant, 1);
1327 : chenm001 1.14 continue;
1328 :     }
1329 : chenm001 1.15
1330 : edgomez 1.19 if (!BitstreamGetBit(bs)) { // modb=='0'
1331 :     const uint8_t modb2 = BitstreamGetBit(bs);
1332 : chenm001 1.14
1333 :     mb->mb_type = get_mbtype(bs);
1334 : edgomez 1.19
1335 :     if (!modb2) { // modb=='00'
1336 :     mb->cbp = BitstreamGetBits(bs, 6);
1337 : chenm001 1.14 } else {
1338 :     mb->cbp = 0;
1339 :     }
1340 : edgomez 1.19 if (mb->mb_type && mb->cbp) {
1341 : chenm001 1.14 quant += get_dbquant(bs);
1342 :    
1343 : edgomez 1.19 if (quant > 31) {
1344 : chenm001 1.14 quant = 31;
1345 : chenm001 1.26 } else if (quant < 1) {
1346 : chenm001 1.14 quant = 1;
1347 :     }
1348 :     }
1349 :     } else {
1350 :     mb->mb_type = MODE_DIRECT_NONE_MV;
1351 : edgomez 1.19 mb->cbp = 0;
1352 : chenm001 1.14 }
1353 :    
1354 : chenm001 1.30 mb->quant = quant;
1355 :     mb->mode = MODE_INTER4V;
1356 : chenm001 1.14 //DEBUG1("Switch bm_type=",mb->mb_type);
1357 :    
1358 : chenm001 1.27 #ifdef BFRAMES_DEC_DEBUG
1359 :     BFRAME_DEBUG
1360 :     #endif
1361 : chl 1.33
1362 : edgomez 1.19 switch (mb->mb_type) {
1363 : chenm001 1.14 case MODE_DIRECT:
1364 : chenm001 1.30 get_b_motion_vector(dec, bs, x, y, &mv, 1, zeromv);
1365 : chenm001 1.14
1366 :     case MODE_DIRECT_NONE_MV:
1367 : chl 1.33 {
1368 : chenm001 1.30 const int64_t TRB = dec->time_pp - dec->time_bp, TRD = dec->time_pp;
1369 : chenm001 1.14 int i;
1370 : edgomez 1.19
1371 :     for (i = 0; i < 4; i++) {
1372 : chenm001 1.30 mb->mvs[i].x = (int32_t) ((TRB * last_mb->mvs[i].x)
1373 :     / TRD + mv.x);
1374 :     mb->b_mvs[i].x = (int32_t) ((mv.x == 0)
1375 :     ? ((TRB - TRD) * last_mb->mvs[i].x)
1376 :     / TRD
1377 :     : mb->mvs[i].x - last_mb->mvs[i].x);
1378 :     mb->mvs[i].y = (int32_t) ((TRB * last_mb->mvs[i].y)
1379 :     / TRD + mv.y);
1380 :     mb->b_mvs[i].y = (int32_t) ((mv.y == 0)
1381 :     ? ((TRB - TRD) * last_mb->mvs[i].y)
1382 :     / TRD
1383 :     : mb->mvs[i].y - last_mb->mvs[i].y);
1384 : chenm001 1.14 }
1385 :     //DEBUG("B-frame Direct!\n");
1386 :     }
1387 : edgomez 1.19 decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1388 : chenm001 1.30 mb, x, y, bs);
1389 : chenm001 1.14 break;
1390 :    
1391 :     case MODE_INTERPOLATE:
1392 : edgomez 1.19 get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_forward,
1393 :     dec->p_fmv);
1394 : chenm001 1.30 dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1395 : edgomez 1.19
1396 :     get_b_motion_vector(dec, bs, x, y, &mb->b_mvs[0],
1397 :     fcode_backward, dec->p_bmv);
1398 : chenm001 1.30 dec->p_bmv = mb->b_mvs[1] = mb->b_mvs[2] =
1399 :     mb->b_mvs[3] = mb->b_mvs[0];
1400 : chenm001 1.14
1401 : edgomez 1.19 decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1402 : chenm001 1.30 mb, x, y, bs);
1403 : chenm001 1.14 //DEBUG("B-frame Bidir!\n");
1404 :     break;
1405 :    
1406 :     case MODE_BACKWARD:
1407 : edgomez 1.19 get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_backward,
1408 :     dec->p_bmv);
1409 : chenm001 1.30 dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1410 : chenm001 1.15
1411 : chenm001 1.30 mb->mode = MODE_INTER;
1412 : chenm001 1.14 decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 0);
1413 :     //DEBUG("B-frame Backward!\n");
1414 :     break;
1415 :    
1416 :     case MODE_FORWARD:
1417 : edgomez 1.19 get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_forward,
1418 :     dec->p_fmv);
1419 : chenm001 1.30 dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1420 : chenm001 1.15
1421 : chenm001 1.30 mb->mode = MODE_INTER;
1422 : chenm001 1.14 decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 1);
1423 : chenm001 1.15 //DEBUG("B-frame Forward!\n");
1424 : chenm001 1.14 break;
1425 :    
1426 :     default:
1427 : chl 1.33 DEBUG1("Not support B-frame mb_type =", mb->mb_type);
1428 :     }
1429 : chenm001 1.14
1430 : edgomez 1.19 } // end of FOR
1431 : chenm001 1.14 }
1432 : chenm001 1.27 #ifdef BFRAMES_DEC_DEBUG
1433 :     if (!first){
1434 :     first=1;
1435 :     if (fp)
1436 :     fclose(fp);
1437 :     }
1438 :     #endif
1439 : chenm001 1.14 }
1440 :    
1441 :     // swap two MACROBLOCK array
1442 : edgomez 1.19 void
1443 :     mb_swap(MACROBLOCK ** mb1,
1444 :     MACROBLOCK ** mb2)
1445 : chenm001 1.14 {
1446 : edgomez 1.19 MACROBLOCK *temp = *mb1;
1447 :    
1448 :     *mb1 = *mb2;
1449 :     *mb2 = temp;
1450 : chenm001 1.14 }
1451 :    
1452 : edgomez 1.19 int
1453 :     decoder_decode(DECODER * dec,
1454 : suxen_drol 1.37.2.8 XVID_DEC_FRAME * frame, XVID_DEC_STATS * stats)
1455 : Isibaar 1.1 {
1456 : edgomez 1.7
1457 : Isibaar 1.1 Bitstream bs;
1458 :     uint32_t rounding;
1459 : suxen_drol 1.37.2.8 uint32_t reduced_resolution;
1460 : Isibaar 1.1 uint32_t quant;
1461 : chenm001 1.14 uint32_t fcode_forward;
1462 :     uint32_t fcode_backward;
1463 : Isibaar 1.1 uint32_t intra_dc_threshold;
1464 : suxen_drol 1.37.2.8 VECTOR gmc_mv[5];
1465 : chenm001 1.11 uint32_t vop_type;
1466 : Isibaar 1.1
1467 :     start_global_timer();
1468 : albeu 1.32
1469 :     dec->out_frm = (frame->colorspace == XVID_CSP_EXTERN) ? frame->image : NULL;
1470 : edgomez 1.19
1471 : Isibaar 1.1 BitstreamInit(&bs, frame->bitstream, frame->length);
1472 :    
1473 : suxen_drol 1.37.2.8 // XXX: 0x7f is only valid whilst decoding vfw xvid/divx5 avi's
1474 : suxen_drol 1.37.2.9 if(frame->length == 1 && BitstreamShowBits(&bs, 8) == 0x7f)
1475 : suxen_drol 1.37.2.8 {
1476 :     if (stats)
1477 :     stats->notify = XVID_DEC_VOP;
1478 :     frame->length = 1;
1479 :     image_output(&dec->cur, dec->width, dec->height, dec->edged_width,
1480 :     frame->image, frame->stride, frame->colorspace, dec->interlacing);
1481 : Isibaar 1.37.2.5 return XVID_ERR_OK;
1482 : suxen_drol 1.37.2.8 }
1483 : Isibaar 1.37.2.4
1484 : chenm001 1.11 // add by chenm001 <chenm001@163.com>
1485 :     // for support B-frame to reference last 2 frame
1486 : Isibaar 1.18 dec->frames++;
1487 : suxen_drol 1.37.2.8
1488 :     xxx:
1489 : edgomez 1.19 vop_type =
1490 : suxen_drol 1.37.2.8 BitstreamReadHeaders(&bs, dec, &rounding, &reduced_resolution,
1491 :     &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, gmc_mv);
1492 :    
1493 :     DPRINTF(DPRINTF_HEADER, "vop_type=%i", vop_type);
1494 :    
1495 :     if (vop_type == -2 || vop_type == -3)
1496 :     {
1497 :     if (vop_type == -3)
1498 :     decoder_resize(dec);
1499 :    
1500 :     if (stats)
1501 :     {
1502 :     stats->notify = XVID_DEC_VOL;
1503 :     stats->data.vol.general = 0;
1504 :     if (dec->interlacing)
1505 :     stats->data.vol.general |= XVID_INTERLACING;
1506 :     stats->data.vol.width = dec->width;
1507 :     stats->data.vol.height = dec->height;
1508 :     stats->data.vol.aspect_ratio = dec->aspect_ratio;
1509 :     stats->data.vol.par_width = dec->par_width;
1510 :     stats->data.vol.par_height = dec->par_height;
1511 :     frame->length = BitstreamPos(&bs) / 8;
1512 :     return XVID_ERR_OK;
1513 :     }
1514 :     goto xxx;
1515 :     }
1516 : edgomez 1.19
1517 :     dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0; // init pred vector to 0
1518 :    
1519 :     switch (vop_type) {
1520 :     case P_VOP:
1521 : suxen_drol 1.37.2.8 decoder_pframe(dec, &bs, rounding, reduced_resolution, quant,
1522 :     fcode_forward, intra_dc_threshold, NULL);
1523 : chenm001 1.26 #ifdef BFRAMES_DEC
1524 : edgomez 1.19 DEBUG1("P_VOP Time=", dec->time);
1525 : chenm001 1.26 #endif
1526 : Isibaar 1.1 break;
1527 :    
1528 : edgomez 1.19 case I_VOP:
1529 : suxen_drol 1.37.2.8 decoder_iframe(dec, &bs, reduced_resolution, quant, intra_dc_threshold);
1530 : chenm001 1.26 #ifdef BFRAMES_DEC
1531 : edgomez 1.19 DEBUG1("I_VOP Time=", dec->time);
1532 : chenm001 1.26 #endif
1533 : Isibaar 1.1 break;
1534 :    
1535 : edgomez 1.19 case B_VOP:
1536 : suxen_drol 1.21 #ifdef BFRAMES_DEC
1537 : edgomez 1.19 if (dec->time_pp > dec->time_bp) {
1538 :     DEBUG1("B_VOP Time=", dec->time);
1539 : chenm001 1.14 decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);
1540 :     } else {
1541 :     DEBUG("broken B-frame!");
1542 :     }
1543 : suxen_drol 1.21 #else
1544 :     image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);
1545 : Isibaar 1.18 #endif
1546 : Isibaar 1.1 break;
1547 : edgomez 1.19
1548 : suxen_drol 1.37.2.8 case S_VOP :
1549 :     decoder_pframe(dec, &bs, rounding, reduced_resolution, quant,
1550 :     fcode_forward, intra_dc_threshold, gmc_mv);
1551 :     break;
1552 :    
1553 : edgomez 1.19 case N_VOP: // vop not coded
1554 : suxen_drol 1.21 // when low_delay==0, N_VOP's should interpolate between the past and future frames
1555 :     image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);
1556 : Isibaar 1.37.2.4 #ifdef BFRAMES_DEC
1557 :     DEBUG1("N_VOP Time=", dec->time);
1558 :     #endif
1559 : Isibaar 1.1 break;
1560 :    
1561 : edgomez 1.19 default:
1562 : suxen_drol 1.37.2.8 if (stats)
1563 :     stats->notify = 0;
1564 : Isibaar 1.1 return XVID_ERR_FAIL;
1565 :     }
1566 :    
1567 : chenm001 1.28 #ifdef BFRAMES_DEC_DEBUG
1568 : chenm001 1.27 if (frame->length != BitstreamPos(&bs) / 8){
1569 :     DEBUG2("InLen/UseLen",frame->length, BitstreamPos(&bs) / 8);
1570 :     }
1571 : chenm001 1.28 #endif
1572 : Isibaar 1.1 frame->length = BitstreamPos(&bs) / 8;
1573 :    
1574 : chenm001 1.27
1575 : suxen_drol 1.21 #ifdef BFRAMES_DEC
1576 : chenm001 1.17 // test if no B_VOP
1577 : suxen_drol 1.37.2.8 if (dec->low_delay || dec->frames == 0) {
1578 : Isibaar 1.18 #endif
1579 : suxen_drol 1.37.2.8 image_output(&dec->cur, dec->width, dec->height, dec->edged_width,
1580 :     frame->image, frame->stride, frame->colorspace, dec->interlacing);
1581 : chenm001 1.27
1582 : suxen_drol 1.21 #ifdef BFRAMES_DEC
1583 : chenm001 1.17 } else {
1584 : suxen_drol 1.37.2.8 if (dec->frames >= 1) {
1585 : chenm001 1.17 start_timer();
1586 : suxen_drol 1.37.2.8 if ((vop_type == I_VOP || vop_type == P_VOP || vop_type == S_VOP)) {
1587 : edgomez 1.19 image_output(&dec->refn[0], dec->width, dec->height,
1588 :     dec->edged_width, frame->image, frame->stride,
1589 : suxen_drol 1.37.2.8 frame->colorspace, dec->interlacing);
1590 : chenm001 1.17 } else if (vop_type == B_VOP) {
1591 : edgomez 1.19 image_output(&dec->cur, dec->width, dec->height,
1592 :     dec->edged_width, frame->image, frame->stride,
1593 : suxen_drol 1.37.2.8 frame->colorspace, dec->interlacing);
1594 : chenm001 1.17 }
1595 :     stop_conv_timer();
1596 : chenm001 1.14 }
1597 :     }
1598 : Isibaar 1.18 #endif
1599 :    
1600 : suxen_drol 1.37.2.8 if (vop_type == I_VOP || vop_type == P_VOP || vop_type == S_VOP) {
1601 : chenm001 1.14 image_swap(&dec->refn[0], &dec->refn[1]);
1602 :     image_swap(&dec->cur, &dec->refn[0]);
1603 : chenm001 1.31
1604 : chenm001 1.14 // swap MACROBLOCK
1605 : chenm001 1.31 // the Divx will not set the low_delay flage some times
1606 :     // so follow code will wrong to not swap at that time
1607 :     // this will broken bitstream! so I'm change it,
1608 :     // But that is not the best way! can anyone tell me how
1609 :     // to do another way?
1610 :     // 18-07-2002 MinChen<chenm001@163.com>
1611 :     //if (!dec->low_delay && vop_type == P_VOP)
1612 :     if (vop_type == P_VOP)
1613 : chenm001 1.15 mb_swap(&dec->mbs, &dec->last_mbs);
1614 : suxen_drol 1.37.2.8 }
1615 :    
1616 :     if (stats)
1617 :     {
1618 :     stats->notify = XVID_DEC_VOP;
1619 :     stats->data.vop.time_base = (int)dec->time_base;
1620 :     stats->data.vop.time_increment = 0; //XXX: todo
1621 : chenm001 1.14 }
1622 :    
1623 : Isibaar 1.1 emms();
1624 :    
1625 :     stop_global_timer();
1626 :    
1627 :     return XVID_ERR_OK;
1628 :     }
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4