1 /*****************************************************************************
2 * vpar_headers.c : headers parsing
4 *****************************************************************************/
6 /*****************************************************************************
8 *****************************************************************************/
19 #include "vlc_thread.h"
22 #include "debug.h" /* ?? temporaire, requis par netlist.h */
25 #include "input_netlist.h"
26 #include "decoder_fifo.h"
28 #include "video_output.h"
30 #include "vdec_idct.h"
31 #include "video_decoder.h"
32 #include "vdec_motion.h"
34 #include "vpar_blocks.h"
35 #include "vpar_headers.h"
36 #include "video_fifo.h"
37 #include "vpar_synchro.h"
38 #include "video_parser.h"
39 #include "vpar_motion.h"
44 static __inline__ void NextStartCode( vpar_thread_t * p_vpar );
45 static void SequenceHeader( vpar_thread_t * p_vpar );
46 static void GroupHeader( vpar_thread_t * p_vpar );
47 static void PictureHeader( vpar_thread_t * p_vpar );
48 static void SliceHeader00( vpar_thread_t * p_vpar,
49 int * pi_mb_address, int i_mb_base,
51 static void SliceHeader01( vpar_thread_t * p_vpar,
52 int * pi_mb_address, int i_mb_base,
54 static void SliceHeader10( vpar_thread_t * p_vpar,
55 int * pi_mb_address, int i_mb_base,
57 static void SliceHeader11( vpar_thread_t * p_vpar,
58 int * pi_mb_address, int i_mb_base,
60 static __inline__ void SliceHeader( vpar_thread_t * p_vpar,
61 int * pi_mb_address, int i_mb_base,
63 static void ExtensionAndUserData( vpar_thread_t * p_vpar );
64 static void QuantMatrixExtension( vpar_thread_t * p_vpar );
65 static void SequenceScalableExtension( vpar_thread_t * p_vpar );
66 static void SequenceDisplayExtension( vpar_thread_t * p_vpar );
67 static void PictureDisplayExtension( vpar_thread_t * p_vpar );
68 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar );
69 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar );
70 static void CopyrightExtension( vpar_thread_t * p_vpar );
76 /*****************************************************************************
77 * pi_default_intra_quant : default quantization matrix
78 *****************************************************************************/
80 int pi_default_intra_quant[] =
82 8, 16, 19, 22, 26, 27, 29, 34,
83 16, 16, 22, 24, 27, 29, 34, 37,
84 19, 22, 26, 27, 29, 34, 34, 38,
85 22, 22, 26, 27, 29, 34, 37, 40,
86 22, 26, 27, 29, 32, 35, 40, 48,
87 26, 27, 29, 32, 35, 40, 48, 58,
88 26, 27, 29, 34, 38, 46, 56, 69,
89 27, 29, 35, 38, 46, 56, 69, 83
92 int pi_default_intra_quant[] =
94 2048, 5681, 6355, 6623, 6656, 5431, 4018, 2401,
95 5681, 7880, 10207, 10021, 9587, 8091, 6534, 3625,
96 6355, 10207, 11363, 10619, 9700, 8935, 6155, 3507,
97 6623, 9186, 10226, 9557, 8730, 8041, 6028, 3322,
98 5632, 9232, 9031, 8730, 8192, 7040, 5542, 3390,
99 5230, 7533, 7621, 7568, 7040, 6321, 5225, 3219,
100 3602, 5189, 5250, 5539, 5265, 5007, 4199, 2638,
101 1907, 2841, 3230, 3156, 3249, 3108, 2638, 1617
105 /*****************************************************************************
106 * pi_default_nonintra_quant : default quantization matrix
107 *****************************************************************************/
109 int pi_default_nonintra_quant[] =
111 16, 16, 16, 16, 16, 16, 16, 16,
112 16, 16, 16, 16, 16, 16, 16, 16,
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
121 int pi_default_nonintra_quanit[] =
123 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
124 5680, 7888, 7424, 6688, 5680, 4464, 3072, 1568,
125 5344, 7424, 6992, 6288, 5344, 4208, 2896, 1472,
126 4816, 6688, 6288, 5664, 4816, 3792, 2608, 1328,
127 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
128 3216, 4464, 4208, 3792, 3216, 2528, 1744, 880,
129 2224, 3072, 2896, 2608, 2224, 1744, 1200, 608,
130 1136, 1568, 1472, 1328, 1136, 880, 608, 304
134 /*****************************************************************************
135 * pi_scan : zig-zag and alternate scan patterns
136 *****************************************************************************/
139 { /* Zig-Zag pattern */
140 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
141 12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
142 35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
143 58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
145 { /* Alternate scan pattern */
146 0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
147 41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
148 51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
149 53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
154 * Local inline functions.
157 /*****************************************************************************
158 * NextStartCode : Find the next start code
159 *****************************************************************************/
160 static __inline__ void NextStartCode( vpar_thread_t * p_vpar )
162 /* Re-align the buffer on an 8-bit boundary */
163 RealignBits( &p_vpar->bit_stream );
165 while( ShowBits( &p_vpar->bit_stream, 24 ) != 0x01L && !p_vpar->b_die )
167 RemoveBits( &p_vpar->bit_stream, 8 );
171 /*****************************************************************************
172 * ReferenceUpdate : Update the reference pointers when we have a new picture
173 *****************************************************************************/
174 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
176 picture_t * p_newref )
178 if( i_coding_type != B_CODING_TYPE )
180 if( p_vpar->sequence.p_forward != NULL )
181 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
182 if( p_vpar->sequence.p_backward != NULL )
184 vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
185 vpar_SynchroDate( p_vpar ) );
187 p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
188 p_vpar->sequence.p_backward = p_newref;
189 if( p_newref != NULL )
190 vout_LinkPicture( p_vpar->p_vout, p_newref );
194 /*****************************************************************************
195 * ReferenceReplace : Replace the last reference pointer when we destroy
197 *****************************************************************************/
198 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
200 picture_t * p_newref )
202 if( i_coding_type != B_CODING_TYPE )
204 if( p_vpar->sequence.p_backward != NULL )
205 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
206 p_vpar->sequence.p_backward = p_newref;
207 if( p_newref != NULL )
208 vout_LinkPicture( p_vpar->p_vout, p_newref );
212 /*****************************************************************************
213 * LoadMatrix : Load a quantization matrix
214 *****************************************************************************/
215 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar, quant_matrix_t * p_matrix )
219 if( !p_matrix->b_allocated )
221 /* Allocate a piece of memory to load the matrix. */
222 if( (p_matrix->pi_matrix = (int *)malloc( 64*sizeof(int) )) == NULL )
224 intf_ErrMsg("vpar error: allocation error in LoadMatrix()\n");
228 p_matrix->b_allocated = 1;
231 for( i_dummy = 0; i_dummy < 64; i_dummy++ )
233 p_matrix->pi_matrix[pi_scan[SCAN_ZIGZAG][i_dummy]]
234 = GetBits( &p_vpar->bit_stream, 8 );
238 /* Discrete Fourier Transform requires the quantization matrices to
239 * be normalized before using them. */
240 vdec_NormQuantMatrix( p_matrix->pi_matrix );
244 /*****************************************************************************
245 * LinkMatrix : Link a quantization matrix to another
246 *****************************************************************************/
247 static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, int * pi_array )
249 if( p_matrix->b_allocated )
251 /* Deallocate the piece of memory. */
252 free( p_matrix->pi_matrix );
253 p_matrix->b_allocated = 0;
256 p_matrix->pi_matrix = pi_array;
260 * Exported functions.
263 /*****************************************************************************
264 * vpar_NextSequenceHeader : Find the next sequence header
265 *****************************************************************************/
266 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
268 while( !p_vpar->b_die )
270 NextStartCode( p_vpar );
271 if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
273 RemoveBits( &p_vpar->bit_stream, 8 );
278 /*****************************************************************************
279 * vpar_ParseHeader : Parse the next header
280 *****************************************************************************/
281 int vpar_ParseHeader( vpar_thread_t * p_vpar )
283 while( !p_vpar->b_die )
285 NextStartCode( p_vpar );
286 switch( GetBits32( &p_vpar->bit_stream ) )
288 case SEQUENCE_HEADER_CODE:
289 SequenceHeader( p_vpar );
293 case GROUP_START_CODE:
294 GroupHeader( p_vpar );
298 case PICTURE_START_CODE:
299 PictureHeader( p_vpar );
303 case SEQUENCE_END_CODE:
304 intf_DbgMsg("vpar debug: sequence end code received\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 float r_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_width = GetBits( &p_vpar->bit_stream, 12 );
346 p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
347 p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
348 p_vpar->sequence.r_frame_rate =
349 r_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 RemoveBits( &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 RemoveBits32( &p_vpar->bit_stream );
401 /* extension_start_code_identifier, profile_and_level_indication */
402 RemoveBits( &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 RemoveBits( &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.r_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 >> 1;
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 RemoveBits( &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[5] = {NULL,
517 vpar_IMBType, vpar_PMBType,
518 vpar_BMBType, vpar_DMBType};
521 int i_mb_address, i_mb_base, i_mb;
522 boolean_t b_parsable;
525 RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
526 p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
527 p_vpar->picture.pf_macroblock_type = ppf_macroblock_type
528 [p_vpar->picture.i_coding_type];
529 RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
531 if( p_vpar->picture.i_coding_type == P_CODING_TYPE || p_vpar->picture.i_coding_type == B_CODING_TYPE )
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 );
536 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
538 p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
539 p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
542 /* extra_information_picture */
543 while( GetBits( &p_vpar->bit_stream, 1 ) )
545 RemoveBits( &p_vpar->bit_stream, 8 );
549 * Picture Coding Extension
551 NextStartCode( p_vpar );
552 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
554 /* Parse picture_coding_extension */
555 RemoveBits32( &p_vpar->bit_stream );
556 /* extension_start_code_identifier */
557 RemoveBits( &p_vpar->bit_stream, 4 );
559 p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
560 p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
561 p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
562 p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
563 p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
564 i_structure = GetBits( &p_vpar->bit_stream, 2 );
565 p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
566 p_vpar->picture.b_frame_pred_frame_dct
567 = GetBits( &p_vpar->bit_stream, 1 );
568 p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
569 p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
570 p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
571 p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
572 p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
573 /* repeat_first_field (ISO/IEC 13818-2 6.3.10 is necessary to know
574 * the length of the picture_display_extension structure.
575 * chroma_420_type (obsolete) */
576 RemoveBits( &p_vpar->bit_stream, 1 );
577 p_vpar->picture.b_progressive_frame = GetBits( &p_vpar->bit_stream, 1 );
579 /* composite_display_flag */
580 if( GetBits( &p_vpar->bit_stream, 1 ) )
582 /* v_axis, field_sequence, sub_carrier, burst_amplitude,
583 * sub_carrier_phase */
584 RemoveBits( &p_vpar->bit_stream, 20 );
589 /* MPEG-1 compatibility flags */
590 p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
591 i_structure = FRAME_STRUCTURE;
592 p_vpar->picture.b_frame_pred_frame_dct = 1;
593 p_vpar->picture.b_concealment_mv = 0;
594 p_vpar->picture.b_q_scale_type = 0;
595 p_vpar->picture.b_intra_vlc_format = 0;
596 p_vpar->picture.b_alternate_scan = 0; /* zigzag */
597 p_vpar->picture.b_repeat_first_field = 0;
598 p_vpar->picture.b_progressive_frame = 1;
601 if( p_vpar->picture.i_current_structure &&
602 (i_structure == FRAME_STRUCTURE ||
603 i_structure == p_vpar->picture.i_current_structure) )
605 /* We don't have the second field of the buffered frame. */
606 if( p_vpar->picture.p_picture != NULL )
608 ReferenceReplace( p_vpar,
609 p_vpar->picture.i_coding_type,
612 for( i_mb = 0; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
614 vpar_DestroyMacroblock( &p_vpar->vfifo,
615 p_vpar->picture.pp_mb[i_mb] );
617 vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
620 p_vpar->picture.i_current_structure = 0;
622 intf_DbgMsg("vpar debug: odd number of field picture.\n");
625 /* Do we have the reference pictures ? */
626 b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
627 (p_vpar->sequence.p_backward == NULL)) ||
628 /* p_backward will become p_forward later */
629 ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
630 (p_vpar->sequence.p_forward == NULL ||
631 p_vpar->sequence.p_backward == NULL)));
635 if( p_vpar->picture.i_current_structure )
637 /* Second field of a frame. We will decode it if, and only if we
638 * have decoded the first field. */
639 b_parsable = (p_vpar->picture.p_picture != NULL);
643 /* Does synchro say we have enough time to decode it ? */
644 b_parsable = vpar_SynchroChoose( p_vpar,
645 p_vpar->picture.i_coding_type, i_structure );
651 /* Update the reference pointers. */
652 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
654 /* Warn Synchro we have trashed a picture. */
655 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
657 /* Update context. */
658 if( i_structure != FRAME_STRUCTURE )
659 p_vpar->picture.i_current_structure = i_structure;
660 p_vpar->picture.p_picture = NULL;
665 /* OK, now we are sure we will decode the picture. */
666 #define P_picture p_vpar->picture.p_picture
667 p_vpar->picture.b_error = 0;
668 p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
670 if( !p_vpar->picture.i_current_structure )
672 /* This is a new frame. Get a structure from the video_output. */
673 while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
674 99+p_vpar->sequence.i_chroma_format, /*???*/
675 p_vpar->sequence.i_width,
676 p_vpar->sequence.i_height ) )
679 intf_DbgMsg("vpar debug: allocation error in vout_CreatePicture\n");
680 if( p_vpar->b_die || p_vpar->b_error )
684 mwait( VPAR_IDLE_SLEEP );
687 /* Initialize values. */
688 vpar_SynchroDecode( p_vpar, p_vpar->picture.i_coding_type, i_structure );
689 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
691 /* Put date immediately. */
692 vout_DatePicture( p_vpar->p_vout, P_picture,
693 vpar_SynchroDate( p_vpar ) );
695 P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
696 P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
697 p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
698 << ( 1 - p_vpar->picture.b_frame_structure ) );
699 p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
700 << ( 1 - p_vpar->picture.b_frame_structure ));
702 P_picture->i_deccount = p_vpar->sequence.i_mb_size;
703 vlc_mutex_init( &p_vpar->picture.p_picture->lock_deccount );
704 memset( p_vpar->picture.pp_mb, 0, MAX_MB );
705 /* FIXME ! remove asap */
706 memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
708 /* Update the reference pointers. */
709 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
711 p_vpar->picture.i_current_structure |= i_structure;
712 p_vpar->picture.i_structure = i_structure;
714 /* Initialize picture data for decoding. */
715 if( p_vpar->picture.b_motion_field = (i_structure == BOTTOM_FIELD) )
717 i_mb_base = p_vpar->sequence.i_mb_size >> 1;
718 p_vpar->mb.i_l_y = 1;
719 p_vpar->mb.i_c_y = 1;
724 p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
727 p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
729 /* Extension and User data. */
730 ExtensionAndUserData( p_vpar );
732 /* Picture data (ISO/IEC 13818-2 6.2.3.7). */
733 NextStartCode( p_vpar );
734 while( i_mb_address+i_mb_base < p_vpar->sequence.i_mb_size
735 && !p_vpar->picture.b_error && !p_vpar->b_die )
737 if( ((i_dummy = ShowBits( &p_vpar->bit_stream, 32 ))
738 < SLICE_START_CODE_MIN) ||
739 (i_dummy > SLICE_START_CODE_MAX) )
741 intf_DbgMsg("vpar debug: premature end of picture\n");
742 p_vpar->picture.b_error = 1;
745 RemoveBits32( &p_vpar->bit_stream );
747 /* Decode slice data. */
748 p_vpar->sequence.pf_slice_header( p_vpar, &i_mb_address, i_mb_base, i_dummy & 255 );
751 if( p_vpar->picture.b_error )
754 //fprintf(stderr, "Image trashee\n");
755 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb]; i_mb++ )
757 vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
759 vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
761 ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
763 /* Prepare context for the next picture. */
765 if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
766 p_vpar->picture.i_current_structure = 0;
768 else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
770 //fprintf(stderr, "Image parsee (%d)\n", p_vpar->picture.i_coding_type);
771 /* Frame completely parsed. */
772 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
774 vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
777 /* Link referenced pictures for the decoder
778 * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
779 if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
780 p_vpar->picture.i_coding_type == B_CODING_TYPE )
782 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
784 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
786 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
789 /* Send signal to the video_decoder. */
790 vlc_mutex_lock( &p_vpar->vfifo.lock );
791 vlc_cond_signal( &p_vpar->vfifo.wait );
792 vlc_mutex_unlock( &p_vpar->vfifo.lock );
794 /* Prepare context for the next picture. */
796 p_vpar->picture.i_current_structure = 0;
801 /*****************************************************************************
802 * SliceHeader : Parse the next slice structure
803 *****************************************************************************/
804 static __inline__ void SliceHeader( vpar_thread_t * p_vpar,
805 int * pi_mb_address, int i_mb_base,
808 /* DC predictors initialization table */
809 static int pi_dc_dct_reinit[4] = {128,256,512,1024};
811 int i_mb_address_save = *pi_mb_address;
813 /* slice_vertical_position_extension and priority_breakpoint already done */
814 LoadQuantizerScale( p_vpar );
816 if( GetBits( &p_vpar->bit_stream, 1 ) )
818 /* intra_slice, slice_id */
819 RemoveBits( &p_vpar->bit_stream, 8 );
820 /* extra_information_slice */
821 while( GetBits( &p_vpar->bit_stream, 1 ) )
823 RemoveBits( &p_vpar->bit_stream, 8 );
826 *pi_mb_address = (i_vert_code - 1)*p_vpar->sequence.i_mb_width;
828 /* Reset DC coefficients predictors (ISO/IEC 13818-2 7.2.1). Why
829 * does the reference decoder put 0 instead of the normative values ? */
830 p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
831 = p_vpar->slice.pi_dc_dct_pred[2]
832 = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
834 /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
835 memset( p_vpar->slice.pppi_pmv, 0, 8*sizeof(int) );
839 vpar_ParseMacroblock( p_vpar, pi_mb_address, i_mb_address_save,
841 i_mb_address_save = *pi_mb_address;
843 while( ShowBits( &p_vpar->bit_stream, 23 ) && !p_vpar->b_die );
844 NextStartCode( p_vpar );
847 /*****************************************************************************
848 * SliceHeaderXY : Parse the next slice structure
849 *****************************************************************************
850 * X = i_height > 2800 ?
851 * Y = scalable_mode == SC_DP ?
852 *****************************************************************************/
853 static void SliceHeader00( vpar_thread_t * p_vpar,
854 int * pi_mb_address, int i_mb_base,
857 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
860 static void SliceHeader01( vpar_thread_t * p_vpar,
861 int * pi_mb_address, int i_mb_base,
864 RemoveBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
865 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
868 static void SliceHeader10( vpar_thread_t * p_vpar,
869 int * pi_mb_address, int i_mb_base,
872 i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
873 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
876 static void SliceHeader11( vpar_thread_t * p_vpar,
877 int * pi_mb_address, int i_mb_base,
880 i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
881 RemoveBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
882 SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
885 /*****************************************************************************
886 * ExtensionAndUserData : Parse the extension_and_user_data structure
887 *****************************************************************************/
888 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
890 while( !p_vpar->b_die )
892 NextStartCode( p_vpar );
893 switch( ShowBits( &p_vpar->bit_stream, 32 ) )
895 case EXTENSION_START_CODE:
896 RemoveBits32( &p_vpar->bit_stream );
897 switch( GetBits( &p_vpar->bit_stream, 4 ) )
899 case SEQUENCE_DISPLAY_EXTENSION_ID:
900 SequenceDisplayExtension( p_vpar );
902 case QUANT_MATRIX_EXTENSION_ID:
903 QuantMatrixExtension( p_vpar );
905 case SEQUENCE_SCALABLE_EXTENSION_ID:
906 SequenceScalableExtension( p_vpar );
908 case PICTURE_DISPLAY_EXTENSION_ID:
909 PictureDisplayExtension( p_vpar );
911 case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
912 PictureSpatialScalableExtension( p_vpar );
914 case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
915 PictureTemporalScalableExtension( p_vpar );
917 case COPYRIGHT_EXTENSION_ID:
918 CopyrightExtension( p_vpar );
924 case USER_DATA_START_CODE:
925 RemoveBits32( &p_vpar->bit_stream );
926 /* Wait for the next start code */
936 /*****************************************************************************
937 * SequenceDisplayExtension : Parse the sequence_display_extension structure *
938 *****************************************************************************/
940 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
942 /* We don't care sequence_display_extension. */
944 RemoveBits( &p_vpar->bit_stream, 3 );
945 if( GetBits( &p_vpar->bit_stream, 1 ) )
947 /* Two bytes for color_desciption */
948 RemoveBits( &p_vpar->bit_stream, 16 );
949 p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
951 /* display_horizontal and vertical_size and a marker_bit */
952 RemoveBits( &p_vpar->bit_stream, 29 );
956 /*****************************************************************************
957 * QuantMatrixExtension : Load quantization matrices for luminance *
959 *****************************************************************************/
961 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
963 if( GetBits( &p_vpar->bit_stream, 1 ) )
965 /* Load intra_quantiser_matrix for luminance. */
966 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
970 /* Use the default matrix. */
971 LinkMatrix( &p_vpar->sequence.intra_quant,
972 pi_default_intra_quant );
974 if( GetBits( &p_vpar->bit_stream, 1 ) )
976 /* Load non_intra_quantiser_matrix for luminance. */
977 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
981 /* Use the default matrix. */
982 LinkMatrix( &p_vpar->sequence.nonintra_quant,
983 pi_default_nonintra_quant );
985 if( GetBits( &p_vpar->bit_stream, 1 ) )
987 /* Load intra_quantiser_matrix for chrominance. */
988 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
992 /* Link the chrominance intra matrix to the luminance one. */
993 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
994 p_vpar->sequence.intra_quant.pi_matrix );
996 if( GetBits( &p_vpar->bit_stream, 1 ) )
998 /* Load non_intra_quantiser_matrix for chrominance. */
999 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
1003 /* Link the chrominance intra matrix to the luminance one. */
1004 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
1005 p_vpar->sequence.intra_quant.pi_matrix );
1007 if( GetBits( &p_vpar->bit_stream, 1 ) )
1009 /* Load non_intra_quantiser_matrix for chrominance. */
1010 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
1014 /* Link the chrominance nonintra matrix to the luminance one. */
1015 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
1016 p_vpar->sequence.nonintra_quant.pi_matrix );
1021 /*****************************************************************************
1022 * SequenceScalableExtension : Parse the sequence_scalable_extension *
1023 * structure to handle scalable coding *
1024 *****************************************************************************/
1026 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
1028 /* We don't care about anything scalable except the scalable mode. */
1029 switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
1030 /* The length of the structure depends on the value of the scalable_mode */
1033 RemoveBits32( &p_vpar->bit_stream );
1034 RemoveBits( &p_vpar->bit_stream, 21 );
1037 RemoveBits( &p_vpar->bit_stream, 12 );
1040 RemoveBits( &p_vpar->bit_stream, 4 );
1044 /*****************************************************************************
1045 * PictureDisplayExtension : Parse the picture_display_extension structure *
1046 *****************************************************************************/
1048 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
1050 /* Number of frame center offset */
1052 /* I am not sure it works but it should
1053 (fewer tests than shown in §6.3.12) */
1054 i_nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
1055 p_vpar->picture.b_repeat_first_field +
1056 p_vpar->picture.b_top_field_first
1057 : ( p_vpar->picture.b_frame_structure + 1 ) +
1058 p_vpar->picture.b_repeat_first_field;
1059 for( i_dummy = 0; i_dummy < i_nb; i_dummy++ )
1061 RemoveBits( &p_vpar->bit_stream, 17 );
1062 RemoveBits( &p_vpar->bit_stream, 17 );
1067 /*****************************************************************************
1068 * PictureSpatialScalableExtension *
1069 *****************************************************************************/
1071 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
1073 /* That's scalable, so we trash it */
1074 RemoveBits32( &p_vpar->bit_stream );
1075 RemoveBits( &p_vpar->bit_stream, 16 );
1079 /*****************************************************************************
1080 * PictureTemporalScalableExtension *
1081 *****************************************************************************/
1083 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1085 /* Scalable again, trashed again */
1086 RemoveBits( &p_vpar->bit_stream, 23 );
1090 /*****************************************************************************
1091 * CopyrightExtension : Keeps some legal informations *
1092 *****************************************************************************/
1094 static void CopyrightExtension( vpar_thread_t * p_vpar )
1096 u32 i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1097 p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1098 /* A flag that says whether the copyright information is significant */
1099 p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1100 /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1101 p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1103 RemoveBits( &p_vpar->bit_stream, 8 );
1104 /* The copyright_number is split in three parts */
1106 i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1107 RemoveBits( &p_vpar->bit_stream, 1 );
1109 i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1110 RemoveBits( &p_vpar->bit_stream, 1 );
1111 /* third part and sum */
1112 p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) |
1113 ( (u64)i_copyright_nb_2 << 22 ) |
1114 ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );