]> git.sesse.net Git - vlc/blob - src/video_parser/vpar_headers.c
Avancement du debuggage du motion.
[vlc] / src / video_parser / vpar_headers.c
1 /*****************************************************************************
2  * vpar_headers.c : headers parsing
3  * (c)1999 VideoLAN
4  *****************************************************************************/
5
6 /*****************************************************************************
7  * Preamble
8  *****************************************************************************/
9 #include <errno.h>
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <unistd.h>
13 #include <string.h>
14 #include <sys/uio.h>
15 #include <X11/Xlib.h>
16 #include <X11/extensions/XShm.h>
17
18 #include "config.h"
19 #include "common.h"
20 #include "mtime.h"
21 #include "vlc_thread.h"
22
23 #include "intf_msg.h"
24 #include "debug.h"                    /* ?? temporaire, requis par netlist.h */
25
26 #include "input.h"
27 #include "input_netlist.h"
28 #include "decoder_fifo.h"
29 #include "video.h"
30 #include "video_output.h"
31
32 #include "vdec_idct.h"
33 #include "video_decoder.h"
34 #include "vdec_motion.h"
35
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"
42
43 /*
44  * Local prototypes
45  */
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,
52                            u32 i_vert_code );
53 static void SliceHeader01( vpar_thread_t * p_vpar,
54                            int * pi_mb_address, int i_mb_base,
55                            u32 i_vert_code );
56 static void SliceHeader10( vpar_thread_t * p_vpar,
57                            int * pi_mb_address, int i_mb_base,
58                            u32 i_vert_code );
59 static void SliceHeader11( vpar_thread_t * p_vpar,
60                            int * pi_mb_address, int i_mb_base,
61                            u32 i_vert_code );
62 static __inline__ void SliceHeader( vpar_thread_t * p_vpar,
63                                     int * pi_mb_address, int i_mb_base,
64                                     u32 i_vert_code );
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 );
73
74 /*
75  * Standard variables
76  */
77
78 /*****************************************************************************
79  * pi_default_intra_quant : default quantization matrix
80  *****************************************************************************/
81 #ifndef VDEC_DFT
82 int pi_default_intra_quant[] =
83 {
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
92 };      
93 #else
94 int pi_default_intra_quant[] =
95 {
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        
104 };
105 #endif
106
107 /*****************************************************************************
108  * pi_default_nonintra_quant : default quantization matrix
109  *****************************************************************************/
110 #ifndef VDEC_DFT
111 int pi_default_nonintra_quant[] =
112 {
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
121 };
122 #else
123 int pi_default_nonintra_quanit[] =
124 {
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 
133 };
134 #endif
135
136 /*****************************************************************************
137  * pi_scan : zig-zag and alternate scan patterns
138  *****************************************************************************/
139 u8 pi_scan[2][64] =
140 {
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
146     },
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
152     }
153 };
154
155 /*
156  * Local inline functions.
157  */
158
159 /*****************************************************************************
160  * NextStartCode : Find the next start code
161  *****************************************************************************/
162 static __inline__ void NextStartCode( vpar_thread_t * p_vpar )
163 {
164     /* Re-align the buffer on an 8-bit boundary */
165     RealignBits( &p_vpar->bit_stream );
166
167     while( ShowBits( &p_vpar->bit_stream, 24 ) != 0x01L && !p_vpar->b_die )
168     {
169         RemoveBits( &p_vpar->bit_stream, 8 );
170     }
171 }
172
173 /*****************************************************************************
174  * ReferenceUpdate : Update the reference pointers when we have a new picture
175  *****************************************************************************/
176 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
177                                         int i_coding_type,
178                                         picture_t * p_newref )
179 {
180     if( i_coding_type != B_CODING_TYPE )
181     {
182         if( p_vpar->sequence.p_forward != NULL )
183             vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
184         p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
185         p_vpar->sequence.p_backward = p_newref;
186         if( p_newref != NULL )
187             vout_LinkPicture( p_vpar->p_vout, p_newref );
188     }
189 }
190
191 /*****************************************************************************
192  * ReferenceReplace : Replace the last reference pointer when we destroy
193  * a picture
194  *****************************************************************************/
195 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
196                                          int i_coding_type,
197                                          picture_t * p_newref )
198 {
199     if( i_coding_type != B_CODING_TYPE )
200     {
201         if( p_vpar->sequence.p_backward != NULL )
202             vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
203         p_vpar->sequence.p_backward = p_newref;
204         if( p_newref != NULL )
205             vout_LinkPicture( p_vpar->p_vout, p_newref );
206     }
207 }
208
209 /*****************************************************************************
210  * LoadMatrix : Load a quantization matrix
211  *****************************************************************************/
212 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar, quant_matrix_t * p_matrix )
213 {
214     int i_dummy;
215     
216     if( !p_matrix->b_allocated )
217     {
218         /* Allocate a piece of memory to load the matrix. */
219         p_matrix->pi_matrix = (int *)malloc( 64*sizeof(int) );
220         p_matrix->b_allocated = 1;
221     }
222     
223     for( i_dummy = 0; i_dummy < 64; i_dummy++ )
224     {
225         p_matrix->pi_matrix[pi_scan[SCAN_ZIGZAG][i_dummy]]
226              = GetBits( &p_vpar->bit_stream, 8 );
227     }
228
229 #ifdef VDEC_DFT
230     /* Discrete Fourier Transform requires the quantization matrices to
231      * be normalized before using them. */
232     vdec_NormQuantMatrix( p_matrix->pi_matrix );
233 #endif
234 }
235
236 /*****************************************************************************
237  * LinkMatrix : Link a quantization matrix to another
238  *****************************************************************************/
239 static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, int * pi_array )
240 {
241     if( p_matrix->b_allocated )
242     {
243         /* Deallocate the piece of memory. */
244         free( p_matrix->pi_matrix );
245         p_matrix->b_allocated = 0;
246     }
247     
248     p_matrix->pi_matrix = pi_array;
249 }
250
251 /*
252  * Exported functions.
253  */
254
255 /*****************************************************************************
256  * vpar_NextSequenceHeader : Find the next sequence header
257  *****************************************************************************/
258 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
259 {
260     while( !p_vpar->b_die )
261     {
262         NextStartCode( p_vpar );
263         if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
264             return 0;
265         RemoveBits( &p_vpar->bit_stream, 8 );
266     }
267     return 1;
268 }
269
270 /*****************************************************************************
271  * vpar_ParseHeader : Parse the next header
272  *****************************************************************************/
273 int vpar_ParseHeader( vpar_thread_t * p_vpar )
274 {
275     while( !p_vpar->b_die )
276     {
277         NextStartCode( p_vpar );
278         switch( GetBits32( &p_vpar->bit_stream ) )
279         {
280         case SEQUENCE_HEADER_CODE:
281             SequenceHeader( p_vpar );
282             return 0;
283             break;
284
285         case GROUP_START_CODE:
286             GroupHeader( p_vpar );
287             return 0;
288             break;
289
290         case PICTURE_START_CODE:
291             PictureHeader( p_vpar );
292             return 0;
293             break;
294
295         case SEQUENCE_END_CODE:
296             intf_DbgMsg("vpar debug: sequence end code received\n");
297             return 1;
298             break;
299
300         default:
301         }
302     }
303
304     return 0;
305 }
306
307 /*
308  * Following functions are local
309  */
310
311 /*****************************************************************************
312  * SequenceHeader : Parse the next sequence header
313  *****************************************************************************/
314 static void SequenceHeader( vpar_thread_t * p_vpar )
315 {
316 #define RESERVED    -1 
317     static float r_frame_rate_table[16] =
318     {
319         0.0,
320         ((23.0*1000.0)/1001.0),
321         24.0,
322         25.0,
323         ((30.0*1000.0)/1001.0),
324         30.0,
325         50.0,
326         ((60.0*1000.0)/1001.0),
327         60.0,
328         RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
329     };
330 #undef RESERVED
331
332     int i_height_save, i_width_save;
333     
334     i_height_save = p_vpar->sequence.i_height;
335     i_width_save = p_vpar->sequence.i_width;
336
337     p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
338     p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
339     p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
340     p_vpar->sequence.r_frame_rate =
341             r_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
342
343     /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
344      * constrained_parameters_flag */
345     RemoveBits( &p_vpar->bit_stream, 30 );
346     
347     /*
348      * Quantization matrices
349      */
350     if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
351     {
352         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
353     }
354     else
355     {
356         /* Use default matrix. */
357         LinkMatrix( &p_vpar->sequence.intra_quant, pi_default_intra_quant );
358     }
359     
360     if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
361     {
362         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
363     }
364     else
365     {
366         /* Use default matrix. */
367         LinkMatrix( &p_vpar->sequence.nonintra_quant, pi_default_nonintra_quant );
368     }
369     
370     /* Unless later overwritten by a matrix extension, we have the same
371      * matrices for luminance and chrominance. */
372     LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
373                 p_vpar->sequence.intra_quant.pi_matrix );
374     LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
375                 p_vpar->sequence.nonintra_quant.pi_matrix );
376
377     /*
378      * Sequence Extension
379      */
380     NextStartCode( p_vpar );
381     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
382     {
383         int                         i_dummy;
384         static f_chroma_pattern_t   ppf_chroma_pattern[4] =
385                             {NULL, vpar_CodedPattern420,
386                              vpar_CodedPattern422, vpar_CodedPattern444};
387
388         /* Turn the MPEG2 flag on */
389         p_vpar->sequence.b_mpeg2 = 1;
390     
391         /* Parse sequence_extension */
392         RemoveBits32( &p_vpar->bit_stream );
393         /* extension_start_code_identifier, profile_and_level_indication */
394         RemoveBits( &p_vpar->bit_stream, 12 );
395         p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
396         p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
397         p_vpar->sequence.pf_decode_pattern = ppf_chroma_pattern
398                                     [p_vpar->sequence.i_chroma_format];
399         p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
400         p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
401         /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
402         RemoveBits( &p_vpar->bit_stream, 22 );
403         /* frame_rate_extension_n */
404         i_dummy = GetBits( &p_vpar->bit_stream, 2 );
405         /* frame_rate_extension_d */
406         p_vpar->sequence.r_frame_rate *= (i_dummy + 1)
407                                   / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
408
409         p_vpar->sequence.pf_decode_mv = vpar_MPEG2MotionVector;
410     }
411     else
412     {
413         /* It's an MPEG-1 stream. Put adequate parameters. */
414
415         p_vpar->sequence.b_mpeg2 = 0;
416         p_vpar->sequence.b_progressive = 1;
417         p_vpar->sequence.i_chroma_format = CHROMA_420;
418         p_vpar->sequence.pf_decode_pattern = vpar_CodedPattern420;
419
420         p_vpar->sequence.pf_decode_mv = vpar_MPEG1MotionVector;
421     }
422
423     /* Update sizes */
424     p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
425     p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
426                                    (p_vpar->sequence.i_height + 15) / 16 :
427                                    2 * ((p_vpar->sequence.i_height + 31) / 32);
428     p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
429                                         * p_vpar->sequence.i_mb_height;
430     p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
431     p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
432     p_vpar->sequence.i_size = p_vpar->sequence.i_width
433                                         * p_vpar->sequence.i_height;
434
435     /* Update chromatic information */
436     switch( p_vpar->sequence.i_chroma_format )
437     {
438     case CHROMA_420:
439         p_vpar->sequence.i_chroma_nb_blocks = 2;
440         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
441         p_vpar->sequence.i_chroma_mb_width = 8;
442         p_vpar->sequence.i_chroma_mb_height = 8;
443         break;
444
445     case CHROMA_422:
446         p_vpar->sequence.i_chroma_nb_blocks = 4;
447         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
448         p_vpar->sequence.i_chroma_mb_width = 8;
449         p_vpar->sequence.i_chroma_mb_height = 16;
450         break;
451
452     case CHROMA_444:
453         p_vpar->sequence.i_chroma_nb_blocks = 8;
454         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
455         p_vpar->sequence.i_chroma_mb_width = 16;
456         p_vpar->sequence.i_chroma_mb_height = 16;
457     }
458
459     /* Slice Header functions */
460     if( p_vpar->sequence.i_height <= 2800 )
461     {
462         if( p_vpar->sequence.i_scalable_mode != SC_DP )
463         {
464             p_vpar->sequence.pf_slice_header = SliceHeader00;
465         }
466         else
467         {
468             p_vpar->sequence.pf_slice_header = SliceHeader01;
469         }
470     }
471     else
472     {
473         if( p_vpar->sequence.i_scalable_mode != SC_DP )
474         {
475             p_vpar->sequence.pf_slice_header = SliceHeader10;
476         }
477         else
478         {
479             p_vpar->sequence.pf_slice_header = SliceHeader11;
480         }
481     }
482
483     if(    p_vpar->sequence.i_width != i_width_save
484         || p_vpar->sequence.i_height != i_height_save )
485     {
486          /* What do we do in case of a size change ??? */
487     }
488
489     /* Extension and User data */
490     ExtensionAndUserData( p_vpar );
491 }
492
493 /*****************************************************************************
494  * GroupHeader : Parse the next group of pictures header
495  *****************************************************************************/
496 static void GroupHeader( vpar_thread_t * p_vpar )
497 {
498     /* Nothing to do, we don't care. */
499     RemoveBits( &p_vpar->bit_stream, 27 );
500     ExtensionAndUserData( p_vpar );
501 }
502
503 /*****************************************************************************
504  * PictureHeader : Parse the next picture header
505  *****************************************************************************/
506 static void PictureHeader( vpar_thread_t * p_vpar )
507 {
508     static f_macroblock_type_t ppf_macroblock_type[5] = {NULL,
509                                                   vpar_IMBType, vpar_PMBType,
510                                                   vpar_BMBType, vpar_DMBType};
511
512     int                 i_structure;
513     int                 i_mb_address, i_mb_base, i_mb;
514     boolean_t           b_parsable;
515     u32                 i_dummy;
516     
517     RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
518     p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
519     p_vpar->picture.pf_macroblock_type = ppf_macroblock_type
520                                          [p_vpar->picture.i_coding_type];
521     RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
522  
523     if( p_vpar->picture.i_coding_type == P_CODING_TYPE || p_vpar->picture.i_coding_type == B_CODING_TYPE )
524     {
525         p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
526         p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
527     }
528     if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
529     {
530         p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
531         p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
532     }
533
534     /* extra_information_picture */
535     while( GetBits( &p_vpar->bit_stream, 1 ) )
536     {
537         RemoveBits( &p_vpar->bit_stream, 8 );
538     }
539
540     /* 
541      * Picture Coding Extension
542      */
543     NextStartCode( p_vpar );
544     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
545     {
546         /* Parse picture_coding_extension */
547         RemoveBits32( &p_vpar->bit_stream );
548         /* extension_start_code_identifier */
549         RemoveBits( &p_vpar->bit_stream, 4 );
550         
551         p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
552         p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
553         p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
554         p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
555         p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
556         i_structure = GetBits( &p_vpar->bit_stream, 2 );
557         p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
558         p_vpar->picture.b_frame_pred_frame_dct
559              = GetBits( &p_vpar->bit_stream, 1 );
560         p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
561         p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
562         p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
563         p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
564         p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
565         /* repeat_first_field (ISO/IEC 13818-2 6.3.10 is necessary to know
566          * the length of the picture_display_extension structure.
567          * chroma_420_type (obsolete) */
568         RemoveBits( &p_vpar->bit_stream, 1 );
569         p_vpar->picture.b_progressive_frame = GetBits( &p_vpar->bit_stream, 1 );
570         
571         /* composite_display_flag */
572         if( GetBits( &p_vpar->bit_stream, 1 ) )
573         {
574             /* v_axis, field_sequence, sub_carrier, burst_amplitude,
575              * sub_carrier_phase */
576             RemoveBits( &p_vpar->bit_stream, 20 );
577         }
578     }
579     else
580     {
581         /* MPEG-1 compatibility flags */
582         p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
583         i_structure = FRAME_STRUCTURE;
584         p_vpar->picture.b_frame_pred_frame_dct = 1;
585         p_vpar->picture.b_concealment_mv = 0;
586         p_vpar->picture.b_q_scale_type = 0;
587         p_vpar->picture.b_intra_vlc_format = 0;
588         p_vpar->picture.b_alternate_scan = 0; /* zigzag */
589         p_vpar->picture.b_repeat_first_field = 0;
590         p_vpar->picture.b_progressive_frame = 1;
591     }
592
593     if( p_vpar->picture.i_current_structure &&
594         (i_structure == FRAME_STRUCTURE ||
595          i_structure == p_vpar->picture.i_current_structure) )
596     {
597         /* We don't have the second field of the buffered frame. */
598         if( p_vpar->picture.p_picture != NULL )
599         {
600             ReferenceReplace( p_vpar,
601                       p_vpar->picture.i_coding_type,
602                       NULL );
603
604             for( i_mb = 0; i_mb < p_vpar->sequence.i_mb_size >> 1; i_mb++ )
605             {
606                 vpar_DestroyMacroblock( &p_vpar->vfifo,
607                                         p_vpar->picture.pp_mb[i_mb] );
608             }
609             vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
610         }
611         
612         p_vpar->picture.i_current_structure = 0;
613
614         intf_DbgMsg("vpar debug: odd number of field picture.\n");
615     }
616
617     /* Do we have the reference pictures ? */
618     b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
619                     (p_vpar->sequence.p_backward == NULL)) ||
620                      /* p_backward will become p_forward later */
621                    ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
622                     (p_vpar->sequence.p_forward == NULL ||
623                      p_vpar->sequence.p_backward == NULL)));
624
625     if( b_parsable )
626     {
627         if( p_vpar->picture.i_current_structure )
628         {
629             /* Second field of a frame. We will decode it if, and only if we
630             * have decoded the first frame. */
631             b_parsable = (p_vpar->picture.p_picture != NULL);
632         }
633         else
634         {
635             /* Does synchro say we have enough time to decode it ? */
636             b_parsable = vpar_SynchroChoose( p_vpar,
637                                p_vpar->picture.i_coding_type, i_structure );
638         }
639     }
640
641     if( !b_parsable )
642     {
643         /* Update the reference pointers. */
644         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
645         
646         /* Warn Synchro we have trashed a picture. */
647         vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
648
649         /* Update context. */
650         if( i_structure != FRAME_STRUCTURE )
651             p_vpar->picture.i_current_structure = i_structure;
652         p_vpar->picture.p_picture = NULL;
653
654         return;
655     }
656
657     /* OK, now we are sure we will decode the picture. */
658 #define P_picture p_vpar->picture.p_picture
659     p_vpar->picture.b_error = 0;
660
661     if( !p_vpar->picture.i_current_structure )
662     {
663         /* This is a new frame. Get a structure from the video_output. */
664         while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
665                                         99+p_vpar->sequence.i_chroma_format, /*???*/
666                                         p_vpar->sequence.i_width,
667                                         p_vpar->sequence.i_height ) )
668              == NULL )
669         {
670             intf_ErrMsg("vpar debug: allocation error in vout_CreatePicture\n");
671             if( p_vpar->b_die )
672             {
673                 return;
674             }
675             mwait( VPAR_IDLE_SLEEP );
676         }
677
678         /* Initialize values. */
679         P_picture->date = vpar_SynchroDecode( p_vpar,
680                                               p_vpar->picture.i_coding_type,
681                                               i_structure );
682         P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
683         P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
684         p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
685                     << ( 1 - p_vpar->picture.b_frame_structure ) );
686         p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
687                     << ( 1 - p_vpar->picture.b_frame_structure ));
688
689         P_picture->i_deccount = p_vpar->sequence.i_mb_size;
690         memset( p_vpar->picture.pp_mb, 0, MAX_MB );
691 memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
692
693         /* Update the reference pointers. */
694         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
695     }
696     p_vpar->picture.i_current_structure |= i_structure;
697     p_vpar->picture.i_structure = i_structure;
698     p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
699
700     /* Initialize picture data for decoding. */
701     if( i_structure == BOTTOM_FIELD )
702     {
703         i_mb_base = p_vpar->sequence.i_mb_size >> 1;
704         p_vpar->mb.i_l_y = 1;
705         p_vpar->mb.i_c_y = 1;
706     }
707     else
708     {
709         i_mb_base = 0;
710         p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
711     }
712     i_mb_address = 0;
713     p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
714
715     /* Extension and User data. */
716     ExtensionAndUserData( p_vpar );
717
718     /* Picture data (ISO/IEC 13818-2 6.2.3.7). */
719     NextStartCode( p_vpar );
720     while( i_mb_address+i_mb_base < p_vpar->sequence.i_mb_size
721            && !p_vpar->picture.b_error && !p_vpar->b_die )
722     {
723         if( ((i_dummy = ShowBits( &p_vpar->bit_stream, 32 ))
724                  < SLICE_START_CODE_MIN) ||
725             (i_dummy > SLICE_START_CODE_MAX) )
726         {
727             intf_DbgMsg("vpar debug: premature end of picture\n");
728             p_vpar->picture.b_error = 1;
729             break;
730         }
731         RemoveBits32( &p_vpar->bit_stream );
732         
733         /* Decode slice data. */
734         p_vpar->sequence.pf_slice_header( p_vpar, &i_mb_address, i_mb_base, i_dummy & 255 );
735     }
736   
737     if( p_vpar->picture.b_error )
738     {
739         /* Trash picture. */
740 fprintf(stderr, "Image trashee\n");
741         for( i_mb = 1; p_vpar->picture.pp_mb[i_mb]; i_mb++ )
742         {
743             vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
744         }
745         vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
746
747         ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
748
749         /* Prepare context for the next picture. */
750         P_picture = NULL;
751         if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
752             p_vpar->picture.i_current_structure = 0;
753     }
754     else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
755     {
756 fprintf(stderr, "Image parsee (%d)\n", p_vpar->picture.i_coding_type);
757         /* Frame completely parsed. */
758         for( i_mb = 1; p_vpar->picture.pp_mb[i_mb]; i_mb++ )
759         {
760             vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
761         }
762
763         /* Link referenced pictures for the decoder 
764          * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
765         if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
766             p_vpar->picture.i_coding_type == B_CODING_TYPE )
767         {
768             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
769         }
770         if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
771         {
772             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
773         } 
774
775         /* Send signal to the video_decoder. */
776         vlc_mutex_lock( &p_vpar->vfifo.lock );
777         vlc_cond_signal( &p_vpar->vfifo.wait );
778         vlc_mutex_unlock( &p_vpar->vfifo.lock );
779         
780         /* Prepare context for the next picture. */
781         P_picture = NULL;
782         p_vpar->picture.i_current_structure = 0;
783     }
784 #undef P_picture
785 }
786
787 /*****************************************************************************
788  * SliceHeader : Parse the next slice structure
789  *****************************************************************************/
790 static __inline__ void SliceHeader( vpar_thread_t * p_vpar,
791                                     int * pi_mb_address, int i_mb_base,
792                                     u32 i_vert_code )
793 {
794     /* DC predictors initialization table */
795     static int              pi_dc_dct_reinit[4] = {128,256,512,1024};
796
797     int                     i_mb_address_save = *pi_mb_address;
798     
799     /* slice_vertical_position_extension and priority_breakpoint already done */
800     LoadQuantizerScale( p_vpar );
801
802     if( GetBits( &p_vpar->bit_stream, 1 ) )
803     {
804         /* intra_slice, slice_id */
805         RemoveBits( &p_vpar->bit_stream, 8 );
806         /* extra_information_slice */
807         while( GetBits( &p_vpar->bit_stream, 1 ) )
808         {
809             RemoveBits( &p_vpar->bit_stream, 8 );
810         }
811     }
812     *pi_mb_address = (i_vert_code - 1)*p_vpar->sequence.i_mb_width;
813     
814     /* Reset DC coefficients predictors (ISO/IEC 13818-2 7.2.1). Why
815      * does the reference decoder put 0 instead of the normative values ? */
816     p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
817         = p_vpar->slice.pi_dc_dct_pred[2]
818         = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
819
820     /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
821     memset( p_vpar->slice.pppi_pmv, 0, 8*sizeof(int) );
822
823     do
824     {
825         vpar_ParseMacroblock( p_vpar, pi_mb_address, i_mb_address_save,
826                               i_mb_base );
827         i_mb_address_save = *pi_mb_address;
828     }
829     while( ShowBits( &p_vpar->bit_stream, 23 ) && !p_vpar->b_die );
830     NextStartCode( p_vpar );
831 }
832
833 /*****************************************************************************
834  * SliceHeaderXY : Parse the next slice structure
835  *****************************************************************************
836  * X = i_height > 2800 ?
837  * Y = scalable_mode == SC_DP ?
838  *****************************************************************************/
839 static void SliceHeader00( vpar_thread_t * p_vpar,
840                            int * pi_mb_address, int i_mb_base,
841                            u32 i_vert_code )
842 {
843     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
844 }
845
846 static void SliceHeader01( vpar_thread_t * p_vpar,
847                            int * pi_mb_address, int i_mb_base,
848                            u32 i_vert_code )
849 {
850     RemoveBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
851     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
852 }
853
854 static void SliceHeader10( vpar_thread_t * p_vpar,
855                            int * pi_mb_address, int i_mb_base,
856                            u32 i_vert_code )
857 {
858     i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
859     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
860 }
861
862 static void SliceHeader11( vpar_thread_t * p_vpar,
863                            int * pi_mb_address, int i_mb_base,
864                            u32 i_vert_code )
865 {
866     i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
867     RemoveBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
868     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
869 }
870
871 /*****************************************************************************
872  * ExtensionAndUserData : Parse the extension_and_user_data structure
873  *****************************************************************************/
874 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
875 {
876     while( !p_vpar->b_die )
877     {
878         NextStartCode( p_vpar );
879         switch( ShowBits( &p_vpar->bit_stream, 32 ) )
880         {
881         case EXTENSION_START_CODE:
882             RemoveBits32( &p_vpar->bit_stream );
883             switch( GetBits( &p_vpar->bit_stream, 4 ) )
884             {
885             case SEQUENCE_DISPLAY_EXTENSION_ID:
886                 SequenceDisplayExtension( p_vpar );
887                 break;
888             case QUANT_MATRIX_EXTENSION_ID:
889                 QuantMatrixExtension( p_vpar );
890                 break;
891             case SEQUENCE_SCALABLE_EXTENSION_ID:
892                 SequenceScalableExtension( p_vpar );
893                 break;
894             case PICTURE_DISPLAY_EXTENSION_ID:
895                 PictureDisplayExtension( p_vpar );
896                 break;
897             case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
898                 PictureSpatialScalableExtension( p_vpar );
899                 break;
900             case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
901                 PictureTemporalScalableExtension( p_vpar );
902                 break;
903             case COPYRIGHT_EXTENSION_ID:
904                 CopyrightExtension( p_vpar );
905                 break;
906             default:
907             }
908             break;
909
910         case USER_DATA_START_CODE:
911             RemoveBits32( &p_vpar->bit_stream );
912             /* Wait for the next start code */
913             break;
914
915         default:
916             return;
917         }
918     }
919 }
920
921
922 /*****************************************************************************
923  * SequenceDisplayExtension : Parse the sequence_display_extension structure *
924  *****************************************************************************/
925
926 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
927 {
928     /* We don't care sequence_display_extension. */
929     /* video_format */
930     RemoveBits( &p_vpar->bit_stream, 3 );
931     if( GetBits( &p_vpar->bit_stream, 1 ) )
932     {
933         /* Two bytes for color_desciption */
934         RemoveBits( &p_vpar->bit_stream, 16 );
935         p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
936     }
937     /* display_horizontal and vertical_size and a marker_bit */
938     RemoveBits( &p_vpar->bit_stream, 29 );
939 }
940
941
942 /*****************************************************************************
943  * QuantMatrixExtension : Load quantization matrices for luminance           *
944  *                        and chrominance                                    *
945  *****************************************************************************/
946
947 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
948 {
949     if( GetBits( &p_vpar->bit_stream, 1 ) )
950     {
951         /* Load intra_quantiser_matrix for luminance. */
952         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
953     }
954     else
955     {
956         /* Use the default matrix. */
957         LinkMatrix( &p_vpar->sequence.intra_quant,
958                     pi_default_intra_quant );
959     }
960     if( GetBits( &p_vpar->bit_stream, 1 ) )
961     {
962         /* Load non_intra_quantiser_matrix for luminance. */
963         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
964     }
965     else
966     {
967         /* Use the default matrix. */
968         LinkMatrix( &p_vpar->sequence.nonintra_quant,
969                     pi_default_nonintra_quant );
970     }
971     if( GetBits( &p_vpar->bit_stream, 1 ) )
972     {
973         /* Load intra_quantiser_matrix for chrominance. */
974         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
975     }
976     else
977     {
978         /* Link the chrominance intra matrix to the luminance one. */
979         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
980                     p_vpar->sequence.intra_quant.pi_matrix );
981     }
982     if( GetBits( &p_vpar->bit_stream, 1 ) )
983     {
984         /* Load non_intra_quantiser_matrix for chrominance. */
985         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
986     }
987     else
988     {
989         /* Link the chrominance intra matrix to the luminance one. */
990         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
991                     p_vpar->sequence.intra_quant.pi_matrix );
992     }
993     if( GetBits( &p_vpar->bit_stream, 1 ) )
994     {
995         /* Load non_intra_quantiser_matrix for chrominance. */
996         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
997     }
998     else
999     {
1000         /* Link the chrominance nonintra matrix to the luminance one. */
1001         LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
1002                     p_vpar->sequence.nonintra_quant.pi_matrix );
1003     }
1004 }
1005
1006
1007 /*****************************************************************************
1008  * SequenceScalableExtension : Parse the sequence_scalable_extension         *
1009  *                             structure to handle scalable coding           *
1010  *****************************************************************************/
1011
1012 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
1013 {
1014     /* We don't care about anything scalable except the scalable mode. */
1015     switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
1016     /* The length of the structure depends on the value of the scalable_mode */
1017     {
1018         case 1:
1019             RemoveBits32( &p_vpar->bit_stream );
1020             RemoveBits( &p_vpar->bit_stream, 21 );
1021             break;
1022         case 2:
1023             RemoveBits( &p_vpar->bit_stream, 12 );
1024             break;
1025         default:
1026             RemoveBits( &p_vpar->bit_stream, 4 );
1027     }
1028
1029 }
1030 /*****************************************************************************
1031  * PictureDisplayExtension : Parse the picture_display_extension structure   *
1032  *****************************************************************************/
1033
1034 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
1035 {
1036     /* Number of frame center offset */
1037     int nb;
1038     /* I am not sure it works but it should
1039         (fewer tests than shown in ยง6.3.12) */
1040     nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
1041                                           p_vpar->picture.b_repeat_first_field +
1042                                           p_vpar->picture.b_top_field_first
1043                          : ( p_vpar->picture.b_frame_structure + 1 ) +
1044                            p_vpar->picture.b_repeat_first_field;
1045     RemoveBits( &p_vpar->bit_stream, 34 * nb );
1046 }
1047
1048
1049 /*****************************************************************************
1050  * PictureSpatialScalableExtension                                           *
1051  *****************************************************************************/
1052
1053 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
1054 {
1055     /* That's scalable, so we trash it */
1056     RemoveBits32( &p_vpar->bit_stream );
1057     RemoveBits( &p_vpar->bit_stream, 16 );
1058 }
1059
1060
1061 /*****************************************************************************
1062  * PictureTemporalScalableExtension                                          *
1063  *****************************************************************************/
1064
1065 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1066 {
1067     /* Scalable again, trashed again */
1068     RemoveBits( &p_vpar->bit_stream, 23 );
1069 }
1070
1071
1072 /*****************************************************************************
1073  * CopyrightExtension : Keeps some legal informations                        *
1074  *****************************************************************************/
1075
1076 static void CopyrightExtension( vpar_thread_t * p_vpar )
1077 {
1078     u32     i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1079     p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1080         /* A flag that says whether the copyright information is significant */
1081     p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1082         /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1083     p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1084         /* Reserved bits */
1085     RemoveBits( &p_vpar->bit_stream, 8 );
1086         /* The copyright_number is split in three parts */
1087         /* first part */
1088     i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1089     RemoveBits( &p_vpar->bit_stream, 1 );
1090         /* second part */
1091     i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1092     RemoveBits( &p_vpar->bit_stream, 1 );
1093         /* third part and sum */
1094     p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) +
1095                                       ( (u64)i_copyright_nb_2 << 22 ) +
1096                                       ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );
1097 }