[svn] / branches / dev-api-3 / xvidcore / src / bitstream / bitstream.c Repository:
ViewVC logotype

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 698 - (view) (download)

1 : Isibaar 3 /******************************************************************************
2 :     * *
3 :     * This file is part of XviD, a free MPEG-4 video encoder/decoder *
4 :     * *
5 :     * XviD is an implementation of a part of one or more MPEG-4 Video tools *
6 :     * as specified in ISO/IEC 14496-2 standard. Those intending to use this *
7 :     * software module in hardware or software products are advised that its *
8 :     * use may infringe existing patents or copyrights, and any such use *
9 :     * would be at such party's own risk. The original developer of this *
10 :     * software module and his/her company, and subsequent editors and their *
11 :     * companies, will have no liability for use of this software or *
12 :     * modifications or derivatives thereof. *
13 :     * *
14 :     * XviD is free software; you can redistribute it and/or modify it *
15 :     * under the terms of the GNU General Public License as published by *
16 :     * the Free Software Foundation; either version 2 of the License, or *
17 :     * (at your option) any later version. *
18 :     * *
19 :     * XviD is distributed in the hope that it will be useful, but *
20 :     * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 :     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 :     * GNU General Public License for more details. *
23 :     * *
24 :     * You should have received a copy of the GNU General Public License *
25 :     * along with this program; if not, write to the Free Software *
26 :     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
27 :     * *
28 :     ******************************************************************************/
29 :    
30 :     /******************************************************************************
31 :     * *
32 :     * bitstream.c *
33 :     * *
34 :     * Copyright (C) 2001 - Peter Ross <pross@cs.rmit.edu.au> *
35 :     * *
36 :     * For more information visit the XviD homepage: http://www.xvid.org *
37 :     * *
38 :     ******************************************************************************/
39 :    
40 :     /******************************************************************************
41 : chenm001 223 * *
42 : Isibaar 3 * Revision history: *
43 : chenm001 223 * *
44 : chl 619 * 28.10.2002 GMC support - gruel *
45 : Isibaar 579 * 04.10.2002 qpel support - Isibaar *
46 : chenm001 294 * 11.07.2002 add VOP width & height return to dec when dec->width *
47 :     * or dec->height is 0 (for use in examples/ex1.c) *
48 :     * MinChen <chenm001@163.com> *
49 :     * 22.05.2002 bs_put_matrix fix *
50 : suxen_drol 229 * 20.05.2002 added BitstreamWriteUserData *
51 : Isibaar 579 * 19.06.2002 Fix a little bug in use custom quant matrix *
52 :     * MinChen <chenm001@163.com> *
53 :     * 08.05.2002 add low_delay support for B_VOP decode *
54 :     * MinChen <chenm001@163.com> *
55 : suxen_drol 164 * 06.05.2002 low_delay *
56 : suxen_drol 163 * 06.05.2002 fixed fincr/fbase error *
57 :     * 01.05.2002 added BVOP support to BitstreamWriteVopHeader *
58 : chenm001 124 * 15.04.2002 rewrite log2bin use asm386 By MinChen <chenm001@163.com> *
59 : chenm001 223 * 26.03.2002 interlacing support *
60 :     * 03.03.2002 qmatrix writing *
61 :     * 03.03.2002 merged BITREADER and BITWRITER *
62 : Isibaar 579 * 30.02.2002 intra_dc_threshold support *
63 :     * 04.12.2001 support for additional headers *
64 :     * 16.12.2001 inital version *
65 :     * *
66 : Isibaar 3 ******************************************************************************/
67 :    
68 :    
69 : Isibaar 645 #include <string.h>
70 : Isibaar 3 #include "bitstream.h"
71 :     #include "zigzag.h"
72 : Isibaar 4 #include "../quant/quant_matrix.h"
73 : chl 619 #include "mbcoding.h"
74 : Isibaar 3
75 : chenm001 124
76 : edgomez 195 static uint32_t __inline
77 :     log2bin(uint32_t value)
78 : Isibaar 3 {
79 : chenm001 124 /* Changed by Chenm001 */
80 :     #ifndef WIN32
81 : Isibaar 3 int n = 0;
82 : edgomez 195
83 :     while (value) {
84 : Isibaar 3 value >>= 1;
85 :     n++;
86 :     }
87 :     return n;
88 : chenm001 124 #else
89 : edgomez 195 __asm {
90 : suxen_drol 206 bsr eax, value
91 :     inc eax
92 :     }
93 : chenm001 124 #endif
94 : Isibaar 3 }
95 :    
96 :    
97 : edgomez 195 static const uint32_t intra_dc_threshold_table[] = {
98 :     32, /* never use */
99 : Isibaar 3 13,
100 :     15,
101 :     17,
102 :     19,
103 :     21,
104 :     23,
105 :     1,
106 :     };
107 :    
108 :    
109 : edgomez 195 void
110 :     bs_get_matrix(Bitstream * bs,
111 :     uint8_t * matrix)
112 :     {
113 :     int i = 0;
114 :     int last, value = 0;
115 : Isibaar 4
116 : edgomez 195 do {
117 :     last = value;
118 :     value = BitstreamGetBits(bs, 8);
119 :     matrix[scan_tables[0][i++]] = value;
120 :     }
121 :     while (value != 0 && i < 64);
122 : chenm001 223 i--; // fix little bug at coeff not full
123 : edgomez 195
124 :     while (i < 64) {
125 :     matrix[scan_tables[0][i++]] = last;
126 :     }
127 :     }
128 :    
129 : suxen_drol 248
130 :    
131 :     // for PVOP addbits == fcode - 1
132 :     // for BVOP addbits == max(fcode,bcode) - 1
133 :     // returns mbpos
134 :     int
135 : suxen_drol 631 read_video_packet_header(Bitstream *bs,
136 :     DECODER * dec,
137 :     const int addbits,
138 :     int * quant,
139 :     int * fcode_forward,
140 :     int * fcode_backward,
141 :     int * intra_dc_threshold)
142 : suxen_drol 248 {
143 : suxen_drol 631 int startcode_bits = NUMBITS_VP_RESYNC_MARKER + addbits;
144 :     int mbnum_bits = log2bin(dec->mb_width * dec->mb_height - 1);
145 : suxen_drol 248 int mbnum;
146 : suxen_drol 631 int hec = 0;
147 : suxen_drol 248
148 :     BitstreamSkip(bs, BitstreamNumBitsToByteAlign(bs));
149 : suxen_drol 631 BitstreamSkip(bs, startcode_bits);
150 : suxen_drol 248
151 : suxen_drol 252 DPRINTF(DPRINTF_STARTCODE, "<video_packet_header>");
152 :    
153 : suxen_drol 631 if (dec->shape != VIDOBJLAY_SHAPE_RECTANGULAR)
154 :     {
155 :     hec = BitstreamGetBit(bs); /* header_extension_code */
156 :     if (hec && !(dec->sprite_enable == SPRITE_STATIC /* && current_coding_type = I_VOP */))
157 :     {
158 :     BitstreamSkip(bs, 13); /* vop_width */
159 :     READ_MARKER();
160 :     BitstreamSkip(bs, 13); /* vop_height */
161 :     READ_MARKER();
162 :     BitstreamSkip(bs, 13); /* vop_horizontal_mc_spatial_ref */
163 :     READ_MARKER();
164 :     BitstreamSkip(bs, 13); /* vop_vertical_mc_spatial_ref */
165 :     READ_MARKER();
166 :     }
167 :     }
168 : suxen_drol 248
169 : suxen_drol 631 mbnum = BitstreamGetBits(bs, mbnum_bits); /* macroblock_number */
170 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "mbnum %i", mbnum);
171 : suxen_drol 248
172 : suxen_drol 631 if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY)
173 :     {
174 :     *quant = BitstreamGetBits(bs, 5); /* quant_scale */
175 :     DPRINTF(DPRINTF_HEADER, "quant %i", *quant);
176 :     }
177 : suxen_drol 248
178 : suxen_drol 631 if (dec->shape == VIDOBJLAY_SHAPE_RECTANGULAR)
179 :     hec = BitstreamGetBit(bs); /* header_extension_code */
180 :    
181 :    
182 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "header_extension_code %i", hec);
183 : suxen_drol 631 if (hec)
184 :     {
185 :     int time_base;
186 :     int time_increment;
187 :     int coding_type;
188 : suxen_drol 248
189 : suxen_drol 631 for (time_base=0; BitstreamGetBit(bs)!=0; time_base++); /* modulo_time_base */
190 :     READ_MARKER();
191 :     if (dec->time_inc_bits)
192 :     time_increment = (BitstreamGetBits(bs, dec->time_inc_bits)); /* vop_time_increment */
193 :     READ_MARKER();
194 :     DPRINTF(DPRINTF_HEADER,"time %i:%i", time_base, time_increment);
195 :    
196 :     coding_type = BitstreamGetBits(bs, 2);
197 :     DPRINTF(DPRINTF_HEADER,"coding_type %i", coding_type);
198 :    
199 :     if (dec->shape != VIDOBJLAY_SHAPE_RECTANGULAR)
200 :     {
201 :     BitstreamSkip(bs, 1); /* change_conv_ratio_disable */
202 :     if (coding_type != I_VOP)
203 :     BitstreamSkip(bs, 1); /* vop_shape_coding_type */
204 :     }
205 :    
206 :     if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY)
207 :     {
208 :     *intra_dc_threshold = intra_dc_threshold_table[BitstreamGetBits(bs, 3)];
209 :    
210 :     if (dec->sprite_enable == SPRITE_GMC && coding_type == S_VOP &&
211 :     dec->sprite_warping_points > 0)
212 :     {
213 :     // TODO: sprite trajectory
214 :     }
215 :     if (dec->reduced_resolution_enable &&
216 :     dec->shape == VIDOBJLAY_SHAPE_RECTANGULAR &&
217 :     (coding_type == P_VOP || coding_type == I_VOP))
218 :     {
219 : suxen_drol 694 BitstreamSkip(bs, 1); /* XXX: vop_reduced_resolution */
220 : suxen_drol 631 }
221 :    
222 :     if (coding_type != I_VOP && fcode_forward)
223 :     {
224 :     *fcode_forward = BitstreamGetBits(bs, 3);
225 :     DPRINTF(DPRINTF_HEADER,"fcode_forward %i", *fcode_forward);
226 :     }
227 :    
228 :     if (coding_type == B_VOP && fcode_backward)
229 :     {
230 :     *fcode_backward = BitstreamGetBits(bs, 3);
231 :     DPRINTF(DPRINTF_HEADER,"fcode_backward %i", fcode_backward);
232 :     }
233 :     }
234 :    
235 :     }
236 :    
237 :     if (dec->newpred_enable)
238 :     {
239 :     int vop_id;
240 :     int vop_id_for_prediction;
241 :    
242 :     vop_id = BitstreamGetBits(bs, MIN(dec->time_inc_bits + 3, 15));
243 :     DPRINTF(DPRINTF_HEADER, "vop_id %i", vop_id);
244 :     if (BitstreamGetBit(bs)) /* vop_id_for_prediction_indication */
245 :     {
246 :     vop_id_for_prediction = BitstreamGetBits(bs, MIN(dec->time_inc_bits + 3, 15));
247 :     DPRINTF(DPRINTF_HEADER, "vop_id_for_prediction %i", vop_id_for_prediction);
248 :     }
249 :     READ_MARKER();
250 :     }
251 :    
252 : suxen_drol 248 return mbnum;
253 :     }
254 :    
255 :    
256 :    
257 : suxen_drol 694
258 :     /* vol estimation header */
259 :     static void
260 :     read_vol_complexity_estimation_header(Bitstream * bs, DECODER * dec)
261 :     {
262 :     ESTIMATION * e = &dec->estimation;
263 :    
264 :     e->method = BitstreamGetBits(bs, 2); /* estimation_method */
265 :     DPRINTF(DPRINTF_HEADER,"+ complexity_estimation_header; method=%i", e->method);
266 :    
267 :     if (e->method == 0 || e->method == 1)
268 :     {
269 :     if (!BitstreamGetBit(bs)) /* shape_complexity_estimation_disable */
270 :     {
271 :     e->opaque = BitstreamGetBit(bs); /* opaque */
272 :     e->transparent = BitstreamGetBit(bs); /* transparent */
273 :     e->intra_cae = BitstreamGetBit(bs); /* intra_cae */
274 :     e->inter_cae = BitstreamGetBit(bs); /* inter_cae */
275 :     e->no_update = BitstreamGetBit(bs); /* no_update */
276 :     e->upsampling = BitstreamGetBit(bs); /* upsampling */
277 :     }
278 :    
279 :     if (!BitstreamGetBit(bs)) /* texture_complexity_estimation_set_1_disable */
280 :     {
281 :     e->intra_blocks = BitstreamGetBit(bs); /* intra_blocks */
282 :     e->inter_blocks = BitstreamGetBit(bs); /* inter_blocks */
283 :     e->inter4v_blocks = BitstreamGetBit(bs); /* inter4v_blocks */
284 :     e->not_coded_blocks = BitstreamGetBit(bs); /* not_coded_blocks */
285 :     }
286 :     }
287 :    
288 :     READ_MARKER();
289 :    
290 :     if (!BitstreamGetBit(bs)) /* texture_complexity_estimation_set_2_disable */
291 :     {
292 :     e->dct_coefs = BitstreamGetBit(bs); /* dct_coefs */
293 :     e->dct_lines = BitstreamGetBit(bs); /* dct_lines */
294 :     e->vlc_symbols = BitstreamGetBit(bs); /* vlc_symbols */
295 :     e->vlc_bits = BitstreamGetBit(bs); /* vlc_bits */
296 :     }
297 :    
298 :     if (!BitstreamGetBit(bs)) /* motion_compensation_complexity_disable */
299 :     {
300 :     e->apm = BitstreamGetBit(bs); /* apm */
301 :     e->npm = BitstreamGetBit(bs); /* npm */
302 :     e->interpolate_mc_q = BitstreamGetBit(bs); /* interpolate_mc_q */
303 :     e->forw_back_mc_q = BitstreamGetBit(bs); /* forw_back_mc_q */
304 :     e->halfpel2 = BitstreamGetBit(bs); /* halfpel2 */
305 :     e->halfpel4 = BitstreamGetBit(bs); /* halfpel4 */
306 :     }
307 :    
308 :     READ_MARKER();
309 :    
310 :     if (e->method == 1)
311 :     {
312 :     if (!BitstreamGetBit(bs)) /* version2_complexity_estimation_disable */
313 :     {
314 :     e->sadct = BitstreamGetBit(bs); /* sadct */
315 :     e->quarterpel = BitstreamGetBit(bs); /* quarterpel */
316 :     }
317 :     }
318 :     }
319 :    
320 :    
321 :     /* vop estimation header */
322 :     static void
323 :     read_vop_complexity_estimation_header(Bitstream * bs, DECODER * dec, int coding_type)
324 :     {
325 :     ESTIMATION * e = &dec->estimation;
326 :    
327 :     if (e->method == 0)
328 :     {
329 :     if (coding_type == I_VOP) {
330 :     if (e->opaque) BitstreamSkip(bs, 8); /* dcecs_opaque */
331 :     if (e->transparent) BitstreamSkip(bs, 8); /* */
332 :     if (e->intra_cae) BitstreamSkip(bs, 8); /* */
333 :     if (e->inter_cae) BitstreamSkip(bs, 8); /* */
334 :     if (e->no_update) BitstreamSkip(bs, 8); /* */
335 :     if (e->upsampling) BitstreamSkip(bs, 8); /* */
336 :     if (e->intra_blocks) BitstreamSkip(bs, 8); /* */
337 :     if (e->not_coded_blocks) BitstreamSkip(bs, 8); /* */
338 :     if (e->dct_coefs) BitstreamSkip(bs, 8); /* */
339 :     if (e->dct_lines) BitstreamSkip(bs, 8); /* */
340 :     if (e->vlc_symbols) BitstreamSkip(bs, 8); /* */
341 :     if (e->vlc_bits) BitstreamSkip(bs, 8); /* */
342 :     if (e->sadct) BitstreamSkip(bs, 8); /* */
343 :     }
344 :    
345 :     if (coding_type == P_VOP) {
346 :     if (e->opaque) BitstreamSkip(bs, 8); /* */
347 :     if (e->transparent) BitstreamSkip(bs, 8); /* */
348 :     if (e->intra_cae) BitstreamSkip(bs, 8); /* */
349 :     if (e->inter_cae) BitstreamSkip(bs, 8); /* */
350 :     if (e->no_update) BitstreamSkip(bs, 8); /* */
351 :     if (e->upsampling) BitstreamSkip(bs, 8); /* */
352 :     if (e->intra_blocks) BitstreamSkip(bs, 8); /* */
353 :     if (e->not_coded_blocks) BitstreamSkip(bs, 8); /* */
354 :     if (e->dct_coefs) BitstreamSkip(bs, 8); /* */
355 :     if (e->dct_lines) BitstreamSkip(bs, 8); /* */
356 :     if (e->vlc_symbols) BitstreamSkip(bs, 8); /* */
357 :     if (e->vlc_bits) BitstreamSkip(bs, 8); /* */
358 :     if (e->inter_blocks) BitstreamSkip(bs, 8); /* */
359 :     if (e->inter4v_blocks) BitstreamSkip(bs, 8); /* */
360 :     if (e->apm) BitstreamSkip(bs, 8); /* */
361 :     if (e->npm) BitstreamSkip(bs, 8); /* */
362 :     if (e->forw_back_mc_q) BitstreamSkip(bs, 8); /* */
363 :     if (e->halfpel2) BitstreamSkip(bs, 8); /* */
364 :     if (e->halfpel4) BitstreamSkip(bs, 8); /* */
365 :     if (e->sadct) BitstreamSkip(bs, 8); /* */
366 :     if (e->quarterpel) BitstreamSkip(bs, 8); /* */
367 :     }
368 :     if (coding_type == B_VOP) {
369 :     if (e->opaque) BitstreamSkip(bs, 8); /* */
370 :     if (e->transparent) BitstreamSkip(bs, 8); /* */
371 :     if (e->intra_cae) BitstreamSkip(bs, 8); /* */
372 :     if (e->inter_cae) BitstreamSkip(bs, 8); /* */
373 :     if (e->no_update) BitstreamSkip(bs, 8); /* */
374 :     if (e->upsampling) BitstreamSkip(bs, 8); /* */
375 :     if (e->intra_blocks) BitstreamSkip(bs, 8); /* */
376 :     if (e->not_coded_blocks) BitstreamSkip(bs, 8); /* */
377 :     if (e->dct_coefs) BitstreamSkip(bs, 8); /* */
378 :     if (e->dct_lines) BitstreamSkip(bs, 8); /* */
379 :     if (e->vlc_symbols) BitstreamSkip(bs, 8); /* */
380 :     if (e->vlc_bits) BitstreamSkip(bs, 8); /* */
381 :     if (e->inter_blocks) BitstreamSkip(bs, 8); /* */
382 :     if (e->inter4v_blocks) BitstreamSkip(bs, 8); /* */
383 :     if (e->apm) BitstreamSkip(bs, 8); /* */
384 :     if (e->npm) BitstreamSkip(bs, 8); /* */
385 :     if (e->forw_back_mc_q) BitstreamSkip(bs, 8); /* */
386 :     if (e->halfpel2) BitstreamSkip(bs, 8); /* */
387 :     if (e->halfpel4) BitstreamSkip(bs, 8); /* */
388 :     if (e->interpolate_mc_q) BitstreamSkip(bs, 8); /* */
389 :     if (e->sadct) BitstreamSkip(bs, 8); /* */
390 :     if (e->quarterpel) BitstreamSkip(bs, 8); /* */
391 :     }
392 :    
393 :     if (coding_type == S_VOP && dec->sprite_enable == SPRITE_STATIC) {
394 :     if (e->intra_blocks) BitstreamSkip(bs, 8); /* */
395 :     if (e->not_coded_blocks) BitstreamSkip(bs, 8); /* */
396 :     if (e->dct_coefs) BitstreamSkip(bs, 8); /* */
397 :     if (e->dct_lines) BitstreamSkip(bs, 8); /* */
398 :     if (e->vlc_symbols) BitstreamSkip(bs, 8); /* */
399 :     if (e->vlc_bits) BitstreamSkip(bs, 8); /* */
400 :     if (e->inter_blocks) BitstreamSkip(bs, 8); /* */
401 :     if (e->inter4v_blocks) BitstreamSkip(bs, 8); /* */
402 :     if (e->apm) BitstreamSkip(bs, 8); /* */
403 :     if (e->npm) BitstreamSkip(bs, 8); /* */
404 :     if (e->forw_back_mc_q) BitstreamSkip(bs, 8); /* */
405 :     if (e->halfpel2) BitstreamSkip(bs, 8); /* */
406 :     if (e->halfpel4) BitstreamSkip(bs, 8); /* */
407 :     if (e->interpolate_mc_q) BitstreamSkip(bs, 8); /* */
408 :     }
409 :     }
410 :     }
411 :    
412 :    
413 :    
414 :    
415 :    
416 : Isibaar 3 /*
417 :     decode headers
418 :     returns coding_type, or -1 if error
419 :     */
420 :    
421 : suxen_drol 252 #define VIDOBJ_START_CODE_MASK 0x0000001f
422 :     #define VIDOBJLAY_START_CODE_MASK 0x0000000f
423 :    
424 : edgomez 195 int
425 :     BitstreamReadHeaders(Bitstream * bs,
426 :     DECODER * dec,
427 :     uint32_t * rounding,
428 : suxen_drol 631 uint32_t * reduced_resolution,
429 : edgomez 195 uint32_t * quant,
430 :     uint32_t * fcode_forward,
431 :     uint32_t * fcode_backward,
432 : suxen_drol 631 uint32_t * intra_dc_threshold,
433 :     VECTOR * gmc_mv)
434 : Isibaar 3 {
435 :     uint32_t vol_ver_id;
436 :     uint32_t coding_type;
437 :     uint32_t start_code;
438 : edgomez 195 uint32_t time_incr = 0;
439 :     int32_t time_increment;
440 : suxen_drol 631 int resize = 0;
441 : chenm001 156
442 : edgomez 195 do {
443 : suxen_drol 631
444 : Isibaar 3 BitstreamByteAlign(bs);
445 :     start_code = BitstreamShowBits(bs, 32);
446 :    
447 : edgomez 195 if (start_code == VISOBJSEQ_START_CODE) {
448 : suxen_drol 252
449 :     int profile;
450 :    
451 :     DPRINTF(DPRINTF_STARTCODE, "<visual_object_sequence>");
452 :    
453 : edgomez 195 BitstreamSkip(bs, 32); // visual_object_sequence_start_code
454 : suxen_drol 252 profile = BitstreamGetBits(bs, 8); // profile_and_level_indication
455 :    
456 :     DPRINTF(DPRINTF_HEADER, "profile_and_level_indication %i", profile);
457 :    
458 : edgomez 195 } else if (start_code == VISOBJSEQ_STOP_CODE) {
459 : suxen_drol 252
460 : edgomez 195 BitstreamSkip(bs, 32); // visual_object_sequence_stop_code
461 : suxen_drol 252
462 :     DPRINTF(DPRINTF_STARTCODE, "</visual_object_sequence>");
463 :    
464 : edgomez 195 } else if (start_code == VISOBJ_START_CODE) {
465 : suxen_drol 252
466 :     DPRINTF(DPRINTF_STARTCODE, "<visual_object>");
467 :    
468 : edgomez 195 BitstreamSkip(bs, 32); // visual_object_start_code
469 :     if (BitstreamGetBit(bs)) // is_visual_object_identified
470 : Isibaar 3 {
471 : edgomez 195 vol_ver_id = BitstreamGetBits(bs, 4); // visual_object_ver_id
472 : suxen_drol 252 DPRINTF(DPRINTF_HEADER,"ver_id %i", vol_ver_id);
473 : edgomez 195 BitstreamSkip(bs, 3); // visual_object_priority
474 :     } else {
475 : Isibaar 3 vol_ver_id = 1;
476 :     }
477 :    
478 :     if (BitstreamShowBits(bs, 4) != VISOBJ_TYPE_VIDEO) // visual_object_type
479 :     {
480 : suxen_drol 252 DPRINTF(DPRINTF_ERROR, "visual_object_type != video");
481 : Isibaar 3 return -1;
482 :     }
483 :     BitstreamSkip(bs, 4);
484 :    
485 :     // video_signal_type
486 :    
487 : edgomez 195 if (BitstreamGetBit(bs)) // video_signal_type
488 : Isibaar 3 {
489 : suxen_drol 252 DPRINTF(DPRINTF_HEADER,"+ video_signal_type");
490 : edgomez 195 BitstreamSkip(bs, 3); // video_format
491 :     BitstreamSkip(bs, 1); // video_range
492 :     if (BitstreamGetBit(bs)) // color_description
493 : Isibaar 3 {
494 : suxen_drol 252 DPRINTF(DPRINTF_HEADER,"+ color_description");
495 : edgomez 195 BitstreamSkip(bs, 8); // color_primaries
496 :     BitstreamSkip(bs, 8); // transfer_characteristics
497 :     BitstreamSkip(bs, 8); // matrix_coefficients
498 : Isibaar 3 }
499 :     }
500 : suxen_drol 252 } else if ((start_code & ~VIDOBJ_START_CODE_MASK) == VIDOBJ_START_CODE) {
501 :    
502 :     DPRINTF(DPRINTF_STARTCODE, "<video_object>");
503 :     DPRINTF(DPRINTF_HEADER, "vo id %i", start_code & VIDOBJ_START_CODE_MASK);
504 :    
505 : edgomez 195 BitstreamSkip(bs, 32); // video_object_start_code
506 : suxen_drol 252
507 :     } else if ((start_code & ~VIDOBJLAY_START_CODE_MASK) == VIDOBJLAY_START_CODE) {
508 :    
509 :     DPRINTF(DPRINTF_STARTCODE, "<video_object_layer>");
510 :     DPRINTF(DPRINTF_HEADER, "vol id %i", start_code & VIDOBJLAY_START_CODE_MASK);
511 :    
512 : edgomez 195 BitstreamSkip(bs, 32); // video_object_layer_start_code
513 : Isibaar 3
514 : edgomez 195 BitstreamSkip(bs, 1); // random_accessible_vol
515 : Isibaar 3
516 :     // video_object_type_indication
517 : suxen_drol 631 if (BitstreamShowBits(bs, 8) != VIDOBJLAY_TYPE_SIMPLE &&
518 :     BitstreamShowBits(bs, 8) != VIDOBJLAY_TYPE_CORE &&
519 :     BitstreamShowBits(bs, 8) != VIDOBJLAY_TYPE_MAIN &&
520 :     BitstreamShowBits(bs, 8) != VIDOBJLAY_TYPE_ACE &&
521 :     BitstreamShowBits(bs, 8) != VIDOBJLAY_TYPE_ART_SIMPLE &&
522 :     BitstreamShowBits(bs, 8) != 0) // BUGGY DIVX
523 : Isibaar 3 {
524 : suxen_drol 252 DPRINTF(DPRINTF_ERROR,"video_object_type_indication %i not supported ",
525 :     BitstreamShowBits(bs, 8));
526 : Isibaar 3 return -1;
527 :     }
528 :     BitstreamSkip(bs, 8);
529 :    
530 :    
531 : edgomez 195 if (BitstreamGetBit(bs)) // is_object_layer_identifier
532 : Isibaar 3 {
533 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "+ is_object_layer_identifier");
534 : edgomez 195 vol_ver_id = BitstreamGetBits(bs, 4); // video_object_layer_verid
535 : suxen_drol 252 DPRINTF(DPRINTF_HEADER,"ver_id %i", vol_ver_id);
536 : edgomez 195 BitstreamSkip(bs, 3); // video_object_layer_priority
537 :     } else {
538 : Isibaar 3 vol_ver_id = 1;
539 :     }
540 :    
541 : suxen_drol 631 dec->aspect_ratio = BitstreamGetBits(bs, 4);
542 :    
543 :     if (dec->aspect_ratio == VIDOBJLAY_AR_EXTPAR) // aspect_ratio_info
544 : Isibaar 3 {
545 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "+ aspect_ratio_info");
546 : suxen_drol 631 dec->par_width = BitstreamGetBits(bs, 8); // par_width
547 :     dec->par_height = BitstreamGetBits(bs, 8); // par_height
548 : Isibaar 3 }
549 :    
550 : edgomez 195 if (BitstreamGetBit(bs)) // vol_control_parameters
551 : Isibaar 3 {
552 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "+ vol_control_parameters");
553 : edgomez 195 BitstreamSkip(bs, 2); // chroma_format
554 :     dec->low_delay = BitstreamGetBit(bs); // low_delay
555 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "low_delay %i", dec->low_delay);
556 : edgomez 195 if (BitstreamGetBit(bs)) // vbv_parameters
557 : Isibaar 3 {
558 : suxen_drol 252 DPRINTF(DPRINTF_HEADER,"+ vbv_parameters");
559 : edgomez 195 BitstreamSkip(bs, 15); // first_half_bitrate
560 : Isibaar 3 READ_MARKER();
561 : edgomez 195 BitstreamSkip(bs, 15); // latter_half_bitrate
562 : Isibaar 3 READ_MARKER();
563 : edgomez 195 BitstreamSkip(bs, 15); // first_half_vbv_buffer_size
564 : Isibaar 3 READ_MARKER();
565 : edgomez 195 BitstreamSkip(bs, 3); // latter_half_vbv_buffer_size
566 :     BitstreamSkip(bs, 11); // first_half_vbv_occupancy
567 : Isibaar 3 READ_MARKER();
568 : edgomez 195 BitstreamSkip(bs, 15); // latter_half_vbv_occupancy
569 : Isibaar 3 READ_MARKER();
570 :     }
571 :     }
572 :    
573 :     dec->shape = BitstreamGetBits(bs, 2); // video_object_layer_shape
574 : suxen_drol 631
575 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "shape %i", dec->shape);
576 : suxen_drol 631 if (dec->shape != VIDOBJLAY_SHAPE_RECTANGULAR)
577 :     {
578 :     DPRINTF(DPRINTF_ERROR,"non-rectangular shapes are not supported");
579 :     }
580 : edgomez 195
581 :     if (dec->shape == VIDOBJLAY_SHAPE_GRAYSCALE && vol_ver_id != 1) {
582 :     BitstreamSkip(bs, 4); // video_object_layer_shape_extension
583 : Isibaar 3 }
584 :    
585 :     READ_MARKER();
586 :    
587 : chenm001 156 // *************************** for decode B-frame time ***********************
588 : suxen_drol 631 dec->time_inc_resolution = BitstreamGetBits(bs, 16); // vop_time_increment_resolution
589 :     DPRINTF(DPRINTF_HEADER,"vop_time_increment_resolution %i", dec->time_inc_resolution);
590 : suxen_drol 252
591 : suxen_drol 631 // dec->time_inc_resolution--;
592 : suxen_drol 252
593 : suxen_drol 631 if (dec->time_inc_resolution > 0) {
594 :     dec->time_inc_bits = log2bin(dec->time_inc_resolution-1);
595 : edgomez 195 } else {
596 : Isibaar 3 // dec->time_inc_bits = 0;
597 :     // for "old" xvid compatibility, set time_inc_bits = 1
598 :     dec->time_inc_bits = 1;
599 :     }
600 :    
601 :     READ_MARKER();
602 :    
603 : edgomez 195 if (BitstreamGetBit(bs)) // fixed_vop_rate
604 : Isibaar 3 {
605 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "+ fixed_vop_rate");
606 : Isibaar 3 BitstreamSkip(bs, dec->time_inc_bits); // fixed_vop_time_increment
607 :     }
608 :    
609 : edgomez 195 if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY) {
610 : Isibaar 3
611 : edgomez 195 if (dec->shape == VIDOBJLAY_SHAPE_RECTANGULAR) {
612 : Isibaar 3 uint32_t width, height;
613 :    
614 :     READ_MARKER();
615 : edgomez 195 width = BitstreamGetBits(bs, 13); // video_object_layer_width
616 : Isibaar 3 READ_MARKER();
617 : edgomez 195 height = BitstreamGetBits(bs, 13); // video_object_layer_height
618 : Isibaar 3 READ_MARKER();
619 :    
620 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "width %i", width);
621 :     DPRINTF(DPRINTF_HEADER, "height %i", height);
622 :    
623 : suxen_drol 631 if (dec->width != width || dec->height != height)
624 :     {
625 :     if (dec->fixed_dimensions)
626 :     {
627 :     DPRINTF(DPRINTF_ERROR, "XVID_DEC_PARAM width/height does not match bitstream");
628 :     return -1;
629 :     }
630 :     resize = 1;
631 : chenm001 294 dec->width = width;
632 :     dec->height = height;
633 : Isibaar 3 }
634 :     }
635 : h 69
636 : suxen_drol 252 dec->interlacing = BitstreamGetBit(bs);
637 : suxen_drol 631 DPRINTF(DPRINTF_HEADER, "interlacing %i", dec->interlacing);
638 : Isibaar 3
639 : edgomez 195 if (!BitstreamGetBit(bs)) // obmc_disable
640 : Isibaar 3 {
641 : suxen_drol 252 DPRINTF(DPRINTF_ERROR, "obmc_disabled==false not supported");
642 : Isibaar 3 // TODO
643 :     // fucking divx4.02 has this enabled
644 :     }
645 :    
646 : suxen_drol 631 dec->sprite_enable = BitstreamGetBits(bs, (vol_ver_id == 1 ? 1 : 2)); // sprite_enable
647 :    
648 :     if (dec->sprite_enable == SPRITE_STATIC || dec->sprite_enable == SPRITE_GMC)
649 : Isibaar 3 {
650 : suxen_drol 631 int low_latency_sprite_enable;
651 :    
652 :     if (dec->sprite_enable != SPRITE_GMC)
653 :     {
654 :     int sprite_width;
655 :     int sprite_height;
656 :     int sprite_left_coord;
657 :     int sprite_top_coord;
658 :     sprite_width = BitstreamGetBits(bs, 13); // sprite_width
659 :     READ_MARKER();
660 :     sprite_height = BitstreamGetBits(bs, 13); // sprite_height
661 :     READ_MARKER();
662 :     sprite_left_coord = BitstreamGetBits(bs, 13); // sprite_left_coordinate
663 :     READ_MARKER();
664 :     sprite_top_coord = BitstreamGetBits(bs, 13); // sprite_top_coordinate
665 :     READ_MARKER();
666 :     }
667 :     dec->sprite_warping_points = BitstreamGetBits(bs, 6); // no_of_sprite_warping_points
668 :     dec->sprite_warping_accuracy = BitstreamGetBits(bs, 2); // sprite_warping_accuracy
669 :     dec->sprite_brightness_change = BitstreamGetBits(bs, 1); // brightness_change
670 :     if (dec->sprite_enable != SPRITE_GMC)
671 :     {
672 :     low_latency_sprite_enable = BitstreamGetBits(bs, 1); // low_latency_sprite_enable
673 :     }
674 : Isibaar 3 }
675 : edgomez 195
676 :     if (vol_ver_id != 1 &&
677 :     dec->shape != VIDOBJLAY_SHAPE_RECTANGULAR) {
678 :     BitstreamSkip(bs, 1); // sadct_disable
679 : Isibaar 3 }
680 :    
681 : edgomez 195 if (BitstreamGetBit(bs)) // not_8_bit
682 : Isibaar 3 {
683 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "not_8_bit==true (ignored)");
684 : Isibaar 3 dec->quant_bits = BitstreamGetBits(bs, 4); // quant_precision
685 : edgomez 195 BitstreamSkip(bs, 4); // bits_per_pixel
686 :     } else {
687 : Isibaar 3 dec->quant_bits = 5;
688 :     }
689 :    
690 : edgomez 195 if (dec->shape == VIDOBJLAY_SHAPE_GRAYSCALE) {
691 :     BitstreamSkip(bs, 1); // no_gray_quant_update
692 :     BitstreamSkip(bs, 1); // composition_method
693 :     BitstreamSkip(bs, 1); // linear_composition
694 : Isibaar 3 }
695 :    
696 : edgomez 195 dec->quant_type = BitstreamGetBit(bs); // quant_type
697 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "quant_type %i", dec->quant_type);
698 : Isibaar 3
699 : edgomez 195 if (dec->quant_type) {
700 :     if (BitstreamGetBit(bs)) // load_intra_quant_mat
701 : Isibaar 3 {
702 : Isibaar 20 uint8_t matrix[64];
703 : edgomez 195
704 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "load_intra_quant_mat");
705 :    
706 : Isibaar 4 bs_get_matrix(bs, matrix);
707 :     set_intra_matrix(matrix);
708 : edgomez 195 } else
709 : Isibaar 20 set_intra_matrix(get_default_intra_matrix());
710 : Isibaar 4
711 : edgomez 195 if (BitstreamGetBit(bs)) // load_inter_quant_mat
712 : Isibaar 3 {
713 : edgomez 195 uint8_t matrix[64];
714 : suxen_drol 252
715 :     DPRINTF(DPRINTF_HEADER, "load_inter_quant_mat");
716 : edgomez 195
717 : Isibaar 4 bs_get_matrix(bs, matrix);
718 :     set_inter_matrix(matrix);
719 : edgomez 195 } else
720 : Isibaar 20 set_inter_matrix(get_default_inter_matrix());
721 : Isibaar 3
722 : edgomez 195 if (dec->shape == VIDOBJLAY_SHAPE_GRAYSCALE) {
723 : suxen_drol 252 DPRINTF(DPRINTF_ERROR, "greyscale matrix not supported");
724 : Isibaar 3 return -1;
725 :     }
726 : Isibaar 4
727 : Isibaar 3 }
728 :    
729 : edgomez 195
730 :     if (vol_ver_id != 1) {
731 : Isibaar 333 dec->quarterpel = BitstreamGetBit(bs); // quarter_sample
732 : suxen_drol 631 DPRINTF(DPRINTF_HEADER,"quarterpel %i", dec->quarterpel);
733 : Isibaar 3 }
734 : Isibaar 333 else
735 :     dec->quarterpel = 0;
736 :    
737 : Isibaar 3
738 : suxen_drol 694 dec->complexity_estimation_disable = BitstreamGetBit(bs); /* complexity estimation disable */
739 :     if (!dec->complexity_estimation_disable)
740 : Isibaar 3 {
741 : suxen_drol 694 read_vol_complexity_estimation_header(bs, dec);
742 : Isibaar 3 }
743 :    
744 : suxen_drol 252 BitstreamSkip(bs, 1); // resync_marker_disable
745 : Isibaar 3
746 : edgomez 195 if (BitstreamGetBit(bs)) // data_partitioned
747 : Isibaar 3 {
748 : suxen_drol 252 DPRINTF(DPRINTF_ERROR, "data_partitioned not supported");
749 : edgomez 195 BitstreamSkip(bs, 1); // reversible_vlc
750 : Isibaar 3 }
751 :    
752 : edgomez 195 if (vol_ver_id != 1) {
753 : suxen_drol 631 dec->newpred_enable = BitstreamGetBit(bs);
754 :     if (dec->newpred_enable) // newpred_enable
755 : Isibaar 3 {
756 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "+ newpred_enable");
757 : edgomez 195 BitstreamSkip(bs, 2); // requested_upstream_message_type
758 :     BitstreamSkip(bs, 1); // newpred_segment_type
759 : Isibaar 3 }
760 : suxen_drol 694 dec->reduced_resolution_enable = BitstreamGetBit(bs); /* reduced_resolution_vop_enable */
761 :     DPRINTF(DPRINTF_HEADER, "reduced_resolution_enable %i", dec->reduced_resolution_enable);
762 : Isibaar 3 }
763 : suxen_drol 631 else
764 :     {
765 :     dec->newpred_enable = 0;
766 :     dec->reduced_resolution_enable = 0;
767 :     }
768 : edgomez 195
769 : suxen_drol 694 dec->scalability = BitstreamGetBit(bs); /* scalability */
770 :     if (dec->scalability)
771 : Isibaar 3 {
772 : suxen_drol 252 DPRINTF(DPRINTF_ERROR, "scalability not supported");
773 : suxen_drol 694 BitstreamSkip(bs, 1); /* hierarchy_type */
774 :     BitstreamSkip(bs, 4); /* ref_layer_id */
775 :     BitstreamSkip(bs, 1); /* ref_layer_sampling_direc */
776 :     BitstreamSkip(bs, 5); /* hor_sampling_factor_n */
777 :     BitstreamSkip(bs, 5); /* hor_sampling_factor_m */
778 :     BitstreamSkip(bs, 5); /* vert_sampling_factor_n */
779 :     BitstreamSkip(bs, 5); /* vert_sampling_factor_m */
780 :     BitstreamSkip(bs, 1); /* enhancement_type */
781 :     if(dec->shape == VIDOBJLAY_SHAPE_BINARY /* && hierarchy_type==0 */) {
782 :     BitstreamSkip(bs, 1); /* use_ref_shape */
783 :     BitstreamSkip(bs, 1); /* use_ref_texture */
784 :     BitstreamSkip(bs, 5); /* shape_hor_sampling_factor_n */
785 :     BitstreamSkip(bs, 5); /* shape_hor_sampling_factor_m */
786 :     BitstreamSkip(bs, 5); /* shape_vert_sampling_factor_n */
787 :     BitstreamSkip(bs, 5); /* shape_vert_sampling_factor_m */
788 :     }
789 : Isibaar 3 return -1;
790 :     }
791 : edgomez 195 } else // dec->shape == BINARY_ONLY
792 : Isibaar 3 {
793 : edgomez 195 if (vol_ver_id != 1) {
794 : suxen_drol 694 dec->scalability = BitstreamGetBit(bs); /* scalability */
795 :     if (dec->scalability)
796 : Isibaar 3 {
797 : suxen_drol 694 DPRINTF(DPRINTF_ERROR, "scalability not supported");
798 :     BitstreamSkip(bs, 4); /* ref_layer_id */
799 :     BitstreamSkip(bs, 5); /* hor_sampling_factor_n */
800 :     BitstreamSkip(bs, 5); /* hor_sampling_factor_m */
801 :     BitstreamSkip(bs, 5); /* vert_sampling_factor_n */
802 :     BitstreamSkip(bs, 5); /* vert_sampling_factor_m */
803 : Isibaar 3 return -1;
804 :     }
805 :     }
806 : edgomez 195 BitstreamSkip(bs, 1); // resync_marker_disable
807 : Isibaar 3
808 :     }
809 :    
810 : suxen_drol 631 return (resize ? -3 : -2 ); /* VOL */
811 :    
812 : edgomez 195 } else if (start_code == GRPOFVOP_START_CODE) {
813 : suxen_drol 252
814 :     DPRINTF(DPRINTF_STARTCODE, "<group_of_vop>");
815 :    
816 : Isibaar 3 BitstreamSkip(bs, 32);
817 :     {
818 :     int hours, minutes, seconds;
819 : edgomez 195
820 : Isibaar 3 hours = BitstreamGetBits(bs, 5);
821 :     minutes = BitstreamGetBits(bs, 6);
822 :     READ_MARKER();
823 :     seconds = BitstreamGetBits(bs, 6);
824 : suxen_drol 252
825 :     DPRINTF(DPRINTF_HEADER, "time %ih%im%is", hours);
826 : Isibaar 3 }
827 : edgomez 195 BitstreamSkip(bs, 1); // closed_gov
828 :     BitstreamSkip(bs, 1); // broken_link
829 : suxen_drol 252
830 : edgomez 195 } else if (start_code == VOP_START_CODE) {
831 : suxen_drol 252
832 :     DPRINTF(DPRINTF_STARTCODE, "<vop>");
833 :    
834 : edgomez 195 BitstreamSkip(bs, 32); // vop_start_code
835 : Isibaar 3
836 : edgomez 195 coding_type = BitstreamGetBits(bs, 2); // vop_coding_type
837 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "coding_type %i", coding_type);
838 : Isibaar 3
839 : chenm001 156 // *************************** for decode B-frame time ***********************
840 : edgomez 195 while (BitstreamGetBit(bs) != 0) // time_base
841 : chenm001 156 time_incr++;
842 : edgomez 195
843 : Isibaar 3 READ_MARKER();
844 : edgomez 195
845 :     if (dec->time_inc_bits) {
846 : chenm001 156 time_increment = (BitstreamGetBits(bs, dec->time_inc_bits)); // vop_time_increment
847 : Isibaar 3 }
848 : suxen_drol 240
849 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "time_base %i", time_incr);
850 :     DPRINTF(DPRINTF_HEADER, "time_increment %i", time_increment);
851 :    
852 :     DPRINTF(DPRINTF_TIMECODE, "%c %i:%i",
853 : suxen_drol 631 coding_type == I_VOP ? 'I' : coding_type == P_VOP ? 'P' : coding_type == B_VOP ? 'B' : 'S',
854 : suxen_drol 240 time_incr, time_increment);
855 :    
856 : edgomez 195 if (coding_type != B_VOP) {
857 :     dec->last_time_base = dec->time_base;
858 : chenm001 156 dec->time_base += time_incr;
859 : chl 316 dec->time = time_increment;
860 :    
861 : suxen_drol 631 /* dec->time_base * dec->time_inc_resolution +
862 : edgomez 195 time_increment;
863 : chl 316 */ dec->time_pp = (uint32_t)
864 : suxen_drol 631 (dec->time_inc_resolution + dec->time - dec->last_non_b_time)%dec->time_inc_resolution;
865 : edgomez 195 dec->last_non_b_time = dec->time;
866 :     } else {
867 : chl 316 dec->time = time_increment;
868 :     /*
869 : edgomez 195 (dec->last_time_base +
870 : suxen_drol 631 time_incr) * dec->time_inc_resolution + time_increment;
871 : chl 316 */
872 : chl 313 dec->time_bp = (uint32_t)
873 : suxen_drol 631 (dec->time_inc_resolution + dec->last_non_b_time - dec->time)%dec->time_inc_resolution;
874 : chenm001 156 }
875 : Isibaar 3
876 :     READ_MARKER();
877 :    
878 : edgomez 195 if (!BitstreamGetBit(bs)) // vop_coded
879 : Isibaar 3 {
880 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "vop_coded==false");
881 : Isibaar 3 return N_VOP;
882 :     }
883 :    
884 : suxen_drol 631 if (dec->newpred_enable)
885 :     {
886 :     int vop_id;
887 :     int vop_id_for_prediction;
888 :    
889 :     vop_id = BitstreamGetBits(bs, MIN(dec->time_inc_bits + 3, 15));
890 :     DPRINTF(DPRINTF_HEADER, "vop_id %i", vop_id);
891 :     if (BitstreamGetBit(bs)) /* vop_id_for_prediction_indication */
892 :     {
893 :     vop_id_for_prediction = BitstreamGetBits(bs, MIN(dec->time_inc_bits + 3, 15));
894 :     DPRINTF(DPRINTF_HEADER, "vop_id_for_prediction %i", vop_id_for_prediction);
895 :     }
896 :     READ_MARKER();
897 :     }
898 : Isibaar 3
899 : suxen_drol 631
900 :    
901 : chenm001 156 // fix a little bug by MinChen <chenm002@163.com>
902 : edgomez 195 if ((dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY) &&
903 : suxen_drol 631 ( (coding_type == P_VOP) || (coding_type == S_VOP && dec->sprite_enable == SPRITE_GMC) ) ) {
904 : Isibaar 3 *rounding = BitstreamGetBit(bs); // rounding_type
905 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "rounding %i", *rounding);
906 : Isibaar 3 }
907 :    
908 : suxen_drol 631 if (dec->reduced_resolution_enable &&
909 :     dec->shape == VIDOBJLAY_SHAPE_RECTANGULAR &&
910 :     (coding_type == P_VOP || coding_type == I_VOP)) {
911 : Isibaar 3
912 : suxen_drol 631 *reduced_resolution = BitstreamGetBit(bs);
913 : suxen_drol 694 DPRINTF(DPRINTF_HEADER, "reduced_resolution %i", *reduced_resolution);
914 : suxen_drol 631 }
915 :     else
916 :     {
917 :     *reduced_resolution = 0;
918 :     }
919 :    
920 : edgomez 195 if (dec->shape != VIDOBJLAY_SHAPE_RECTANGULAR) {
921 : suxen_drol 631 if(!(dec->sprite_enable == SPRITE_STATIC && coding_type == I_VOP)) {
922 : edgomez 195
923 : suxen_drol 631 uint32_t width, height;
924 :     uint32_t horiz_mc_ref, vert_mc_ref;
925 : Isibaar 3
926 : suxen_drol 631 width = BitstreamGetBits(bs, 13);
927 :     READ_MARKER();
928 :     height = BitstreamGetBits(bs, 13);
929 :     READ_MARKER();
930 :     horiz_mc_ref = BitstreamGetBits(bs, 13);
931 :     READ_MARKER();
932 :     vert_mc_ref = BitstreamGetBits(bs, 13);
933 :     READ_MARKER();
934 : Isibaar 3
935 : suxen_drol 631 DPRINTF(DPRINTF_HEADER, "width %i", width);
936 :     DPRINTF(DPRINTF_HEADER, "height %i", height);
937 :     DPRINTF(DPRINTF_HEADER, "horiz_mc_ref %i", horiz_mc_ref);
938 :     DPRINTF(DPRINTF_HEADER, "vert_mc_ref %i", vert_mc_ref);
939 :     }
940 :    
941 : edgomez 195 BitstreamSkip(bs, 1); // change_conv_ratio_disable
942 :     if (BitstreamGetBit(bs)) // vop_constant_alpha
943 : Isibaar 3 {
944 : edgomez 195 BitstreamSkip(bs, 8); // vop_constant_alpha_value
945 : Isibaar 3 }
946 :     }
947 :    
948 : edgomez 195 if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY) {
949 : suxen_drol 694
950 :     if (!dec->complexity_estimation_disable)
951 :     {
952 :     read_vop_complexity_estimation_header(bs, dec, coding_type);
953 :     }
954 :    
955 : Isibaar 3 // intra_dc_vlc_threshold
956 : edgomez 195 *intra_dc_threshold =
957 :     intra_dc_threshold_table[BitstreamGetBits(bs, 3)];
958 : Isibaar 3
959 : h 543 dec->top_field_first = 0;
960 :     dec->alternate_vertical_scan = 0;
961 :    
962 : edgomez 195 if (dec->interlacing) {
963 : suxen_drol 252 dec->top_field_first = BitstreamGetBit(bs);
964 :     DPRINTF(DPRINTF_HEADER, "interlace top_field_first %i", dec->top_field_first);
965 :     dec->alternate_vertical_scan = BitstreamGetBit(bs);
966 :     DPRINTF(DPRINTF_HEADER, "interlace alternate_vertical_scan %i", dec->alternate_vertical_scan);
967 :    
968 : h 69 }
969 : Isibaar 3 }
970 : edgomez 195
971 : suxen_drol 631 if ((dec->sprite_enable == SPRITE_STATIC || dec->sprite_enable== SPRITE_GMC) && coding_type == S_VOP) {
972 :    
973 :     int i;
974 :    
975 :     for (i = 0 ; i < dec->sprite_warping_points; i++)
976 :     {
977 :     int length;
978 :     int x = 0, y = 0;
979 :    
980 :     /* sprite code borowed from ffmpeg; thx Michael Niedermayer <michaelni@gmx.at> */
981 :     length = bs_get_spritetrajectory(bs);
982 :     if(length){
983 :     x= BitstreamGetBits(bs, length);
984 :     if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
985 :     x = - (x ^ ((1 << length) - 1));
986 :     }
987 :     READ_MARKER();
988 :    
989 :     length = bs_get_spritetrajectory(bs);
990 :     if(length){
991 :     y = BitstreamGetBits(bs, length);
992 :     if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
993 :     y = - (y ^ ((1 << length) - 1));
994 :     }
995 :     READ_MARKER();
996 :    
997 :     gmc_mv[i].x = x;
998 :     gmc_mv[i].y = y;
999 :    
1000 :     DPRINTF(DPRINTF_HEADER,"sprite_warping_point[%i] xy=(%i,%i)", i, x, y);
1001 :     }
1002 :    
1003 :     if (dec->sprite_brightness_change)
1004 :     {
1005 :     // XXX: brightness_change_factor()
1006 :     }
1007 :     if (dec->sprite_enable == SPRITE_STATIC)
1008 :     {
1009 :     // XXX: todo
1010 :     }
1011 :    
1012 :     }
1013 :    
1014 : edgomez 195 if ((*quant = BitstreamGetBits(bs, dec->quant_bits)) < 1) // vop_quant
1015 : Isibaar 157 *quant = 1;
1016 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "quant %i", *quant);
1017 : edgomez 195
1018 :     if (coding_type != I_VOP) {
1019 :     *fcode_forward = BitstreamGetBits(bs, 3); // fcode_forward
1020 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "fcode_forward %i", *fcode_forward);
1021 : Isibaar 3 }
1022 : edgomez 195
1023 :     if (coding_type == B_VOP) {
1024 :     *fcode_backward = BitstreamGetBits(bs, 3); // fcode_backward
1025 : suxen_drol 252 DPRINTF(DPRINTF_HEADER, "fcode_backward %i", *fcode_backward);
1026 : Isibaar 3 }
1027 : edgomez 195 if (!dec->scalability) {
1028 :     if ((dec->shape != VIDOBJLAY_SHAPE_RECTANGULAR) &&
1029 :     (coding_type != I_VOP)) {
1030 :     BitstreamSkip(bs, 1); // vop_shape_coding_type
1031 : chenm001 156 }
1032 :     }
1033 : Isibaar 3 return coding_type;
1034 : suxen_drol 252
1035 : edgomez 195 } else if (start_code == USERDATA_START_CODE) {
1036 : Isibaar 645 char tmp[256];
1037 : suxen_drol 698 int i, version, build;
1038 :     char packed;
1039 : suxen_drol 252
1040 : edgomez 195 BitstreamSkip(bs, 32); // user_data_start_code
1041 : suxen_drol 252
1042 : Isibaar 645 tmp[0] = BitstreamShowBits(bs, 8);
1043 :    
1044 :     for(i = 1; i < 256; i++){
1045 :     tmp[i] = (BitstreamShowBits(bs, 16) & 0xFF);
1046 :    
1047 :     if(tmp[i] == 0)
1048 :     break;
1049 :    
1050 :     BitstreamSkip(bs, 8);
1051 :     }
1052 :    
1053 :     DPRINTF(DPRINTF_STARTCODE, "<user_data>: %s\n", tmp);
1054 :    
1055 : suxen_drol 694 /* divx detection */
1056 :     i = sscanf(tmp, "DivX%dBuild%d%c", &version, &build, &packed);
1057 :     if (i < 2)
1058 :     i = sscanf(tmp, "DivX%db%d%c", &version, &build, &packed);
1059 :    
1060 :     if (i >= 2)
1061 :     {
1062 :     dec->packed_mode = (i == 3 && packed == 'p');
1063 :     DPRINTF(DPRINTF_HEADER, "divx version=%i, build=%i packed=%i",
1064 :     version, build, dec->packed_mode);
1065 :     }
1066 : Isibaar 645
1067 : edgomez 195 } else // start_code == ?
1068 : Isibaar 3 {
1069 : edgomez 195 if (BitstreamShowBits(bs, 24) == 0x000001) {
1070 : suxen_drol 252 DPRINTF(DPRINTF_STARTCODE, "<unknown: %x>", BitstreamShowBits(bs, 32));
1071 : Isibaar 3 }
1072 :     BitstreamSkip(bs, 8);
1073 :     }
1074 :     }
1075 :     while ((BitstreamPos(bs) >> 3) < bs->length);
1076 :    
1077 : suxen_drol 233 //DPRINTF("*** WARNING: no vop_start_code found");
1078 : edgomez 195 return -1; /* ignore it */
1079 : Isibaar 3 }
1080 :    
1081 :    
1082 :     /* write custom quant matrix */
1083 :    
1084 : edgomez 195 static void
1085 :     bs_put_matrix(Bitstream * bs,
1086 :     const int16_t * matrix)
1087 : Isibaar 3 {
1088 :     int i, j;
1089 :     const int last = matrix[scan_tables[0][63]];
1090 :    
1091 : suxen_drol 233 for (j = 63; j > 0 && matrix[scan_tables[0][j - 1]] == last; j--);
1092 : Isibaar 3
1093 : edgomez 195 for (i = 0; i <= j; i++) {
1094 : Isibaar 3 BitstreamPutBits(bs, matrix[scan_tables[0][i]], 8);
1095 :     }
1096 :    
1097 : edgomez 195 if (j < 63) {
1098 : Isibaar 3 BitstreamPutBits(bs, 0, 8);
1099 :     }
1100 :     }
1101 :    
1102 :    
1103 :     /*
1104 :     write vol header
1105 :     */
1106 : edgomez 195 void
1107 :     BitstreamWriteVolHeader(Bitstream * const bs,
1108 :     const MBParam * pParam,
1109 : chl 619 const FRAMEINFO * const frame)
1110 : Isibaar 3 {
1111 : chl 619 int vol_ver_id=1;
1112 :    
1113 :     if ( (pParam->m_quarterpel) || (frame->global_flags & XVID_GMC) )
1114 :     vol_ver_id = 2;
1115 :    
1116 : Isibaar 3 // video object_start_code & vo_id
1117 : edgomez 195 BitstreamPad(bs);
1118 : Isibaar 3 BitstreamPutBits(bs, VO_START_CODE, 27);
1119 : edgomez 195 BitstreamPutBits(bs, 0, 5);
1120 : Isibaar 3
1121 :     // video_object_layer_start_code & vol_id
1122 :     BitstreamPutBits(bs, VOL_START_CODE, 28);
1123 :     BitstreamPutBits(bs, 0, 4);
1124 :    
1125 : edgomez 195 BitstreamPutBit(bs, 0); // random_accessible_vol
1126 :     BitstreamPutBits(bs, 0, 8); // video_object_type_indication
1127 : Isibaar 579
1128 : chl 619 if (vol_ver_id == 1)
1129 : Isibaar 579 {
1130 :     BitstreamPutBit(bs, 0); // is_object_layer_identified (0=not given)
1131 :     }
1132 :     else
1133 :     {
1134 :     BitstreamPutBit(bs, 1); // is_object_layer_identified
1135 : chl 619 BitstreamPutBits(bs, vol_ver_id, 4); // vol_ver_id == 2
1136 :     BitstreamPutBits(bs, 4, 3); // vol_ver_priority (1==lowest, 7==highest) ??
1137 : Isibaar 579 }
1138 :    
1139 : edgomez 195 BitstreamPutBits(bs, 1, 4); // aspect_ratio_info (1=1:1)
1140 : suxen_drol 164
1141 : chl 387 BitstreamPutBit(bs, 1); // vol_control_parameters
1142 :     BitstreamPutBits(bs, 1, 2); // chroma_format 1="4:2:0"
1143 :    
1144 : edgomez 195 if (pParam->max_bframes > 0) {
1145 :     BitstreamPutBit(bs, 0); // low_delay
1146 :     } else
1147 : suxen_drol 164 {
1148 : chl 386 BitstreamPutBit(bs, 1); // low_delay
1149 : suxen_drol 164 }
1150 : chl 387 BitstreamPutBit(bs, 0); // vbv_parameters (0=not given)
1151 : suxen_drol 164
1152 : edgomez 195 BitstreamPutBits(bs, 0, 2); // video_object_layer_shape (0=rectangular)
1153 : Isibaar 3
1154 :     WRITE_MARKER();
1155 : edgomez 195
1156 : suxen_drol 631 /* time_inc_resolution; ignored by current decore versions
1157 : edgomez 195 eg. 2fps res=2 inc=1
1158 :     25fps res=25 inc=1
1159 :     29.97fps res=30000 inc=1001
1160 :     */
1161 : suxen_drol 163 BitstreamPutBits(bs, pParam->fbase, 16);
1162 : Isibaar 3
1163 :     WRITE_MARKER();
1164 :    
1165 : suxen_drol 241 BitstreamPutBit(bs, 1); // fixed_vop_rate = 1
1166 :     BitstreamPutBits(bs, pParam->fincr, log2bin(pParam->fbase)); // fixed_vop_time_increment
1167 : Isibaar 3
1168 :     WRITE_MARKER();
1169 : edgomez 195 BitstreamPutBits(bs, pParam->width, 13); // width
1170 : Isibaar 3 WRITE_MARKER();
1171 : edgomez 195 BitstreamPutBits(bs, pParam->height, 13); // height
1172 : Isibaar 3 WRITE_MARKER();
1173 : edgomez 195
1174 :     BitstreamPutBit(bs, frame->global_flags & XVID_INTERLACING); // interlace
1175 : Isibaar 3 BitstreamPutBit(bs, 1); // obmc_disable (overlapped block motion compensation)
1176 : Isibaar 579
1177 : chl 619 if (vol_ver_id != 1)
1178 :     { if (frame->global_flags & XVID_GMC)
1179 :     { BitstreamPutBits(bs, 2, 2); // sprite_enable=='GMC'
1180 :     BitstreamPutBits(bs, 2, 6); // no_of_sprite_warping_points
1181 :     BitstreamPutBits(bs, 3, 2); // sprite_warping_accuracy 0==1/2, 1=1/4, 2=1/8, 3=1/16
1182 :     BitstreamPutBit(bs, 0); // sprite_brightness_change (not supported)
1183 :    
1184 :     /* currently we use no_of_sprite_warping_points==2, sprite_warping_accuracy==3
1185 :     for DivX5 compatability */
1186 :    
1187 :     } else
1188 :     BitstreamPutBits(bs, 0, 2); // sprite_enable==off
1189 : Isibaar 579 }
1190 :     else
1191 : chl 619 BitstreamPutBit(bs, 0); // sprite_enable==off
1192 : Isibaar 579
1193 : chl 619 BitstreamPutBit(bs, 0); // not_8_bit
1194 : Isibaar 3
1195 :     // quant_type 0=h.263 1=mpeg4(quantizer tables)
1196 : suxen_drol 136 BitstreamPutBit(bs, pParam->m_quant_type);
1197 : edgomez 195
1198 :     if (pParam->m_quant_type) {
1199 : Isibaar 4 BitstreamPutBit(bs, get_intra_matrix_status()); // load_intra_quant_mat
1200 : edgomez 195 if (get_intra_matrix_status()) {
1201 : Isibaar 4 bs_put_matrix(bs, get_intra_matrix());
1202 : Isibaar 3 }
1203 :    
1204 : edgomez 195 BitstreamPutBit(bs, get_inter_matrix_status()); // load_inter_quant_mat
1205 :     if (get_inter_matrix_status()) {
1206 : Isibaar 4 bs_put_matrix(bs, get_inter_matrix());
1207 : Isibaar 3 }
1208 :    
1209 :     }
1210 :    
1211 : chl 619 if (vol_ver_id != 1) {
1212 :     if (pParam->m_quarterpel)
1213 :     BitstreamPutBit(bs, 1); // quarterpel
1214 :     else
1215 :     BitstreamPutBit(bs, 0); // no quarterpel
1216 : Isibaar 579 }
1217 :    
1218 : Isibaar 3 BitstreamPutBit(bs, 1); // complexity_estimation_disable
1219 :     BitstreamPutBit(bs, 1); // resync_marker_disable
1220 :     BitstreamPutBit(bs, 0); // data_partitioned
1221 : Isibaar 579
1222 : chl 619 if (vol_ver_id != 1)
1223 : Isibaar 579 {
1224 :     BitstreamPutBit(bs, 0); // newpred_enable
1225 :     BitstreamPutBit(bs, 0); // reduced_resolution_vop_enabled
1226 :     }
1227 : chl 619
1228 :     BitstreamPutBit(bs, 0); // scalability
1229 : Isibaar 579
1230 : Isibaar 3 }
1231 :    
1232 :    
1233 :     /*
1234 :     write vop header
1235 :     */
1236 : edgomez 195 void
1237 :     BitstreamWriteVopHeader(Bitstream * const bs,
1238 :     const MBParam * pParam,
1239 : chl 619 const FRAMEINFO * const frame,
1240 : suxen_drol 229 int vop_coded)
1241 : Isibaar 3 {
1242 : suxen_drol 152 uint32_t i;
1243 : chl 387
1244 : edgomez 195 BitstreamPad(bs);
1245 :     BitstreamPutBits(bs, VOP_START_CODE, 32);
1246 : Isibaar 3
1247 : edgomez 195 BitstreamPutBits(bs, frame->coding_type, 2);
1248 : suxen_drol 631 DPRINTF(DPRINTF_HEADER, "coding_type = %i", frame->coding_type);
1249 : edgomez 195
1250 :     for (i = 0; i < frame->seconds; i++) {
1251 : suxen_drol 152 BitstreamPutBit(bs, 1);
1252 :     }
1253 :     BitstreamPutBit(bs, 0);
1254 : Isibaar 3
1255 :     WRITE_MARKER();
1256 :    
1257 :     // time_increment: value=nth_of_sec, nbits = log2(resolution)
1258 : chl 619
1259 : edgomez 195 BitstreamPutBits(bs, frame->ticks, log2bin(pParam->fbase));
1260 : suxen_drol 631 /*DPRINTF("[%i:%i] %c", frame->seconds, frame->ticks,
1261 : edgomez 195 frame->coding_type == I_VOP ? 'I' : frame->coding_type ==
1262 : suxen_drol 252 P_VOP ? 'P' : 'B');*/
1263 : Isibaar 3
1264 :     WRITE_MARKER();
1265 :    
1266 : suxen_drol 229 if (!vop_coded) {
1267 :     BitstreamPutBits(bs, 0, 1);
1268 :     return;
1269 :     }
1270 :    
1271 : edgomez 195 BitstreamPutBits(bs, 1, 1); // vop_coded
1272 : Isibaar 3
1273 : chl 619 if ( (frame->coding_type == P_VOP) || (frame->coding_type == S_VOP) )
1274 : suxen_drol 136 BitstreamPutBits(bs, frame->rounding_type, 1);
1275 : Isibaar 3
1276 : edgomez 195 BitstreamPutBits(bs, 0, 3); // intra_dc_vlc_threshold
1277 :    
1278 :     if (frame->global_flags & XVID_INTERLACING) {
1279 : h 543 BitstreamPutBit(bs, (frame->global_flags & XVID_TOPFIELDFIRST));
1280 :     BitstreamPutBit(bs, (frame->global_flags & XVID_ALTERNATESCAN));
1281 : h 69 }
1282 : chl 619
1283 :     if (frame->coding_type == S_VOP) {
1284 :     if (1) { // no_of_sprite_warping_points>=1
1285 :     if (pParam->m_quarterpel)
1286 :     bs_put_spritetrajectory(bs, frame->GMC_MV.x/2 ); // du[0]
1287 :     else
1288 :     bs_put_spritetrajectory(bs, frame->GMC_MV.x ); // du[0]
1289 :     WRITE_MARKER();
1290 :    
1291 :     if (pParam->m_quarterpel)
1292 :     bs_put_spritetrajectory(bs, frame->GMC_MV.y/2 ); // dv[0]
1293 :     else
1294 :     bs_put_spritetrajectory(bs, frame->GMC_MV.y ); // dv[0]
1295 :     WRITE_MARKER();
1296 : suxen_drol 631
1297 :    
1298 :     if (pParam->m_quarterpel)
1299 :     {
1300 :     DPRINTF(DPRINTF_HEADER,"sprite_warping_point[%i] xy=(%i,%i) *QPEL*", 0, frame->GMC_MV.x/2, frame->GMC_MV.y/2);
1301 :     }
1302 :     else
1303 :     {
1304 :     DPRINTF(DPRINTF_HEADER,"sprite_warping_point[%i] xy=(%i,%i)", 0, frame->GMC_MV.x, frame->GMC_MV.y);
1305 :     }
1306 :    
1307 : chl 619 }
1308 :     /* GMC is halfpel in bitstream, even though GMC_MV was pseudo-qpel (2*halfpel) */
1309 : h 69
1310 : chl 619 if (2) { // no_of_sprite_warping_points>=2 (for DivX5 compat)
1311 :     bs_put_spritetrajectory(bs, 0 );
1312 :     WRITE_MARKER();
1313 :     bs_put_spritetrajectory(bs, 0 );
1314 :     WRITE_MARKER();
1315 :     }
1316 :     // no support for brightness_change!
1317 :     }
1318 :    
1319 : suxen_drol 694
1320 :     DPRINTF(DPRINTF_HEADER, "quant = %i", frame->quant);
1321 :    
1322 : edgomez 195 BitstreamPutBits(bs, frame->quant, 5); // quantizer
1323 :    
1324 : suxen_drol 136 if (frame->coding_type != I_VOP)
1325 : edgomez 195 BitstreamPutBits(bs, frame->fcode, 3); // forward_fixed_code
1326 : suxen_drol 152
1327 :     if (frame->coding_type == B_VOP)
1328 : edgomez 195 BitstreamPutBits(bs, frame->bcode, 3); // backward_fixed_code
1329 : suxen_drol 152
1330 : Isibaar 3 }
1331 : suxen_drol 229
1332 :     void
1333 :     BitstreamWriteUserData(Bitstream * const bs,
1334 :     uint8_t * data,
1335 :     const int length)
1336 :     {
1337 :     int i;
1338 :    
1339 :     BitstreamPad(bs);
1340 :     BitstreamPutBits(bs, USERDATA_START_CODE, 32);
1341 :    
1342 :     for (i = 0; i < length; i++) {
1343 :     BitstreamPutBits(bs, data[i], 8);
1344 :     }
1345 :    
1346 : chl 313 }

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