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, 16 ) != 0 && !p_vpar->b_die )
169 DumpBits( &p_vpar->bit_stream, 8 );
171 DumpBits( &p_vpar->bit_stream, 16 );
174 /*****************************************************************************
175 * ReferenceUpdate : Update the reference pointers when we have a new picture
176 *****************************************************************************/
177 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
179 picture_t * p_newref )
181 if( i_coding_type != B_CODING_TYPE )
183 if( p_vpar->sequence.p_forward != NULL )
184 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
185 p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
186 p_vpar->sequence.p_backward = p_newref;
187 if( p_newref != NULL )
188 vout_LinkPicture( p_vpar->p_vout, p_newref );
192 /*****************************************************************************
193 * ReferenceReplace : Replace the last reference pointer when we destroy
195 *****************************************************************************/
196 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
198 picture_t * p_newref )
200 if( i_coding_type != B_CODING_TYPE )
202 if( p_vpar->sequence.p_backward != NULL )
203 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
204 p_vpar->sequence.p_backward = p_newref;
205 if( p_newref != NULL )
206 vout_LinkPicture( p_vpar->p_vout, p_newref );
210 /*****************************************************************************
211 * LoadMatrix : Load a quantization matrix
212 *****************************************************************************/
213 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar, quant_matrix_t * p_matrix )
217 if( !p_matrix->b_allocated )
219 /* Allocate a piece of memory to load the matrix. */
220 p_matrix->pi_matrix = (int *)malloc( 64*sizeof(int) );
221 p_matrix->b_allocated = 1;
224 for( i_dummy = 0; i_dummy < 64; i_dummy++ )
226 p_matrix->pi_matrix[pi_scan[SCAN_ZIGZAG][i_dummy]]
227 = GetBits( &p_vpar->bit_stream, 8 );
231 /* Discrete Fourier Transform requires the quantization matrices to
232 * be normalized before using them. */
233 vdec_NormQuantMatrix( p_matrix->pi_matrix );
237 /*****************************************************************************
238 * LinkMatrix : Link a quantization matrix to another
239 *****************************************************************************/
240 static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, int * pi_array )
244 if( p_matrix->b_allocated )
246 /* Deallocate the piece of memory. */
247 free( p_matrix->pi_matrix );
248 p_matrix->b_allocated = 0;
251 p_matrix->pi_matrix = pi_array;
255 * Exported functions.
258 /*****************************************************************************
259 * vpar_NextSequenceHeader : Find the next sequence header
260 *****************************************************************************/
261 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
263 while( !p_vpar->b_die )
265 NextStartCode( p_vpar );
266 if( ShowBits( &p_vpar->bit_stream, 16 ) == SEQUENCE_HEADER_CODE )
272 /*****************************************************************************
273 * vpar_ParseHeader : Parse the next header
274 *****************************************************************************/
275 int vpar_ParseHeader( vpar_thread_t * p_vpar )
277 while( !p_vpar->b_die )
279 NextStartCode( p_vpar );
280 switch( GetBits32( &p_vpar->bit_stream ) )
282 case SEQUENCE_HEADER_CODE:
283 fprintf( stderr, "begin sequence header\n" );
284 SequenceHeader( p_vpar );
285 fprintf( stderr, "end sequence header\n" );
289 case GROUP_START_CODE:
290 fprintf( stderr, "begin group\n" );
291 GroupHeader( p_vpar );
292 fprintf( stderr, "end group\n" );
296 case PICTURE_START_CODE:
297 fprintf( stderr, "begin picture\n" );
298 PictureHeader( p_vpar );
299 fprintf( stderr, "end picture\n" );
303 case SEQUENCE_END_CODE:
304 fprintf( stderr, "sequence header end code\n" );
316 * Following functions are local
319 /*****************************************************************************
320 * SequenceHeader : Parse the next sequence header
321 *****************************************************************************/
322 static void SequenceHeader( vpar_thread_t * p_vpar )
325 static double d_frame_rate_table[16] =
328 ((23.0*1000.0)/1001.0),
331 ((30.0*1000.0)/1001.0),
334 ((60.0*1000.0)/1001.0),
336 RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
340 int i_height_save, i_width_save;
342 i_height_save = p_vpar->sequence.i_height;
343 i_width_save = p_vpar->sequence.i_width;
345 p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
346 p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
347 p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
348 p_vpar->sequence.d_frame_rate =
349 d_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
351 /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
352 * constrained_parameters_flag */
353 DumpBits( &p_vpar->bit_stream, 30 );
356 * Quantization matrices
358 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
360 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
364 /* Use default matrix. */
365 LinkMatrix( &p_vpar->sequence.intra_quant, pi_default_intra_quant );
368 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
370 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
374 /* Use default matrix. */
375 LinkMatrix( &p_vpar->sequence.nonintra_quant, pi_default_nonintra_quant );
378 /* Unless later overwritten by a matrix extension, we have the same
379 * matrices for luminance and chrominance. */
380 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
381 p_vpar->sequence.intra_quant.pi_matrix );
382 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
383 p_vpar->sequence.nonintra_quant.pi_matrix );
388 NextStartCode( p_vpar );
389 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
392 static f_chroma_pattern_t ppf_chroma_pattern[4] =
393 {NULL, vpar_CodedPattern420,
394 vpar_CodedPattern422, vpar_CodedPattern444};
396 /* Turn the MPEG2 flag on */
397 p_vpar->sequence.b_mpeg2 = 1;
399 /* Parse sequence_extension */
400 DumpBits32( &p_vpar->bit_stream );
401 /* extension_start_code_identifier, profile_and_level_indication */
402 DumpBits( &p_vpar->bit_stream, 12 );
403 p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
404 p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
405 p_vpar->sequence.pf_decode_pattern = ppf_chroma_pattern
406 [p_vpar->sequence.i_chroma_format];
407 p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
408 p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
409 /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
410 DumpBits( &p_vpar->bit_stream, 22 );
411 /* frame_rate_extension_n */
412 i_dummy = GetBits( &p_vpar->bit_stream, 2 );
413 /* frame_rate_extension_d */
414 p_vpar->sequence.d_frame_rate *= (i_dummy + 1)
415 / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
417 p_vpar->sequence.pf_decode_mv = vpar_MPEG2MotionVector;
421 /* It's an MPEG-1 stream. Put adequate parameters. */
423 p_vpar->sequence.b_mpeg2 = 0;
424 p_vpar->sequence.b_progressive = 1;
425 p_vpar->sequence.i_chroma_format = CHROMA_420;
426 p_vpar->sequence.pf_decode_pattern = vpar_CodedPattern420;
428 p_vpar->sequence.pf_decode_mv = vpar_MPEG1MotionVector;
432 p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
433 p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
434 (p_vpar->sequence.i_height + 15) / 16 :
435 2 * (p_vpar->sequence.i_height + 31) / 32;
436 p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
437 * p_vpar->sequence.i_mb_height;
438 p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
439 p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
440 p_vpar->sequence.i_size = p_vpar->sequence.i_width
441 * p_vpar->sequence.i_height;
443 /* Update chromatic information */
444 switch( p_vpar->sequence.i_chroma_format )
447 p_vpar->sequence.i_chroma_nb_blocks = 2;
448 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 2;
449 p_vpar->sequence.i_chroma_mb_width = 8;
450 p_vpar->sequence.i_chroma_mb_height = 8;
454 p_vpar->sequence.i_chroma_nb_blocks = 4;
455 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
456 p_vpar->sequence.i_chroma_mb_width = 8;
457 p_vpar->sequence.i_chroma_mb_height = 16;
461 p_vpar->sequence.i_chroma_nb_blocks = 8;
462 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
463 p_vpar->sequence.i_chroma_mb_width = 16;
464 p_vpar->sequence.i_chroma_mb_height = 16;
467 /* Slice Header functions */
468 if( p_vpar->sequence.i_height <= 2800 )
470 if( p_vpar->sequence.i_scalable_mode != SC_DP )
472 p_vpar->sequence.pf_slice_header = SliceHeader00;
476 p_vpar->sequence.pf_slice_header = SliceHeader01;
481 if( p_vpar->sequence.i_scalable_mode != SC_DP )
483 p_vpar->sequence.pf_slice_header = SliceHeader10;
487 p_vpar->sequence.pf_slice_header = SliceHeader11;
491 if( p_vpar->sequence.i_width != i_width_save
492 || p_vpar->sequence.i_height != i_height_save )
494 /* What do we do in case of a size change ??? */
497 /* Extension and User data */
498 ExtensionAndUserData( p_vpar );
501 /*****************************************************************************
502 * GroupHeader : Parse the next group of pictures header
503 *****************************************************************************/
504 static void GroupHeader( vpar_thread_t * p_vpar )
506 /* Nothing to do, we don't care. */
507 DumpBits( &p_vpar->bit_stream, 27 );
508 ExtensionAndUserData( p_vpar );
511 /*****************************************************************************
512 * PictureHeader : Parse the next picture header
513 *****************************************************************************/
514 static void PictureHeader( vpar_thread_t * p_vpar )
516 static f_macroblock_type_t ppf_macroblock_type[4] =
517 {vpar_IMBType, vpar_PMBType,
518 vpar_BMBType, vpar_DMBType};
521 int i_mb_address, i_mb_base, i_mb;
522 elem_t * p_y, p_u, p_v;
523 boolean_t b_parsable;
526 DumpBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
527 p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
528 p_vpar->picture.pf_macroblock_type = ppf_macroblock_type
529 [p_vpar->picture.i_coding_type];
531 DumpBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
533 p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
534 p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
535 p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
536 p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
538 /* extra_information_picture */
539 while( GetBits( &p_vpar->bit_stream, 1 ) )
541 DumpBits( &p_vpar->bit_stream, 8 );
545 * Picture Coding Extension
547 fprintf( stderr, "picture1\n" );
548 NextStartCode( p_vpar );
549 if( ShowBits( &p_vpar->bit_stream, 16 ) == EXTENSION_START_CODE )
551 /* Parse picture_coding_extension */
552 DumpBits32( &p_vpar->bit_stream );
553 /* extension_start_code_identifier */
554 DumpBits( &p_vpar->bit_stream, 4 );
556 p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
557 p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
558 p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
559 p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
560 p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
561 i_structure = GetBits( &p_vpar->bit_stream, 2 );
562 p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
563 p_vpar->picture.b_frame_pred_frame_dct
564 = GetBits( &p_vpar->bit_stream, 1 );
565 p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
566 p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
567 p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
568 p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
569 p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
570 /* repeat_first_field (ISO/IEC 13818-2 6.3.10 is necessary to know
571 * the length of the picture_display_extension structure.
572 * chroma_420_type (obsolete) */
573 DumpBits( &p_vpar->bit_stream, 1 );
574 p_vpar->picture.b_progressive_frame = GetBits( &p_vpar->bit_stream, 1 );
576 /* composite_display_flag */
577 if( GetBits( &p_vpar->bit_stream, 1 ) )
579 /* v_axis, field_sequence, sub_carrier, burst_amplitude,
580 * sub_carrier_phase */
581 DumpBits( &p_vpar->bit_stream, 20 );
586 /* MPEG-1 compatibility flags */
587 p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
588 i_structure = FRAME_STRUCTURE;
589 p_vpar->picture.b_frame_pred_frame_dct = 1;
590 p_vpar->picture.b_concealment_mv = 0;
591 p_vpar->picture.b_q_scale_type = 0;
592 p_vpar->picture.b_intra_vlc_format = 0;
593 p_vpar->picture.b_alternate_scan = 0; /* zigzag */
594 p_vpar->picture.b_repeat_first_field = 0;
595 p_vpar->picture.b_progressive_frame = 1;
598 if( p_vpar->picture.i_current_structure &&
599 (i_structure == FRAME_STRUCTURE ||
600 i_structure == p_vpar->picture.i_current_structure) )
602 /* We don't have the second field of the buffered frame. */
603 if( p_vpar->picture.p_picture != NULL )
605 ReferenceReplace( p_vpar,
606 p_vpar->picture.i_coding_type,
609 for( i_mb = 0; i_mb < p_vpar->sequence.i_mb_size >> 1; i_mb++ )
611 vpar_DestroyMacroblock( &p_vpar->vfifo,
612 p_vpar->picture.pp_mb[i_mb] );
614 vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
617 p_vpar->picture.i_current_structure = 0;
619 intf_DbgMsg("vpar debug: odd number of field picture.");
622 if( p_vpar->picture.i_current_structure )
624 /* Second field of a frame. We will decode it if, and only if we
625 * have decoded the first frame. */
626 b_parsable = (p_vpar->picture.p_picture != NULL);
630 /* Do we have the reference pictures ? */
631 b_parsable = !((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
632 (p_vpar->sequence.p_forward == NULL)) ||
633 ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
634 (p_vpar->sequence.p_forward == NULL ||
635 p_vpar->sequence.p_backward == NULL));
639 /* Does synchro say we have enough time to decode it ? */
640 b_parsable = vpar_SynchroChoose( p_vpar,
641 p_vpar->picture.i_coding_type, i_structure );
647 /* Update the reference pointers. */
648 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
650 /* Warn Synchro we have trashed a picture. */
651 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
653 /* Update context. */
654 if( i_structure != FRAME_STRUCTURE )
655 p_vpar->picture.i_current_structure = i_structure;
656 p_vpar->picture.p_picture = NULL;
661 /* OK, now we are sure we will decode the picture. */
662 #define P_picture p_vpar->picture.p_picture
663 p_vpar->picture.b_error = 0;
665 if( !p_vpar->picture.i_current_structure )
667 /* This is a new frame. Get a structure from the video_output. */
668 P_picture = vout_CreatePicture( p_vpar->p_vout,
669 99+p_vpar->sequence.i_chroma_format, /*???*/
670 p_vpar->sequence.i_width,
671 p_vpar->sequence.i_height,
672 p_vpar->sequence.i_width*sizeof(yuv_data_t) );
674 /* Initialize values. */
675 P_picture->date = vpar_SynchroDecode( p_vpar,
676 p_vpar->picture.i_coding_type,
678 p_vpar->picture.i_l_stride = - 8 + ( p_vpar->sequence.i_width
679 << ( 1 - p_vpar->picture.b_frame_structure ) );
680 p_vpar->picture.i_c_stride = -8 + ( p_vpar->sequence.i_width
681 << (( 1 - p_vpar->picture.b_frame_structure ) +
682 ( 3 - p_vpar->sequence.i_chroma_format )) );
684 /* Update the reference pointers. */
685 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
687 p_vpar->picture.i_current_structure |= i_structure;
688 p_vpar->picture.i_structure = i_structure;
689 p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
691 /* Initialize picture data for decoding. */
692 if( i_structure == BOTTOM_FIELD )
694 i_mb_base = p_vpar->sequence.i_mb_size >> 1;
695 p_vpar->mb.i_l_y = 16;
696 p_vpar->mb.i_c_y = p_vpar->sequence.i_chroma_mb_height;
701 p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
704 p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
706 /* Extension and User data. */
707 ExtensionAndUserData( p_vpar );
709 /* Picture data (ISO/IEC 13818-2 6.2.3.7). */
710 NextStartCode( p_vpar );
711 while( i_mb_address+i_mb_base < p_vpar->sequence.i_mb_size
712 && !p_vpar->picture.b_error)
714 if( ((i_dummy = ShowBits( &p_vpar->bit_stream, 32 ))
715 < SLICE_START_CODE_MIN) ||
716 (i_dummy > SLICE_START_CODE_MAX) )
718 intf_DbgMsg("vpar debug: premature end of picture");
719 p_vpar->picture.b_error = 1;
722 DumpBits32( &p_vpar->bit_stream );
724 /* Decode slice data. */
725 SliceHeader( p_vpar, &i_mb_address, i_mb_base, i_dummy & 255 );
728 /* Link referenced pictures for the decoder
729 * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
730 if( p_vpar->sequence.p_forward != NULL )
732 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
734 if( p_vpar->sequence.p_backward != NULL )
736 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
739 if( p_vpar->picture.b_error )
742 for( i_mb = 0; p_vpar->picture.pp_mb[i_mb]; i_mb++ )
744 vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
747 ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
748 vout_DestroyPicture( p_vpar->p_vout, P_picture );
750 /* Unlink referenced pictures */
751 if( p_vpar->sequence.p_forward != NULL )
753 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
755 if( p_vpar->sequence.p_backward != NULL )
757 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
760 /* Prepare context for the next picture. */
763 else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
765 /* Frame completely parsed. */
766 P_picture->i_deccount = p_vpar->sequence.i_mb_size;
767 for( i_mb = 0; i_mb < p_vpar->sequence.i_mb_size; i_mb++ )
769 vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
772 /* Prepare context for the next picture. */
778 /*****************************************************************************
779 * SliceHeader : Parse the next slice structure
780 *****************************************************************************/
781 static __inline__ void SliceHeader( vpar_thread_t * p_vpar,
782 int * pi_mb_address, int i_mb_base,
785 /* DC predictors initialization table */
786 static int pi_dc_dct_reinit[4] = {128,256,512,1024};
788 int i_mb_address_save = *pi_mb_address;
790 /* slice_vertical_position_extension and priority_breakpoint already done */
791 LoadQuantizerScale( p_vpar );
793 if( GetBits( &p_vpar->bit_stream, 1 ) )
795 /* intra_slice, slice_id */
796 DumpBits( &p_vpar->bit_stream, 8 );
797 /* extra_information_slice */
798 while( GetBits( &p_vpar->bit_stream, 1 ) )
800 DumpBits( &p_vpar->bit_stream, 8 );
804 *pi_mb_address = (i_vert_code - 1)*p_vpar->sequence.i_mb_width;
806 /* Reset DC coefficients predictors (ISO/IEC 13818-2 7.2.1). Why
807 * does the reference decoder put 0 instead of the normative values ? */
808 p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
809 = p_vpar->slice.pi_dc_dct_pred[2]
810 = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
812 /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
813 memset( p_vpar->slice.pppi_pmv, 0, 8*sizeof(int) );
817 vpar_ParseMacroblock( p_vpar, pi_mb_address, i_mb_address_save,
819 i_mb_address_save = *pi_mb_address;
821 while( !ShowBits( &p_vpar->bit_stream, 23 ) );
824 /*****************************************************************************
825 * SliceHeaderXY : Parse the next slice structure
826 *****************************************************************************
827 * X = i_height > 2800 ?
828 * Y = scalable_mode == SC_DP ?
829 *****************************************************************************/
830 static void SliceHeader00( vpar_thread_t * p_vpar,
831 int * pi_mb_address, int i_mb_base,
834 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
837 static void SliceHeader01( vpar_thread_t * p_vpar,
838 int * pi_mb_address, int i_mb_base,
841 DumpBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
842 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
845 static void SliceHeader10( vpar_thread_t * p_vpar,
846 int * pi_mb_address, int i_mb_base,
849 i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
850 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
853 static void SliceHeader11( vpar_thread_t * p_vpar,
854 int * pi_mb_address, int i_mb_base,
857 i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
858 DumpBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
859 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
862 /*****************************************************************************
863 * ExtensionAndUserData : Parse the extension_and_user_data structure
864 *****************************************************************************/
865 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
867 while( !p_vpar->b_die )
869 NextStartCode( p_vpar );
870 switch( ShowBits( &p_vpar->bit_stream, 32 ) )
872 case EXTENSION_START_CODE:
873 DumpBits32( &p_vpar->bit_stream );
874 switch( GetBits( &p_vpar->bit_stream, 4 ) )
876 case SEQUENCE_DISPLAY_EXTENSION_ID:
877 SequenceDisplayExtension( p_vpar );
879 case QUANT_MATRIX_EXTENSION_ID:
880 QuantMatrixExtension( p_vpar );
882 case SEQUENCE_SCALABLE_EXTENSION_ID:
883 SequenceScalableExtension( p_vpar );
885 case PICTURE_DISPLAY_EXTENSION_ID:
886 PictureDisplayExtension( p_vpar );
888 case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
889 PictureSpatialScalableExtension( p_vpar );
891 case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
892 PictureTemporalScalableExtension( p_vpar );
894 case COPYRIGHT_EXTENSION_ID:
895 CopyrightExtension( p_vpar );
901 case USER_DATA_START_CODE:
902 DumpBits32( &p_vpar->bit_stream );
903 /* Wait for the next start code */
913 /*****************************************************************************
914 * SequenceDisplayExtension : Parse the sequence_display_extension structure *
915 *****************************************************************************/
917 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
919 /* We don't care sequence_display_extension. */
921 DumpBits( &p_vpar->bit_stream, 3 );
922 if( GetBits( &p_vpar->bit_stream, 1 ) )
924 /* Three bytes for color_desciption */
925 DumpBits( &p_vpar->bit_stream, 24 );
927 /* display_horizontal and vertical_size and a marker_bit */
928 DumpBits( &p_vpar->bit_stream, 29 );
932 /*****************************************************************************
933 * QuantMatrixExtension : Load quantization matrices for luminance *
935 *****************************************************************************/
937 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
939 if( GetBits( &p_vpar->bit_stream, 1 ) )
941 /* Load intra_quantiser_matrix for luminance. */
942 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
946 /* Use the default matrix. */
947 LinkMatrix( &p_vpar->sequence.intra_quant,
948 pi_default_intra_quant );
950 if( GetBits( &p_vpar->bit_stream, 1 ) )
952 /* Load non_intra_quantiser_matrix for luminance. */
953 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
957 /* Use the default matrix. */
958 LinkMatrix( &p_vpar->sequence.nonintra_quant,
959 pi_default_nonintra_quant );
961 if( GetBits( &p_vpar->bit_stream, 1 ) )
963 /* Load intra_quantiser_matrix for chrominance. */
964 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
968 /* Link the chrominance intra matrix to the luminance one. */
969 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
970 p_vpar->sequence.intra_quant.pi_matrix );
972 if( GetBits( &p_vpar->bit_stream, 1 ) )
974 /* Load non_intra_quantiser_matrix for chrominance. */
975 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
979 /* Link the chrominance intra matrix to the luminance one. */
980 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
981 p_vpar->sequence.intra_quant.pi_matrix );
983 if( GetBits( &p_vpar->bit_stream, 1 ) )
985 /* Load non_intra_quantiser_matrix for chrominance. */
986 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
990 /* Link the chrominance nonintra matrix to the luminance one. */
991 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
992 p_vpar->sequence.nonintra_quant.pi_matrix );
997 /*****************************************************************************
998 * SequenceScalableExtension : Parse the sequence_scalable_extension *
999 * structure to handle scalable coding *
1000 *****************************************************************************/
1002 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
1004 /* We don't care about anything scalable except the scalable mode. */
1005 switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
1006 /* The length of the structure depends on the value of the scalable_mode */
1009 DumpBits32( &p_vpar->bit_stream );
1010 DumpBits( &p_vpar->bit_stream, 21 );
1013 DumpBits( &p_vpar->bit_stream, 12 );
1016 DumpBits( &p_vpar->bit_stream, 4 );
1020 /*****************************************************************************
1021 * PictureDisplayExtension : Parse the picture_display_extension structure *
1022 *****************************************************************************/
1024 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
1026 /* Number of frame center offset */
1028 /* I am not sure it works but it should
1029 (fewer tests than shown in ยง6.3.12) */
1030 nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
1031 p_vpar->picture.b_repeat_first_field +
1032 p_vpar->picture.b_top_field_first
1033 : ( p_vpar->picture.b_frame_structure + 1 ) +
1034 p_vpar->picture.b_repeat_first_field;
1035 DumpBits( &p_vpar->bit_stream, 34 * nb );
1039 /*****************************************************************************
1040 * PictureSpatialScalableExtension *
1041 *****************************************************************************/
1043 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
1045 /* That's scalable, so we trash it */
1046 DumpBits32( &p_vpar->bit_stream );
1047 DumpBits( &p_vpar->bit_stream, 16 );
1051 /*****************************************************************************
1052 * PictureTemporalScalableExtension *
1053 *****************************************************************************/
1055 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1057 /* Scalable again, trashed again */
1058 DumpBits( &p_vpar->bit_stream, 23 );
1062 /*****************************************************************************
1063 * CopyrightExtension : Keeps some legal informations *
1064 *****************************************************************************/
1066 static void CopyrightExtension( vpar_thread_t * p_vpar )
1068 u32 i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1069 p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1070 /* A flag that says whether the copyright information is significant */
1071 p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1072 /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1073 p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1075 DumpBits( &p_vpar->bit_stream, 8 );
1076 /* The copyright_number is split in three parts */
1078 i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1079 DumpBits( &p_vpar->bit_stream, 1 );
1081 i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1082 DumpBits( &p_vpar->bit_stream, 1 );
1083 /* third part and sum */
1084 p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) +
1085 ( (u64)i_copyright_nb_2 << 22 ) +
1086 ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );