* Fixed a segfault in the SPU decoder initialization.
[vlc.git] / src / video_parser / vpar_headers.c
1 /*****************************************************************************
2  * vpar_headers.c : headers parsing
3  *****************************************************************************
4  * Copyright (C) 1999, 2000 VideoLAN
5  * $Id: vpar_headers.c,v 1.84 2001/05/01 12:22:18 sam Exp $
6  *
7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
8  *          Stéphane Borel <stef@via.ecp.fr>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  * 
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include "defs.h"
29
30 #include <stdlib.h>                                                /* free() */
31 #include <string.h>                                    /* memcpy(), memset() */
32
33 #include "config.h"
34 #include "common.h"
35 #include "threads.h"
36 #include "mtime.h"
37
38 #include "intf_msg.h"
39
40 #include "stream_control.h"
41 #include "input_ext-dec.h"
42
43 #include "video.h"
44 #include "video_output.h"
45
46 #include "video_decoder.h"
47 #include "vdec_motion.h"
48 #include "../video_decoder/vdec_idct.h"
49
50 #include "vpar_blocks.h"
51 #include "../video_decoder/vpar_headers.h"
52 #include "../video_decoder/vpar_synchro.h"
53 #include "../video_decoder/video_parser.h"
54 #include "../video_decoder/video_fifo.h"
55
56 #include "main.h" /* XXX REMOVE THIS */
57
58 /*
59  * Local prototypes
60  */
61 static __inline__ void NextStartCode( bit_stream_t * );
62 static void SequenceHeader( vpar_thread_t * p_vpar );
63 static void GroupHeader( vpar_thread_t * p_vpar );
64 static void PictureHeader( vpar_thread_t * p_vpar );
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 u8 pi_default_intra_quant[] =
82 {
83     8,  16, 19, 22, 26, 27, 29, 34,
84     16, 16, 22, 24, 27, 29, 34, 37,
85     19, 22, 26, 27, 29, 34, 34, 38,
86     22, 22, 26, 27, 29, 34, 37, 40,
87     22, 26, 27, 29, 32, 35, 40, 48,
88     26, 27, 29, 32, 35, 40, 48, 58,
89     26, 27, 29, 34, 38, 46, 56, 69,
90     27, 29, 35, 38, 46, 56, 69, 83
91 };
92
93 /*****************************************************************************
94  * pi_default_nonintra_quant : default quantization matrix
95  *****************************************************************************/
96 u8 pi_default_nonintra_quant[] =
97 {
98     16, 16, 16, 16, 16, 16, 16, 16,
99     16, 16, 16, 16, 16, 16, 16, 16,
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 };
107
108 /*****************************************************************************
109  * pi_scan : zig-zag and alternate scan patterns
110  *****************************************************************************/
111 u8 pi_scan[2][64] =
112 {
113     { /* Zig-Zag pattern */
114         0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
115         12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
116         35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
117         58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
118     },
119     { /* Alternate scan pattern */
120         0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
121         41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
122         51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
123         53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
124     }
125 };
126
127 /*
128  * Local inline functions.
129  */
130
131 /*****************************************************************************
132  * ReferenceUpdate : Update the reference pointers when we have a new picture
133  *****************************************************************************/
134 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
135                                         int i_coding_type,
136                                         picture_t * p_newref )
137 {
138     if( i_coding_type != B_CODING_TYPE )
139     {
140         if( p_vpar->sequence.p_forward != NULL )
141         {
142             vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
143         }
144         if( p_vpar->sequence.p_backward != NULL )
145         {
146             vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
147                               vpar_SynchroDate( p_vpar ) );
148         }
149         p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
150         p_vpar->sequence.p_backward = p_newref;
151         if( p_newref != NULL )
152         {
153             vout_LinkPicture( p_vpar->p_vout, p_newref );
154         }
155     }
156     else if( p_newref != NULL )
157     {
158         /* Put date immediately. */
159         vout_DatePicture( p_vpar->p_vout, p_newref, vpar_SynchroDate(p_vpar) );
160     }
161 }
162
163 /*****************************************************************************
164  * ReferenceReplace : Replace the last reference pointer when we destroy
165  *                    a picture
166  *****************************************************************************/
167 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
168                                          int i_coding_type,
169                                          picture_t * p_newref )
170 {
171     if( i_coding_type != B_CODING_TYPE )
172     {
173         if( p_vpar->sequence.p_backward != NULL )
174         {
175             vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
176         }
177         p_vpar->sequence.p_backward = p_newref;
178         if( p_newref != NULL )
179         {
180             vout_LinkPicture( p_vpar->p_vout, p_newref );
181         }
182     }
183 }
184
185 /*****************************************************************************
186  * LoadMatrix : Load a quantization matrix
187  *****************************************************************************/
188 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar,
189                                    quant_matrix_t * p_matrix )
190 {
191     int i_dummy;
192
193     if( !p_matrix->b_allocated )
194     {
195         /* Allocate a piece of memory to load the matrix. */
196         if( (p_matrix->pi_matrix = (u8 *)malloc( 64*sizeof(u8) )) == NULL )
197         {
198             intf_ErrMsg( "vpar error: allocation error in LoadMatrix()" );
199             p_vpar->p_fifo->b_error = 1;
200             return;
201         }
202         p_matrix->b_allocated = 1;
203     }
204
205     for( i_dummy = 0; i_dummy < 64; i_dummy++ )
206     {
207         p_matrix->pi_matrix[p_vpar->ppi_scan[SCAN_ZIGZAG][i_dummy]]
208              = GetBits( &p_vpar->bit_stream, 8 );
209     }
210
211 #ifdef VDEC_DFT
212     /* Discrete Fourier Transform requires the quantization matrices to
213      * be normalized before using them. */
214     vdec_NormQuantMatrix( p_matrix->pi_matrix );
215 #endif
216 }
217
218 /*****************************************************************************
219  * LinkMatrix : Link a quantization matrix to another
220  *****************************************************************************/
221 static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, u8 * pi_array )
222 {
223     if( p_matrix->b_allocated )
224     {
225         /* Deallocate the piece of memory. */
226         free( p_matrix->pi_matrix );
227         p_matrix->b_allocated = 0;
228     }
229
230     p_matrix->pi_matrix = pi_array;
231 }
232
233 /*
234  * Exported functions.
235  */
236
237 /*****************************************************************************
238  * vpar_NextSequenceHeader : Find the next sequence header
239  *****************************************************************************/
240 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
241 {
242     while( !p_vpar->p_fifo->b_die )
243     {
244         NextStartCode( &p_vpar->bit_stream );
245         if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
246         {
247             return 0;
248         }
249         RemoveBits( &p_vpar->bit_stream, 8 );
250     }
251     return 1;
252 }
253
254 /*****************************************************************************
255  * vpar_ParseHeader : Parse the next header
256  *****************************************************************************/
257 int vpar_ParseHeader( vpar_thread_t * p_vpar )
258 {
259     while( !p_vpar->p_fifo->b_die )
260     {
261         NextStartCode( &p_vpar->bit_stream );
262         switch( GetBits32( &p_vpar->bit_stream ) )
263         {
264         case SEQUENCE_HEADER_CODE:
265 #ifdef STATS
266             p_vpar->c_sequences++;
267 #endif
268             SequenceHeader( p_vpar );
269             return 0;
270             break;
271
272         case GROUP_START_CODE:
273             GroupHeader( p_vpar );
274             return 0;
275             break;
276
277         case PICTURE_START_CODE:
278             PictureHeader( p_vpar );
279             return 0;
280             break;
281
282         case SEQUENCE_END_CODE:
283             intf_DbgMsg("vpar debug: sequence end code received");
284             return 1;
285             break;
286
287         default:
288             break;
289         }
290     }
291
292     return 0;
293 }
294
295 /*
296  * Following functions are local
297  */
298
299 /*****************************************************************************
300  * SequenceHeader : Parse the next sequence header
301  *****************************************************************************/
302 static void SequenceHeader( vpar_thread_t * p_vpar )
303 {
304 #define RESERVED    -1
305     static int i_frame_rate_table[16] =
306     {
307         0,
308         23 * 1000,
309         24 * 1001,
310         25 * 1001,
311         30 * 1000,
312         30 * 1001,
313         50 * 1001,
314         60 * 1000,
315         60 * 1001,
316         RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
317     };
318 #undef RESERVED
319
320     int i_height_save, i_width_save;
321
322     i_height_save = p_vpar->sequence.i_height;
323     i_width_save = p_vpar->sequence.i_width;
324
325     p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
326     p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
327     p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
328     p_vpar->sequence.i_frame_rate =
329             i_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
330
331     /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
332      * constrained_parameters_flag */
333     RemoveBits( &p_vpar->bit_stream, 30 );
334
335     /*
336      * Quantization matrices
337      */
338     if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
339     {
340         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
341     }
342     else
343     {
344         /* Use default matrix. */
345         LinkMatrix( &p_vpar->sequence.intra_quant,
346                     p_vpar->pi_default_intra_quant );
347     }
348
349     if( GetBits(&p_vpar->bit_stream, 1) ) /* load_non_intra_quantizer_matrix */
350     {
351         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
352     }
353     else
354     {
355         /* Use default matrix. */
356         LinkMatrix( &p_vpar->sequence.nonintra_quant,
357                     p_vpar->pi_default_nonintra_quant );
358     }
359
360     /* Unless later overwritten by a matrix extension, we have the same
361      * matrices for luminance and chrominance. */
362     LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
363                 p_vpar->sequence.intra_quant.pi_matrix );
364     LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
365                 p_vpar->sequence.nonintra_quant.pi_matrix );
366
367     /*
368      * Sequence Extension
369      */
370     NextStartCode( &p_vpar->bit_stream );
371     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
372     {
373         int                         i_dummy;
374
375         /* Turn the MPEG2 flag on */
376         p_vpar->sequence.b_mpeg2 = 1;
377
378         /* Parse sequence_extension */
379         RemoveBits32( &p_vpar->bit_stream );
380         /* extension_start_code_identifier, profile_and_level_indication */
381         RemoveBits( &p_vpar->bit_stream, 12 );
382         p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
383         p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
384         p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
385         p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
386         /* bit_rate_extension, marker_bit, vbv_buffer_size_extension,
387          * low_delay */
388         RemoveBits( &p_vpar->bit_stream, 22 );
389         /* frame_rate_extension_n */
390         i_dummy = GetBits( &p_vpar->bit_stream, 2 );
391         /* frame_rate_extension_d */
392         p_vpar->sequence.i_frame_rate *= (i_dummy + 1)
393                                   / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
394     }
395     else
396     {
397         /* It's an MPEG-1 stream. Put adequate parameters. */
398
399         p_vpar->sequence.b_mpeg2 = 0;
400         p_vpar->sequence.b_progressive = 1;
401         p_vpar->sequence.i_chroma_format = CHROMA_420;
402     }
403
404     /* Update sizes */
405     p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
406     p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
407                                    (p_vpar->sequence.i_height + 15) / 16 :
408                                    2 * ((p_vpar->sequence.i_height + 31) / 32);
409     p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
410                                         * p_vpar->sequence.i_mb_height;
411     p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
412     p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
413     p_vpar->sequence.i_size = p_vpar->sequence.i_width
414                                         * p_vpar->sequence.i_height;
415
416     /* Update chromatic information. */
417     switch( p_vpar->sequence.i_chroma_format )
418     {
419     case CHROMA_420:
420         p_vpar->sequence.i_chroma_nb_blocks = 2;
421         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
422         p_vpar->sequence.i_chroma_mb_width = 8;
423         p_vpar->sequence.i_chroma_mb_height = 8;
424         break;
425
426     case CHROMA_422:
427         p_vpar->sequence.i_chroma_nb_blocks = 4;
428         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
429         p_vpar->sequence.i_chroma_mb_width = 8;
430         p_vpar->sequence.i_chroma_mb_height = 16;
431         break;
432
433     case CHROMA_444:
434         p_vpar->sequence.i_chroma_nb_blocks = 8;
435         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
436         p_vpar->sequence.i_chroma_mb_width = 16;
437         p_vpar->sequence.i_chroma_mb_height = 16;
438     }
439
440     /* Reset scalable_mode. */
441     p_vpar->sequence.i_scalable_mode = SC_NONE;
442
443 #if 0
444     if(    p_vpar->sequence.i_width != i_width_save
445         || p_vpar->sequence.i_height != i_height_save )
446     {
447          /* FIXME: What do we do in case of a size change ?? */
448     }
449 #endif
450
451     /* Extension and User data */
452     ExtensionAndUserData( p_vpar );
453
454     /* XXX: The vout request and fifo opening will eventually be here */
455     if( p_vpar->p_vout == NULL )
456     {
457         if( p_main->p_vout == NULL )
458         {
459             intf_Msg( "vpar: no vout present, spawning one" );
460             p_main->p_vout = vout_CreateThread( NULL );
461         }
462
463         p_vpar->p_vout = p_main->p_vout;
464     }
465 }
466
467 /*****************************************************************************
468  * GroupHeader : Parse the next group of pictures header
469  *****************************************************************************/
470 static void GroupHeader( vpar_thread_t * p_vpar )
471 {
472     /* Nothing to do, we don't care. */
473     RemoveBits( &p_vpar->bit_stream, 27 );
474     ExtensionAndUserData( p_vpar );
475 }
476
477 /*****************************************************************************
478  * PictureHeader : Parse the next picture header
479  *****************************************************************************/
480 static void PictureHeader( vpar_thread_t * p_vpar )
481 {
482     int                 i_structure;
483     int                 i_mb_base;
484     boolean_t           b_parsable;
485 #ifdef VDEC_SMP
486     int                 i_mb;
487 #endif
488
489     /* Recover in case of stream discontinuity. */
490     if( p_vpar->sequence.b_expect_discontinuity )
491     {
492         ReferenceUpdate( p_vpar, I_CODING_TYPE, NULL );
493         ReferenceUpdate( p_vpar, I_CODING_TYPE, NULL );
494         if( p_vpar->picture.p_picture != NULL )
495         {
496 #ifdef VDEC_SMP
497             int     i_mb;
498
499             for( i_mb = 0; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
500             {
501                 vpar_DestroyMacroblock( &p_vpar->vfifo,
502                                         p_vpar->picture.pp_mb[i_mb] );
503             }
504 #endif
505             vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
506         }
507         p_vpar->sequence.b_expect_discontinuity = 0;
508     }
509
510     /* Parse the picture header. */
511     RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
512     p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
513     RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
514
515     if( p_vpar->picture.i_coding_type == P_CODING_TYPE
516         || p_vpar->picture.i_coding_type == B_CODING_TYPE )
517     {
518         p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
519         p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
520     }
521     if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
522     {
523         p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
524         p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
525     }
526
527     /* extra_information_picture */
528     while( GetBits( &p_vpar->bit_stream, 1 ) )
529     {
530         RemoveBits( &p_vpar->bit_stream, 8 );
531     }
532
533     /*
534      * Picture Coding Extension
535      */
536     NextStartCode( &p_vpar->bit_stream );
537     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
538     {
539         /* Parse picture_coding_extension */
540         RemoveBits32( &p_vpar->bit_stream );
541         /* extension_start_code_identifier */
542         RemoveBits( &p_vpar->bit_stream, 4 );
543
544         p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
545         p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
546         p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
547         p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
548         p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
549         i_structure = GetBits( &p_vpar->bit_stream, 2 );
550         p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
551         p_vpar->picture.b_frame_pred_frame_dct
552              = GetBits( &p_vpar->bit_stream, 1 );
553         p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
554         p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
555         p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
556         p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
557         p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
558         /* chroma_420_type (obsolete) */
559         RemoveBits( &p_vpar->bit_stream, 1 );
560         p_vpar->picture.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
561
562         /* composite_display_flag */
563         if( GetBits( &p_vpar->bit_stream, 1 ) )
564         {
565             /* v_axis, field_sequence, sub_carrier, burst_amplitude,
566              * sub_carrier_phase */
567             RemoveBits( &p_vpar->bit_stream, 20 );
568         }
569     }
570     else
571     {
572         /* MPEG-1 compatibility flags */
573         p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
574         i_structure = FRAME_STRUCTURE;
575         p_vpar->picture.b_top_field_first = 0;
576         p_vpar->picture.b_frame_pred_frame_dct = 1;
577         p_vpar->picture.b_concealment_mv = 0;
578         p_vpar->picture.b_q_scale_type = 0;
579         p_vpar->picture.b_intra_vlc_format = 0;
580         p_vpar->picture.b_alternate_scan = 0; /* zigzag */
581         p_vpar->picture.b_repeat_first_field = 0;
582         p_vpar->picture.b_progressive = 1;
583     }
584
585 #ifdef STATS
586     p_vpar->pc_pictures[p_vpar->picture.i_coding_type]++;
587 #endif
588
589     if( p_vpar->picture.i_current_structure &&
590         (i_structure == FRAME_STRUCTURE ||
591          i_structure == p_vpar->picture.i_current_structure) )
592     {
593         /* We don't have the second field of the buffered frame. */
594         if( p_vpar->picture.p_picture != NULL )
595         {
596             ReferenceReplace( p_vpar,
597                       p_vpar->picture.i_coding_type,
598                       NULL );
599
600 #ifdef VDEC_SMP
601             for( i_mb = 0; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
602             {
603                 vpar_DestroyMacroblock( &p_vpar->vfifo,
604                                         p_vpar->picture.pp_mb[i_mb] );
605             }
606 #endif
607             vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
608         }
609
610         p_vpar->picture.i_current_structure = 0;
611
612         intf_WarnMsg( 2, "Odd number of field pictures." );
613     }
614
615     /* Do we have the reference pictures ? */
616     b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
617                     (p_vpar->sequence.p_backward == NULL)) ||
618                      /* p_backward will become p_forward later */
619                    ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
620                     (p_vpar->sequence.p_forward == NULL ||
621                      p_vpar->sequence.p_backward == NULL)));
622
623     if( p_vpar->picture.i_current_structure )
624     {
625         /* Second field of a frame. We will decode it if, and only if we
626          * have decoded the first field. */
627         if( b_parsable )
628         {
629             b_parsable = (p_vpar->picture.p_picture != NULL);
630         }
631     }
632     else
633     {
634         int     i_repeat_field;
635
636         /* Compute the number of times the frame will be emitted by the
637          * decoder (number of half-periods). */
638         if( p_vpar->sequence.b_progressive )
639         {
640             i_repeat_field = (1 + p_vpar->picture.b_repeat_first_field
641                                 + p_vpar->picture.b_top_field_first) * 2;
642         }
643         else
644         {
645             if( p_vpar->picture.b_progressive )
646             {
647                 i_repeat_field = 2 + p_vpar->picture.b_repeat_first_field;
648             }
649             else
650             {
651                 i_repeat_field = 2;
652             }
653         }
654
655         /* Warn synchro we have a new picture (updates pictures index). */
656         vpar_SynchroNewPicture( p_vpar, p_vpar->picture.i_coding_type,
657                                 i_repeat_field );
658
659         if( b_parsable )
660         {
661             /* Does synchro say we have enough time to decode it ? */
662             b_parsable = vpar_SynchroChoose( p_vpar,
663                                p_vpar->picture.i_coding_type, i_structure );
664         }
665     }
666
667     if( !b_parsable )
668     {
669         /* Update the reference pointers. */
670         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
671
672         /* Update context. */
673         if( i_structure != FRAME_STRUCTURE )
674         {
675             if( (p_vpar->picture.i_current_structure | i_structure)
676                     == FRAME_STRUCTURE )
677             {
678                 p_vpar->picture.i_current_structure = 0;
679             }
680             else
681             {
682                 /* The frame is complete. */
683                 p_vpar->picture.i_current_structure = i_structure;
684
685                 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
686             }
687         }
688         else
689         {
690             /* Warn Synchro we have trashed a picture. */
691             vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
692         }
693         p_vpar->picture.p_picture = NULL;
694
695         return;
696     }
697
698     /* OK, now we are sure we will decode the picture. */
699 #ifdef STATS
700     p_vpar->pc_decoded_pictures[p_vpar->picture.i_coding_type]++;
701 #endif
702
703 #define P_picture p_vpar->picture.p_picture
704     p_vpar->picture.b_error = 0;
705     p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
706
707     if( !p_vpar->picture.i_current_structure )
708     {
709         /* This is a new frame. Get a structure from the video_output. */
710         while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
711                               /* XXX */ 99+p_vpar->sequence.i_chroma_format,
712                                         p_vpar->sequence.i_width,
713                                         p_vpar->sequence.i_height ) )
714              == NULL )
715         {
716             intf_DbgMsg("vpar debug: allocation error in vout_CreatePicture, delaying");
717             if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
718             {
719                 return;
720             }
721             msleep( VPAR_OUTMEM_SLEEP );
722         }
723
724         /* Initialize values. */
725         vpar_SynchroDecode( p_vpar, p_vpar->picture.i_coding_type, i_structure );
726         P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
727         P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
728         p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
729                     << ( 1 - p_vpar->picture.b_frame_structure ) );
730         p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
731                     << ( 1 - p_vpar->picture.b_frame_structure ));
732
733         P_picture->i_deccount = p_vpar->sequence.i_mb_size;
734 #ifdef VDEC_SMP
735         memset( p_vpar->picture.pp_mb, 0, MAX_MB*sizeof(macroblock_t *) );
736 #endif
737 /* FIXME ! remove asap ?? */
738 //memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
739
740         /* Update the reference pointers. */
741         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
742
743 #ifdef VDEC_SMP
744         /* Link referenced pictures for the decoder
745          * They are unlinked in vpar_ReleaseMacroblock() &
746          * vpar_DestroyMacroblock() */
747         if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
748             p_vpar->picture.i_coding_type == B_CODING_TYPE )
749         {
750             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
751         }
752         if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
753         {
754             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
755         }
756 #endif
757     }
758     p_vpar->picture.i_current_structure |= i_structure;
759     p_vpar->picture.i_structure = i_structure;
760
761     /* Initialize picture data for decoding. */
762     if( i_structure == BOTTOM_FIELD )
763     {
764         i_mb_base = p_vpar->sequence.i_mb_size >> 1;
765         p_vpar->mb.i_l_y = 1;
766         p_vpar->mb.i_c_y = 1;
767     }
768     else
769     {
770         i_mb_base = 0;
771         p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
772     }
773     p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
774
775     /* Extension and User data. */
776     ExtensionAndUserData( p_vpar );
777
778     /* This is an MP@ML decoder, please note that neither of the following
779      * assertions can be true :
780      *   p_vpar->sequence.i_chroma_format != CHROMA_420
781      *   p_vpar->sequence.i_height > 2800
782      *   p_vpar->sequence.i_scalable_mode == SC_DP
783      * Be cautious if you try to use the decoder for other profiles and
784      * levels.
785      */
786     if( p_vpar->sequence.b_mpeg2 )
787     {
788         static f_picture_data_t ppf_picture_data[4][4] =
789         {
790             {
791                 NULL, NULL, NULL, NULL
792             },
793             {
794                 /* TOP_FIELD */
795 #if (VPAR_OPTIM_LEVEL > 1)
796                 NULL, vpar_PictureData2IT, vpar_PictureData2PT,
797                 vpar_PictureData2BT
798 #else
799                 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
800                 vpar_PictureDataGENERIC
801 #endif
802             },
803             {
804                 /* BOTTOM_FIELD */
805 #if (VPAR_OPTIM_LEVEL > 1)
806                 NULL, vpar_PictureData2IB, vpar_PictureData2PB,
807                 vpar_PictureData2BB
808 #else
809                 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
810                 vpar_PictureDataGENERIC
811 #endif
812             },
813             {
814                 /* FRAME_PICTURE */
815 #if (VPAR_OPTIM_LEVEL > 0)
816                 NULL, vpar_PictureData2IF, vpar_PictureData2PF,
817                 vpar_PictureData2BF
818 #else
819                 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
820                 vpar_PictureDataGENERIC
821 #endif
822             }
823         };
824
825         ppf_picture_data[p_vpar->picture.i_structure]
826                         [p_vpar->picture.i_coding_type]( p_vpar, i_mb_base );
827     }
828     else
829     {
830 #if (VPAR_OPTIM_LEVEL > 0)
831         static f_picture_data_t pf_picture_data[5] =
832         { NULL, vpar_PictureData1I, vpar_PictureData1P, vpar_PictureData1B,
833           vpar_PictureData1D };
834
835         pf_picture_data[p_vpar->picture.i_coding_type]( p_vpar, i_mb_base );
836 #else
837         vpar_PictureDataGENERIC( p_vpar, i_mb_base );
838 #endif
839     }
840
841     if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
842     {
843         return;
844     }
845
846     if( p_vpar->picture.b_error )
847     {
848         /* Trash picture. */
849 #ifdef VDEC_SMP
850         for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
851         {
852             vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
853         }
854 #endif
855
856 #ifdef STATS
857         p_vpar->pc_malformed_pictures[p_vpar->picture.i_coding_type]++;
858 #endif
859
860         if( P_picture->i_deccount != 1 )
861         {
862             vpar_SynchroEnd( p_vpar, 1 );
863             vout_DestroyPicture( p_vpar->p_vout, P_picture );
864         }
865
866         ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
867
868         /* Prepare context for the next picture. */
869         P_picture = NULL;
870         if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
871             p_vpar->picture.i_current_structure = 0;
872     }
873     else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
874     {
875         /* Frame completely parsed. */
876 #ifdef VDEC_SMP
877         for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
878         {
879             vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
880         }
881
882         /* Send signal to the video_decoder. */
883         vlc_mutex_lock( &p_vpar->vfifo.lock );
884         vlc_cond_signal( &p_vpar->vfifo.wait );
885         vlc_mutex_unlock( &p_vpar->vfifo.lock );
886 #endif
887
888         /* Prepare context for the next picture. */
889         P_picture = NULL;
890         p_vpar->picture.i_current_structure = 0;
891     }
892 #undef P_picture
893 }
894
895 /*****************************************************************************
896  * ExtensionAndUserData : Parse the extension_and_user_data structure
897  *****************************************************************************/
898 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
899 {
900     while( !p_vpar->p_fifo->b_die )
901     {
902         NextStartCode( &p_vpar->bit_stream );
903         switch( ShowBits( &p_vpar->bit_stream, 32 ) )
904         {
905         case EXTENSION_START_CODE:
906             RemoveBits32( &p_vpar->bit_stream );
907             switch( GetBits( &p_vpar->bit_stream, 4 ) )
908             {
909             case SEQUENCE_DISPLAY_EXTENSION_ID:
910                 SequenceDisplayExtension( p_vpar );
911                 break;
912             case QUANT_MATRIX_EXTENSION_ID:
913                 QuantMatrixExtension( p_vpar );
914                 break;
915             case SEQUENCE_SCALABLE_EXTENSION_ID:
916                 SequenceScalableExtension( p_vpar );
917                 break;
918             case PICTURE_DISPLAY_EXTENSION_ID:
919                 PictureDisplayExtension( p_vpar );
920                 break;
921             case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
922                 PictureSpatialScalableExtension( p_vpar );
923                 break;
924             case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
925                 PictureTemporalScalableExtension( p_vpar );
926                 break;
927             case COPYRIGHT_EXTENSION_ID:
928                 CopyrightExtension( p_vpar );
929                 break;
930             default:
931                 break;
932             }
933             break;
934
935         case USER_DATA_START_CODE:
936             RemoveBits32( &p_vpar->bit_stream );
937             /* Wait for the next start code */
938             break;
939
940         default:
941             return;
942         }
943     }
944 }
945
946
947 /*****************************************************************************
948  * SequenceDisplayExtension : Parse the sequence_display_extension structure *
949  *****************************************************************************/
950
951 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
952 {
953     /* We don't care sequence_display_extension. */
954     /* video_format */
955     RemoveBits( &p_vpar->bit_stream, 3 );
956     if( GetBits( &p_vpar->bit_stream, 1 ) )
957     {
958         /* Two bytes for color_desciption */
959         RemoveBits( &p_vpar->bit_stream, 16 );
960         p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
961     }
962     /* display_horizontal and vertical_size and a marker_bit */
963     RemoveBits( &p_vpar->bit_stream, 29 );
964 }
965
966
967 /*****************************************************************************
968  * QuantMatrixExtension : Load quantization matrices for luminance           *
969  *                        and chrominance                                    *
970  *****************************************************************************/
971
972 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
973 {
974     if( GetBits( &p_vpar->bit_stream, 1 ) )
975     {
976         /* Load intra_quantiser_matrix for luminance. */
977         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
978     }
979     else
980     {
981         /* Use the default matrix. */
982         LinkMatrix( &p_vpar->sequence.intra_quant,
983                     p_vpar->pi_default_intra_quant );
984     }
985     if( GetBits( &p_vpar->bit_stream, 1 ) )
986     {
987         /* Load non_intra_quantiser_matrix for luminance. */
988         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
989     }
990     else
991     {
992         /* Use the default matrix. */
993         LinkMatrix( &p_vpar->sequence.nonintra_quant,
994                     p_vpar->pi_default_nonintra_quant );
995     }
996     if( GetBits( &p_vpar->bit_stream, 1 ) )
997     {
998         /* Load intra_quantiser_matrix for chrominance. */
999         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
1000     }
1001     else
1002     {
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 );
1006     }
1007     if( GetBits( &p_vpar->bit_stream, 1 ) )
1008     {
1009         /* Load non_intra_quantiser_matrix for chrominance. */
1010         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
1011     }
1012     else
1013     {
1014         /* Link the chrominance intra matrix to the luminance one. */
1015         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
1016                     p_vpar->sequence.intra_quant.pi_matrix );
1017     }
1018     if( GetBits( &p_vpar->bit_stream, 1 ) )
1019     {
1020         /* Load non_intra_quantiser_matrix for chrominance. */
1021         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
1022     }
1023     else
1024     {
1025         /* Link the chrominance nonintra matrix to the luminance one. */
1026         LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
1027                     p_vpar->sequence.nonintra_quant.pi_matrix );
1028     }
1029 }
1030
1031
1032 /*****************************************************************************
1033  * SequenceScalableExtension : Parse the sequence_scalable_extension         *
1034  *                             structure to handle scalable coding           *
1035  *****************************************************************************/
1036
1037 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
1038 {
1039     /* We don't care about anything scalable except the scalable mode. */
1040     switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
1041     /* The length of the structure depends on the value of the scalable_mode */
1042     {
1043         case 1:
1044             RemoveBits32( &p_vpar->bit_stream );
1045             RemoveBits( &p_vpar->bit_stream, 21 );
1046             break;
1047         case 2:
1048             RemoveBits( &p_vpar->bit_stream, 12 );
1049             break;
1050         default:
1051             RemoveBits( &p_vpar->bit_stream, 4 );
1052     }
1053
1054 }
1055 /*****************************************************************************
1056  * PictureDisplayExtension : Parse the picture_display_extension structure   *
1057  *****************************************************************************/
1058
1059 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
1060 {
1061     /* Number of frame center offset */
1062     int i_nb, i_dummy;
1063     /* I am not sure it works but it should
1064         (fewer tests than shown in §6.3.12) */
1065     i_nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
1066                                             p_vpar->picture.b_repeat_first_field +
1067                                             p_vpar->picture.b_top_field_first
1068                            : ( p_vpar->picture.b_frame_structure + 1 ) +
1069                              p_vpar->picture.b_repeat_first_field;
1070     for( i_dummy = 0; i_dummy < i_nb; i_dummy++ )
1071     {
1072         RemoveBits( &p_vpar->bit_stream, 17 );
1073         RemoveBits( &p_vpar->bit_stream, 17 );
1074     }
1075 }
1076
1077
1078 /*****************************************************************************
1079  * PictureSpatialScalableExtension                                           *
1080  *****************************************************************************/
1081
1082 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
1083 {
1084     /* That's scalable, so we trash it */
1085     RemoveBits32( &p_vpar->bit_stream );
1086     RemoveBits( &p_vpar->bit_stream, 16 );
1087 }
1088
1089
1090 /*****************************************************************************
1091  * PictureTemporalScalableExtension                                          *
1092  *****************************************************************************/
1093
1094 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1095 {
1096     /* Scalable again, trashed again */
1097     RemoveBits( &p_vpar->bit_stream, 23 );
1098 }
1099
1100
1101 /*****************************************************************************
1102  * CopyrightExtension : Keeps some legal informations                        *
1103  *****************************************************************************/
1104
1105 static void CopyrightExtension( vpar_thread_t * p_vpar )
1106 {
1107     u32     i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1108     p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1109         /* A flag that says whether the copyright information is significant */
1110     p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1111         /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1112     p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1113         /* Reserved bits */
1114     RemoveBits( &p_vpar->bit_stream, 8 );
1115         /* The copyright_number is split in three parts */
1116         /* first part */
1117     i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1118     RemoveBits( &p_vpar->bit_stream, 1 );
1119         /* second part */
1120     i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1121     RemoveBits( &p_vpar->bit_stream, 1 );
1122         /* third part and sum */
1123     p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) |
1124                                       ( (u64)i_copyright_nb_2 << 22 ) |
1125                                       ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );
1126 }