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