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

Annotation of /trunk/xvidcore/src/decoder.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1524 - (view) (download)

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

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