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

Annotation of /xvidcore/src/bitstream/bitstream.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.28.2.7 - (view) (download)

1 : Isibaar 1.1 /******************************************************************************
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 1.16 * *
42 : Isibaar 1.1 * Revision history: *
43 : chenm001 1.16 * *
44 : chl 1.28.2.4 * 28.10.2002 GMC support - gruel *
45 : Isibaar 1.28.2.3 * 04.10.2002 qpel support - Isibaar *
46 : chenm001 1.23 * 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 1.17 * 20.05.2002 added BitstreamWriteUserData *
51 : Isibaar 1.28.2.3 * 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 1.12 * 06.05.2002 low_delay *
56 : suxen_drol 1.11 * 06.05.2002 fixed fincr/fbase error *
57 :     * 01.05.2002 added BVOP support to BitstreamWriteVopHeader *
58 : chenm001 1.6 * 15.04.2002 rewrite log2bin use asm386 By MinChen <chenm001@163.com> *
59 : chenm001 1.16 * 26.03.2002 interlacing support *
60 :     * 03.03.2002 qmatrix writing *
61 :     * 03.03.2002 merged BITREADER and BITWRITER *
62 : Isibaar 1.28.2.3 * 30.02.2002 intra_dc_threshold support *
63 :     * 04.12.2001 support for additional headers *
64 :     * 16.12.2001 inital version *
65 :     * *
66 : Isibaar 1.1 ******************************************************************************/
67 :    
68 :    
69 : Isibaar 1.28.2.6 #include <string.h>
70 : Isibaar 1.1 #include "bitstream.h"
71 :     #include "zigzag.h"
72 : Isibaar 1.2 #include "../quant/quant_matrix.h"
73 : chl 1.28.2.4 #include "mbcoding.h"
74 : Isibaar 1.1
75 : chenm001 1.6
76 : edgomez 1.14 static uint32_t __inline
77 :     log2bin(uint32_t value)
78 : Isibaar 1.1 {
79 : chenm001 1.6 /* Changed by Chenm001 */
80 :     #ifndef WIN32
81 : Isibaar 1.1 int n = 0;
82 : edgomez 1.14
83 :     while (value) {
84 : Isibaar 1.1 value >>= 1;
85 :     n++;
86 :     }
87 :     return n;
88 : chenm001 1.6 #else
89 : edgomez 1.14 __asm {
90 : suxen_drol 1.15 bsr eax, value
91 :     inc eax
92 :     }
93 : chenm001 1.6 #endif
94 : Isibaar 1.1 }
95 :    
96 :    
97 : edgomez 1.14 static const uint32_t intra_dc_threshold_table[] = {
98 :     32, /* never use */
99 : Isibaar 1.1 13,
100 :     15,
101 :     17,
102 :     19,
103 :     21,
104 :     23,
105 :     1,
106 :     };
107 :    
108 :    
109 : edgomez 1.14 void
110 :     bs_get_matrix(Bitstream * bs,
111 :     uint8_t * matrix)
112 :     {
113 :     int i = 0;
114 :     int last, value = 0;
115 :    
116 :     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 1.16 i--; // fix little bug at coeff not full
123 : edgomez 1.14
124 :     while (i < 64) {
125 :     matrix[scan_tables[0][i++]] = last;
126 :     }
127 :     }
128 : Isibaar 1.2
129 : suxen_drol 1.21
130 :    
131 :     // for PVOP addbits == fcode - 1
132 :     // for BVOP addbits == max(fcode,bcode) - 1
133 :     // returns mbpos
134 :     int
135 : suxen_drol 1.28.2.5 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 1.21 {
143 : suxen_drol 1.28.2.5 int startcode_bits = NUMBITS_VP_RESYNC_MARKER + addbits;
144 :     int mbnum_bits = log2bin(dec->mb_width * dec->mb_height - 1);
145 : suxen_drol 1.21 int mbnum;
146 : suxen_drol 1.28.2.5 int hec = 0;
147 : suxen_drol 1.21
148 :     BitstreamSkip(bs, BitstreamNumBitsToByteAlign(bs));
149 : suxen_drol 1.28.2.5 BitstreamSkip(bs, startcode_bits);
150 : suxen_drol 1.21
151 : suxen_drol 1.22 DPRINTF(DPRINTF_STARTCODE, "<video_packet_header>");
152 :    
153 : suxen_drol 1.28.2.5 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 1.21
169 : suxen_drol 1.28.2.5 mbnum = BitstreamGetBits(bs, mbnum_bits); /* macroblock_number */
170 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "mbnum %i", mbnum);
171 : suxen_drol 1.21
172 : suxen_drol 1.28.2.5 if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY)
173 :     {
174 :     *quant = BitstreamGetBits(bs, 5); /* quant_scale */
175 :     DPRINTF(DPRINTF_HEADER, "quant %i", *quant);
176 :     }
177 :    
178 :     if (dec->shape == VIDOBJLAY_SHAPE_RECTANGULAR)
179 :     hec = BitstreamGetBit(bs); /* header_extension_code */
180 :    
181 : suxen_drol 1.21
182 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "header_extension_code %i", hec);
183 : suxen_drol 1.28.2.5 if (hec)
184 :     {
185 :     int time_base;
186 :     int time_increment;
187 :     int coding_type;
188 :    
189 :     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 1.28.2.7 BitstreamSkip(bs, 1); /* XXX: vop_reduced_resolution */
220 : suxen_drol 1.28.2.5 }
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 : suxen_drol 1.21
252 :     return mbnum;
253 :     }
254 :    
255 :    
256 :    
257 : suxen_drol 1.28.2.7
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 1.1 /*
417 :     decode headers
418 :     returns coding_type, or -1 if error
419 :     */
420 :    
421 : suxen_drol 1.22 #define VIDOBJ_START_CODE_MASK 0x0000001f
422 :     #define VIDOBJLAY_START_CODE_MASK 0x0000000f
423 :    
424 : edgomez 1.14 int
425 :     BitstreamReadHeaders(Bitstream * bs,
426 :     DECODER * dec,
427 :     uint32_t * rounding,
428 : suxen_drol 1.28.2.5 uint32_t * reduced_resolution,
429 : edgomez 1.14 uint32_t * quant,
430 :     uint32_t * fcode_forward,
431 :     uint32_t * fcode_backward,
432 : suxen_drol 1.28.2.5 uint32_t * intra_dc_threshold,
433 :     VECTOR * gmc_mv)
434 : Isibaar 1.1 {
435 :     uint32_t vol_ver_id;
436 :     uint32_t coding_type;
437 :     uint32_t start_code;
438 : edgomez 1.14 uint32_t time_incr = 0;
439 :     int32_t time_increment;
440 : suxen_drol 1.28.2.5 int resize = 0;
441 : chenm001 1.9
442 : edgomez 1.14 do {
443 : suxen_drol 1.28.2.5
444 : Isibaar 1.1 BitstreamByteAlign(bs);
445 :     start_code = BitstreamShowBits(bs, 32);
446 :    
447 : edgomez 1.14 if (start_code == VISOBJSEQ_START_CODE) {
448 : suxen_drol 1.22
449 :     int profile;
450 :    
451 :     DPRINTF(DPRINTF_STARTCODE, "<visual_object_sequence>");
452 :    
453 : edgomez 1.14 BitstreamSkip(bs, 32); // visual_object_sequence_start_code
454 : suxen_drol 1.22 profile = BitstreamGetBits(bs, 8); // profile_and_level_indication
455 :    
456 :     DPRINTF(DPRINTF_HEADER, "profile_and_level_indication %i", profile);
457 :    
458 : edgomez 1.14 } else if (start_code == VISOBJSEQ_STOP_CODE) {
459 : suxen_drol 1.22
460 : edgomez 1.14 BitstreamSkip(bs, 32); // visual_object_sequence_stop_code
461 : suxen_drol 1.22
462 :     DPRINTF(DPRINTF_STARTCODE, "</visual_object_sequence>");
463 :    
464 : edgomez 1.14 } else if (start_code == VISOBJ_START_CODE) {
465 : suxen_drol 1.22
466 :     DPRINTF(DPRINTF_STARTCODE, "<visual_object>");
467 :    
468 : edgomez 1.14 BitstreamSkip(bs, 32); // visual_object_start_code
469 :     if (BitstreamGetBit(bs)) // is_visual_object_identified
470 : Isibaar 1.1 {
471 : edgomez 1.14 vol_ver_id = BitstreamGetBits(bs, 4); // visual_object_ver_id
472 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER,"ver_id %i", vol_ver_id);
473 : edgomez 1.14 BitstreamSkip(bs, 3); // visual_object_priority
474 :     } else {
475 : Isibaar 1.1 vol_ver_id = 1;
476 :     }
477 :    
478 :     if (BitstreamShowBits(bs, 4) != VISOBJ_TYPE_VIDEO) // visual_object_type
479 :     {
480 : suxen_drol 1.22 DPRINTF(DPRINTF_ERROR, "visual_object_type != video");
481 : Isibaar 1.1 return -1;
482 :     }
483 :     BitstreamSkip(bs, 4);
484 :    
485 :     // video_signal_type
486 :    
487 : edgomez 1.14 if (BitstreamGetBit(bs)) // video_signal_type
488 : Isibaar 1.1 {
489 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER,"+ video_signal_type");
490 : edgomez 1.14 BitstreamSkip(bs, 3); // video_format
491 :     BitstreamSkip(bs, 1); // video_range
492 :     if (BitstreamGetBit(bs)) // color_description
493 : Isibaar 1.1 {
494 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER,"+ color_description");
495 : edgomez 1.14 BitstreamSkip(bs, 8); // color_primaries
496 :     BitstreamSkip(bs, 8); // transfer_characteristics
497 :     BitstreamSkip(bs, 8); // matrix_coefficients
498 : Isibaar 1.1 }
499 :     }
500 : suxen_drol 1.22 } 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 1.14 BitstreamSkip(bs, 32); // video_object_start_code
506 : suxen_drol 1.22
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 1.14 BitstreamSkip(bs, 32); // video_object_layer_start_code
513 : Isibaar 1.1
514 : edgomez 1.14 BitstreamSkip(bs, 1); // random_accessible_vol
515 : Isibaar 1.1
516 :     // video_object_type_indication
517 : suxen_drol 1.28.2.5 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 1.1 {
524 : suxen_drol 1.22 DPRINTF(DPRINTF_ERROR,"video_object_type_indication %i not supported ",
525 :     BitstreamShowBits(bs, 8));
526 : Isibaar 1.1 return -1;
527 :     }
528 :     BitstreamSkip(bs, 8);
529 :    
530 :    
531 : edgomez 1.14 if (BitstreamGetBit(bs)) // is_object_layer_identifier
532 : Isibaar 1.1 {
533 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "+ is_object_layer_identifier");
534 : edgomez 1.14 vol_ver_id = BitstreamGetBits(bs, 4); // video_object_layer_verid
535 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER,"ver_id %i", vol_ver_id);
536 : edgomez 1.14 BitstreamSkip(bs, 3); // video_object_layer_priority
537 :     } else {
538 : Isibaar 1.1 vol_ver_id = 1;
539 :     }
540 :    
541 : suxen_drol 1.28.2.5 dec->aspect_ratio = BitstreamGetBits(bs, 4);
542 :    
543 :     if (dec->aspect_ratio == VIDOBJLAY_AR_EXTPAR) // aspect_ratio_info
544 : Isibaar 1.1 {
545 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "+ aspect_ratio_info");
546 : suxen_drol 1.28.2.5 dec->par_width = BitstreamGetBits(bs, 8); // par_width
547 :     dec->par_height = BitstreamGetBits(bs, 8); // par_height
548 : Isibaar 1.1 }
549 :    
550 : edgomez 1.14 if (BitstreamGetBit(bs)) // vol_control_parameters
551 : Isibaar 1.1 {
552 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "+ vol_control_parameters");
553 : edgomez 1.14 BitstreamSkip(bs, 2); // chroma_format
554 :     dec->low_delay = BitstreamGetBit(bs); // low_delay
555 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "low_delay %i", dec->low_delay);
556 : edgomez 1.14 if (BitstreamGetBit(bs)) // vbv_parameters
557 : Isibaar 1.1 {
558 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER,"+ vbv_parameters");
559 : edgomez 1.14 BitstreamSkip(bs, 15); // first_half_bitrate
560 : Isibaar 1.1 READ_MARKER();
561 : edgomez 1.14 BitstreamSkip(bs, 15); // latter_half_bitrate
562 : Isibaar 1.1 READ_MARKER();
563 : edgomez 1.14 BitstreamSkip(bs, 15); // first_half_vbv_buffer_size
564 : Isibaar 1.1 READ_MARKER();
565 : edgomez 1.14 BitstreamSkip(bs, 3); // latter_half_vbv_buffer_size
566 :     BitstreamSkip(bs, 11); // first_half_vbv_occupancy
567 : Isibaar 1.1 READ_MARKER();
568 : edgomez 1.14 BitstreamSkip(bs, 15); // latter_half_vbv_occupancy
569 : Isibaar 1.1 READ_MARKER();
570 :     }
571 :     }
572 :    
573 :     dec->shape = BitstreamGetBits(bs, 2); // video_object_layer_shape
574 : suxen_drol 1.28.2.5
575 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "shape %i", dec->shape);
576 : suxen_drol 1.28.2.5 if (dec->shape != VIDOBJLAY_SHAPE_RECTANGULAR)
577 :     {
578 :     DPRINTF(DPRINTF_ERROR,"non-rectangular shapes are not supported");
579 :     }
580 : edgomez 1.14
581 :     if (dec->shape == VIDOBJLAY_SHAPE_GRAYSCALE && vol_ver_id != 1) {
582 :     BitstreamSkip(bs, 4); // video_object_layer_shape_extension
583 : Isibaar 1.1 }
584 :    
585 :     READ_MARKER();
586 :    
587 : chenm001 1.9 // *************************** for decode B-frame time ***********************
588 : suxen_drol 1.28.2.5 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 1.22
591 : suxen_drol 1.28.2.5 // dec->time_inc_resolution--;
592 : suxen_drol 1.22
593 : suxen_drol 1.28.2.5 if (dec->time_inc_resolution > 0) {
594 :     dec->time_inc_bits = log2bin(dec->time_inc_resolution-1);
595 : edgomez 1.14 } else {
596 : Isibaar 1.1 // 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 1.14 if (BitstreamGetBit(bs)) // fixed_vop_rate
604 : Isibaar 1.1 {
605 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "+ fixed_vop_rate");
606 : Isibaar 1.1 BitstreamSkip(bs, dec->time_inc_bits); // fixed_vop_time_increment
607 :     }
608 :    
609 : edgomez 1.14 if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY) {
610 : Isibaar 1.1
611 : edgomez 1.14 if (dec->shape == VIDOBJLAY_SHAPE_RECTANGULAR) {
612 : Isibaar 1.1 uint32_t width, height;
613 :    
614 :     READ_MARKER();
615 : edgomez 1.14 width = BitstreamGetBits(bs, 13); // video_object_layer_width
616 : Isibaar 1.1 READ_MARKER();
617 : edgomez 1.14 height = BitstreamGetBits(bs, 13); // video_object_layer_height
618 : Isibaar 1.1 READ_MARKER();
619 :    
620 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "width %i", width);
621 :     DPRINTF(DPRINTF_HEADER, "height %i", height);
622 : chenm001 1.23
623 : suxen_drol 1.28.2.5 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 1.23 dec->width = width;
632 :     dec->height = height;
633 : Isibaar 1.1 }
634 :     }
635 : h 1.4
636 : suxen_drol 1.22 dec->interlacing = BitstreamGetBit(bs);
637 : suxen_drol 1.28.2.5 DPRINTF(DPRINTF_HEADER, "interlacing %i", dec->interlacing);
638 : Isibaar 1.1
639 : edgomez 1.14 if (!BitstreamGetBit(bs)) // obmc_disable
640 : Isibaar 1.1 {
641 : suxen_drol 1.22 DPRINTF(DPRINTF_ERROR, "obmc_disabled==false not supported");
642 : Isibaar 1.1 // TODO
643 :     // fucking divx4.02 has this enabled
644 :     }
645 :    
646 : suxen_drol 1.28.2.5 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 1.1 {
650 : suxen_drol 1.28.2.5 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 1.1 }
675 : edgomez 1.14
676 :     if (vol_ver_id != 1 &&
677 :     dec->shape != VIDOBJLAY_SHAPE_RECTANGULAR) {
678 :     BitstreamSkip(bs, 1); // sadct_disable
679 : Isibaar 1.1 }
680 :    
681 : edgomez 1.14 if (BitstreamGetBit(bs)) // not_8_bit
682 : Isibaar 1.1 {
683 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "not_8_bit==true (ignored)");
684 : Isibaar 1.1 dec->quant_bits = BitstreamGetBits(bs, 4); // quant_precision
685 : edgomez 1.14 BitstreamSkip(bs, 4); // bits_per_pixel
686 :     } else {
687 : Isibaar 1.1 dec->quant_bits = 5;
688 :     }
689 :    
690 : edgomez 1.14 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 1.1 }
695 :    
696 : edgomez 1.14 dec->quant_type = BitstreamGetBit(bs); // quant_type
697 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "quant_type %i", dec->quant_type);
698 : Isibaar 1.1
699 : edgomez 1.14 if (dec->quant_type) {
700 :     if (BitstreamGetBit(bs)) // load_intra_quant_mat
701 : Isibaar 1.1 {
702 : Isibaar 1.3 uint8_t matrix[64];
703 : edgomez 1.14
704 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "load_intra_quant_mat");
705 :    
706 : Isibaar 1.2 bs_get_matrix(bs, matrix);
707 :     set_intra_matrix(matrix);
708 : edgomez 1.14 } else
709 : Isibaar 1.3 set_intra_matrix(get_default_intra_matrix());
710 : Isibaar 1.2
711 : edgomez 1.14 if (BitstreamGetBit(bs)) // load_inter_quant_mat
712 : Isibaar 1.1 {
713 : edgomez 1.14 uint8_t matrix[64];
714 : suxen_drol 1.22
715 :     DPRINTF(DPRINTF_HEADER, "load_inter_quant_mat");
716 : edgomez 1.14
717 : Isibaar 1.2 bs_get_matrix(bs, matrix);
718 :     set_inter_matrix(matrix);
719 : edgomez 1.14 } else
720 : Isibaar 1.3 set_inter_matrix(get_default_inter_matrix());
721 : Isibaar 1.1
722 : edgomez 1.14 if (dec->shape == VIDOBJLAY_SHAPE_GRAYSCALE) {
723 : suxen_drol 1.22 DPRINTF(DPRINTF_ERROR, "greyscale matrix not supported");
724 : Isibaar 1.1 return -1;
725 :     }
726 : Isibaar 1.2
727 : Isibaar 1.1 }
728 :    
729 : edgomez 1.14
730 :     if (vol_ver_id != 1) {
731 : Isibaar 1.26 dec->quarterpel = BitstreamGetBit(bs); // quarter_sample
732 : suxen_drol 1.28.2.5 DPRINTF(DPRINTF_HEADER,"quarterpel %i", dec->quarterpel);
733 : Isibaar 1.26 }
734 :     else
735 : Isibaar 1.1 dec->quarterpel = 0;
736 : Isibaar 1.26
737 : Isibaar 1.1
738 : suxen_drol 1.28.2.7 dec->complexity_estimation_disable = BitstreamGetBit(bs); /* complexity estimation disable */
739 :     if (!dec->complexity_estimation_disable)
740 : Isibaar 1.1 {
741 : suxen_drol 1.28.2.7 read_vol_complexity_estimation_header(bs, dec);
742 : Isibaar 1.1 }
743 :    
744 : suxen_drol 1.22 BitstreamSkip(bs, 1); // resync_marker_disable
745 : Isibaar 1.1
746 : edgomez 1.14 if (BitstreamGetBit(bs)) // data_partitioned
747 : Isibaar 1.1 {
748 : suxen_drol 1.22 DPRINTF(DPRINTF_ERROR, "data_partitioned not supported");
749 : edgomez 1.14 BitstreamSkip(bs, 1); // reversible_vlc
750 : Isibaar 1.1 }
751 :    
752 : edgomez 1.14 if (vol_ver_id != 1) {
753 : suxen_drol 1.28.2.5 dec->newpred_enable = BitstreamGetBit(bs);
754 :     if (dec->newpred_enable) // newpred_enable
755 : Isibaar 1.1 {
756 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "+ newpred_enable");
757 : edgomez 1.14 BitstreamSkip(bs, 2); // requested_upstream_message_type
758 :     BitstreamSkip(bs, 1); // newpred_segment_type
759 : Isibaar 1.1 }
760 : suxen_drol 1.28.2.7 dec->reduced_resolution_enable = BitstreamGetBit(bs); /* reduced_resolution_vop_enable */
761 :     DPRINTF(DPRINTF_HEADER, "reduced_resolution_enable %i", dec->reduced_resolution_enable);
762 : Isibaar 1.1 }
763 : suxen_drol 1.28.2.5 else
764 :     {
765 :     dec->newpred_enable = 0;
766 :     dec->reduced_resolution_enable = 0;
767 :     }
768 : edgomez 1.14
769 : suxen_drol 1.28.2.7 dec->scalability = BitstreamGetBit(bs); /* scalability */
770 :     if (dec->scalability)
771 : Isibaar 1.1 {
772 : suxen_drol 1.22 DPRINTF(DPRINTF_ERROR, "scalability not supported");
773 : suxen_drol 1.28.2.7 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 1.1 return -1;
790 :     }
791 : edgomez 1.14 } else // dec->shape == BINARY_ONLY
792 : Isibaar 1.1 {
793 : edgomez 1.14 if (vol_ver_id != 1) {
794 : suxen_drol 1.28.2.7 dec->scalability = BitstreamGetBit(bs); /* scalability */
795 :     if (dec->scalability)
796 : Isibaar 1.1 {
797 : suxen_drol 1.28.2.7 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 1.1 return -1;
804 :     }
805 :     }
806 : edgomez 1.14 BitstreamSkip(bs, 1); // resync_marker_disable
807 : Isibaar 1.1
808 :     }
809 :    
810 : suxen_drol 1.28.2.5 return (resize ? -3 : -2 ); /* VOL */
811 :    
812 : edgomez 1.14 } else if (start_code == GRPOFVOP_START_CODE) {
813 : suxen_drol 1.22
814 :     DPRINTF(DPRINTF_STARTCODE, "<group_of_vop>");
815 :    
816 : Isibaar 1.1 BitstreamSkip(bs, 32);
817 :     {
818 :     int hours, minutes, seconds;
819 : edgomez 1.14
820 : Isibaar 1.1 hours = BitstreamGetBits(bs, 5);
821 :     minutes = BitstreamGetBits(bs, 6);
822 :     READ_MARKER();
823 :     seconds = BitstreamGetBits(bs, 6);
824 : suxen_drol 1.22
825 :     DPRINTF(DPRINTF_HEADER, "time %ih%im%is", hours);
826 : Isibaar 1.1 }
827 : edgomez 1.14 BitstreamSkip(bs, 1); // closed_gov
828 :     BitstreamSkip(bs, 1); // broken_link
829 : suxen_drol 1.22
830 : edgomez 1.14 } else if (start_code == VOP_START_CODE) {
831 : suxen_drol 1.22
832 :     DPRINTF(DPRINTF_STARTCODE, "<vop>");
833 :    
834 : edgomez 1.14 BitstreamSkip(bs, 32); // vop_start_code
835 : Isibaar 1.1
836 : edgomez 1.14 coding_type = BitstreamGetBits(bs, 2); // vop_coding_type
837 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "coding_type %i", coding_type);
838 : Isibaar 1.1
839 : chenm001 1.9 // *************************** for decode B-frame time ***********************
840 : edgomez 1.14 while (BitstreamGetBit(bs) != 0) // time_base
841 : chenm001 1.9 time_incr++;
842 : edgomez 1.14
843 : Isibaar 1.1 READ_MARKER();
844 : edgomez 1.14
845 :     if (dec->time_inc_bits) {
846 : chenm001 1.9 time_increment = (BitstreamGetBits(bs, dec->time_inc_bits)); // vop_time_increment
847 :     }
848 : suxen_drol 1.19
849 : suxen_drol 1.22 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 1.28.2.5 coding_type == I_VOP ? 'I' : coding_type == P_VOP ? 'P' : coding_type == B_VOP ? 'B' : 'S',
854 : suxen_drol 1.19 time_incr, time_increment);
855 :    
856 : edgomez 1.14 if (coding_type != B_VOP) {
857 :     dec->last_time_base = dec->time_base;
858 : chenm001 1.9 dec->time_base += time_incr;
859 : chl 1.25 dec->time = time_increment;
860 :    
861 : suxen_drol 1.28.2.5 /* dec->time_base * dec->time_inc_resolution +
862 : edgomez 1.14 time_increment;
863 : chl 1.25 */ dec->time_pp = (uint32_t)
864 : suxen_drol 1.28.2.5 (dec->time_inc_resolution + dec->time - dec->last_non_b_time)%dec->time_inc_resolution;
865 : edgomez 1.14 dec->last_non_b_time = dec->time;
866 :     } else {
867 : chl 1.25 dec->time = time_increment;
868 :     /*
869 : edgomez 1.14 (dec->last_time_base +
870 : suxen_drol 1.28.2.5 time_incr) * dec->time_inc_resolution + time_increment;
871 : chl 1.25 */
872 : chl 1.24 dec->time_bp = (uint32_t)
873 : suxen_drol 1.28.2.5 (dec->time_inc_resolution + dec->last_non_b_time - dec->time)%dec->time_inc_resolution;
874 : Isibaar 1.1 }
875 :    
876 :     READ_MARKER();
877 :    
878 : edgomez 1.14 if (!BitstreamGetBit(bs)) // vop_coded
879 : Isibaar 1.1 {
880 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "vop_coded==false");
881 : Isibaar 1.1 return N_VOP;
882 :     }
883 :    
884 : suxen_drol 1.28.2.5 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 :    
899 :    
900 : Isibaar 1.1
901 : chenm001 1.9 // fix a little bug by MinChen <chenm002@163.com>
902 : edgomez 1.14 if ((dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY) &&
903 : suxen_drol 1.28.2.5 ( (coding_type == P_VOP) || (coding_type == S_VOP && dec->sprite_enable == SPRITE_GMC) ) ) {
904 : Isibaar 1.1 *rounding = BitstreamGetBit(bs); // rounding_type
905 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "rounding %i", *rounding);
906 : Isibaar 1.1 }
907 :    
908 : suxen_drol 1.28.2.5 if (dec->reduced_resolution_enable &&
909 :     dec->shape == VIDOBJLAY_SHAPE_RECTANGULAR &&
910 :     (coding_type == P_VOP || coding_type == I_VOP)) {
911 :    
912 :     *reduced_resolution = BitstreamGetBit(bs);
913 : suxen_drol 1.28.2.7 DPRINTF(DPRINTF_HEADER, "reduced_resolution %i", *reduced_resolution);
914 : suxen_drol 1.28.2.5 }
915 :     else
916 :     {
917 :     *reduced_resolution = 0;
918 :     }
919 : Isibaar 1.1
920 : edgomez 1.14 if (dec->shape != VIDOBJLAY_SHAPE_RECTANGULAR) {
921 : suxen_drol 1.28.2.5 if(!(dec->sprite_enable == SPRITE_STATIC && coding_type == I_VOP)) {
922 : edgomez 1.14
923 : suxen_drol 1.28.2.5 uint32_t width, height;
924 :     uint32_t horiz_mc_ref, vert_mc_ref;
925 : Isibaar 1.1
926 : suxen_drol 1.28.2.5 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 :    
935 :     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 : Isibaar 1.1
941 : edgomez 1.14 BitstreamSkip(bs, 1); // change_conv_ratio_disable
942 :     if (BitstreamGetBit(bs)) // vop_constant_alpha
943 : Isibaar 1.1 {
944 : edgomez 1.14 BitstreamSkip(bs, 8); // vop_constant_alpha_value
945 : Isibaar 1.1 }
946 :     }
947 :    
948 : edgomez 1.14 if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY) {
949 : suxen_drol 1.28.2.7
950 :     if (!dec->complexity_estimation_disable)
951 :     {
952 :     read_vop_complexity_estimation_header(bs, dec, coding_type);
953 :     }
954 :    
955 : Isibaar 1.1 // intra_dc_vlc_threshold
956 : edgomez 1.14 *intra_dc_threshold =
957 :     intra_dc_threshold_table[BitstreamGetBits(bs, 3)];
958 : Isibaar 1.1
959 : h 1.28.2.1 dec->top_field_first = 0;
960 :     dec->alternate_vertical_scan = 0;
961 :    
962 : edgomez 1.14 if (dec->interlacing) {
963 : suxen_drol 1.22 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 1.4 }
969 : Isibaar 1.1 }
970 : edgomez 1.14
971 : suxen_drol 1.28.2.5 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 1.14 if ((*quant = BitstreamGetBits(bs, dec->quant_bits)) < 1) // vop_quant
1015 : Isibaar 1.10 *quant = 1;
1016 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "quant %i", *quant);
1017 : edgomez 1.14
1018 :     if (coding_type != I_VOP) {
1019 :     *fcode_forward = BitstreamGetBits(bs, 3); // fcode_forward
1020 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "fcode_forward %i", *fcode_forward);
1021 : Isibaar 1.1 }
1022 : edgomez 1.14
1023 :     if (coding_type == B_VOP) {
1024 :     *fcode_backward = BitstreamGetBits(bs, 3); // fcode_backward
1025 : suxen_drol 1.22 DPRINTF(DPRINTF_HEADER, "fcode_backward %i", *fcode_backward);
1026 : chenm001 1.9 }
1027 : edgomez 1.14 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 1.9 }
1032 : Isibaar 1.1 }
1033 :     return coding_type;
1034 : suxen_drol 1.22
1035 : edgomez 1.14 } else if (start_code == USERDATA_START_CODE) {
1036 : Isibaar 1.28.2.6 char tmp[256];
1037 : suxen_drol 1.28.2.7 int i, version, build, packed;
1038 : suxen_drol 1.22
1039 : edgomez 1.14 BitstreamSkip(bs, 32); // user_data_start_code
1040 : suxen_drol 1.22
1041 : Isibaar 1.28.2.6 tmp[0] = BitstreamShowBits(bs, 8);
1042 :    
1043 :     for(i = 1; i < 256; i++){
1044 :     tmp[i] = (BitstreamShowBits(bs, 16) & 0xFF);
1045 :    
1046 :     if(tmp[i] == 0)
1047 :     break;
1048 :    
1049 :     BitstreamSkip(bs, 8);
1050 :     }
1051 :    
1052 :     DPRINTF(DPRINTF_STARTCODE, "<user_data>: %s\n", tmp);
1053 :    
1054 : suxen_drol 1.28.2.7 /* divx detection */
1055 :     i = sscanf(tmp, "DivX%dBuild%d%c", &version, &build, &packed);
1056 :     if (i < 2)
1057 :     i = sscanf(tmp, "DivX%db%d%c", &version, &build, &packed);
1058 :    
1059 :     if (i >= 2)
1060 :     {
1061 :     dec->packed_mode = (i == 3 && packed == 'p');
1062 :     DPRINTF(DPRINTF_HEADER, "divx version=%i, build=%i packed=%i",
1063 :     version, build, dec->packed_mode);
1064 : Isibaar 1.28.2.6 }
1065 : suxen_drol 1.28.2.7
1066 : edgomez 1.14 } else // start_code == ?
1067 : Isibaar 1.1 {
1068 : edgomez 1.14 if (BitstreamShowBits(bs, 24) == 0x000001) {
1069 : suxen_drol 1.22 DPRINTF(DPRINTF_STARTCODE, "<unknown: %x>", BitstreamShowBits(bs, 32));
1070 : Isibaar 1.1 }
1071 :     BitstreamSkip(bs, 8);
1072 :     }
1073 :     }
1074 :     while ((BitstreamPos(bs) >> 3) < bs->length);
1075 :    
1076 : suxen_drol 1.18 //DPRINTF("*** WARNING: no vop_start_code found");
1077 : edgomez 1.14 return -1; /* ignore it */
1078 : Isibaar 1.1 }
1079 :    
1080 :    
1081 :     /* write custom quant matrix */
1082 :    
1083 : edgomez 1.14 static void
1084 :     bs_put_matrix(Bitstream * bs,
1085 :     const int16_t * matrix)
1086 : Isibaar 1.1 {
1087 :     int i, j;
1088 :     const int last = matrix[scan_tables[0][63]];
1089 :    
1090 : suxen_drol 1.18 for (j = 63; j > 0 && matrix[scan_tables[0][j - 1]] == last; j--);
1091 : Isibaar 1.1
1092 : edgomez 1.14 for (i = 0; i <= j; i++) {
1093 : Isibaar 1.1 BitstreamPutBits(bs, matrix[scan_tables[0][i]], 8);
1094 :     }
1095 :    
1096 : edgomez 1.14 if (j < 63) {
1097 : Isibaar 1.1 BitstreamPutBits(bs, 0, 8);
1098 :     }
1099 :     }
1100 :    
1101 :    
1102 :     /*
1103 :     write vol header
1104 :     */
1105 : edgomez 1.14 void
1106 :     BitstreamWriteVolHeader(Bitstream * const bs,
1107 :     const MBParam * pParam,
1108 : chl 1.28.2.4 const FRAMEINFO * const frame)
1109 : Isibaar 1.1 {
1110 : chl 1.28.2.4 int vol_ver_id=1;
1111 :    
1112 :     if ( (pParam->m_quarterpel) || (frame->global_flags & XVID_GMC) )
1113 :     vol_ver_id = 2;
1114 :    
1115 : Isibaar 1.1 // video object_start_code & vo_id
1116 : edgomez 1.14 BitstreamPad(bs);
1117 : Isibaar 1.1 BitstreamPutBits(bs, VO_START_CODE, 27);
1118 : edgomez 1.14 BitstreamPutBits(bs, 0, 5);
1119 : Isibaar 1.1
1120 :     // video_object_layer_start_code & vol_id
1121 :     BitstreamPutBits(bs, VOL_START_CODE, 28);
1122 :     BitstreamPutBits(bs, 0, 4);
1123 :    
1124 : edgomez 1.14 BitstreamPutBit(bs, 0); // random_accessible_vol
1125 :     BitstreamPutBits(bs, 0, 8); // video_object_type_indication
1126 : Isibaar 1.28.2.3
1127 : chl 1.28.2.4 if (vol_ver_id == 1)
1128 : Isibaar 1.28.2.3 {
1129 :     BitstreamPutBit(bs, 0); // is_object_layer_identified (0=not given)
1130 :     }
1131 :     else
1132 :     {
1133 :     BitstreamPutBit(bs, 1); // is_object_layer_identified
1134 : chl 1.28.2.4 BitstreamPutBits(bs, vol_ver_id, 4); // vol_ver_id == 2
1135 :     BitstreamPutBits(bs, 4, 3); // vol_ver_priority (1==lowest, 7==highest) ??
1136 : Isibaar 1.28.2.3 }
1137 :    
1138 : edgomez 1.14 BitstreamPutBits(bs, 1, 4); // aspect_ratio_info (1=1:1)
1139 : suxen_drol 1.12
1140 : chl 1.28 BitstreamPutBit(bs, 1); // vol_control_parameters
1141 :     BitstreamPutBits(bs, 1, 2); // chroma_format 1="4:2:0"
1142 :    
1143 : edgomez 1.14 if (pParam->max_bframes > 0) {
1144 :     BitstreamPutBit(bs, 0); // low_delay
1145 :     } else
1146 : suxen_drol 1.12 {
1147 : chl 1.27 BitstreamPutBit(bs, 1); // low_delay
1148 : suxen_drol 1.12 }
1149 : chl 1.28 BitstreamPutBit(bs, 0); // vbv_parameters (0=not given)
1150 : suxen_drol 1.12
1151 : edgomez 1.14 BitstreamPutBits(bs, 0, 2); // video_object_layer_shape (0=rectangular)
1152 : Isibaar 1.1
1153 :     WRITE_MARKER();
1154 : edgomez 1.14
1155 : suxen_drol 1.28.2.5 /* time_inc_resolution; ignored by current decore versions
1156 : edgomez 1.14 eg. 2fps res=2 inc=1
1157 :     25fps res=25 inc=1
1158 :     29.97fps res=30000 inc=1001
1159 :     */
1160 : chl 1.28 BitstreamPutBits(bs, pParam->fbase, 16);
1161 : Isibaar 1.1
1162 :     WRITE_MARKER();
1163 :    
1164 : suxen_drol 1.20 BitstreamPutBit(bs, 1); // fixed_vop_rate = 1
1165 :     BitstreamPutBits(bs, pParam->fincr, log2bin(pParam->fbase)); // fixed_vop_time_increment
1166 : Isibaar 1.1
1167 :     WRITE_MARKER();
1168 : edgomez 1.14 BitstreamPutBits(bs, pParam->width, 13); // width
1169 : Isibaar 1.1 WRITE_MARKER();
1170 : edgomez 1.14 BitstreamPutBits(bs, pParam->height, 13); // height
1171 : Isibaar 1.1 WRITE_MARKER();
1172 : edgomez 1.14
1173 :     BitstreamPutBit(bs, frame->global_flags & XVID_INTERLACING); // interlace
1174 : Isibaar 1.1 BitstreamPutBit(bs, 1); // obmc_disable (overlapped block motion compensation)
1175 : Isibaar 1.28.2.3
1176 : chl 1.28.2.4 if (vol_ver_id != 1)
1177 :     { if (frame->global_flags & XVID_GMC)
1178 :     { BitstreamPutBits(bs, 2, 2); // sprite_enable=='GMC'
1179 :     BitstreamPutBits(bs, 2, 6); // no_of_sprite_warping_points
1180 :     BitstreamPutBits(bs, 3, 2); // sprite_warping_accuracy 0==1/2, 1=1/4, 2=1/8, 3=1/16
1181 :     BitstreamPutBit(bs, 0); // sprite_brightness_change (not supported)
1182 :    
1183 :     /* currently we use no_of_sprite_warping_points==2, sprite_warping_accuracy==3
1184 :     for DivX5 compatability */
1185 :    
1186 :     } else
1187 :     BitstreamPutBits(bs, 0, 2); // sprite_enable==off
1188 : Isibaar 1.28.2.3 }
1189 :     else
1190 : chl 1.28.2.4 BitstreamPutBit(bs, 0); // sprite_enable==off
1191 : Isibaar 1.28.2.3
1192 : chl 1.28.2.4 BitstreamPutBit(bs, 0); // not_8_bit
1193 : Isibaar 1.1
1194 :     // quant_type 0=h.263 1=mpeg4(quantizer tables)
1195 : suxen_drol 1.7 BitstreamPutBit(bs, pParam->m_quant_type);
1196 : edgomez 1.14
1197 :     if (pParam->m_quant_type) {
1198 : Isibaar 1.2 BitstreamPutBit(bs, get_intra_matrix_status()); // load_intra_quant_mat
1199 : edgomez 1.14 if (get_intra_matrix_status()) {
1200 : Isibaar 1.2 bs_put_matrix(bs, get_intra_matrix());
1201 : Isibaar 1.1 }
1202 :    
1203 : edgomez 1.14 BitstreamPutBit(bs, get_inter_matrix_status()); // load_inter_quant_mat
1204 :     if (get_inter_matrix_status()) {
1205 : Isibaar 1.2 bs_put_matrix(bs, get_inter_matrix());
1206 : Isibaar 1.1 }
1207 :    
1208 :     }
1209 :    
1210 : chl 1.28.2.4 if (vol_ver_id != 1) {
1211 :     if (pParam->m_quarterpel)
1212 :     BitstreamPutBit(bs, 1); // quarterpel
1213 :     else
1214 :     BitstreamPutBit(bs, 0); // no quarterpel
1215 : Isibaar 1.28.2.3 }
1216 :    
1217 : Isibaar 1.1 BitstreamPutBit(bs, 1); // complexity_estimation_disable
1218 :     BitstreamPutBit(bs, 1); // resync_marker_disable
1219 :     BitstreamPutBit(bs, 0); // data_partitioned
1220 : Isibaar 1.28.2.3
1221 : chl 1.28.2.4 if (vol_ver_id != 1)
1222 : Isibaar 1.28.2.3 {
1223 :     BitstreamPutBit(bs, 0); // newpred_enable
1224 :     BitstreamPutBit(bs, 0); // reduced_resolution_vop_enabled
1225 :     }
1226 : chl 1.28.2.4
1227 : Isibaar 1.1 BitstreamPutBit(bs, 0); // scalability
1228 : chl 1.28.2.4
1229 : Isibaar 1.1 }
1230 :    
1231 :    
1232 :     /*
1233 :     write vop header
1234 :     */
1235 : edgomez 1.14 void
1236 :     BitstreamWriteVopHeader(Bitstream * const bs,
1237 :     const MBParam * pParam,
1238 : chl 1.28.2.4 const FRAMEINFO * const frame,
1239 : suxen_drol 1.17 int vop_coded)
1240 : Isibaar 1.1 {
1241 : suxen_drol 1.8 uint32_t i;
1242 : chl 1.28
1243 : edgomez 1.14 BitstreamPad(bs);
1244 :     BitstreamPutBits(bs, VOP_START_CODE, 32);
1245 :    
1246 :     BitstreamPutBits(bs, frame->coding_type, 2);
1247 : suxen_drol 1.28.2.5 DPRINTF(DPRINTF_HEADER, "coding_type = %i", frame->coding_type);
1248 : Isibaar 1.1
1249 : edgomez 1.14 for (i = 0; i < frame->seconds; i++) {
1250 : suxen_drol 1.8 BitstreamPutBit(bs, 1);
1251 :     }
1252 :     BitstreamPutBit(bs, 0);
1253 : Isibaar 1.1
1254 :     WRITE_MARKER();
1255 :    
1256 :     // time_increment: value=nth_of_sec, nbits = log2(resolution)
1257 : chl 1.28.2.4
1258 : edgomez 1.14 BitstreamPutBits(bs, frame->ticks, log2bin(pParam->fbase));
1259 : suxen_drol 1.28.2.5 /*DPRINTF("[%i:%i] %c", frame->seconds, frame->ticks,
1260 : edgomez 1.14 frame->coding_type == I_VOP ? 'I' : frame->coding_type ==
1261 : suxen_drol 1.22 P_VOP ? 'P' : 'B');*/
1262 : Isibaar 1.1
1263 :     WRITE_MARKER();
1264 :    
1265 : suxen_drol 1.17 if (!vop_coded) {
1266 :     BitstreamPutBits(bs, 0, 1);
1267 :     return;
1268 :     }
1269 :    
1270 : edgomez 1.14 BitstreamPutBits(bs, 1, 1); // vop_coded
1271 : Isibaar 1.1
1272 : chl 1.28.2.4 if ( (frame->coding_type == P_VOP) || (frame->coding_type == S_VOP) )
1273 : suxen_drol 1.7 BitstreamPutBits(bs, frame->rounding_type, 1);
1274 : Isibaar 1.1
1275 : edgomez 1.14 BitstreamPutBits(bs, 0, 3); // intra_dc_vlc_threshold
1276 :    
1277 :     if (frame->global_flags & XVID_INTERLACING) {
1278 : h 1.28.2.1 BitstreamPutBit(bs, (frame->global_flags & XVID_TOPFIELDFIRST));
1279 :     BitstreamPutBit(bs, (frame->global_flags & XVID_ALTERNATESCAN));
1280 : h 1.4 }
1281 : chl 1.28.2.4
1282 :     if (frame->coding_type == S_VOP) {
1283 :     if (1) { // no_of_sprite_warping_points>=1
1284 :     if (pParam->m_quarterpel)
1285 :     bs_put_spritetrajectory(bs, frame->GMC_MV.x/2 ); // du[0]
1286 :     else
1287 :     bs_put_spritetrajectory(bs, frame->GMC_MV.x ); // du[0]
1288 :     WRITE_MARKER();
1289 :    
1290 :     if (pParam->m_quarterpel)
1291 :     bs_put_spritetrajectory(bs, frame->GMC_MV.y/2 ); // dv[0]
1292 :     else
1293 :     bs_put_spritetrajectory(bs, frame->GMC_MV.y ); // dv[0]
1294 :     WRITE_MARKER();
1295 : suxen_drol 1.28.2.5
1296 :    
1297 :     if (pParam->m_quarterpel)
1298 :     {
1299 :     DPRINTF(DPRINTF_HEADER,"sprite_warping_point[%i] xy=(%i,%i) *QPEL*", 0, frame->GMC_MV.x/2, frame->GMC_MV.y/2);
1300 :     }
1301 :     else
1302 :     {
1303 :     DPRINTF(DPRINTF_HEADER,"sprite_warping_point[%i] xy=(%i,%i)", 0, frame->GMC_MV.x, frame->GMC_MV.y);
1304 :     }
1305 :    
1306 : chl 1.28.2.4 }
1307 :     /* GMC is halfpel in bitstream, even though GMC_MV was pseudo-qpel (2*halfpel) */
1308 : h 1.4
1309 : chl 1.28.2.4 if (2) { // no_of_sprite_warping_points>=2 (for DivX5 compat)
1310 :     bs_put_spritetrajectory(bs, 0 );
1311 :     WRITE_MARKER();
1312 :     bs_put_spritetrajectory(bs, 0 );
1313 :     WRITE_MARKER();
1314 :     }
1315 :     // no support for brightness_change!
1316 :     }
1317 :    
1318 : suxen_drol 1.28.2.7
1319 :     DPRINTF(DPRINTF_HEADER, "quant = %i", frame->quant);
1320 :    
1321 : edgomez 1.14 BitstreamPutBits(bs, frame->quant, 5); // quantizer
1322 :    
1323 : suxen_drol 1.7 if (frame->coding_type != I_VOP)
1324 : edgomez 1.14 BitstreamPutBits(bs, frame->fcode, 3); // forward_fixed_code
1325 : suxen_drol 1.8
1326 :     if (frame->coding_type == B_VOP)
1327 : edgomez 1.14 BitstreamPutBits(bs, frame->bcode, 3); // backward_fixed_code
1328 : suxen_drol 1.8
1329 : Isibaar 1.1 }
1330 : suxen_drol 1.17
1331 :     void
1332 :     BitstreamWriteUserData(Bitstream * const bs,
1333 :     uint8_t * data,
1334 :     const int length)
1335 :     {
1336 :     int i;
1337 :    
1338 :     BitstreamPad(bs);
1339 :     BitstreamPutBits(bs, USERDATA_START_CODE, 32);
1340 :    
1341 :     for (i = 0; i < length; i++) {
1342 :     BitstreamPutBits(bs, data[i], 8);
1343 :     }
1344 :    
1345 : chl 1.24 }

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