779cfa9eaaf48b13be02ffd6c5012345900585be
[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.83 2001/05/01 04:18: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_main->p_vout == NULL )
456     {
457         intf_Msg( "vpar: no vout present, spawning one" );
458         p_main->p_vout = p_vpar->p_vout = vout_CreateThread( NULL );
459     }
460 }
461
462 /*****************************************************************************
463  * GroupHeader : Parse the next group of pictures header
464  *****************************************************************************/
465 static void GroupHeader( vpar_thread_t * p_vpar )
466 {
467     /* Nothing to do, we don't care. */
468     RemoveBits( &p_vpar->bit_stream, 27 );
469     ExtensionAndUserData( p_vpar );
470 }
471
472 /*****************************************************************************
473  * PictureHeader : Parse the next picture header
474  *****************************************************************************/
475 static void PictureHeader( vpar_thread_t * p_vpar )
476 {
477     int                 i_structure;
478     int                 i_mb_base;
479     boolean_t           b_parsable;
480 #ifdef VDEC_SMP
481     int                 i_mb;
482 #endif
483
484     /* Recover in case of stream discontinuity. */
485     if( p_vpar->sequence.b_expect_discontinuity )
486     {
487         ReferenceUpdate( p_vpar, I_CODING_TYPE, NULL );
488         ReferenceUpdate( p_vpar, I_CODING_TYPE, NULL );
489         if( p_vpar->picture.p_picture != NULL )
490         {
491 #ifdef VDEC_SMP
492             int     i_mb;
493
494             for( i_mb = 0; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
495             {
496                 vpar_DestroyMacroblock( &p_vpar->vfifo,
497                                         p_vpar->picture.pp_mb[i_mb] );
498             }
499 #endif
500             vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
501         }
502         p_vpar->sequence.b_expect_discontinuity = 0;
503     }
504
505     /* Parse the picture header. */
506     RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
507     p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
508     RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
509
510     if( p_vpar->picture.i_coding_type == P_CODING_TYPE
511         || p_vpar->picture.i_coding_type == B_CODING_TYPE )
512     {
513         p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
514         p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
515     }
516     if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
517     {
518         p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
519         p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
520     }
521
522     /* extra_information_picture */
523     while( GetBits( &p_vpar->bit_stream, 1 ) )
524     {
525         RemoveBits( &p_vpar->bit_stream, 8 );
526     }
527
528     /*
529      * Picture Coding Extension
530      */
531     NextStartCode( &p_vpar->bit_stream );
532     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
533     {
534         /* Parse picture_coding_extension */
535         RemoveBits32( &p_vpar->bit_stream );
536         /* extension_start_code_identifier */
537         RemoveBits( &p_vpar->bit_stream, 4 );
538
539         p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
540         p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
541         p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
542         p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
543         p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
544         i_structure = GetBits( &p_vpar->bit_stream, 2 );
545         p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
546         p_vpar->picture.b_frame_pred_frame_dct
547              = GetBits( &p_vpar->bit_stream, 1 );
548         p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
549         p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
550         p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
551         p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
552         p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
553         /* chroma_420_type (obsolete) */
554         RemoveBits( &p_vpar->bit_stream, 1 );
555         p_vpar->picture.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
556
557         /* composite_display_flag */
558         if( GetBits( &p_vpar->bit_stream, 1 ) )
559         {
560             /* v_axis, field_sequence, sub_carrier, burst_amplitude,
561              * sub_carrier_phase */
562             RemoveBits( &p_vpar->bit_stream, 20 );
563         }
564     }
565     else
566     {
567         /* MPEG-1 compatibility flags */
568         p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
569         i_structure = FRAME_STRUCTURE;
570         p_vpar->picture.b_top_field_first = 0;
571         p_vpar->picture.b_frame_pred_frame_dct = 1;
572         p_vpar->picture.b_concealment_mv = 0;
573         p_vpar->picture.b_q_scale_type = 0;
574         p_vpar->picture.b_intra_vlc_format = 0;
575         p_vpar->picture.b_alternate_scan = 0; /* zigzag */
576         p_vpar->picture.b_repeat_first_field = 0;
577         p_vpar->picture.b_progressive = 1;
578     }
579
580 #ifdef STATS
581     p_vpar->pc_pictures[p_vpar->picture.i_coding_type]++;
582 #endif
583
584     if( p_vpar->picture.i_current_structure &&
585         (i_structure == FRAME_STRUCTURE ||
586          i_structure == p_vpar->picture.i_current_structure) )
587     {
588         /* We don't have the second field of the buffered frame. */
589         if( p_vpar->picture.p_picture != NULL )
590         {
591             ReferenceReplace( p_vpar,
592                       p_vpar->picture.i_coding_type,
593                       NULL );
594
595 #ifdef VDEC_SMP
596             for( i_mb = 0; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
597             {
598                 vpar_DestroyMacroblock( &p_vpar->vfifo,
599                                         p_vpar->picture.pp_mb[i_mb] );
600             }
601 #endif
602             vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
603         }
604
605         p_vpar->picture.i_current_structure = 0;
606
607         intf_WarnMsg( 2, "Odd number of field pictures." );
608     }
609
610     /* Do we have the reference pictures ? */
611     b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
612                     (p_vpar->sequence.p_backward == NULL)) ||
613                      /* p_backward will become p_forward later */
614                    ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
615                     (p_vpar->sequence.p_forward == NULL ||
616                      p_vpar->sequence.p_backward == NULL)));
617
618     if( p_vpar->picture.i_current_structure )
619     {
620         /* Second field of a frame. We will decode it if, and only if we
621          * have decoded the first field. */
622         if( b_parsable )
623         {
624             b_parsable = (p_vpar->picture.p_picture != NULL);
625         }
626     }
627     else
628     {
629         int     i_repeat_field;
630
631         /* Compute the number of times the frame will be emitted by the
632          * decoder (number of half-periods). */
633         if( p_vpar->sequence.b_progressive )
634         {
635             i_repeat_field = (1 + p_vpar->picture.b_repeat_first_field
636                                 + p_vpar->picture.b_top_field_first) * 2;
637         }
638         else
639         {
640             if( p_vpar->picture.b_progressive )
641             {
642                 i_repeat_field = 2 + p_vpar->picture.b_repeat_first_field;
643             }
644             else
645             {
646                 i_repeat_field = 2;
647             }
648         }
649
650         /* Warn synchro we have a new picture (updates pictures index). */
651         vpar_SynchroNewPicture( p_vpar, p_vpar->picture.i_coding_type,
652                                 i_repeat_field );
653
654         if( b_parsable )
655         {
656             /* Does synchro say we have enough time to decode it ? */
657             b_parsable = vpar_SynchroChoose( p_vpar,
658                                p_vpar->picture.i_coding_type, i_structure );
659         }
660     }
661
662     if( !b_parsable )
663     {
664         /* Update the reference pointers. */
665         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
666
667         /* Update context. */
668         if( i_structure != FRAME_STRUCTURE )
669         {
670             if( (p_vpar->picture.i_current_structure | i_structure)
671                     == FRAME_STRUCTURE )
672             {
673                 p_vpar->picture.i_current_structure = 0;
674             }
675             else
676             {
677                 /* The frame is complete. */
678                 p_vpar->picture.i_current_structure = i_structure;
679
680                 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
681             }
682         }
683         else
684         {
685             /* Warn Synchro we have trashed a picture. */
686             vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
687         }
688         p_vpar->picture.p_picture = NULL;
689
690         return;
691     }
692
693     /* OK, now we are sure we will decode the picture. */
694 #ifdef STATS
695     p_vpar->pc_decoded_pictures[p_vpar->picture.i_coding_type]++;
696 #endif
697
698 #define P_picture p_vpar->picture.p_picture
699     p_vpar->picture.b_error = 0;
700     p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
701
702     if( !p_vpar->picture.i_current_structure )
703     {
704         /* This is a new frame. Get a structure from the video_output. */
705         while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
706                               /* XXX */ 99+p_vpar->sequence.i_chroma_format,
707                                         p_vpar->sequence.i_width,
708                                         p_vpar->sequence.i_height ) )
709              == NULL )
710         {
711             intf_DbgMsg("vpar debug: allocation error in vout_CreatePicture, delaying");
712             if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
713             {
714                 return;
715             }
716             msleep( VPAR_OUTMEM_SLEEP );
717         }
718
719         /* Initialize values. */
720         vpar_SynchroDecode( p_vpar, p_vpar->picture.i_coding_type, i_structure );
721         P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
722         P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
723         p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
724                     << ( 1 - p_vpar->picture.b_frame_structure ) );
725         p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
726                     << ( 1 - p_vpar->picture.b_frame_structure ));
727
728         P_picture->i_deccount = p_vpar->sequence.i_mb_size;
729 #ifdef VDEC_SMP
730         memset( p_vpar->picture.pp_mb, 0, MAX_MB*sizeof(macroblock_t *) );
731 #endif
732 /* FIXME ! remove asap ?? */
733 //memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
734
735         /* Update the reference pointers. */
736         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
737
738 #ifdef VDEC_SMP
739         /* Link referenced pictures for the decoder
740          * They are unlinked in vpar_ReleaseMacroblock() &
741          * vpar_DestroyMacroblock() */
742         if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
743             p_vpar->picture.i_coding_type == B_CODING_TYPE )
744         {
745             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
746         }
747         if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
748         {
749             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
750         }
751 #endif
752     }
753     p_vpar->picture.i_current_structure |= i_structure;
754     p_vpar->picture.i_structure = i_structure;
755
756     /* Initialize picture data for decoding. */
757     if( i_structure == BOTTOM_FIELD )
758     {
759         i_mb_base = p_vpar->sequence.i_mb_size >> 1;
760         p_vpar->mb.i_l_y = 1;
761         p_vpar->mb.i_c_y = 1;
762     }
763     else
764     {
765         i_mb_base = 0;
766         p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
767     }
768     p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
769
770     /* Extension and User data. */
771     ExtensionAndUserData( p_vpar );
772
773     /* This is an MP@ML decoder, please note that neither of the following
774      * assertions can be true :
775      *   p_vpar->sequence.i_chroma_format != CHROMA_420
776      *   p_vpar->sequence.i_height > 2800
777      *   p_vpar->sequence.i_scalable_mode == SC_DP
778      * Be cautious if you try to use the decoder for other profiles and
779      * levels.
780      */
781     if( p_vpar->sequence.b_mpeg2 )
782     {
783         static f_picture_data_t ppf_picture_data[4][4] =
784         {
785             {
786                 NULL, NULL, NULL, NULL
787             },
788             {
789                 /* TOP_FIELD */
790 #if (VPAR_OPTIM_LEVEL > 1)
791                 NULL, vpar_PictureData2IT, vpar_PictureData2PT,
792                 vpar_PictureData2BT
793 #else
794                 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
795                 vpar_PictureDataGENERIC
796 #endif
797             },
798             {
799                 /* BOTTOM_FIELD */
800 #if (VPAR_OPTIM_LEVEL > 1)
801                 NULL, vpar_PictureData2IB, vpar_PictureData2PB,
802                 vpar_PictureData2BB
803 #else
804                 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
805                 vpar_PictureDataGENERIC
806 #endif
807             },
808             {
809                 /* FRAME_PICTURE */
810 #if (VPAR_OPTIM_LEVEL > 0)
811                 NULL, vpar_PictureData2IF, vpar_PictureData2PF,
812                 vpar_PictureData2BF
813 #else
814                 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
815                 vpar_PictureDataGENERIC
816 #endif
817             }
818         };
819
820         ppf_picture_data[p_vpar->picture.i_structure]
821                         [p_vpar->picture.i_coding_type]( p_vpar, i_mb_base );
822     }
823     else
824     {
825 #if (VPAR_OPTIM_LEVEL > 0)
826         static f_picture_data_t pf_picture_data[5] =
827         { NULL, vpar_PictureData1I, vpar_PictureData1P, vpar_PictureData1B,
828           vpar_PictureData1D };
829
830         pf_picture_data[p_vpar->picture.i_coding_type]( p_vpar, i_mb_base );
831 #else
832         vpar_PictureDataGENERIC( p_vpar, i_mb_base );
833 #endif
834     }
835
836     if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
837     {
838         return;
839     }
840
841     if( p_vpar->picture.b_error )
842     {
843         /* Trash picture. */
844 #ifdef VDEC_SMP
845         for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
846         {
847             vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
848         }
849 #endif
850
851 #ifdef STATS
852         p_vpar->pc_malformed_pictures[p_vpar->picture.i_coding_type]++;
853 #endif
854
855         if( P_picture->i_deccount != 1 )
856         {
857             vpar_SynchroEnd( p_vpar, 1 );
858             vout_DestroyPicture( p_vpar->p_vout, P_picture );
859         }
860
861         ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
862
863         /* Prepare context for the next picture. */
864         P_picture = NULL;
865         if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
866             p_vpar->picture.i_current_structure = 0;
867     }
868     else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
869     {
870         /* Frame completely parsed. */
871 #ifdef VDEC_SMP
872         for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
873         {
874             vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
875         }
876
877         /* Send signal to the video_decoder. */
878         vlc_mutex_lock( &p_vpar->vfifo.lock );
879         vlc_cond_signal( &p_vpar->vfifo.wait );
880         vlc_mutex_unlock( &p_vpar->vfifo.lock );
881 #endif
882
883         /* Prepare context for the next picture. */
884         P_picture = NULL;
885         p_vpar->picture.i_current_structure = 0;
886     }
887 #undef P_picture
888 }
889
890 /*****************************************************************************
891  * ExtensionAndUserData : Parse the extension_and_user_data structure
892  *****************************************************************************/
893 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
894 {
895     while( !p_vpar->p_fifo->b_die )
896     {
897         NextStartCode( &p_vpar->bit_stream );
898         switch( ShowBits( &p_vpar->bit_stream, 32 ) )
899         {
900         case EXTENSION_START_CODE:
901             RemoveBits32( &p_vpar->bit_stream );
902             switch( GetBits( &p_vpar->bit_stream, 4 ) )
903             {
904             case SEQUENCE_DISPLAY_EXTENSION_ID:
905                 SequenceDisplayExtension( p_vpar );
906                 break;
907             case QUANT_MATRIX_EXTENSION_ID:
908                 QuantMatrixExtension( p_vpar );
909                 break;
910             case SEQUENCE_SCALABLE_EXTENSION_ID:
911                 SequenceScalableExtension( p_vpar );
912                 break;
913             case PICTURE_DISPLAY_EXTENSION_ID:
914                 PictureDisplayExtension( p_vpar );
915                 break;
916             case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
917                 PictureSpatialScalableExtension( p_vpar );
918                 break;
919             case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
920                 PictureTemporalScalableExtension( p_vpar );
921                 break;
922             case COPYRIGHT_EXTENSION_ID:
923                 CopyrightExtension( p_vpar );
924                 break;
925             default:
926                 break;
927             }
928             break;
929
930         case USER_DATA_START_CODE:
931             RemoveBits32( &p_vpar->bit_stream );
932             /* Wait for the next start code */
933             break;
934
935         default:
936             return;
937         }
938     }
939 }
940
941
942 /*****************************************************************************
943  * SequenceDisplayExtension : Parse the sequence_display_extension structure *
944  *****************************************************************************/
945
946 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
947 {
948     /* We don't care sequence_display_extension. */
949     /* video_format */
950     RemoveBits( &p_vpar->bit_stream, 3 );
951     if( GetBits( &p_vpar->bit_stream, 1 ) )
952     {
953         /* Two bytes for color_desciption */
954         RemoveBits( &p_vpar->bit_stream, 16 );
955         p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
956     }
957     /* display_horizontal and vertical_size and a marker_bit */
958     RemoveBits( &p_vpar->bit_stream, 29 );
959 }
960
961
962 /*****************************************************************************
963  * QuantMatrixExtension : Load quantization matrices for luminance           *
964  *                        and chrominance                                    *
965  *****************************************************************************/
966
967 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
968 {
969     if( GetBits( &p_vpar->bit_stream, 1 ) )
970     {
971         /* Load intra_quantiser_matrix for luminance. */
972         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
973     }
974     else
975     {
976         /* Use the default matrix. */
977         LinkMatrix( &p_vpar->sequence.intra_quant,
978                     p_vpar->pi_default_intra_quant );
979     }
980     if( GetBits( &p_vpar->bit_stream, 1 ) )
981     {
982         /* Load non_intra_quantiser_matrix for luminance. */
983         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
984     }
985     else
986     {
987         /* Use the default matrix. */
988         LinkMatrix( &p_vpar->sequence.nonintra_quant,
989                     p_vpar->pi_default_nonintra_quant );
990     }
991     if( GetBits( &p_vpar->bit_stream, 1 ) )
992     {
993         /* Load intra_quantiser_matrix for chrominance. */
994         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
995     }
996     else
997     {
998         /* Link the chrominance intra matrix to the luminance one. */
999         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
1000                     p_vpar->sequence.intra_quant.pi_matrix );
1001     }
1002     if( GetBits( &p_vpar->bit_stream, 1 ) )
1003     {
1004         /* Load non_intra_quantiser_matrix for chrominance. */
1005         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
1006     }
1007     else
1008     {
1009         /* Link the chrominance intra matrix to the luminance one. */
1010         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
1011                     p_vpar->sequence.intra_quant.pi_matrix );
1012     }
1013     if( GetBits( &p_vpar->bit_stream, 1 ) )
1014     {
1015         /* Load non_intra_quantiser_matrix for chrominance. */
1016         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
1017     }
1018     else
1019     {
1020         /* Link the chrominance nonintra matrix to the luminance one. */
1021         LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
1022                     p_vpar->sequence.nonintra_quant.pi_matrix );
1023     }
1024 }
1025
1026
1027 /*****************************************************************************
1028  * SequenceScalableExtension : Parse the sequence_scalable_extension         *
1029  *                             structure to handle scalable coding           *
1030  *****************************************************************************/
1031
1032 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
1033 {
1034     /* We don't care about anything scalable except the scalable mode. */
1035     switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
1036     /* The length of the structure depends on the value of the scalable_mode */
1037     {
1038         case 1:
1039             RemoveBits32( &p_vpar->bit_stream );
1040             RemoveBits( &p_vpar->bit_stream, 21 );
1041             break;
1042         case 2:
1043             RemoveBits( &p_vpar->bit_stream, 12 );
1044             break;
1045         default:
1046             RemoveBits( &p_vpar->bit_stream, 4 );
1047     }
1048
1049 }
1050 /*****************************************************************************
1051  * PictureDisplayExtension : Parse the picture_display_extension structure   *
1052  *****************************************************************************/
1053
1054 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
1055 {
1056     /* Number of frame center offset */
1057     int i_nb, i_dummy;
1058     /* I am not sure it works but it should
1059         (fewer tests than shown in §6.3.12) */
1060     i_nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
1061                                             p_vpar->picture.b_repeat_first_field +
1062                                             p_vpar->picture.b_top_field_first
1063                            : ( p_vpar->picture.b_frame_structure + 1 ) +
1064                              p_vpar->picture.b_repeat_first_field;
1065     for( i_dummy = 0; i_dummy < i_nb; i_dummy++ )
1066     {
1067         RemoveBits( &p_vpar->bit_stream, 17 );
1068         RemoveBits( &p_vpar->bit_stream, 17 );
1069     }
1070 }
1071
1072
1073 /*****************************************************************************
1074  * PictureSpatialScalableExtension                                           *
1075  *****************************************************************************/
1076
1077 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
1078 {
1079     /* That's scalable, so we trash it */
1080     RemoveBits32( &p_vpar->bit_stream );
1081     RemoveBits( &p_vpar->bit_stream, 16 );
1082 }
1083
1084
1085 /*****************************************************************************
1086  * PictureTemporalScalableExtension                                          *
1087  *****************************************************************************/
1088
1089 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1090 {
1091     /* Scalable again, trashed again */
1092     RemoveBits( &p_vpar->bit_stream, 23 );
1093 }
1094
1095
1096 /*****************************************************************************
1097  * CopyrightExtension : Keeps some legal informations                        *
1098  *****************************************************************************/
1099
1100 static void CopyrightExtension( vpar_thread_t * p_vpar )
1101 {
1102     u32     i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1103     p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1104         /* A flag that says whether the copyright information is significant */
1105     p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1106         /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1107     p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1108         /* Reserved bits */
1109     RemoveBits( &p_vpar->bit_stream, 8 );
1110         /* The copyright_number is split in three parts */
1111         /* first part */
1112     i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1113     RemoveBits( &p_vpar->bit_stream, 1 );
1114         /* second part */
1115     i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1116     RemoveBits( &p_vpar->bit_stream, 1 );
1117         /* third part and sum */
1118     p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) |
1119                                       ( (u64)i_copyright_nb_2 << 22 ) |
1120                                       ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );
1121 }