X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fvideo_parser%2Fvideo_parser.c;h=0ffaa98f48b469481279310911d8173d3fb1a873;hb=a70f8bb371466209770c4c3bcdb7137b94acef66;hp=6a6d32035fbf863d3ace69c4493eee08116a75d3;hpb=796346ac800b3a3571f87f427e9c9cfc9d51d9dc;p=vlc diff --git a/src/video_parser/video_parser.c b/src/video_parser/video_parser.c index 6a6d32035f..0ffaa98f48 100644 --- a/src/video_parser/video_parser.c +++ b/src/video_parser/video_parser.c @@ -1,177 +1,222 @@ -/******************************************************************************* +/***************************************************************************** * video_parser.c : video parser thread - * (c)1999 VideoLAN - *******************************************************************************/ - -/* ?? passer en terminate/destroy avec les signaux supplémentaires */ - -/******************************************************************************* + ***************************************************************************** + * Copyright (C) 1999, 2000 VideoLAN + * $Id: video_parser.c,v 1.82 2001/05/01 04:18:18 sam Exp $ + * + * Authors: Christophe Massiot + * Samuel Hocevar + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + *****************************************************************************/ + +/***************************************************************************** * Preamble - *******************************************************************************/ + *****************************************************************************/ +#include "defs.h" + +#include /* malloc(), free() */ +#include /* getpid() */ #include -#include -#include -#include #include -#include + +#ifdef STATS +# include +#endif #include "config.h" #include "common.h" +#include "threads.h" #include "mtime.h" -#include "vlc_thread.h" +#include "modules.h" #include "intf_msg.h" -#include "debug.h" /* ?? temporaire, requis par netlist.h */ -#include "input.h" -#include "input_netlist.h" -#include "decoder_fifo.h" +#include "stream_control.h" +#include "input_ext-dec.h" + #include "video.h" #include "video_output.h" -#include "vdec_idct.h" #include "video_decoder.h" #include "vdec_motion.h" +#include "../video_decoder/vdec_idct.h" #include "vpar_blocks.h" -#include "vpar_headers.h" -#include "vpar_synchro.h" -#include "video_parser.h" -#include "video_fifo.h" +#include "../video_decoder/vpar_headers.h" +#include "../video_decoder/vpar_synchro.h" +#include "../video_decoder/video_parser.h" +#include "../video_decoder/video_fifo.h" /* * Local prototypes */ -//static int CheckConfiguration ( video_cfg_t *p_cfg ); -static int InitThread ( vpar_thread_t *p_vpar ); -static void RunThread ( vpar_thread_t *p_vpar ); -static void ErrorThread ( vpar_thread_t *p_vpar ); -static void EndThread ( vpar_thread_t *p_vpar ); +static int InitThread ( vpar_thread_t * ); +static void RunThread ( vpar_thread_t * ); +static void ErrorThread ( vpar_thread_t * ); +static void EndThread ( vpar_thread_t * ); +static void BitstreamCallback ( bit_stream_t *, boolean_t ); -/******************************************************************************* +/***************************************************************************** * 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; -vpar_thread_t * vpar_CreateThread( /* video_cfg_t *p_cfg, */ input_thread_t *p_input /*, - vout_thread_t *p_vout, int *pi_status */ ) + *****************************************************************************/ +vlc_thread_t vpar_CreateThread( vdec_config_t * p_config ) { vpar_thread_t * p_vpar; - intf_DbgMsg("vpar debug: creating video parser thread\n"); + intf_DbgMsg( "vpar debug: creating video parser thread" ); /* Allocate the memory needed to store the thread's structure */ if ( (p_vpar = (vpar_thread_t *)malloc( sizeof(vpar_thread_t) )) == NULL ) { - intf_ErrMsg("vpar error: not enough memory for vpar_CreateThread() to create the new thread\n"); - return( NULL ); + intf_ErrMsg( "vpar error: not enough memory " + "for vpar_CreateThread() to create the new thread"); + return( 0 ); } /* * Initialize the thread properties */ - p_vpar->b_die = 0; - p_vpar->b_error = 0; + p_vpar->p_fifo = p_config->decoder_config.p_decoder_fifo; + p_vpar->p_config = p_config; + + p_vpar->p_vout = p_config->p_vout; /* - * Initialize the input properties + * Choose the best motion compensation module */ - /* Initialize the decoder fifo's data lock and conditional variable and set - * its buffer as empty */ - vlc_mutex_init( &p_vpar->fifo.data_lock ); - vlc_cond_init( &p_vpar->fifo.data_wait ); - p_vpar->fifo.i_start = 0; - p_vpar->fifo.i_end = 0; - /* Initialize the bit stream structure */ - p_vpar->bit_stream.p_input = p_input; - p_vpar->bit_stream.p_decoder_fifo = &p_vpar->fifo; - p_vpar->bit_stream.fifo.buffer = 0; - p_vpar->bit_stream.fifo.i_available = 0; - -/* FIXME !!!! */ -p_vpar->p_vout = p_main->p_intf->p_vout; + p_vpar->p_motion_module = module_Need( MODULE_CAPABILITY_MOTION, NULL ); - /* Spawn the video parser thread */ - if ( vlc_thread_create(&p_vpar->thread_id, "video parser", (vlc_thread_func_t)RunThread, (void *)p_vpar) ) + if( p_vpar->p_motion_module == NULL ) { - intf_ErrMsg("vpar error: can't spawn video parser thread\n"); + intf_ErrMsg( "vpar error: no suitable motion compensation module" ); free( p_vpar ); - return( NULL ); + return( 0 ); } - intf_DbgMsg("vpar debug: video parser thread (%p) created\n", p_vpar); - 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); - - /* Ask thread to kill itself */ - p_vpar->b_die = 1; - /* Make sure the parser thread leaves the GetByte() function */ - vlc_mutex_lock( &(p_vpar->fifo.data_lock) ); - vlc_cond_signal( &(p_vpar->fifo.data_wait) ); - vlc_mutex_unlock( &(p_vpar->fifo.data_lock) ); - - /* Waiting for the parser thread to exit */ - /* Remove this as soon as the "status" flag is implemented */ - vlc_thread_join( p_vpar->thread_id ); -} +#define M ( p_vpar->pppf_motion ) +#define S ( p_vpar->ppf_motion_skipped ) +#define F ( p_vpar->p_motion_module->p_functions->motion.functions.motion ) + M[0][0][0] = M[0][0][1] = M[0][0][2] = M[0][0][3] = NULL; + M[0][1][0] = M[0][1][1] = M[0][1][2] = M[0][1][3] = NULL; + M[1][0][0] = NULL; + M[1][1][0] = NULL; + M[2][0][0] = NULL; + M[2][1][0] = NULL; + M[3][0][0] = NULL; + M[3][1][0] = NULL; + + M[1][0][1] = F.pf_field_field_420; + M[1][1][1] = F.pf_frame_field_420; + M[2][0][1] = F.pf_field_field_422; + M[2][1][1] = F.pf_frame_field_422; + M[3][0][1] = F.pf_field_field_444; + M[3][1][1] = F.pf_frame_field_444; + + M[1][0][2] = F.pf_field_16x8_420; + M[1][1][2] = F.pf_frame_frame_420; + M[2][0][2] = F.pf_field_16x8_422; + M[2][1][2] = F.pf_frame_frame_422; + M[3][0][2] = F.pf_field_16x8_444; + M[3][1][2] = F.pf_frame_frame_444; + + M[1][0][3] = F.pf_field_dmv_420; + M[1][1][3] = F.pf_frame_dmv_420; + M[2][0][3] = F.pf_field_dmv_422; + M[2][1][3] = F.pf_frame_dmv_422; + M[3][0][3] = F.pf_field_dmv_444; + M[3][1][3] = F.pf_frame_dmv_444; + + S[0][0] = S[0][1] = S[0][2] = S[0][3] = NULL; + S[1][0] = NULL; + S[2][0] = NULL; + S[3][0] = NULL; + + S[1][1] = F.pf_field_field_420; + S[2][1] = F.pf_field_field_422; + S[3][1] = F.pf_field_field_444; + + S[1][2] = F.pf_field_field_420; + S[2][2] = F.pf_field_field_422; + S[3][2] = F.pf_field_field_444; + + S[1][3] = F.pf_frame_frame_420; + S[2][3] = F.pf_frame_frame_422; + S[3][3] = F.pf_frame_frame_444; +#undef F +#undef S +#undef M + + /* + * Choose the best IDCT module + */ + p_vpar->p_idct_module = module_Need( MODULE_CAPABILITY_IDCT, NULL ); + + if( p_vpar->p_idct_module == NULL ) + { + intf_ErrMsg( "vpar error: no suitable IDCT module" ); + module_Unneed( p_vpar->p_motion_module ); + free( p_vpar ); + return( 0 ); + } -/* following functions are local */ +#define f p_vpar->p_idct_module->p_functions->idct.functions.idct + p_vpar->pf_init = f.pf_init; + p_vpar->pf_sparse_idct = f.pf_sparse_idct; + p_vpar->pf_idct = f.pf_idct; + p_vpar->pf_norm_scan = f.pf_norm_scan; +#undef f -/******************************************************************************* - * 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 ) -{ - /* ?? */ + /* Spawn the video parser thread */ + if ( vlc_thread_create( &p_vpar->thread_id, "video parser", + (vlc_thread_func_t)RunThread, (void *)p_vpar ) ) + { + intf_ErrMsg("vpar error: can't spawn video parser thread"); + module_Unneed( p_vpar->p_idct_module ); + module_Unneed( p_vpar->p_motion_module ); + free( p_vpar ); + return( 0 ); + } - return( 0 ); + intf_DbgMsg("vpar debug: video parser thread (%p) created", p_vpar); + return( p_vpar->thread_id ); } -#endif -/******************************************************************************* +/* following functions are local */ + +/***************************************************************************** * 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 - intf_DbgMsg("vpar debug: initializing video parser thread %p\n", p_vpar); + intf_DbgMsg("vpar debug: initializing video parser thread %p", p_vpar); - /* Our first job is to initialize the bit stream structure with the - * beginning of the input stream */ - vlc_mutex_lock( &p_vpar->fifo.data_lock ); - while ( DECODER_FIFO_ISEMPTY(p_vpar->fifo) ) - { - 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; - vlc_mutex_unlock( &p_vpar->fifo.data_lock ); + p_vpar->p_config->decoder_config.pf_init_bit_stream( &p_vpar->bit_stream, + p_vpar->p_config->decoder_config.p_decoder_fifo, BitstreamCallback, + (void *)p_vpar ); /* Initialize parsing data */ p_vpar->sequence.p_forward = NULL; @@ -180,6 +225,9 @@ 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; + p_vpar->sequence.i_matrix_coefficients = 1; + p_vpar->sequence.next_pts = p_vpar->sequence.next_dts = 0; + p_vpar->sequence.b_expect_discontinuity = 0; /* Initialize copyright information */ p_vpar->sequence.b_copyright_flag = 0; @@ -192,108 +240,99 @@ static int InitThread( vpar_thread_t *p_vpar ) /* Initialize other properties */ #ifdef STATS - p_vpar->c_loops = 0; - p_vpar->c_idle_loops = 0; - p_vpar->c_pictures = 0; - p_vpar->c_i_pictures = 0; - p_vpar->c_p_pictures = 0; - p_vpar->c_b_pictures = 0; - p_vpar->c_decoded_pictures = 0; - p_vpar->c_decoded_i_pictures = 0; - p_vpar->c_decoded_p_pictures = 0; - p_vpar->c_decoded_b_pictures = 0; + p_vpar->c_loops = 0; + p_vpar->c_sequences = 0; + memset(p_vpar->pc_pictures, 0, sizeof(p_vpar->pc_pictures)); + memset(p_vpar->pc_decoded_pictures, 0, sizeof(p_vpar->pc_decoded_pictures)); + memset(p_vpar->pc_malformed_pictures, 0, + sizeof(p_vpar->pc_malformed_pictures)); #endif /* 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 ? */ + /* FIXME: 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; + +# if !defined(SYS_BEOS) && !defined(WIN32) +# if VDEC_NICE + /* Re-nice ourself */ + if( nice(VDEC_NICE) == -1 ) + { + intf_WarnMsg( 2, "vpar warning : couldn't nice() (%s)", + strerror(errno) ); + } +# endif +# endif +#endif /* Initialize lookup tables */ -#if defined(MPEG2_COMPLIANT) && !defined(VDEC_DFT) - vpar_InitCrop( p_vpar ); -#endif vpar_InitMbAddrInc( p_vpar ); vpar_InitDCTTables( p_vpar ); vpar_InitPMBType( p_vpar ); vpar_InitBMBType( p_vpar ); - vpar_InitCodedPattern( p_vpar ); vpar_InitDCTTables( p_vpar ); + vpar_InitScanTable( p_vpar ); /* * Initialize the synchro properties */ - /* 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 100 ms */ - p_vpar->synchro.decode_time = 500000; - /* assume there were about 3 P and 6 B images between I's */ - p_vpar->synchro.current_p_count = 1; - p_vpar->synchro.p_count_predict = 3; - p_vpar->synchro.current_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; - } + vpar_SynchroInit( p_vpar ); /* Mark thread as running and return */ - intf_DbgMsg("vpar debug: InitThread(%p) succeeded\n", p_vpar); + intf_DbgMsg("vpar debug: InitThread(%p) succeeded", p_vpar); return( 0 ); } -/******************************************************************************* +/***************************************************************************** * RunThread: generic parser thread - ******************************************************************************* - * Video parser thread. This function does only returns when the thread is - * terminated. - *******************************************************************************/ + ***************************************************************************** + * Video parser thread. This function only returns when the thread is + * terminated. + *****************************************************************************/ static void RunThread( vpar_thread_t *p_vpar ) { - intf_DbgMsg("vpar debug: running video parser thread (%p) (pid == %i)\n", p_vpar, getpid()); + intf_DbgMsg("vpar debug: running video parser thread (%p) (pid == %i)", 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; + p_vpar->p_fifo->b_error = InitThread( p_vpar ); /* * Main loop - it is not executed if an error occured during * initialization */ - while( (!p_vpar->b_die) && (!p_vpar->b_error) ) + while( (!p_vpar->p_fifo->b_die) && (!p_vpar->p_fifo->b_error) ) { /* Find the next sequence header in the stream */ - p_vpar->b_error = vpar_NextSequenceHeader( p_vpar ); + p_vpar->p_fifo->b_error = vpar_NextSequenceHeader( p_vpar ); + while( (!p_vpar->p_fifo->b_die) && (!p_vpar->p_fifo->b_error) ) + { #ifdef STATS - p_vpar->c_sequences++; + p_vpar->c_loops++; #endif - - while( (!p_vpar->b_die) && (!p_vpar->b_error) ) - { /* Parse the next sequence, group or picture header */ if( vpar_ParseHeader( p_vpar ) ) { @@ -301,71 +340,124 @@ static void RunThread( vpar_thread_t *p_vpar ) break; }; } - } + } /* * Error loop */ - if( p_vpar->b_error ) + if( p_vpar->p_fifo->b_error ) { ErrorThread( p_vpar ); } /* 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 */ - 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 ); + /* We take the lock, because we are going to read/write the start/end + * indexes of the decoder fifo */ + vlc_mutex_lock( &p_vpar->p_fifo->data_lock ); - /* ?? trash all trashable PES packets */ - while( !DECODER_FIFO_ISEMPTY(p_vpar->fifo) ) + /* Wait until a `die' order is sent */ + while( !p_vpar->p_fifo->b_die ) + { + /* Trash all received PES packets */ + while( !DECODER_FIFO_ISEMPTY(*p_vpar->p_fifo) ) { - input_NetlistFreePES( p_vpar->bit_stream.p_input, - DECODER_FIFO_START(p_vpar->fifo) ); - DECODER_FIFO_INCSTART( p_vpar->fifo ); + p_vpar->p_fifo->pf_delete_pes( p_vpar->p_fifo->p_packets_mgt, + DECODER_FIFO_START(*p_vpar->p_fifo) ); + DECODER_FIFO_INCSTART( *p_vpar->p_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->p_fifo->data_wait, &p_vpar->p_fifo->data_lock ); } + + /* We can release the lock before leaving */ + vlc_mutex_unlock( &p_vpar->p_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 sucessful * 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); + intf_DbgMsg("vpar debug: destroying video parser thread %p", p_vpar); -#ifdef DEBUG - /* Check for remaining PES packets */ - /* ?? */ -#endif + /* Release used video buffers. */ + if( p_vpar->sequence.p_forward != NULL ) + { + vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward ); + } + if( p_vpar->sequence.p_backward != NULL ) + { + vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward, + vpar_SynchroDate( p_vpar ) ); + vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward ); + } + if( p_vpar->picture.p_picture != NULL ) + { + vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture ); + } - /* Destroy thread structures allocated by InitThread */ -// vout_DestroyStream( p_vpar->p_vout, p_vpar->i_stream ); - /* ?? */ +#ifdef STATS + intf_Msg("vpar stats: %d loops among %d sequence(s)", + p_vpar->c_loops, p_vpar->c_sequences); + + { + struct tms cpu_usage; + times( &cpu_usage ); + + intf_Msg("vpar stats: cpu usage (user: %d, system: %d)", + cpu_usage.tms_utime, cpu_usage.tms_stime); + } + + intf_Msg("vpar stats: Read %d frames/fields (I %d/P %d/B %d)", + p_vpar->pc_pictures[I_CODING_TYPE] + + p_vpar->pc_pictures[P_CODING_TYPE] + + p_vpar->pc_pictures[B_CODING_TYPE], + p_vpar->pc_pictures[I_CODING_TYPE], + p_vpar->pc_pictures[P_CODING_TYPE], + p_vpar->pc_pictures[B_CODING_TYPE]); + intf_Msg("vpar stats: Decoded %d frames/fields (I %d/P %d/B %d)", + p_vpar->pc_decoded_pictures[I_CODING_TYPE] + + p_vpar->pc_decoded_pictures[P_CODING_TYPE] + + p_vpar->pc_decoded_pictures[B_CODING_TYPE], + p_vpar->pc_decoded_pictures[I_CODING_TYPE], + p_vpar->pc_decoded_pictures[P_CODING_TYPE], + p_vpar->pc_decoded_pictures[B_CODING_TYPE]); + intf_Msg("vpar stats: Read %d malformed frames/fields (I %d/P %d/B %d)", + p_vpar->pc_malformed_pictures[I_CODING_TYPE] + + p_vpar->pc_malformed_pictures[P_CODING_TYPE] + + p_vpar->pc_malformed_pictures[B_CODING_TYPE], + p_vpar->pc_malformed_pictures[I_CODING_TYPE], + p_vpar->pc_malformed_pictures[P_CODING_TYPE], + p_vpar->pc_malformed_pictures[B_CODING_TYPE]); +#define S p_vpar->sequence + intf_Msg("vpar info: %s stream (%dx%d), %d.%d pi/s", + S.b_mpeg2 ? "MPEG-2" : "MPEG-1", + S.i_width, S.i_height, S.i_frame_rate/1001, S.i_frame_rate % 1001); + intf_Msg("vpar info: %s, %s, matrix_coeff: %d", + S.b_progressive ? "Progressive" : "Non-progressive", + S.i_scalable_mode ? "scalable" : "non-scalable", + S.i_matrix_coefficients); +#endif /* Dispose of matrices if they have been allocated. */ if( p_vpar->sequence.intra_quant.b_allocated ) @@ -385,14 +477,74 @@ static void EndThread( vpar_thread_t *p_vpar ) 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->p_config ); - intf_DbgMsg("vpar debug: EndThread(%p)\n", p_vpar); +#ifdef VDEC_SMP + /* Destroy lock and cond */ + vlc_mutex_destroy( &(p_vpar->vbuffer.lock) ); + vlc_cond_destroy( &(p_vpar->vfifo.wait) ); + vlc_mutex_destroy( &(p_vpar->vfifo.lock) ); +#endif + + vlc_mutex_destroy( &(p_vpar->synchro.fifo_lock) ); + + module_Unneed( p_vpar->p_idct_module ); + module_Unneed( p_vpar->p_motion_module ); + + free( p_vpar ); + + intf_DbgMsg("vpar debug: EndThread(%p)", p_vpar); +} + +/***************************************************************************** + * BitstreamCallback: Import parameters from the new data/PES packet + ***************************************************************************** + * This function is called by input's NextDataPacket. + *****************************************************************************/ +static void BitstreamCallback ( bit_stream_t * p_bit_stream, + boolean_t b_new_pes ) +{ + vpar_thread_t * p_vpar = (vpar_thread_t *)p_bit_stream->p_callback_arg; + + if( b_new_pes ) + { + p_vpar->sequence.next_pts = + DECODER_FIFO_START( *p_bit_stream->p_decoder_fifo )->i_pts; + p_vpar->sequence.next_dts = + DECODER_FIFO_START( *p_bit_stream->p_decoder_fifo )->i_dts; + p_vpar->sequence.i_current_rate = + DECODER_FIFO_START( *p_bit_stream->p_decoder_fifo )->i_rate; + + if( DECODER_FIFO_START( *p_bit_stream->p_decoder_fifo )->b_discontinuity ) + { +#ifdef TRACE_VPAR + intf_DbgMsg( "Discontinuity in BitstreamCallback" ); +#endif + /* Escape the current picture and reset the picture predictors. */ + p_vpar->sequence.b_expect_discontinuity = 1; + p_vpar->picture.b_error = 1; + } + } + + if( p_bit_stream->p_data->b_discard_payload ) + { +#ifdef TRACE_VPAR + intf_DbgMsg( "Discard payload in BitstreamCallback" ); +#endif + /* 1 packet messed up, trash the slice. */ + p_vpar->picture.b_error = 1; + } }