1 /*****************************************************************************
2 * vpar_headers.c : headers parsing
4 *****************************************************************************/
6 /*****************************************************************************
8 *****************************************************************************/
16 #include <X11/extensions/XShm.h>
21 #include "vlc_thread.h"
24 #include "debug.h" /* ?? temporaire, requis par netlist.h */
27 #include "input_netlist.h"
28 #include "decoder_fifo.h"
30 #include "video_output.h"
32 #include "vdec_idct.h"
33 #include "video_decoder.h"
34 #include "vdec_motion.h"
36 #include "vpar_blocks.h"
37 #include "vpar_headers.h"
38 #include "video_fifo.h"
39 #include "vpar_synchro.h"
40 #include "video_parser.h"
41 #include "vpar_motion.h"
46 static __inline__ void NextStartCode( vpar_thread_t * p_vpar );
47 static void SequenceHeader( vpar_thread_t * p_vpar );
48 static void GroupHeader( vpar_thread_t * p_vpar );
49 static void PictureHeader( vpar_thread_t * p_vpar );
50 static void SliceHeader00( vpar_thread_t * p_vpar,
51 int * pi_mb_address, int i_mb_base,
53 static void SliceHeader01( vpar_thread_t * p_vpar,
54 int * pi_mb_address, int i_mb_base,
56 static void SliceHeader10( vpar_thread_t * p_vpar,
57 int * pi_mb_address, int i_mb_base,
59 static void SliceHeader11( vpar_thread_t * p_vpar,
60 int * pi_mb_address, int i_mb_base,
62 static __inline__ void SliceHeader( vpar_thread_t * p_vpar,
63 int * pi_mb_address, int i_mb_base,
65 static void ExtensionAndUserData( vpar_thread_t * p_vpar );
66 static void QuantMatrixExtension( vpar_thread_t * p_vpar );
67 static void SequenceScalableExtension( vpar_thread_t * p_vpar );
68 static void SequenceDisplayExtension( vpar_thread_t * p_vpar );
69 static void PictureDisplayExtension( vpar_thread_t * p_vpar );
70 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar );
71 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar );
72 static void CopyrightExtension( vpar_thread_t * p_vpar );
78 /*****************************************************************************
79 * pi_default_intra_quant : default quantization matrix
80 *****************************************************************************/
82 int pi_default_intra_quant[] =
84 8, 16, 19, 22, 26, 27, 29, 34,
85 16, 16, 22, 24, 27, 29, 34, 37,
86 19, 22, 26, 27, 29, 34, 34, 38,
87 22, 22, 26, 27, 29, 34, 37, 40,
88 22, 26, 27, 29, 32, 35, 40, 48,
89 26, 27, 29, 32, 35, 40, 48, 58,
90 26, 27, 29, 34, 38, 46, 56, 69,
91 27, 29, 35, 38, 46, 56, 69, 83
94 int pi_default_intra_quant[] =
96 2048, 5681, 6355, 6623, 6656, 5431, 4018, 2401,
97 5681, 7880, 10207, 10021, 9587, 8091, 6534, 3625,
98 6355, 10207, 11363, 10619, 9700, 8935, 6155, 3507,
99 6623, 9186, 10226, 9557, 8730, 8041, 6028, 3322,
100 5632, 9232, 9031, 8730, 8192, 7040, 5542, 3390,
101 5230, 7533, 7621, 7568, 7040, 6321, 5225, 3219,
102 3602, 5189, 5250, 5539, 5265, 5007, 4199, 2638,
103 1907, 2841, 3230, 3156, 3249, 3108, 2638, 1617
107 /*****************************************************************************
108 * pi_default_nonintra_quant : default quantization matrix
109 *****************************************************************************/
111 int pi_default_nonintra_quant[] =
113 16, 16, 16, 16, 16, 16, 16, 16,
114 16, 16, 16, 16, 16, 16, 16, 16,
115 16, 16, 16, 16, 16, 16, 16, 16,
116 16, 16, 16, 16, 16, 16, 16, 16,
117 16, 16, 16, 16, 16, 16, 16, 16,
118 16, 16, 16, 16, 16, 16, 16, 16,
119 16, 16, 16, 16, 16, 16, 16, 16,
120 16, 16, 16, 16, 16, 16, 16, 16
123 int pi_default_nonintra_quanit[] =
125 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
126 5680, 7888, 7424, 6688, 5680, 4464, 3072, 1568,
127 5344, 7424, 6992, 6288, 5344, 4208, 2896, 1472,
128 4816, 6688, 6288, 5664, 4816, 3792, 2608, 1328,
129 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
130 3216, 4464, 4208, 3792, 3216, 2528, 1744, 880,
131 2224, 3072, 2896, 2608, 2224, 1744, 1200, 608,
132 1136, 1568, 1472, 1328, 1136, 880, 608, 304
136 /*****************************************************************************
137 * pi_scan : zig-zag and alternate scan patterns
138 *****************************************************************************/
141 { /* Zig-Zag pattern */
142 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
143 12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
144 35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
145 58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
147 { /* Alternate scan pattern */
148 0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
149 41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
150 51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
151 53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
156 * Local inline functions.
159 /*****************************************************************************
160 * NextStartCode : Find the next start code
161 *****************************************************************************/
162 static __inline__ void NextStartCode( vpar_thread_t * p_vpar )
164 /* Re-align the buffer on an 8-bit boundary */
165 RealignBits( &p_vpar->bit_stream );
167 while( ShowBits( &p_vpar->bit_stream, 24 ) != 0x01L && !p_vpar->b_die )
169 RemoveBits( &p_vpar->bit_stream, 8 );
173 /*****************************************************************************
174 * ReferenceUpdate : Update the reference pointers when we have a new picture
175 *****************************************************************************/
176 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
178 picture_t * p_newref )
180 if( i_coding_type != B_CODING_TYPE )
182 if( p_vpar->sequence.p_forward != NULL )
183 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
184 p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
185 p_vpar->sequence.p_backward = p_newref;
186 if( p_newref != NULL )
187 vout_LinkPicture( p_vpar->p_vout, p_newref );
191 /*****************************************************************************
192 * ReferenceReplace : Replace the last reference pointer when we destroy
194 *****************************************************************************/
195 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
197 picture_t * p_newref )
199 if( i_coding_type != B_CODING_TYPE )
201 if( p_vpar->sequence.p_backward != NULL )
202 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
203 p_vpar->sequence.p_backward = p_newref;
204 if( p_newref != NULL )
205 vout_LinkPicture( p_vpar->p_vout, p_newref );
209 /*****************************************************************************
210 * LoadMatrix : Load a quantization matrix
211 *****************************************************************************/
212 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar, quant_matrix_t * p_matrix )
216 if( !p_matrix->b_allocated )
218 /* Allocate a piece of memory to load the matrix. */
219 p_matrix->pi_matrix = (int *)malloc( 64*sizeof(int) );
220 p_matrix->b_allocated = 1;
223 for( i_dummy = 0; i_dummy < 64; i_dummy++ )
225 p_matrix->pi_matrix[pi_scan[SCAN_ZIGZAG][i_dummy]]
226 = GetBits( &p_vpar->bit_stream, 8 );
230 /* Discrete Fourier Transform requires the quantization matrices to
231 * be normalized before using them. */
232 vdec_NormQuantMatrix( p_matrix->pi_matrix );
236 /*****************************************************************************
237 * LinkMatrix : Link a quantization matrix to another
238 *****************************************************************************/
239 static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, int * pi_array )
241 if( p_matrix->b_allocated )
243 /* Deallocate the piece of memory. */
244 free( p_matrix->pi_matrix );
245 p_matrix->b_allocated = 0;
248 p_matrix->pi_matrix = pi_array;
252 * Exported functions.
255 /*****************************************************************************
256 * vpar_NextSequenceHeader : Find the next sequence header
257 *****************************************************************************/
258 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
260 while( !p_vpar->b_die )
262 NextStartCode( p_vpar );
263 if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
265 RemoveBits( &p_vpar->bit_stream, 8 );
270 /*****************************************************************************
271 * vpar_ParseHeader : Parse the next header
272 *****************************************************************************/
273 int vpar_ParseHeader( vpar_thread_t * p_vpar )
275 while( !p_vpar->b_die )
277 NextStartCode( p_vpar );
278 switch( GetBits32( &p_vpar->bit_stream ) )
280 case SEQUENCE_HEADER_CODE:
281 SequenceHeader( p_vpar );
285 case GROUP_START_CODE:
286 GroupHeader( p_vpar );
290 case PICTURE_START_CODE:
291 PictureHeader( p_vpar );
295 case SEQUENCE_END_CODE:
296 intf_DbgMsg("vpar debug: sequence end code received\n");
308 * Following functions are local
311 /*****************************************************************************
312 * SequenceHeader : Parse the next sequence header
313 *****************************************************************************/
314 static void SequenceHeader( vpar_thread_t * p_vpar )
317 static float r_frame_rate_table[16] =
320 ((23.0*1000.0)/1001.0),
323 ((30.0*1000.0)/1001.0),
326 ((60.0*1000.0)/1001.0),
328 RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
332 int i_height_save, i_width_save;
334 i_height_save = p_vpar->sequence.i_height;
335 i_width_save = p_vpar->sequence.i_width;
337 p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
338 p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
339 p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
340 p_vpar->sequence.r_frame_rate =
341 r_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
343 /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
344 * constrained_parameters_flag */
345 RemoveBits( &p_vpar->bit_stream, 30 );
348 * Quantization matrices
350 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
352 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
356 /* Use default matrix. */
357 LinkMatrix( &p_vpar->sequence.intra_quant, pi_default_intra_quant );
360 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
362 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
366 /* Use default matrix. */
367 LinkMatrix( &p_vpar->sequence.nonintra_quant, pi_default_nonintra_quant );
370 /* Unless later overwritten by a matrix extension, we have the same
371 * matrices for luminance and chrominance. */
372 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
373 p_vpar->sequence.intra_quant.pi_matrix );
374 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
375 p_vpar->sequence.nonintra_quant.pi_matrix );
380 NextStartCode( p_vpar );
381 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
384 static f_chroma_pattern_t ppf_chroma_pattern[4] =
385 {NULL, vpar_CodedPattern420,
386 vpar_CodedPattern422, vpar_CodedPattern444};
388 /* Turn the MPEG2 flag on */
389 p_vpar->sequence.b_mpeg2 = 1;
391 /* Parse sequence_extension */
392 RemoveBits32( &p_vpar->bit_stream );
393 /* extension_start_code_identifier, profile_and_level_indication */
394 RemoveBits( &p_vpar->bit_stream, 12 );
395 p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
396 p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
397 p_vpar->sequence.pf_decode_pattern = ppf_chroma_pattern
398 [p_vpar->sequence.i_chroma_format];
399 p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
400 p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
401 /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
402 RemoveBits( &p_vpar->bit_stream, 22 );
403 /* frame_rate_extension_n */
404 i_dummy = GetBits( &p_vpar->bit_stream, 2 );
405 /* frame_rate_extension_d */
406 p_vpar->sequence.r_frame_rate *= (i_dummy + 1)
407 / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
409 p_vpar->sequence.pf_decode_mv = vpar_MPEG2MotionVector;
413 /* It's an MPEG-1 stream. Put adequate parameters. */
415 p_vpar->sequence.b_mpeg2 = 0;
416 p_vpar->sequence.b_progressive = 1;
417 p_vpar->sequence.i_chroma_format = CHROMA_420;
418 p_vpar->sequence.pf_decode_pattern = vpar_CodedPattern420;
420 p_vpar->sequence.pf_decode_mv = vpar_MPEG1MotionVector;
424 p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
425 p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
426 (p_vpar->sequence.i_height + 15) / 16 :
427 2 * ((p_vpar->sequence.i_height + 31) / 32);
428 p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
429 * p_vpar->sequence.i_mb_height;
430 p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
431 p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
432 p_vpar->sequence.i_size = p_vpar->sequence.i_width
433 * p_vpar->sequence.i_height;
435 /* Update chromatic information */
436 switch( p_vpar->sequence.i_chroma_format )
439 p_vpar->sequence.i_chroma_nb_blocks = 2;
440 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
441 p_vpar->sequence.i_chroma_mb_width = 8;
442 p_vpar->sequence.i_chroma_mb_height = 8;
446 p_vpar->sequence.i_chroma_nb_blocks = 4;
447 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
448 p_vpar->sequence.i_chroma_mb_width = 8;
449 p_vpar->sequence.i_chroma_mb_height = 16;
453 p_vpar->sequence.i_chroma_nb_blocks = 8;
454 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
455 p_vpar->sequence.i_chroma_mb_width = 16;
456 p_vpar->sequence.i_chroma_mb_height = 16;
459 /* Slice Header functions */
460 if( p_vpar->sequence.i_height <= 2800 )
462 if( p_vpar->sequence.i_scalable_mode != SC_DP )
464 p_vpar->sequence.pf_slice_header = SliceHeader00;
468 p_vpar->sequence.pf_slice_header = SliceHeader01;
473 if( p_vpar->sequence.i_scalable_mode != SC_DP )
475 p_vpar->sequence.pf_slice_header = SliceHeader10;
479 p_vpar->sequence.pf_slice_header = SliceHeader11;
483 if( p_vpar->sequence.i_width != i_width_save
484 || p_vpar->sequence.i_height != i_height_save )
486 /* What do we do in case of a size change ??? */
489 /* Extension and User data */
490 ExtensionAndUserData( p_vpar );
493 /*****************************************************************************
494 * GroupHeader : Parse the next group of pictures header
495 *****************************************************************************/
496 static void GroupHeader( vpar_thread_t * p_vpar )
498 /* Nothing to do, we don't care. */
499 RemoveBits( &p_vpar->bit_stream, 27 );
500 ExtensionAndUserData( p_vpar );
503 /*****************************************************************************
504 * PictureHeader : Parse the next picture header
505 *****************************************************************************/
506 static void PictureHeader( vpar_thread_t * p_vpar )
508 static f_macroblock_type_t ppf_macroblock_type[5] = {NULL,
509 vpar_IMBType, vpar_PMBType,
510 vpar_BMBType, vpar_DMBType};
513 int i_mb_address, i_mb_base, i_mb;
514 boolean_t b_parsable;
517 RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
518 p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
519 p_vpar->picture.pf_macroblock_type = ppf_macroblock_type
520 [p_vpar->picture.i_coding_type];
521 RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
523 if( p_vpar->picture.i_coding_type == P_CODING_TYPE || p_vpar->picture.i_coding_type == B_CODING_TYPE )
525 p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
526 p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
528 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
530 p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
531 p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
534 /* extra_information_picture */
535 while( GetBits( &p_vpar->bit_stream, 1 ) )
537 RemoveBits( &p_vpar->bit_stream, 8 );
541 * Picture Coding Extension
543 NextStartCode( p_vpar );
544 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
546 /* Parse picture_coding_extension */
547 RemoveBits32( &p_vpar->bit_stream );
548 /* extension_start_code_identifier */
549 RemoveBits( &p_vpar->bit_stream, 4 );
551 p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
552 p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
553 p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
554 p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
555 p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
556 i_structure = GetBits( &p_vpar->bit_stream, 2 );
557 p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
558 p_vpar->picture.b_frame_pred_frame_dct
559 = GetBits( &p_vpar->bit_stream, 1 );
560 p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
561 p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
562 p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
563 p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
564 p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
565 /* repeat_first_field (ISO/IEC 13818-2 6.3.10 is necessary to know
566 * the length of the picture_display_extension structure.
567 * chroma_420_type (obsolete) */
568 RemoveBits( &p_vpar->bit_stream, 1 );
569 p_vpar->picture.b_progressive_frame = GetBits( &p_vpar->bit_stream, 1 );
571 /* composite_display_flag */
572 if( GetBits( &p_vpar->bit_stream, 1 ) )
574 /* v_axis, field_sequence, sub_carrier, burst_amplitude,
575 * sub_carrier_phase */
576 RemoveBits( &p_vpar->bit_stream, 20 );
581 /* MPEG-1 compatibility flags */
582 p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
583 i_structure = FRAME_STRUCTURE;
584 p_vpar->picture.b_frame_pred_frame_dct = 1;
585 p_vpar->picture.b_concealment_mv = 0;
586 p_vpar->picture.b_q_scale_type = 0;
587 p_vpar->picture.b_intra_vlc_format = 0;
588 p_vpar->picture.b_alternate_scan = 0; /* zigzag */
589 p_vpar->picture.b_repeat_first_field = 0;
590 p_vpar->picture.b_progressive_frame = 1;
593 if( p_vpar->picture.i_current_structure &&
594 (i_structure == FRAME_STRUCTURE ||
595 i_structure == p_vpar->picture.i_current_structure) )
597 /* We don't have the second field of the buffered frame. */
598 if( p_vpar->picture.p_picture != NULL )
600 ReferenceReplace( p_vpar,
601 p_vpar->picture.i_coding_type,
604 for( i_mb = 0; i_mb < p_vpar->sequence.i_mb_size >> 1; i_mb++ )
606 vpar_DestroyMacroblock( &p_vpar->vfifo,
607 p_vpar->picture.pp_mb[i_mb] );
609 vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
612 p_vpar->picture.i_current_structure = 0;
614 intf_DbgMsg("vpar debug: odd number of field picture.\n");
617 /* Do we have the reference pictures ? */
618 b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
619 (p_vpar->sequence.p_backward == NULL)) ||
620 /* p_backward will become p_forward later */
621 ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
622 (p_vpar->sequence.p_forward == NULL ||
623 p_vpar->sequence.p_backward == NULL)));
627 if( p_vpar->picture.i_current_structure )
629 /* Second field of a frame. We will decode it if, and only if we
630 * have decoded the first frame. */
631 b_parsable = (p_vpar->picture.p_picture != NULL);
635 /* Does synchro say we have enough time to decode it ? */
636 b_parsable = vpar_SynchroChoose( p_vpar,
637 p_vpar->picture.i_coding_type, i_structure );
643 /* Update the reference pointers. */
644 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
646 /* Warn Synchro we have trashed a picture. */
647 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
649 /* Update context. */
650 if( i_structure != FRAME_STRUCTURE )
651 p_vpar->picture.i_current_structure = i_structure;
652 p_vpar->picture.p_picture = NULL;
657 /* OK, now we are sure we will decode the picture. */
658 #define P_picture p_vpar->picture.p_picture
659 p_vpar->picture.b_error = 0;
661 if( !p_vpar->picture.i_current_structure )
663 /* This is a new frame. Get a structure from the video_output. */
664 while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
665 99+p_vpar->sequence.i_chroma_format, /*???*/
666 p_vpar->sequence.i_width,
667 p_vpar->sequence.i_height ) )
670 intf_ErrMsg("vpar debug: allocation error in vout_CreatePicture\n");
675 mwait( VPAR_IDLE_SLEEP );
678 /* Initialize values. */
679 P_picture->date = vpar_SynchroDecode( p_vpar,
680 p_vpar->picture.i_coding_type,
682 P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
683 P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
684 p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
685 << ( 1 - p_vpar->picture.b_frame_structure ) );
686 p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
687 << ( 1 - p_vpar->picture.b_frame_structure ));
689 P_picture->i_deccount = p_vpar->sequence.i_mb_size;
690 memset( p_vpar->picture.pp_mb, 0, MAX_MB );
691 memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
693 /* Update the reference pointers. */
694 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
696 p_vpar->picture.i_current_structure |= i_structure;
697 p_vpar->picture.i_structure = i_structure;
698 p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
700 /* Initialize picture data for decoding. */
701 if( i_structure == BOTTOM_FIELD )
703 i_mb_base = p_vpar->sequence.i_mb_size >> 1;
704 p_vpar->mb.i_l_y = 1;
705 p_vpar->mb.i_c_y = 1;
710 p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
713 p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
715 /* Extension and User data. */
716 ExtensionAndUserData( p_vpar );
718 /* Picture data (ISO/IEC 13818-2 6.2.3.7). */
719 NextStartCode( p_vpar );
720 while( i_mb_address+i_mb_base < p_vpar->sequence.i_mb_size
721 && !p_vpar->picture.b_error && !p_vpar->b_die )
723 if( ((i_dummy = ShowBits( &p_vpar->bit_stream, 32 ))
724 < SLICE_START_CODE_MIN) ||
725 (i_dummy > SLICE_START_CODE_MAX) )
727 intf_DbgMsg("vpar debug: premature end of picture\n");
728 p_vpar->picture.b_error = 1;
731 RemoveBits32( &p_vpar->bit_stream );
733 /* Decode slice data. */
734 p_vpar->sequence.pf_slice_header( p_vpar, &i_mb_address, i_mb_base, i_dummy & 255 );
737 if( p_vpar->picture.b_error )
740 fprintf(stderr, "Image trashee\n");
741 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb]; i_mb++ )
743 vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
745 vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
747 ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
749 /* Prepare context for the next picture. */
751 if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
752 p_vpar->picture.i_current_structure = 0;
754 else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
756 fprintf(stderr, "Image parsee (%d)\n", p_vpar->picture.i_coding_type);
757 /* Frame completely parsed. */
758 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb]; i_mb++ )
760 vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
763 /* Link referenced pictures for the decoder
764 * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
765 if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
766 p_vpar->picture.i_coding_type == B_CODING_TYPE )
768 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
770 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
772 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
775 /* Send signal to the video_decoder. */
776 vlc_mutex_lock( &p_vpar->vfifo.lock );
777 vlc_cond_signal( &p_vpar->vfifo.wait );
778 vlc_mutex_unlock( &p_vpar->vfifo.lock );
780 /* Prepare context for the next picture. */
782 p_vpar->picture.i_current_structure = 0;
787 /*****************************************************************************
788 * SliceHeader : Parse the next slice structure
789 *****************************************************************************/
790 static __inline__ void SliceHeader( vpar_thread_t * p_vpar,
791 int * pi_mb_address, int i_mb_base,
794 /* DC predictors initialization table */
795 static int pi_dc_dct_reinit[4] = {128,256,512,1024};
797 int i_mb_address_save = *pi_mb_address;
799 /* slice_vertical_position_extension and priority_breakpoint already done */
800 LoadQuantizerScale( p_vpar );
802 if( GetBits( &p_vpar->bit_stream, 1 ) )
804 /* intra_slice, slice_id */
805 RemoveBits( &p_vpar->bit_stream, 8 );
806 /* extra_information_slice */
807 while( GetBits( &p_vpar->bit_stream, 1 ) )
809 RemoveBits( &p_vpar->bit_stream, 8 );
812 *pi_mb_address = (i_vert_code - 1)*p_vpar->sequence.i_mb_width;
814 /* Reset DC coefficients predictors (ISO/IEC 13818-2 7.2.1). Why
815 * does the reference decoder put 0 instead of the normative values ? */
816 p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
817 = p_vpar->slice.pi_dc_dct_pred[2]
818 = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
820 /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
821 memset( p_vpar->slice.pppi_pmv, 0, 8*sizeof(int) );
825 vpar_ParseMacroblock( p_vpar, pi_mb_address, i_mb_address_save,
827 i_mb_address_save = *pi_mb_address;
829 while( ShowBits( &p_vpar->bit_stream, 23 ) && !p_vpar->b_die );
830 NextStartCode( p_vpar );
833 /*****************************************************************************
834 * SliceHeaderXY : Parse the next slice structure
835 *****************************************************************************
836 * X = i_height > 2800 ?
837 * Y = scalable_mode == SC_DP ?
838 *****************************************************************************/
839 static void SliceHeader00( vpar_thread_t * p_vpar,
840 int * pi_mb_address, int i_mb_base,
843 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
846 static void SliceHeader01( vpar_thread_t * p_vpar,
847 int * pi_mb_address, int i_mb_base,
850 RemoveBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
851 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
854 static void SliceHeader10( vpar_thread_t * p_vpar,
855 int * pi_mb_address, int i_mb_base,
858 i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
859 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
862 static void SliceHeader11( vpar_thread_t * p_vpar,
863 int * pi_mb_address, int i_mb_base,
866 i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
867 RemoveBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
868 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
871 /*****************************************************************************
872 * ExtensionAndUserData : Parse the extension_and_user_data structure
873 *****************************************************************************/
874 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
876 while( !p_vpar->b_die )
878 NextStartCode( p_vpar );
879 switch( ShowBits( &p_vpar->bit_stream, 32 ) )
881 case EXTENSION_START_CODE:
882 RemoveBits32( &p_vpar->bit_stream );
883 switch( GetBits( &p_vpar->bit_stream, 4 ) )
885 case SEQUENCE_DISPLAY_EXTENSION_ID:
886 SequenceDisplayExtension( p_vpar );
888 case QUANT_MATRIX_EXTENSION_ID:
889 QuantMatrixExtension( p_vpar );
891 case SEQUENCE_SCALABLE_EXTENSION_ID:
892 SequenceScalableExtension( p_vpar );
894 case PICTURE_DISPLAY_EXTENSION_ID:
895 PictureDisplayExtension( p_vpar );
897 case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
898 PictureSpatialScalableExtension( p_vpar );
900 case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
901 PictureTemporalScalableExtension( p_vpar );
903 case COPYRIGHT_EXTENSION_ID:
904 CopyrightExtension( p_vpar );
910 case USER_DATA_START_CODE:
911 RemoveBits32( &p_vpar->bit_stream );
912 /* Wait for the next start code */
922 /*****************************************************************************
923 * SequenceDisplayExtension : Parse the sequence_display_extension structure *
924 *****************************************************************************/
926 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
928 /* We don't care sequence_display_extension. */
930 RemoveBits( &p_vpar->bit_stream, 3 );
931 if( GetBits( &p_vpar->bit_stream, 1 ) )
933 /* Two bytes for color_desciption */
934 RemoveBits( &p_vpar->bit_stream, 16 );
935 p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
937 /* display_horizontal and vertical_size and a marker_bit */
938 RemoveBits( &p_vpar->bit_stream, 29 );
942 /*****************************************************************************
943 * QuantMatrixExtension : Load quantization matrices for luminance *
945 *****************************************************************************/
947 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
949 if( GetBits( &p_vpar->bit_stream, 1 ) )
951 /* Load intra_quantiser_matrix for luminance. */
952 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
956 /* Use the default matrix. */
957 LinkMatrix( &p_vpar->sequence.intra_quant,
958 pi_default_intra_quant );
960 if( GetBits( &p_vpar->bit_stream, 1 ) )
962 /* Load non_intra_quantiser_matrix for luminance. */
963 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
967 /* Use the default matrix. */
968 LinkMatrix( &p_vpar->sequence.nonintra_quant,
969 pi_default_nonintra_quant );
971 if( GetBits( &p_vpar->bit_stream, 1 ) )
973 /* Load intra_quantiser_matrix for chrominance. */
974 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
978 /* Link the chrominance intra matrix to the luminance one. */
979 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
980 p_vpar->sequence.intra_quant.pi_matrix );
982 if( GetBits( &p_vpar->bit_stream, 1 ) )
984 /* Load non_intra_quantiser_matrix for chrominance. */
985 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
989 /* Link the chrominance intra matrix to the luminance one. */
990 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
991 p_vpar->sequence.intra_quant.pi_matrix );
993 if( GetBits( &p_vpar->bit_stream, 1 ) )
995 /* Load non_intra_quantiser_matrix for chrominance. */
996 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
1000 /* Link the chrominance nonintra matrix to the luminance one. */
1001 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
1002 p_vpar->sequence.nonintra_quant.pi_matrix );
1007 /*****************************************************************************
1008 * SequenceScalableExtension : Parse the sequence_scalable_extension *
1009 * structure to handle scalable coding *
1010 *****************************************************************************/
1012 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
1014 /* We don't care about anything scalable except the scalable mode. */
1015 switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
1016 /* The length of the structure depends on the value of the scalable_mode */
1019 RemoveBits32( &p_vpar->bit_stream );
1020 RemoveBits( &p_vpar->bit_stream, 21 );
1023 RemoveBits( &p_vpar->bit_stream, 12 );
1026 RemoveBits( &p_vpar->bit_stream, 4 );
1030 /*****************************************************************************
1031 * PictureDisplayExtension : Parse the picture_display_extension structure *
1032 *****************************************************************************/
1034 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
1036 /* Number of frame center offset */
1038 /* I am not sure it works but it should
1039 (fewer tests than shown in ยง6.3.12) */
1040 nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
1041 p_vpar->picture.b_repeat_first_field +
1042 p_vpar->picture.b_top_field_first
1043 : ( p_vpar->picture.b_frame_structure + 1 ) +
1044 p_vpar->picture.b_repeat_first_field;
1045 RemoveBits( &p_vpar->bit_stream, 34 * nb );
1049 /*****************************************************************************
1050 * PictureSpatialScalableExtension *
1051 *****************************************************************************/
1053 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
1055 /* That's scalable, so we trash it */
1056 RemoveBits32( &p_vpar->bit_stream );
1057 RemoveBits( &p_vpar->bit_stream, 16 );
1061 /*****************************************************************************
1062 * PictureTemporalScalableExtension *
1063 *****************************************************************************/
1065 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1067 /* Scalable again, trashed again */
1068 RemoveBits( &p_vpar->bit_stream, 23 );
1072 /*****************************************************************************
1073 * CopyrightExtension : Keeps some legal informations *
1074 *****************************************************************************/
1076 static void CopyrightExtension( vpar_thread_t * p_vpar )
1078 u32 i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1079 p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1080 /* A flag that says whether the copyright information is significant */
1081 p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1082 /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1083 p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1085 RemoveBits( &p_vpar->bit_stream, 8 );
1086 /* The copyright_number is split in three parts */
1088 i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1089 RemoveBits( &p_vpar->bit_stream, 1 );
1091 i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1092 RemoveBits( &p_vpar->bit_stream, 1 );
1093 /* third part and sum */
1094 p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) +
1095 ( (u64)i_copyright_nb_2 << 22 ) +
1096 ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );