* Fixed a segfault in the SPU decoder initialization.
[vlc.git] / src / video_parser / video_parser.c
1 /*****************************************************************************
2  * video_parser.c : video parser thread
3  *****************************************************************************
4  * Copyright (C) 1999, 2000 VideoLAN
5  * $Id: video_parser.c,v 1.83 2001/05/01 12:22:18 sam Exp $
6  *
7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
8  *          Samuel Hocevar <sam@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>                                      /* malloc(), free() */
31 #include <unistd.h>                                              /* getpid() */
32 #include <errno.h>
33 #include <string.h>
34
35 #ifdef STATS
36 #  include <sys/times.h>
37 #endif
38
39 #include "config.h"
40 #include "common.h"
41 #include "threads.h"
42 #include "mtime.h"
43 #include "modules.h"
44
45 #include "intf_msg.h"
46
47 #include "stream_control.h"
48 #include "input_ext-dec.h"
49
50 #include "video.h"
51 #include "video_output.h"
52
53 #include "video_decoder.h"
54 #include "vdec_motion.h"
55 #include "../video_decoder/vdec_idct.h"
56
57 #include "vpar_blocks.h"
58 #include "../video_decoder/vpar_headers.h"
59 #include "../video_decoder/vpar_synchro.h"
60 #include "../video_decoder/video_parser.h"
61 #include "../video_decoder/video_fifo.h"
62
63 /*
64  * Local prototypes
65  */
66 static int      InitThread          ( vpar_thread_t * );
67 static void     RunThread           ( vpar_thread_t * );
68 static void     ErrorThread         ( vpar_thread_t * );
69 static void     EndThread           ( vpar_thread_t * );
70 static void     BitstreamCallback   ( bit_stream_t *, boolean_t );
71
72 /*****************************************************************************
73  * vpar_CreateThread: create a generic parser thread
74  *****************************************************************************
75  * This function creates a new video parser thread, and returns a pointer
76  * to its description. On error, it returns NULL.
77  *****************************************************************************/
78 vlc_thread_t vpar_CreateThread( vdec_config_t * p_config )
79 {
80     vpar_thread_t *     p_vpar;
81
82     intf_DbgMsg( "vpar debug: creating video parser thread" );
83
84     /* Allocate the memory needed to store the thread's structure */
85     if ( (p_vpar = (vpar_thread_t *)malloc( sizeof(vpar_thread_t) )) == NULL )
86     {
87         intf_ErrMsg( "vpar error: not enough memory "
88                      "for vpar_CreateThread() to create the new thread");
89         return( 0 );
90     }
91
92     /*
93      * Initialize the thread properties
94      */
95     p_vpar->p_fifo = p_config->decoder_config.p_decoder_fifo;
96     p_vpar->p_config = p_config;
97
98     /*
99      * Choose the best motion compensation module
100      */
101     p_vpar->p_motion_module = module_Need( MODULE_CAPABILITY_MOTION, NULL );
102
103     if( p_vpar->p_motion_module == NULL )
104     {
105         intf_ErrMsg( "vpar error: no suitable motion compensation module" );
106         free( p_vpar );
107         return( 0 );
108     }
109
110 #define M ( p_vpar->pppf_motion )
111 #define S ( p_vpar->ppf_motion_skipped )
112 #define F ( p_vpar->p_motion_module->p_functions->motion.functions.motion )
113     M[0][0][0] = M[0][0][1] = M[0][0][2] = M[0][0][3] = NULL;
114     M[0][1][0] = M[0][1][1] = M[0][1][2] = M[0][1][3] = NULL;
115     M[1][0][0] = NULL;
116     M[1][1][0] = NULL;
117     M[2][0][0] = NULL;
118     M[2][1][0] = NULL;
119     M[3][0][0] = NULL;
120     M[3][1][0] = NULL;
121
122     M[1][0][1] = F.pf_field_field_420;
123     M[1][1][1] = F.pf_frame_field_420;
124     M[2][0][1] = F.pf_field_field_422;
125     M[2][1][1] = F.pf_frame_field_422;
126     M[3][0][1] = F.pf_field_field_444;
127     M[3][1][1] = F.pf_frame_field_444;
128
129     M[1][0][2] = F.pf_field_16x8_420;
130     M[1][1][2] = F.pf_frame_frame_420;
131     M[2][0][2] = F.pf_field_16x8_422;
132     M[2][1][2] = F.pf_frame_frame_422;
133     M[3][0][2] = F.pf_field_16x8_444;
134     M[3][1][2] = F.pf_frame_frame_444;
135
136     M[1][0][3] = F.pf_field_dmv_420;
137     M[1][1][3] = F.pf_frame_dmv_420;
138     M[2][0][3] = F.pf_field_dmv_422;
139     M[2][1][3] = F.pf_frame_dmv_422;
140     M[3][0][3] = F.pf_field_dmv_444;
141     M[3][1][3] = F.pf_frame_dmv_444;
142
143     S[0][0] = S[0][1] = S[0][2] = S[0][3] = NULL;
144     S[1][0] = NULL;
145     S[2][0] = NULL;
146     S[3][0] = NULL;
147
148     S[1][1] = F.pf_field_field_420;
149     S[2][1] = F.pf_field_field_422;
150     S[3][1] = F.pf_field_field_444;
151
152     S[1][2] = F.pf_field_field_420;
153     S[2][2] = F.pf_field_field_422;
154     S[3][2] = F.pf_field_field_444;
155
156     S[1][3] = F.pf_frame_frame_420;
157     S[2][3] = F.pf_frame_frame_422;
158     S[3][3] = F.pf_frame_frame_444;
159 #undef F
160 #undef S
161 #undef M
162
163      /*
164       * Choose the best IDCT module
165       */
166     p_vpar->p_idct_module = module_Need( MODULE_CAPABILITY_IDCT, NULL );
167
168     if( p_vpar->p_idct_module == NULL )
169     {
170         intf_ErrMsg( "vpar error: no suitable IDCT module" );
171         module_Unneed( p_vpar->p_motion_module );
172         free( p_vpar );
173         return( 0 );
174     }
175
176 #define f p_vpar->p_idct_module->p_functions->idct.functions.idct
177     p_vpar->pf_init         = f.pf_init;
178     p_vpar->pf_sparse_idct  = f.pf_sparse_idct;
179     p_vpar->pf_idct         = f.pf_idct;
180     p_vpar->pf_norm_scan    = f.pf_norm_scan;
181 #undef f
182
183     /* Spawn the video parser thread */
184     if ( vlc_thread_create( &p_vpar->thread_id, "video parser",
185                             (vlc_thread_func_t)RunThread, (void *)p_vpar ) )
186     {
187         intf_ErrMsg("vpar error: can't spawn video parser thread");
188         module_Unneed( p_vpar->p_idct_module );
189         module_Unneed( p_vpar->p_motion_module );
190         free( p_vpar );
191         return( 0 );
192     }
193
194     intf_DbgMsg("vpar debug: video parser thread (%p) created", p_vpar);
195     return( p_vpar->thread_id );
196 }
197
198 /* following functions are local */
199
200 /*****************************************************************************
201  * InitThread: initialize vpar output thread
202  *****************************************************************************
203  * This function is called from RunThread and performs the second step of the
204  * initialization. It returns 0 on success. Note that the thread's flag are not
205  * modified inside this function.
206  *****************************************************************************/
207 static int InitThread( vpar_thread_t *p_vpar )
208 {
209 #ifdef VDEC_SMP
210     int i_dummy;
211 #endif
212
213     intf_DbgMsg("vpar debug: initializing video parser thread %p", p_vpar);
214
215     p_vpar->p_config->decoder_config.pf_init_bit_stream( &p_vpar->bit_stream,
216         p_vpar->p_config->decoder_config.p_decoder_fifo, BitstreamCallback,
217         (void *)p_vpar );
218
219     /* Initialize parsing data */
220     p_vpar->sequence.p_forward = NULL;
221     p_vpar->sequence.p_backward = NULL;
222     p_vpar->sequence.intra_quant.b_allocated = 0;
223     p_vpar->sequence.nonintra_quant.b_allocated = 0;
224     p_vpar->sequence.chroma_intra_quant.b_allocated = 0;
225     p_vpar->sequence.chroma_nonintra_quant.b_allocated = 0;
226     p_vpar->sequence.i_matrix_coefficients = 1;
227     p_vpar->sequence.next_pts = p_vpar->sequence.next_dts = 0;
228     p_vpar->sequence.b_expect_discontinuity = 0;
229
230     /* Initialize copyright information */
231     p_vpar->sequence.b_copyright_flag = 0;
232     p_vpar->sequence.b_original = 0;
233     p_vpar->sequence.i_copyright_id = 0;
234     p_vpar->sequence.i_copyright_nb = 0;
235
236     p_vpar->picture.p_picture = NULL;
237     p_vpar->picture.i_current_structure = 0;
238
239     /* Initialize other properties */
240 #ifdef STATS
241     p_vpar->c_loops = 0;
242     p_vpar->c_sequences = 0;
243     memset(p_vpar->pc_pictures, 0, sizeof(p_vpar->pc_pictures));
244     memset(p_vpar->pc_decoded_pictures, 0, sizeof(p_vpar->pc_decoded_pictures));
245     memset(p_vpar->pc_malformed_pictures, 0,
246            sizeof(p_vpar->pc_malformed_pictures));
247 #endif
248
249     /* Initialize video FIFO */
250     vpar_InitFIFO( p_vpar );
251
252     memset( p_vpar->pp_vdec, 0, NB_VDEC*sizeof(vdec_thread_t *) );
253
254 #ifdef VDEC_SMP
255     /* Spawn video_decoder threads */
256     /* FIXME: modify the number of vdecs at runtime ?? */
257     for( i_dummy = 0; i_dummy < NB_VDEC; i_dummy++ )
258     {
259         if( (p_vpar->pp_vdec[i_dummy] = vdec_CreateThread( p_vpar )) == NULL )
260         {
261             return( 1 );
262         }
263     }
264 #else
265     /* Fake a video_decoder thread */
266     if( (p_vpar->pp_vdec[0] = (vdec_thread_t *)malloc(sizeof( vdec_thread_t )))
267          == NULL || vdec_InitThread( p_vpar->pp_vdec[0] ) )
268     {
269         return( 1 );
270     }
271     p_vpar->pp_vdec[0]->b_die = 0;
272     p_vpar->pp_vdec[0]->b_error = 0;
273     p_vpar->pp_vdec[0]->p_vpar = p_vpar;
274
275 #   if !defined(SYS_BEOS) && !defined(WIN32)
276 #       if VDEC_NICE
277     /* Re-nice ourself */
278     if( nice(VDEC_NICE) == -1 )
279     {
280         intf_WarnMsg( 2, "vpar warning : couldn't nice() (%s)",
281                       strerror(errno) );
282     }
283 #       endif
284 #   endif
285 #endif
286
287     /* Initialize lookup tables */
288     vpar_InitMbAddrInc( p_vpar );
289     vpar_InitDCTTables( p_vpar );
290     vpar_InitPMBType( p_vpar );
291     vpar_InitBMBType( p_vpar );
292     vpar_InitDCTTables( p_vpar );
293     vpar_InitScanTable( p_vpar );
294
295     /*
296      * Initialize the synchro properties
297      */
298     vpar_SynchroInit( p_vpar );
299
300     /* Mark thread as running and return */
301     intf_DbgMsg("vpar debug: InitThread(%p) succeeded", p_vpar);
302     return( 0 );
303 }
304
305 /*****************************************************************************
306  * RunThread: generic parser thread
307  *****************************************************************************
308  * Video parser thread. This function only returns when the thread is
309  * terminated.
310  *****************************************************************************/
311 static void RunThread( vpar_thread_t *p_vpar )
312 {
313     intf_DbgMsg("vpar debug: running video parser thread (%p) (pid == %i)", p_vpar, getpid());
314
315     /*
316      * Initialize thread
317      */
318     p_vpar->p_fifo->b_error = InitThread( p_vpar );
319
320     /*
321      * Main loop - it is not executed if an error occured during
322      * initialization
323      */
324     while( (!p_vpar->p_fifo->b_die) && (!p_vpar->p_fifo->b_error) )
325     {
326         /* Find the next sequence header in the stream */
327         p_vpar->p_fifo->b_error = vpar_NextSequenceHeader( p_vpar );
328
329         while( (!p_vpar->p_fifo->b_die) && (!p_vpar->p_fifo->b_error) )
330         {
331 #ifdef STATS
332             p_vpar->c_loops++;
333 #endif
334             /* Parse the next sequence, group or picture header */
335             if( vpar_ParseHeader( p_vpar ) )
336             {
337                 /* End of sequence */
338                 break;
339             };
340         }
341     }
342
343     /*
344      * Error loop
345      */
346     if( p_vpar->p_fifo->b_error )
347     {
348         ErrorThread( p_vpar );
349     }
350
351     /* End of thread */
352     EndThread( p_vpar );
353 }
354
355 /*****************************************************************************
356  * ErrorThread: RunThread() error loop
357  *****************************************************************************
358  * This function is called when an error occured during thread main's loop. The
359  * thread can still receive feed, but must be ready to terminate as soon as
360  * possible.
361  *****************************************************************************/
362 static void ErrorThread( vpar_thread_t *p_vpar )
363 {
364     /* We take the lock, because we are going to read/write the start/end
365      * indexes of the decoder fifo */
366     vlc_mutex_lock( &p_vpar->p_fifo->data_lock );
367
368     /* Wait until a `die' order is sent */
369     while( !p_vpar->p_fifo->b_die )
370     {
371         /* Trash all received PES packets */
372         while( !DECODER_FIFO_ISEMPTY(*p_vpar->p_fifo) )
373         {
374             p_vpar->p_fifo->pf_delete_pes( p_vpar->p_fifo->p_packets_mgt,
375                                   DECODER_FIFO_START(*p_vpar->p_fifo) );
376             DECODER_FIFO_INCSTART( *p_vpar->p_fifo );
377         }
378
379         /* Waiting for the input thread to put new PES packets in the fifo */
380         vlc_cond_wait( &p_vpar->p_fifo->data_wait, &p_vpar->p_fifo->data_lock );
381     }
382
383     /* We can release the lock before leaving */
384     vlc_mutex_unlock( &p_vpar->p_fifo->data_lock );
385 }
386
387 /*****************************************************************************
388  * EndThread: thread destruction
389  *****************************************************************************
390  * This function is called when the thread ends after a sucessful
391  * initialization.
392  *****************************************************************************/
393 static void EndThread( vpar_thread_t *p_vpar )
394 {
395 #ifdef VDEC_SMP
396     int i_dummy;
397 #endif
398
399     intf_DbgMsg("vpar debug: destroying video parser thread %p", p_vpar);
400
401     /* Release used video buffers. */
402     if( p_vpar->sequence.p_forward != NULL )
403     {
404         vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
405     }
406     if( p_vpar->sequence.p_backward != NULL )
407     {
408         vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
409                           vpar_SynchroDate( p_vpar ) );
410         vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
411     }
412     if( p_vpar->picture.p_picture != NULL )
413     {
414         vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
415     }
416
417 #ifdef STATS
418     intf_Msg("vpar stats: %d loops among %d sequence(s)",
419              p_vpar->c_loops, p_vpar->c_sequences);
420
421     {
422         struct tms cpu_usage;
423         times( &cpu_usage );
424
425         intf_Msg("vpar stats: cpu usage (user: %d, system: %d)",
426                  cpu_usage.tms_utime, cpu_usage.tms_stime);
427     }
428
429     intf_Msg("vpar stats: Read %d frames/fields (I %d/P %d/B %d)",
430              p_vpar->pc_pictures[I_CODING_TYPE]
431              + p_vpar->pc_pictures[P_CODING_TYPE]
432              + p_vpar->pc_pictures[B_CODING_TYPE],
433              p_vpar->pc_pictures[I_CODING_TYPE],
434              p_vpar->pc_pictures[P_CODING_TYPE],
435              p_vpar->pc_pictures[B_CODING_TYPE]);
436     intf_Msg("vpar stats: Decoded %d frames/fields (I %d/P %d/B %d)",
437              p_vpar->pc_decoded_pictures[I_CODING_TYPE]
438              + p_vpar->pc_decoded_pictures[P_CODING_TYPE]
439              + p_vpar->pc_decoded_pictures[B_CODING_TYPE],
440              p_vpar->pc_decoded_pictures[I_CODING_TYPE],
441              p_vpar->pc_decoded_pictures[P_CODING_TYPE],
442              p_vpar->pc_decoded_pictures[B_CODING_TYPE]);
443     intf_Msg("vpar stats: Read %d malformed frames/fields (I %d/P %d/B %d)",
444              p_vpar->pc_malformed_pictures[I_CODING_TYPE]
445              + p_vpar->pc_malformed_pictures[P_CODING_TYPE]
446              + p_vpar->pc_malformed_pictures[B_CODING_TYPE],
447              p_vpar->pc_malformed_pictures[I_CODING_TYPE],
448              p_vpar->pc_malformed_pictures[P_CODING_TYPE],
449              p_vpar->pc_malformed_pictures[B_CODING_TYPE]);
450 #define S   p_vpar->sequence
451     intf_Msg("vpar info: %s stream (%dx%d), %d.%d pi/s",
452              S.b_mpeg2 ? "MPEG-2" : "MPEG-1",
453              S.i_width, S.i_height, S.i_frame_rate/1001, S.i_frame_rate % 1001);
454     intf_Msg("vpar info: %s, %s, matrix_coeff: %d",
455              S.b_progressive ? "Progressive" : "Non-progressive",
456              S.i_scalable_mode ? "scalable" : "non-scalable",
457              S.i_matrix_coefficients);
458 #endif
459
460     /* Dispose of matrices if they have been allocated. */
461     if( p_vpar->sequence.intra_quant.b_allocated )
462     {
463         free( p_vpar->sequence.intra_quant.pi_matrix );
464     }
465     if( p_vpar->sequence.nonintra_quant.b_allocated )
466     {
467         free( p_vpar->sequence.nonintra_quant.pi_matrix) ;
468     }
469     if( p_vpar->sequence.chroma_intra_quant.b_allocated )
470     {
471         free( p_vpar->sequence.chroma_intra_quant.pi_matrix );
472     }
473     if( p_vpar->sequence.chroma_nonintra_quant.b_allocated )
474     {
475         free( p_vpar->sequence.chroma_nonintra_quant.pi_matrix );
476     }
477
478 #ifdef VDEC_SMP
479     /* Destroy vdec threads */
480     for( i_dummy = 0; i_dummy < NB_VDEC; i_dummy++ )
481     {
482         if( p_vpar->pp_vdec[i_dummy] != NULL )
483             vdec_DestroyThread( p_vpar->pp_vdec[i_dummy] );
484         else
485             break;
486     }
487 #else
488     free( p_vpar->pp_vdec[0] );
489 #endif
490
491     free( p_vpar->p_config );
492
493 #ifdef VDEC_SMP
494     /* Destroy lock and cond */
495     vlc_mutex_destroy( &(p_vpar->vbuffer.lock) );
496     vlc_cond_destroy( &(p_vpar->vfifo.wait) );
497     vlc_mutex_destroy( &(p_vpar->vfifo.lock) );
498 #endif
499     
500     vlc_mutex_destroy( &(p_vpar->synchro.fifo_lock) );
501     
502     module_Unneed( p_vpar->p_idct_module );
503     module_Unneed( p_vpar->p_motion_module );
504
505     free( p_vpar );
506
507     intf_DbgMsg("vpar debug: EndThread(%p)", p_vpar);
508 }
509
510 /*****************************************************************************
511  * BitstreamCallback: Import parameters from the new data/PES packet
512  *****************************************************************************
513  * This function is called by input's NextDataPacket.
514  *****************************************************************************/
515 static void BitstreamCallback ( bit_stream_t * p_bit_stream,
516                                 boolean_t b_new_pes )
517 {
518     vpar_thread_t * p_vpar = (vpar_thread_t *)p_bit_stream->p_callback_arg;
519
520     if( b_new_pes )
521     {
522         p_vpar->sequence.next_pts =
523             DECODER_FIFO_START( *p_bit_stream->p_decoder_fifo )->i_pts;
524         p_vpar->sequence.next_dts =
525             DECODER_FIFO_START( *p_bit_stream->p_decoder_fifo )->i_dts;
526         p_vpar->sequence.i_current_rate =
527             DECODER_FIFO_START( *p_bit_stream->p_decoder_fifo )->i_rate;
528
529         if( DECODER_FIFO_START( *p_bit_stream->p_decoder_fifo )->b_discontinuity )
530         {
531 #ifdef TRACE_VPAR
532             intf_DbgMsg( "Discontinuity in BitstreamCallback" );
533 #endif
534             /* Escape the current picture and reset the picture predictors. */
535             p_vpar->sequence.b_expect_discontinuity = 1;
536             p_vpar->picture.b_error = 1;
537         }
538     }
539
540     if( p_bit_stream->p_data->b_discard_payload )
541     {
542 #ifdef TRACE_VPAR
543         intf_DbgMsg( "Discard payload in BitstreamCallback" );
544 #endif
545         /* 1 packet messed up, trash the slice. */
546         p_vpar->picture.b_error = 1;
547     }
548 }