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 "vpar_synchro.h"
37 #include "video_parser.h"
38 #include "video_fifo.h"
43 typedef void (*f_picture_data_t)( vpar_thread_t*, int );
48 static __inline__ void NextStartCode( vpar_thread_t * p_vpar );
49 static void SequenceHeader( vpar_thread_t * p_vpar );
50 static void GroupHeader( vpar_thread_t * p_vpar );
51 static void PictureHeader( vpar_thread_t * p_vpar );
52 static void ExtensionAndUserData( vpar_thread_t * p_vpar );
53 static void QuantMatrixExtension( vpar_thread_t * p_vpar );
54 static void SequenceScalableExtension( vpar_thread_t * p_vpar );
55 static void SequenceDisplayExtension( vpar_thread_t * p_vpar );
56 static void PictureDisplayExtension( vpar_thread_t * p_vpar );
57 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar );
58 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar );
59 static void CopyrightExtension( vpar_thread_t * p_vpar );
65 /*****************************************************************************
66 * pi_default_intra_quant : default quantization matrix
67 *****************************************************************************/
69 int pi_default_intra_quant[] =
71 8, 16, 19, 22, 26, 27, 29, 34,
72 16, 16, 22, 24, 27, 29, 34, 37,
73 19, 22, 26, 27, 29, 34, 34, 38,
74 22, 22, 26, 27, 29, 34, 37, 40,
75 22, 26, 27, 29, 32, 35, 40, 48,
76 26, 27, 29, 32, 35, 40, 48, 58,
77 26, 27, 29, 34, 38, 46, 56, 69,
78 27, 29, 35, 38, 46, 56, 69, 83
81 int pi_default_intra_quant[] =
83 2048, 5681, 6355, 6623, 6656, 5431, 4018, 2401,
84 5681, 7880, 10207, 10021, 9587, 8091, 6534, 3625,
85 6355, 10207, 11363, 10619, 9700, 8935, 6155, 3507,
86 6623, 9186, 10226, 9557, 8730, 8041, 6028, 3322,
87 5632, 9232, 9031, 8730, 8192, 7040, 5542, 3390,
88 5230, 7533, 7621, 7568, 7040, 6321, 5225, 3219,
89 3602, 5189, 5250, 5539, 5265, 5007, 4199, 2638,
90 1907, 2841, 3230, 3156, 3249, 3108, 2638, 1617
94 /*****************************************************************************
95 * pi_default_nonintra_quant : default quantization matrix
96 *****************************************************************************/
98 int pi_default_nonintra_quant[] =
100 16, 16, 16, 16, 16, 16, 16, 16,
101 16, 16, 16, 16, 16, 16, 16, 16,
102 16, 16, 16, 16, 16, 16, 16, 16,
103 16, 16, 16, 16, 16, 16, 16, 16,
104 16, 16, 16, 16, 16, 16, 16, 16,
105 16, 16, 16, 16, 16, 16, 16, 16,
106 16, 16, 16, 16, 16, 16, 16, 16,
107 16, 16, 16, 16, 16, 16, 16, 16
110 int pi_default_nonintra_quanit[] =
112 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
113 5680, 7888, 7424, 6688, 5680, 4464, 3072, 1568,
114 5344, 7424, 6992, 6288, 5344, 4208, 2896, 1472,
115 4816, 6688, 6288, 5664, 4816, 3792, 2608, 1328,
116 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
117 3216, 4464, 4208, 3792, 3216, 2528, 1744, 880,
118 2224, 3072, 2896, 2608, 2224, 1744, 1200, 608,
119 1136, 1568, 1472, 1328, 1136, 880, 608, 304
123 /*****************************************************************************
124 * pi_scan : zig-zag and alternate scan patterns
125 *****************************************************************************/
128 { /* Zig-Zag pattern */
129 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
130 12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
131 35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
132 58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
134 { /* Alternate scan pattern */
135 0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
136 41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
137 51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
138 53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
143 * Local inline functions.
146 /*****************************************************************************
147 * ReferenceUpdate : Update the reference pointers when we have a new picture
148 *****************************************************************************/
149 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
151 picture_t * p_newref )
153 if( i_coding_type != B_CODING_TYPE )
155 if( p_vpar->sequence.p_forward != NULL )
156 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
157 if( p_vpar->sequence.p_backward != NULL )
160 vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
161 vpar_SynchroDate( p_vpar ) );
164 date = vpar_SynchroDate( p_vpar );
165 vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
167 if( p_vpar->synchro.i_coding_type == I_CODING_TYPE )
168 vpar_SynchroKludge( p_vpar, date );
171 p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
172 p_vpar->sequence.p_backward = p_newref;
173 if( p_newref != NULL )
174 vout_LinkPicture( p_vpar->p_vout, p_newref );
176 p_vpar->synchro.i_coding_type = i_coding_type;
179 else if( p_newref != NULL )
181 /* Put date immediately. */
182 vout_DatePicture( p_vpar->p_vout, p_newref,
183 vpar_SynchroDate( p_vpar ) );
187 /*****************************************************************************
188 * ReferenceReplace : Replace the last reference pointer when we destroy
190 *****************************************************************************/
191 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
193 picture_t * p_newref )
195 if( i_coding_type != B_CODING_TYPE )
197 if( p_vpar->sequence.p_backward != NULL )
198 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
199 p_vpar->sequence.p_backward = p_newref;
200 if( p_newref != NULL )
201 vout_LinkPicture( p_vpar->p_vout, p_newref );
205 /*****************************************************************************
206 * LoadMatrix : Load a quantization matrix
207 *****************************************************************************/
208 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar, quant_matrix_t * p_matrix )
212 if( !p_matrix->b_allocated )
214 /* Allocate a piece of memory to load the matrix. */
215 if( (p_matrix->pi_matrix = (int *)malloc( 64*sizeof(int) )) == NULL )
217 intf_ErrMsg("vpar error: allocation error in LoadMatrix()\n");
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 )
242 if( p_matrix->b_allocated )
244 /* Deallocate the piece of memory. */
245 free( p_matrix->pi_matrix );
246 p_matrix->b_allocated = 0;
249 p_matrix->pi_matrix = pi_array;
253 * Exported functions.
256 /*****************************************************************************
257 * vpar_NextSequenceHeader : Find the next sequence header
258 *****************************************************************************/
259 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
261 while( !p_vpar->b_die )
263 NextStartCode( p_vpar );
264 if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
266 RemoveBits( &p_vpar->bit_stream, 8 );
271 /*****************************************************************************
272 * vpar_ParseHeader : Parse the next header
273 *****************************************************************************/
274 int vpar_ParseHeader( vpar_thread_t * p_vpar )
276 while( !p_vpar->b_die )
278 NextStartCode( p_vpar );
279 switch( GetBits32( &p_vpar->bit_stream ) )
281 case SEQUENCE_HEADER_CODE:
282 SequenceHeader( p_vpar );
286 case GROUP_START_CODE:
287 GroupHeader( p_vpar );
291 case PICTURE_START_CODE:
292 PictureHeader( p_vpar );
296 case SEQUENCE_END_CODE:
297 intf_DbgMsg("vpar debug: sequence end code received\n");
309 * Following functions are local
312 /*****************************************************************************
313 * SequenceHeader : Parse the next sequence header
314 *****************************************************************************/
315 static void SequenceHeader( vpar_thread_t * p_vpar )
318 static float r_frame_rate_table[16] =
321 ((23.0*1000.0)/1001.0),
324 ((30.0*1000.0)/1001.0),
327 ((60.0*1000.0)/1001.0),
329 RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
333 int i_height_save, i_width_save;
335 i_height_save = p_vpar->sequence.i_height;
336 i_width_save = p_vpar->sequence.i_width;
338 p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
339 p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
340 p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
341 p_vpar->sequence.r_frame_rate =
342 r_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
344 /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
345 * constrained_parameters_flag */
346 RemoveBits( &p_vpar->bit_stream, 30 );
349 * Quantization matrices
351 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
353 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
357 /* Use default matrix. */
358 LinkMatrix( &p_vpar->sequence.intra_quant, pi_default_intra_quant );
361 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
363 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
367 /* Use default matrix. */
368 LinkMatrix( &p_vpar->sequence.nonintra_quant, pi_default_nonintra_quant );
371 /* Unless later overwritten by a matrix extension, we have the same
372 * matrices for luminance and chrominance. */
373 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
374 p_vpar->sequence.intra_quant.pi_matrix );
375 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
376 p_vpar->sequence.nonintra_quant.pi_matrix );
381 NextStartCode( p_vpar );
382 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
386 /* Turn the MPEG2 flag on */
387 p_vpar->sequence.b_mpeg2 = 1;
389 /* Parse sequence_extension */
390 RemoveBits32( &p_vpar->bit_stream );
391 /* extension_start_code_identifier, profile_and_level_indication */
392 RemoveBits( &p_vpar->bit_stream, 12 );
393 p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
394 p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
395 p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
396 p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
397 /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
398 RemoveBits( &p_vpar->bit_stream, 22 );
399 /* frame_rate_extension_n */
400 i_dummy = GetBits( &p_vpar->bit_stream, 2 );
401 /* frame_rate_extension_d */
402 p_vpar->sequence.r_frame_rate *= (i_dummy + 1)
403 / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
407 /* It's an MPEG-1 stream. Put adequate parameters. */
409 p_vpar->sequence.b_mpeg2 = 0;
410 p_vpar->sequence.b_progressive = 1;
411 p_vpar->sequence.i_chroma_format = CHROMA_420;
415 p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
416 p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
417 (p_vpar->sequence.i_height + 15) / 16 :
418 2 * ((p_vpar->sequence.i_height + 31) / 32);
419 p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
420 * p_vpar->sequence.i_mb_height;
421 p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
422 p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
423 p_vpar->sequence.i_size = p_vpar->sequence.i_width
424 * p_vpar->sequence.i_height;
426 /* Update chromatic information. */
427 switch( p_vpar->sequence.i_chroma_format )
430 p_vpar->sequence.i_chroma_nb_blocks = 2;
431 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
432 p_vpar->sequence.i_chroma_mb_width = 8;
433 p_vpar->sequence.i_chroma_mb_height = 8;
437 p_vpar->sequence.i_chroma_nb_blocks = 4;
438 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
439 p_vpar->sequence.i_chroma_mb_width = 8;
440 p_vpar->sequence.i_chroma_mb_height = 16;
444 p_vpar->sequence.i_chroma_nb_blocks = 8;
445 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
446 p_vpar->sequence.i_chroma_mb_width = 16;
447 p_vpar->sequence.i_chroma_mb_height = 16;
450 /* Reset scalable_mode. */
451 p_vpar->sequence.i_scalable_mode = SC_NONE;
454 if( p_vpar->sequence.i_width != i_width_save
455 || p_vpar->sequence.i_height != i_height_save )
457 /* What do we do in case of a size change ??? */
461 /* Extension and User data */
462 ExtensionAndUserData( p_vpar );
465 /*****************************************************************************
466 * GroupHeader : Parse the next group of pictures header
467 *****************************************************************************/
468 static void GroupHeader( vpar_thread_t * p_vpar )
470 /* Nothing to do, we don't care. */
471 RemoveBits( &p_vpar->bit_stream, 27 );
472 ExtensionAndUserData( p_vpar );
475 /*****************************************************************************
476 * PictureHeader : Parse the next picture header
477 *****************************************************************************/
478 static void PictureHeader( vpar_thread_t * p_vpar )
480 /* Table of optimized PictureData functions. */
481 static f_picture_data_t ppf_picture_data[4][4] =
484 NULL, NULL, NULL, NULL
488 #if (VPAR_OPTIM_LEVEL > 1)
489 NULL, vpar_PictureData2I420TZ, vpar_PictureData2P420TZ,
490 vpar_PictureData2B420TZ
492 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
493 vpar_PictureDataGENERIC
498 #if (VPAR_OPTIM_LEVEL > 1)
499 NULL, vpar_PictureData2I420BZ, vpar_PictureData2P420BZ,
500 vpar_PictureData2B420BZ
502 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
503 vpar_PictureDataGENERIC
508 #if (VPAR_OPTIM_LEVEL > 0)
509 NULL, vpar_PictureData2I420F0, vpar_PictureData2P420F0,
510 vpar_PictureData2B420F0
512 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
513 vpar_PictureDataGENERIC
520 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 RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
529 if( p_vpar->picture.i_coding_type == P_CODING_TYPE
530 || p_vpar->picture.i_coding_type == B_CODING_TYPE )
532 p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
533 p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
535 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
537 p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
538 p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
541 /* extra_information_picture */
542 while( GetBits( &p_vpar->bit_stream, 1 ) )
544 RemoveBits( &p_vpar->bit_stream, 8 );
548 * Picture Coding Extension
550 NextStartCode( p_vpar );
551 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
553 /* Parse picture_coding_extension */
554 RemoveBits32( &p_vpar->bit_stream );
555 /* extension_start_code_identifier */
556 RemoveBits( &p_vpar->bit_stream, 4 );
558 p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
559 p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
560 p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
561 p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
562 p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
563 i_structure = GetBits( &p_vpar->bit_stream, 2 );
564 p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
565 p_vpar->picture.b_frame_pred_frame_dct
566 = GetBits( &p_vpar->bit_stream, 1 );
567 p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
568 p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
569 p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
570 p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
571 p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
572 /* repeat_first_field (ISO/IEC 13818-2 6.3.10 is necessary to know
573 * the length of the picture_display_extension structure.
574 * chroma_420_type (obsolete) */
575 RemoveBits( &p_vpar->bit_stream, 1 );
576 p_vpar->picture.b_progressive_frame = GetBits( &p_vpar->bit_stream, 1 );
578 /* composite_display_flag */
579 if( GetBits( &p_vpar->bit_stream, 1 ) )
581 /* v_axis, field_sequence, sub_carrier, burst_amplitude,
582 * sub_carrier_phase */
583 RemoveBits( &p_vpar->bit_stream, 20 );
588 /* MPEG-1 compatibility flags */
589 p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
590 i_structure = FRAME_STRUCTURE;
591 p_vpar->picture.b_frame_pred_frame_dct = 1;
592 p_vpar->picture.b_concealment_mv = 0;
593 p_vpar->picture.b_q_scale_type = 0;
594 p_vpar->picture.b_intra_vlc_format = 0;
595 p_vpar->picture.b_alternate_scan = 0; /* zigzag */
596 p_vpar->picture.b_repeat_first_field = 0;
597 p_vpar->picture.b_progressive_frame = 1;
600 if( p_vpar->picture.i_current_structure &&
601 (i_structure == FRAME_STRUCTURE ||
602 i_structure == p_vpar->picture.i_current_structure) )
604 /* We don't have the second field of the buffered frame. */
605 if( p_vpar->picture.p_picture != NULL )
607 ReferenceReplace( p_vpar,
608 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] );
618 vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
621 p_vpar->picture.i_current_structure = 0;
623 intf_DbgMsg("vpar debug: odd number of field picture.\n");
626 /* Do we have the reference pictures ? */
627 b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
628 (p_vpar->sequence.p_backward == NULL)) ||
629 /* p_backward will become p_forward later */
630 ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
631 (p_vpar->sequence.p_forward == NULL ||
632 p_vpar->sequence.p_backward == NULL)));
636 if( p_vpar->picture.i_current_structure )
638 /* Second field of a frame. We will decode it if, and only if we
639 * have decoded the first field. */
640 b_parsable = (p_vpar->picture.p_picture != NULL);
644 /* Does synchro say we have enough time to decode it ? */
645 b_parsable = vpar_SynchroChoose( p_vpar,
646 p_vpar->picture.i_coding_type, i_structure );
652 /* Update the reference pointers. */
653 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
655 /* Warn Synchro we have trashed a picture. */
656 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
658 /* Update context. */
659 if( i_structure != FRAME_STRUCTURE )
660 p_vpar->picture.i_current_structure = i_structure;
661 p_vpar->picture.p_picture = NULL;
666 /* OK, now we are sure we will decode the picture. */
667 #define P_picture p_vpar->picture.p_picture
668 p_vpar->picture.b_error = 0;
669 p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
671 if( !p_vpar->picture.i_current_structure )
673 /* This is a new frame. Get a structure from the video_output. */
674 while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
675 99+p_vpar->sequence.i_chroma_format, /*???*/
676 p_vpar->sequence.i_width,
677 p_vpar->sequence.i_height ) )
680 intf_DbgMsg("vpar debug: allocation error in vout_CreatePicture, delaying\n");
681 if( p_vpar->b_die || p_vpar->b_error )
685 msleep( VPAR_OUTMEM_SLEEP );
688 /* Initialize values. */
689 vpar_SynchroDecode( p_vpar, p_vpar->picture.i_coding_type, i_structure );
690 P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
691 P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
692 p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
693 << ( 1 - p_vpar->picture.b_frame_structure ) );
694 p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
695 << ( 1 - p_vpar->picture.b_frame_structure ));
697 P_picture->i_deccount = p_vpar->sequence.i_mb_size;
698 vlc_mutex_init( &p_vpar->picture.p_picture->lock_deccount );
700 memset( p_vpar->picture.pp_mb, 0, MAX_MB*sizeof(macroblock_t *) );
702 /* FIXME ! remove asap */
703 //memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
705 /* Update the reference pointers. */
706 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
709 /* Link referenced pictures for the decoder
710 * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
711 if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
712 p_vpar->picture.i_coding_type == B_CODING_TYPE )
714 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
716 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
718 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
722 p_vpar->picture.i_current_structure |= i_structure;
723 p_vpar->picture.i_structure = i_structure;
725 /* Initialize picture data for decoding. */
726 if( i_structure == BOTTOM_FIELD )
728 i_mb_base = p_vpar->sequence.i_mb_size >> 1;
729 p_vpar->mb.i_l_y = 1;
730 p_vpar->mb.i_c_y = 1;
735 p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
737 p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
739 /* Extension and User data. */
740 ExtensionAndUserData( p_vpar );
742 /* Picture data (ISO/IEC 13818-2 6.2.3.7). */
743 if( p_vpar->sequence.i_chroma_format != CHROMA_420
744 || !p_vpar->sequence.b_mpeg2 || p_vpar->sequence.i_height > 2800
745 || p_vpar->sequence.i_scalable_mode == SC_DP )
747 /* Weird stream. Use the slower generic function. */
748 vpar_PictureDataGENERIC( p_vpar, i_mb_base );
752 /* Try to find an optimized function. */
753 ppf_picture_data[p_vpar->picture.i_structure]
754 [p_vpar->picture.i_coding_type]( p_vpar, i_mb_base );
757 if( p_vpar->b_die || p_vpar->b_error )
762 if( p_vpar->picture.b_error )
765 //fprintf(stderr, "Image trashee\n");
767 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
769 vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
773 if( P_picture->i_deccount != 1 )
775 vout_DestroyPicture( p_vpar->p_vout, P_picture );
778 ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
780 /* Prepare context for the next picture. */
782 if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
783 p_vpar->picture.i_current_structure = 0;
785 else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
787 //fprintf(stderr, "Image parsee (%d)\n", p_vpar->picture.i_coding_type);
788 /* Frame completely parsed. */
790 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
792 vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
795 /* Send signal to the video_decoder. */
796 vlc_mutex_lock( &p_vpar->vfifo.lock );
797 vlc_cond_signal( &p_vpar->vfifo.wait );
798 vlc_mutex_unlock( &p_vpar->vfifo.lock );
801 /* Prepare context for the next picture. */
803 p_vpar->picture.i_current_structure = 0;
808 /*****************************************************************************
809 * ExtensionAndUserData : Parse the extension_and_user_data structure
810 *****************************************************************************/
811 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
813 while( !p_vpar->b_die )
815 NextStartCode( p_vpar );
816 switch( ShowBits( &p_vpar->bit_stream, 32 ) )
818 case EXTENSION_START_CODE:
819 RemoveBits32( &p_vpar->bit_stream );
820 switch( GetBits( &p_vpar->bit_stream, 4 ) )
822 case SEQUENCE_DISPLAY_EXTENSION_ID:
823 SequenceDisplayExtension( p_vpar );
825 case QUANT_MATRIX_EXTENSION_ID:
826 QuantMatrixExtension( p_vpar );
828 case SEQUENCE_SCALABLE_EXTENSION_ID:
829 SequenceScalableExtension( p_vpar );
831 case PICTURE_DISPLAY_EXTENSION_ID:
832 PictureDisplayExtension( p_vpar );
834 case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
835 PictureSpatialScalableExtension( p_vpar );
837 case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
838 PictureTemporalScalableExtension( p_vpar );
840 case COPYRIGHT_EXTENSION_ID:
841 CopyrightExtension( p_vpar );
847 case USER_DATA_START_CODE:
848 RemoveBits32( &p_vpar->bit_stream );
849 /* Wait for the next start code */
859 /*****************************************************************************
860 * SequenceDisplayExtension : Parse the sequence_display_extension structure *
861 *****************************************************************************/
863 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
865 /* We don't care sequence_display_extension. */
867 RemoveBits( &p_vpar->bit_stream, 3 );
868 if( GetBits( &p_vpar->bit_stream, 1 ) )
870 /* Two bytes for color_desciption */
871 RemoveBits( &p_vpar->bit_stream, 16 );
872 p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
874 /* display_horizontal and vertical_size and a marker_bit */
875 RemoveBits( &p_vpar->bit_stream, 29 );
879 /*****************************************************************************
880 * QuantMatrixExtension : Load quantization matrices for luminance *
882 *****************************************************************************/
884 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
886 if( GetBits( &p_vpar->bit_stream, 1 ) )
888 /* Load intra_quantiser_matrix for luminance. */
889 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
893 /* Use the default matrix. */
894 LinkMatrix( &p_vpar->sequence.intra_quant,
895 pi_default_intra_quant );
897 if( GetBits( &p_vpar->bit_stream, 1 ) )
899 /* Load non_intra_quantiser_matrix for luminance. */
900 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
904 /* Use the default matrix. */
905 LinkMatrix( &p_vpar->sequence.nonintra_quant,
906 pi_default_nonintra_quant );
908 if( GetBits( &p_vpar->bit_stream, 1 ) )
910 /* Load intra_quantiser_matrix for chrominance. */
911 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
915 /* Link the chrominance intra matrix to the luminance one. */
916 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
917 p_vpar->sequence.intra_quant.pi_matrix );
919 if( GetBits( &p_vpar->bit_stream, 1 ) )
921 /* Load non_intra_quantiser_matrix for chrominance. */
922 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
926 /* Link the chrominance intra matrix to the luminance one. */
927 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
928 p_vpar->sequence.intra_quant.pi_matrix );
930 if( GetBits( &p_vpar->bit_stream, 1 ) )
932 /* Load non_intra_quantiser_matrix for chrominance. */
933 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
937 /* Link the chrominance nonintra matrix to the luminance one. */
938 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
939 p_vpar->sequence.nonintra_quant.pi_matrix );
944 /*****************************************************************************
945 * SequenceScalableExtension : Parse the sequence_scalable_extension *
946 * structure to handle scalable coding *
947 *****************************************************************************/
949 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
951 /* We don't care about anything scalable except the scalable mode. */
952 switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
953 /* The length of the structure depends on the value of the scalable_mode */
956 RemoveBits32( &p_vpar->bit_stream );
957 RemoveBits( &p_vpar->bit_stream, 21 );
960 RemoveBits( &p_vpar->bit_stream, 12 );
963 RemoveBits( &p_vpar->bit_stream, 4 );
967 /*****************************************************************************
968 * PictureDisplayExtension : Parse the picture_display_extension structure *
969 *****************************************************************************/
971 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
973 /* Number of frame center offset */
975 /* I am not sure it works but it should
976 (fewer tests than shown in §6.3.12) */
977 i_nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
978 p_vpar->picture.b_repeat_first_field +
979 p_vpar->picture.b_top_field_first
980 : ( p_vpar->picture.b_frame_structure + 1 ) +
981 p_vpar->picture.b_repeat_first_field;
982 for( i_dummy = 0; i_dummy < i_nb; i_dummy++ )
984 RemoveBits( &p_vpar->bit_stream, 17 );
985 RemoveBits( &p_vpar->bit_stream, 17 );
990 /*****************************************************************************
991 * PictureSpatialScalableExtension *
992 *****************************************************************************/
994 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
996 /* That's scalable, so we trash it */
997 RemoveBits32( &p_vpar->bit_stream );
998 RemoveBits( &p_vpar->bit_stream, 16 );
1002 /*****************************************************************************
1003 * PictureTemporalScalableExtension *
1004 *****************************************************************************/
1006 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1008 /* Scalable again, trashed again */
1009 RemoveBits( &p_vpar->bit_stream, 23 );
1013 /*****************************************************************************
1014 * CopyrightExtension : Keeps some legal informations *
1015 *****************************************************************************/
1017 static void CopyrightExtension( vpar_thread_t * p_vpar )
1019 u32 i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1020 p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1021 /* A flag that says whether the copyright information is significant */
1022 p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1023 /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1024 p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1026 RemoveBits( &p_vpar->bit_stream, 8 );
1027 /* The copyright_number is split in three parts */
1029 i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1030 RemoveBits( &p_vpar->bit_stream, 1 );
1032 i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1033 RemoveBits( &p_vpar->bit_stream, 1 );
1034 /* third part and sum */
1035 p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) |
1036 ( (u64)i_copyright_nb_2 << 22 ) |
1037 ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );