X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fvideo_parser%2Fvideo_parser.c;h=97c50c1abfb1a76ba700c8bbdb86fd1b93bf5474;hb=25f0492374daa0d57ed99d89df4cc680c39723bb;hp=186ee186c1fc60ffca0b9fe6a99a567e1b51ceb0;hpb=023206d07b1da8a9ff58f54c8cc4bffe4397c4d1;p=vlc diff --git a/src/video_parser/video_parser.c b/src/video_parser/video_parser.c index 186ee186c1..97c50c1abf 100644 --- a/src/video_parser/video_parser.c +++ b/src/video_parser/video_parser.c @@ -1,21 +1,19 @@ -/******************************************************************************* +/***************************************************************************** * video_parser.c : video parser thread * (c)1999 VideoLAN - *******************************************************************************/ + *****************************************************************************/ /* ?? passer en terminate/destroy avec les signaux supplémentaires */ -/******************************************************************************* +/***************************************************************************** * Preamble - *******************************************************************************/ + *****************************************************************************/ #include #include #include #include #include #include -#include -#include #include "config.h" #include "common.h" @@ -23,7 +21,7 @@ #include "vlc_thread.h" #include "intf_msg.h" -#include "debug.h" /* ?? temporaire, requis par netlist.h */ +#include "debug.h" /* ?? temporaire, requis par netlist.h */ #include "input.h" #include "input_netlist.h" @@ -37,9 +35,9 @@ #include "vpar_blocks.h" #include "vpar_headers.h" -#include "video_fifo.h" #include "vpar_synchro.h" #include "video_parser.h" +#include "video_fifo.h" /* * Local prototypes @@ -50,14 +48,14 @@ static void RunThread ( vpar_thread_t *p_vpar ); static void ErrorThread ( vpar_thread_t *p_vpar ); static void EndThread ( vpar_thread_t *p_vpar ); -/******************************************************************************* +/***************************************************************************** * vpar_CreateThread: create a generic parser thread - ******************************************************************************* + ***************************************************************************** * This function creates a new video parser thread, and returns a pointer * to its description. On error, it returns NULL. * Following configuration properties are used: * ?? - *******************************************************************************/ + *****************************************************************************/ #include "main.h" #include "interface.h" extern main_t* p_main; @@ -111,13 +109,13 @@ p_vpar->p_vout = p_main->p_intf->p_vout; return( p_vpar ); } -/******************************************************************************* +/***************************************************************************** * vpar_DestroyThread: destroy a generic parser thread - ******************************************************************************* + ***************************************************************************** * Destroy a terminated thread. This function will return 0 if the thread could * be destroyed, and non 0 else. The last case probably means that the thread * was still active, and another try may succeed. - *******************************************************************************/ + *****************************************************************************/ void vpar_DestroyThread( vpar_thread_t *p_vpar /*, int *pi_status */ ) { intf_DbgMsg("vpar debug: requesting termination of video parser thread %p\n", p_vpar); @@ -136,12 +134,12 @@ void vpar_DestroyThread( vpar_thread_t *p_vpar /*, int *pi_status */ ) /* following functions are local */ -/******************************************************************************* +/***************************************************************************** * CheckConfiguration: check vpar_CreateThread() configuration - ******************************************************************************* + ***************************************************************************** * Set default parameters where required. In DEBUG mode, check if configuration * is valid. - *******************************************************************************/ + *****************************************************************************/ #if 0 static int CheckConfiguration( video_cfg_t *p_cfg ) { @@ -151,16 +149,22 @@ static int CheckConfiguration( video_cfg_t *p_cfg ) } #endif -/******************************************************************************* +/***************************************************************************** * InitThread: initialize vpar output thread - ******************************************************************************* + ***************************************************************************** * This function is called from RunThread and performs the second step of the * initialization. It returns 0 on success. Note that the thread's flag are not * modified inside this function. - *******************************************************************************/ + *****************************************************************************/ static int InitThread( vpar_thread_t *p_vpar ) { - int i_dummy; +#ifdef VDEC_SMP + int i_dummy; +#endif + +#ifdef SAM_SYNCHRO + int i_dummy; +#endif intf_DbgMsg("vpar debug: initializing video parser thread %p\n", p_vpar); @@ -169,22 +173,18 @@ static int InitThread( vpar_thread_t *p_vpar ) vlc_mutex_lock( &p_vpar->fifo.data_lock ); while ( DECODER_FIFO_ISEMPTY(p_vpar->fifo) ) { + if ( p_vpar->b_die ) + { + vlc_mutex_unlock( &p_vpar->fifo.data_lock ); + return( 1 ); + } vlc_cond_wait( &p_vpar->fifo.data_wait, &p_vpar->fifo.data_lock ); } p_vpar->bit_stream.p_ts = DECODER_FIFO_START( p_vpar->fifo )->p_first_ts; - p_vpar->bit_stream.i_byte = p_vpar->bit_stream.p_ts->i_payload_start; + p_vpar->bit_stream.p_byte = p_vpar->bit_stream.p_ts->buffer + p_vpar->bit_stream.p_ts->i_payload_start; + p_vpar->bit_stream.p_end = p_vpar->bit_stream.p_ts->buffer + p_vpar->bit_stream.p_ts->i_payload_end; vlc_mutex_unlock( &p_vpar->fifo.data_lock ); -#if 0 - /* ?? */ - /* Create video stream */ - p_vpar->i_stream = vout_CreateStream( p_vpar->p_vout ); - if( p_vpar->i_stream < 0 ) /* error */ - { - return( 1 ); - } -#endif - /* Initialize parsing data */ p_vpar->sequence.p_forward = NULL; p_vpar->sequence.p_backward = NULL; @@ -192,15 +192,19 @@ static int InitThread( vpar_thread_t *p_vpar ) p_vpar->sequence.nonintra_quant.b_allocated = 0; p_vpar->sequence.chroma_intra_quant.b_allocated = 0; p_vpar->sequence.chroma_nonintra_quant.b_allocated = 0; + /* Initialize copyright information */ p_vpar->sequence.b_copyright_flag = 0; p_vpar->sequence.b_original = 0; p_vpar->sequence.i_copyright_id = 0; p_vpar->sequence.i_copyright_nb = 0; + p_vpar->picture.p_picture = NULL; + p_vpar->picture.i_current_structure = 0; + /* Initialize other properties */ #ifdef STATS - p_vpar->c_loops = 0; + p_vpar->c_loops = 0; p_vpar->c_idle_loops = 0; p_vpar->c_pictures = 0; p_vpar->c_i_pictures = 0; @@ -214,18 +218,30 @@ static int InitThread( vpar_thread_t *p_vpar ) /* Initialize video FIFO */ vpar_InitFIFO( p_vpar ); - - bzero( p_vpar->p_vdec, NB_VDEC*sizeof(vdec_thread_t *) ); - + + memset( p_vpar->pp_vdec, 0, NB_VDEC*sizeof(vdec_thread_t *) ); + +#ifdef VDEC_SMP /* Spawn video_decoder threads */ /* ??? modify the number of vdecs at runtime ? */ for( i_dummy = 0; i_dummy < NB_VDEC; i_dummy++ ) { - if( (p_vpar->p_vdec[i_dummy] = vdec_CreateThread( p_vpar )) == NULL ) + if( (p_vpar->pp_vdec[i_dummy] = vdec_CreateThread( p_vpar )) == NULL ) { return( 1 ); } } +#else + /* Fake a video_decoder thread */ + if( (p_vpar->pp_vdec[0] = (vdec_thread_t *)malloc(sizeof( vdec_thread_t ))) == NULL + || vdec_InitThread( p_vpar->pp_vdec[0] ) ) + { + return( 1 ); + } + p_vpar->pp_vdec[0]->b_die = 0; + p_vpar->pp_vdec[0]->b_error = 0; + p_vpar->pp_vdec[0]->p_vpar = p_vpar; +#endif /* Initialize lookup tables */ #if defined(MPEG2_COMPLIANT) && !defined(VDEC_DFT) @@ -235,32 +251,89 @@ static int InitThread( vpar_thread_t *p_vpar ) vpar_InitDCTTables( p_vpar ); vpar_InitPMBType( p_vpar ); vpar_InitBMBType( p_vpar ); - vpar_InitCodedPattern( p_vpar ); vpar_InitDCTTables( p_vpar ); + + /* + * Initialize the synchro properties + */ +#ifdef SAM_SYNCHRO + p_vpar->synchro.i_last_decode_pts = 0; + p_vpar->synchro.i_last_display_pts = 0; + p_vpar->synchro.i_images_since_pts = 0; + /* for i frames */ + p_vpar->synchro.i_last_i_pts = 0; + p_vpar->synchro.theorical_fps = 25; + p_vpar->synchro.i_last_nondropped_i_pts = 0; + p_vpar->synchro.actual_fps = 20; + /* the fifo */ + p_vpar->synchro.i_fifo_start = 0; + p_vpar->synchro.i_fifo_stop = 0; + /* the counter */ + p_vpar->synchro.modulo = 0; + /* mean decoding time - at least 200 ms for a slow machine */ + p_vpar->synchro.i_mean_decode_time = 200000; + /* assume we can display all Is and 2 Ps */ + p_vpar->synchro.can_display_i = 1; + p_vpar->synchro.can_display_p = 0; + p_vpar->synchro.displayable_p = 2; + p_vpar->synchro.can_display_b = 0; + p_vpar->synchro.displayable_b = 0; + /* assume there were about 3 P and 6 B images between I's */ + p_vpar->synchro.current_p_count = 1; + p_vpar->synchro.nondropped_p_count = 1; + p_vpar->synchro.p_count_predict = 3; + p_vpar->synchro.current_b_count = 1; + p_vpar->synchro.nondropped_b_count = 1; + p_vpar->synchro.b_count_predict = 6; + for( i_dummy = 0; i_dummy < 6; i_dummy++) + { + p_vpar->synchro.tab_p[i_dummy].mean = 3; + p_vpar->synchro.tab_p[i_dummy].deviation = .5; + p_vpar->synchro.tab_b[i_dummy].mean = 6; + p_vpar->synchro.tab_b[i_dummy].deviation = .5; + } +#endif + +#ifdef MEUUH_SYNCHRO + p_vpar->synchro.kludge_level = 5; + p_vpar->synchro.kludge_nbp = p_vpar->synchro.kludge_p = 5; + p_vpar->synchro.kludge_nbb = p_vpar->synchro.kludge_b = 6; + p_vpar->synchro.kludge_b = 0; + p_vpar->synchro.kludge_prevdate = 0; +#endif + +#ifdef POLUX_SYNCHRO + p_vpar->synchro.i_current_frame_date = 0; + p_vpar->synchro.i_backward_frame_date = 0; + + p_vpar->synchro.r_p_average = p_vpar->synchro.i_p_nb = 6; + p_vpar->synchro.r_b_average = p_vpar->synchro.i_b_nb = 6; + p_vpar->synchro.i_p_count = 0; + p_vpar->synchro.i_b_count = 0; + p_vpar->synchro.i_i_count = 0; +#endif + /* Mark thread as running and return */ intf_DbgMsg("vpar debug: InitThread(%p) succeeded\n", p_vpar); return( 0 ); } -/******************************************************************************* +/***************************************************************************** * RunThread: generic parser thread - ******************************************************************************* + ***************************************************************************** * Video parser thread. This function does only returns when the thread is - * terminated. - *******************************************************************************/ + * terminated. + *****************************************************************************/ static void RunThread( vpar_thread_t *p_vpar ) { intf_DbgMsg("vpar debug: running video parser thread (%p) (pid == %i)\n", p_vpar, getpid()); - /* - * Initialize thread + /* + * Initialize thread */ p_vpar->b_error = InitThread( p_vpar ); - if( p_vpar->b_error ) - { - return; - } + p_vpar->b_run = 1; /* @@ -285,7 +358,7 @@ static void RunThread( vpar_thread_t *p_vpar ) break; }; } - } + } /* * Error loop @@ -295,50 +368,54 @@ static void RunThread( vpar_thread_t *p_vpar ) ErrorThread( p_vpar ); } + p_vpar->b_run = 0; + /* End of thread */ EndThread( p_vpar ); - p_vpar->b_run = 0; } -/******************************************************************************* +/***************************************************************************** * ErrorThread: RunThread() error loop - ******************************************************************************* + ***************************************************************************** * This function is called when an error occured during thread main's loop. The * thread can still receive feed, but must be ready to terminate as soon as * possible. - *******************************************************************************/ + *****************************************************************************/ static void ErrorThread( vpar_thread_t *p_vpar ) { - /* Wait until a `die' order */ + /* We take the lock, because we are going to read/write the start/end + * indexes of the decoder fifo */ + vlc_mutex_lock( &p_vpar->fifo.data_lock ); + + /* Wait until a `die' order is sent */ while( !p_vpar->b_die ) { - /* We take the lock, because we are going to read/write the start/end - * indexes of the parser fifo */ - vlc_mutex_lock( &p_vpar->fifo.data_lock ); - - /* ?? trash all trashable PES packets */ + /* Trash all received PES packets */ while( !DECODER_FIFO_ISEMPTY(p_vpar->fifo) ) { - input_NetlistFreePES( p_vpar->bit_stream.p_input, - DECODER_FIFO_START(p_vpar->fifo) ); + input_NetlistFreePES( p_vpar->bit_stream.p_input, DECODER_FIFO_START(p_vpar->fifo) ); DECODER_FIFO_INCSTART( p_vpar->fifo ); } - vlc_mutex_unlock( &p_vpar->fifo.data_lock ); - /* Sleep a while */ - msleep( VPAR_IDLE_SLEEP ); + /* Waiting for the input thread to put new PES packets in the fifo */ + vlc_cond_wait( &p_vpar->fifo.data_wait, &p_vpar->fifo.data_lock ); } + + /* We can release the lock before leaving */ + vlc_mutex_unlock( &p_vpar->fifo.data_lock ); } -/******************************************************************************* +/***************************************************************************** * EndThread: thread destruction - ******************************************************************************* - * This function is called when the thread ends after a sucessfull + ***************************************************************************** + * This function is called when the thread ends after a sucessfull * initialization. - *******************************************************************************/ + *****************************************************************************/ static void EndThread( vpar_thread_t *p_vpar ) { +#ifdef VDEC_SMP int i_dummy; +#endif intf_DbgMsg("vpar debug: destroying video parser thread %p\n", p_vpar); @@ -351,14 +428,38 @@ static void EndThread( vpar_thread_t *p_vpar ) // vout_DestroyStream( p_vpar->p_vout, p_vpar->i_stream ); /* ?? */ + /* Dispose of matrices if they have been allocated. */ + if( p_vpar->sequence.intra_quant.b_allocated ) + { + free( p_vpar->sequence.intra_quant.pi_matrix ); + } + if( p_vpar->sequence.nonintra_quant.b_allocated ) + { + free( p_vpar->sequence.nonintra_quant.pi_matrix) ; + } + if( p_vpar->sequence.chroma_intra_quant.b_allocated ) + { + free( p_vpar->sequence.chroma_intra_quant.pi_matrix ); + } + if( p_vpar->sequence.chroma_nonintra_quant.b_allocated ) + { + free( p_vpar->sequence.chroma_nonintra_quant.pi_matrix ); + } + +#ifdef VDEC_SMP /* Destroy vdec threads */ for( i_dummy = 0; i_dummy < NB_VDEC; i_dummy++ ) { - if( p_vpar->p_vdec[i_dummy] != NULL ) - vdec_DestroyThread( p_vpar->p_vdec[i_dummy] ); + if( p_vpar->pp_vdec[i_dummy] != NULL ) + vdec_DestroyThread( p_vpar->pp_vdec[i_dummy] ); else break; } +#else + free( p_vpar->pp_vdec[0] ); +#endif + + free( p_vpar ); intf_DbgMsg("vpar debug: EndThread(%p)\n", p_vpar); }