X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Finput%2Finput_dec.c;h=905d8d8b2b2842f859ee8c8223ae35295afb4991;hb=7518bb92dd1934dcb190915f68f520556f70f11b;hp=3a87d4aa6dfc829e7c833c76585836a4235467e8;hpb=e3c0699664a71a948da68d89dd31c952d01bb6be;p=vlc diff --git a/src/input/input_dec.c b/src/input/input_dec.c index 3a87d4aa6d..905d8d8b2b 100644 --- a/src/input/input_dec.c +++ b/src/input/input_dec.c @@ -2,7 +2,7 @@ * input_dec.c: Functions for the management of decoders ***************************************************************************** * Copyright (C) 1999-2001 VideoLAN - * $Id: input_dec.c,v 1.33 2002/05/12 01:39:36 massiot Exp $ + * $Id: input_dec.c,v 1.57 2003/01/25 03:12:20 fenrir Exp $ * * Authors: Christophe Massiot * @@ -10,7 +10,7 @@ * 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 @@ -26,74 +26,129 @@ *****************************************************************************/ #include #include /* memcpy(), memset() */ -#include /* off_t */ -#include +#include #include "stream_control.h" #include "input_ext-dec.h" #include "input_ext-intf.h" #include "input_ext-plugins.h" -static decoder_config_t * CreateDecoderConfig( input_thread_t * p_input, - es_descriptor_t * p_es ); -static void DeleteDecoderConfig( decoder_config_t * p_config ); +static decoder_fifo_t * CreateDecoderFifo( input_thread_t *, + es_descriptor_t * ); +static void DeleteDecoderFifo( decoder_fifo_t * ); /***************************************************************************** * input_RunDecoder: spawns a new decoder thread *****************************************************************************/ -vlc_thread_t input_RunDecoder( input_thread_t * p_input, - es_descriptor_t * p_es ) +decoder_fifo_t * input_RunDecoder( input_thread_t * p_input, + es_descriptor_t * p_es ) { - vlc_thread_t thread_id; - char * psz_plugin = NULL; + char *psz_sout; + decoder_fifo_t *p_fifo; + int i_priority; + + /* Create the decoder configuration structure */ + p_fifo = CreateDecoderFifo( p_input, p_es ); - if( p_es->i_type == MPEG1_AUDIO_ES || p_es->i_type == MPEG2_AUDIO_ES ) + if( p_fifo == NULL ) { - psz_plugin = config_GetPszVariable( "mpeg-adec" ); + msg_Err( p_input, "could not create decoder fifo" ); + return NULL; } - if( p_es->i_type == AC3_AUDIO_ES ) + + p_fifo->p_module = NULL; + /* If we are in sout mode, search first for packetizer module then + * codec to do transcoding */ + psz_sout = config_GetPsz( p_input, "sout" ); + if( psz_sout != NULL && *psz_sout != 0 ) { - psz_plugin = config_GetPszVariable( "ac3-adec" ); - } + vlc_bool_t b_sout = VLC_TRUE; + + if( p_es->i_cat == AUDIO_ES ) + { + b_sout = config_GetInt( p_input, "sout-audio" ); + } + else if( p_es->i_cat == VIDEO_ES ) + { + b_sout = config_GetInt( p_input, "sout-video" ); + } + + if( b_sout ) + { + vlc_bool_t b_reencode = VLC_FALSE; + + if( p_es->i_cat == AUDIO_ES ) + { + char *psz_sout_acodec = config_GetPsz( p_input, "sout-acodec" ); + if( psz_sout_acodec != NULL && *psz_sout_acodec != '\0' ) + { + msg_Dbg( p_input, "audio reencoding requested -> unsupported" ); + b_reencode = VLC_TRUE; + } + } + else if( p_es->i_cat == VIDEO_ES ) + { + char *psz_sout_vcodec = config_GetPsz( p_input, "sout-vcodec" ); + if( psz_sout_vcodec != NULL && *psz_sout_vcodec != '\0' ) + { + msg_Dbg( p_input, "video reencoding requested" ); + /* force encoder video output */ + config_PutPsz( p_input, "vout", "encoder" ); + b_reencode = VLC_TRUE; + } + } - /* Get a suitable module */ - p_es->p_module = module_Need( MODULE_CAPABILITY_DECODER, psz_plugin, - (void *)&p_es->i_type ); - if( psz_plugin ) free( psz_plugin ); - if( p_es->p_module == NULL ) + if( !b_reencode ) + { + /* we don't want to reencode so search for a packetizer */ + p_fifo->p_module = + module_Need( p_fifo, "packetizer", "$packetizer" ); + } + else + { + /* get a suitable decoder module to do reencoding*/ + p_fifo->p_module = module_Need( p_fifo, "decoder", "$codec" ); + } + } + } + else { - intf_ErrMsg( "input error: no suitable decoder module for type 0x%x", - p_es->i_type ); - return( 0 ); + /* default Get a suitable decoder module */ + p_fifo->p_module = module_Need( p_fifo, "decoder", "$codec" ); } - /* Create the decoder configuration structure */ - p_es->p_config = CreateDecoderConfig( p_input, p_es ); + if( p_fifo->p_module == NULL ) + { + msg_Err( p_fifo, "no suitable decoder module for fourcc `%4.4s'", + (char*)&p_fifo->i_fourcc ); + DeleteDecoderFifo( p_fifo ); + vlc_object_destroy( p_fifo ); + return NULL; + } - if( p_es->p_config == NULL ) + if ( p_es->i_cat == AUDIO_ES ) + { + i_priority = VLC_THREAD_PRIORITY_AUDIO; + } + else { - intf_ErrMsg( "input error: could not create decoder config" ); - module_Unneed( p_es->p_module ); - return( 0 ); + i_priority = VLC_THREAD_PRIORITY_VIDEO; } /* Spawn the decoder thread */ - if ( vlc_thread_create( &thread_id, "decoder", - (vlc_thread_func_t)p_es->p_module-> - p_functions->dec.functions.dec.pf_run, - (void *)p_es->p_config) ) + if( vlc_thread_create( p_fifo, "decoder", p_fifo->pf_run, + i_priority, VLC_FALSE ) ) { - intf_ErrMsg( "input error: can't spawn decoder thread \"%s\"", - p_es->p_module->psz_name ); - free( p_es->p_config ); - module_Unneed( p_es->p_module ); - return( 0 ); + msg_Err( p_fifo, "cannot spawn decoder thread \"%s\"", + p_fifo->p_module->psz_object_name ); + module_Unneed( p_fifo, p_fifo->p_module ); + return NULL; } p_input->stream.b_changed = 1; - return thread_id; + return p_fifo; } @@ -121,15 +176,18 @@ void input_EndDecoder( input_thread_t * p_input, es_descriptor_t * p_es ) /* Waiting for the thread to exit */ /* I thought that unlocking was better since thread join can be long * but it actually creates late pictures and freezes --stef */ -// vlc_mutex_unlock( &p_input->stream.stream_lock ); - vlc_thread_join( p_es->thread_id ); -// vlc_mutex_lock( &p_input->stream.stream_lock ); + /* vlc_mutex_unlock( &p_input->stream.stream_lock ); */ + vlc_thread_join( p_es->p_decoder_fifo ); + /* vlc_mutex_lock( &p_input->stream.stream_lock ); */ /* Delete decoder configuration */ - DeleteDecoderConfig( p_es->p_config ); + DeleteDecoderFifo( p_es->p_decoder_fifo ); /* Unneed module */ - module_Unneed( p_es->p_module ); + module_Unneed( p_es->p_decoder_fifo, p_es->p_decoder_fifo->p_module ); + + /* Delete the fifo */ + vlc_object_destroy( p_es->p_decoder_fifo ); /* Tell the input there is no more decoder */ p_es->p_decoder_fifo = NULL; @@ -156,17 +214,132 @@ void input_DecodePES( decoder_fifo_t * p_decoder_fifo, pes_packet_t * p_pes ) vlc_mutex_unlock( &p_decoder_fifo->data_lock ); } +/**************************************************************************** + * input_ExtractPES + ***************************************************************************** + * Extract a PES from the fifo. If pp_pes is NULL then the PES is just + * deleted, otherwise *pp_pes will point to this PES. + ****************************************************************************/ +void input_ExtractPES( decoder_fifo_t *p_fifo, pes_packet_t **pp_pes ) +{ + pes_packet_t *p_pes; + + vlc_mutex_lock( &p_fifo->data_lock ); + + if( p_fifo->p_first == NULL ) + { + if( p_fifo->b_die ) + { + vlc_mutex_unlock( &p_fifo->data_lock ); + if( pp_pes ) *pp_pes = NULL; + return; + } + + /* Signal the input thread we're waiting. This is only + * needed in case of slave clock (ES plug-in) but it won't + * harm. */ + vlc_cond_signal( &p_fifo->data_wait ); + + /* Wait for the input to tell us when we received a packet. */ + vlc_cond_wait( &p_fifo->data_wait, &p_fifo->data_lock ); + } + + p_pes = p_fifo->p_first; + p_fifo->p_first = p_pes->p_next; + p_pes->p_next = NULL; + p_fifo->i_depth--; + + if( !p_fifo->p_first ) + { + /* No PES in the FIFO. p_last is no longer valid. */ + p_fifo->pp_last = &p_fifo->p_first; + } + + vlc_mutex_unlock( &p_fifo->data_lock ); + + if( pp_pes ) + *pp_pes = p_pes; + else + input_DeletePES( p_fifo->p_packets_mgt, p_pes ); +} + +/**************************************************************************** + * input_FlushPESFifo + ***************************************************************************** + * Empties the PES fifo of the decoder. + ****************************************************************************/ +void input_FlushPESFifo( decoder_fifo_t *p_fifo ) +{ + pes_packet_t * p_pes; + + vlc_mutex_lock( &p_fifo->data_lock ); + while( p_fifo->p_first ) + { + p_pes = p_fifo->p_first; + p_fifo->p_first = p_fifo->p_first->p_next; + input_DeletePES( p_fifo->p_packets_mgt, p_pes ); + } + /* No PES in the FIFO. p_last is no longer valid. */ + p_fifo->pp_last = &p_fifo->p_first; + vlc_mutex_unlock( &p_fifo->data_lock ); +} + + +/***************************************************************************** + * Create a NULL packet for padding in case of a data loss + *****************************************************************************/ +void input_NullPacket( input_thread_t * p_input, + es_descriptor_t * p_es ) +{ + data_packet_t * p_pad_data; + pes_packet_t * p_pes; + + if( (p_pad_data = input_NewPacketForce( p_input->p_method_data, + PADDING_PACKET_SIZE)) == NULL ) + { + msg_Err( p_input, "no new packet" ); + p_input->b_error = 1; + return; + } + + memset( p_pad_data->p_payload_start, 0, PADDING_PACKET_SIZE ); + p_pad_data->b_discard_payload = 1; + p_pes = p_es->p_pes; + + if( p_pes != NULL ) + { + p_pes->b_discontinuity = 1; + p_pes->p_last->p_next = p_pad_data; + p_pes->p_last = p_pad_data; + p_pes->i_nb_data++; + } + else + { + if( (p_pes = input_NewPES( p_input->p_method_data )) == NULL ) + { + msg_Err( p_input, "no PES packet" ); + p_input->b_error = 1; + return; + } + + p_pes->i_rate = p_input->stream.control.i_rate; + p_pes->p_first = p_pes->p_last = p_pad_data; + p_pes->i_nb_data = 1; + p_pes->b_discontinuity = 1; + input_DecodePES( p_es->p_decoder_fifo, p_pes ); + } +} + /***************************************************************************** * input_EscapeDiscontinuity: send a NULL packet to the decoders *****************************************************************************/ -void input_EscapeDiscontinuity( input_thread_t * p_input, - pgrm_descriptor_t * p_pgrm ) +void input_EscapeDiscontinuity( input_thread_t * p_input ) { - int i_es, i; + unsigned int i_es, i; - for( i_es = 0; i_es < p_pgrm->i_es_number; i_es++ ) + for( i_es = 0; i_es < p_input->stream.i_selected_es_number; i_es++ ) { - es_descriptor_t * p_es = p_pgrm->pp_es[i_es]; + es_descriptor_t * p_es = p_input->stream.pp_selected_es[i_es]; if( p_es->p_decoder_fifo != NULL ) { @@ -183,105 +356,84 @@ void input_EscapeDiscontinuity( input_thread_t * p_input, *****************************************************************************/ void input_EscapeAudioDiscontinuity( input_thread_t * p_input ) { - int i_pgrm, i_es, i; + unsigned int i_es, i; - for( i_pgrm = 0; i_pgrm < p_input->stream.i_pgrm_number; i_pgrm++ ) + for( i_es = 0; i_es < p_input->stream.i_selected_es_number; i_es++ ) { - pgrm_descriptor_t * p_pgrm = p_input->stream.pp_programs[i_pgrm]; + es_descriptor_t * p_es = p_input->stream.pp_selected_es[i_es]; - for( i_es = 0; i_es < p_pgrm->i_es_number; i_es++ ) + if( p_es->p_decoder_fifo != NULL && p_es->i_cat == AUDIO_ES ) { - es_descriptor_t * p_es = p_pgrm->pp_es[i_es]; - - if( p_es->p_decoder_fifo != NULL && p_es->b_audio ) + for( i = 0; i < PADDING_PACKET_NUMBER; i++ ) { - for( i = 0; i < PADDING_PACKET_NUMBER; i++ ) - { - input_NullPacket( p_input, p_es ); - } + input_NullPacket( p_input, p_es ); } } } } /***************************************************************************** - * CreateDecoderConfig: create a decoder_config_t + * CreateDecoderFifo: create a decoder_fifo_t *****************************************************************************/ -static decoder_config_t * CreateDecoderConfig( input_thread_t * p_input, - es_descriptor_t * p_es ) +static decoder_fifo_t * CreateDecoderFifo( input_thread_t * p_input, + es_descriptor_t * p_es ) { - decoder_config_t * p_config; - - p_config = (decoder_config_t *)malloc( sizeof(decoder_config_t) ); - if( p_config == NULL ) - { - intf_ErrMsg( "Unable to allocate memory in CreateDecoderConfig" ); - return NULL; - } + decoder_fifo_t * p_fifo; /* Decoder FIFO */ - if( (p_config->p_decoder_fifo = - (decoder_fifo_t *)malloc( sizeof(decoder_fifo_t) )) == NULL ) + p_fifo = vlc_object_create( p_input, VLC_OBJECT_DECODER ); + if( p_fifo == NULL ) { - intf_ErrMsg( "Out of memory" ); - free( p_config ); + msg_Err( p_input, "out of memory" ); return NULL; } /* Select a new ES */ - p_input->stream.i_selected_es_number++; - p_input->stream.pp_selected_es = realloc( - p_input->stream.pp_selected_es, - p_input->stream.i_selected_es_number - * sizeof(es_descriptor_t *) ); - if( p_input->stream.pp_selected_es == NULL ) - { - intf_ErrMsg( "Unable to realloc memory" ); - free( p_config->p_decoder_fifo ); - free( p_config ); - return NULL; - } - p_input->stream.pp_selected_es[p_input->stream.i_selected_es_number - 1] - = p_es; - - /* Initialize the p_config structure */ - vlc_mutex_init(&p_config->p_decoder_fifo->data_lock); - vlc_cond_init(&p_config->p_decoder_fifo->data_wait); - p_es->p_decoder_fifo = p_config->p_decoder_fifo; - - p_config->i_id = p_es->i_id; - p_config->i_type = p_es->i_type; - p_config->p_demux_data = p_es->p_demux_data; - - p_config->p_stream_ctrl = &p_input->stream.control; - - p_config->p_decoder_fifo->p_first = NULL; - p_config->p_decoder_fifo->pp_last = &p_config->p_decoder_fifo->p_first; - p_config->p_decoder_fifo->i_depth = 0; - p_config->p_decoder_fifo->b_die = p_config->p_decoder_fifo->b_error = 0; - p_config->p_decoder_fifo->p_packets_mgt = p_input->p_method_data; - - return p_config; + INSERT_ELEM( p_input->stream.pp_selected_es, + p_input->stream.i_selected_es_number, + p_input->stream.i_selected_es_number, + p_es ); + + /* Initialize the p_fifo structure */ + vlc_mutex_init( p_input, &p_fifo->data_lock ); + vlc_cond_init( p_input, &p_fifo->data_wait ); + p_es->p_decoder_fifo = p_fifo; + + p_fifo->i_id = p_es->i_id; + p_fifo->i_fourcc = p_es->i_fourcc; + p_fifo->p_demux_data = p_es->p_demux_data; + p_fifo->p_waveformatex = p_es->p_waveformatex; + p_fifo->p_bitmapinfoheader = p_es->p_bitmapinfoheader; + p_fifo->p_stream_ctrl = &p_input->stream.control; + p_fifo->p_sout = p_input->stream.p_sout; + + p_fifo->p_first = NULL; + p_fifo->pp_last = &p_fifo->p_first; + p_fifo->i_depth = 0; + p_fifo->b_die = p_fifo->b_error = 0; + p_fifo->p_packets_mgt = p_input->p_method_data; + + vlc_object_attach( p_fifo, p_input ); + + return p_fifo; } /***************************************************************************** - * DeleteDecoderConfig: create a decoder_config_t + * DeleteDecoderFifo: destroy a decoder_fifo_t *****************************************************************************/ -static void DeleteDecoderConfig( decoder_config_t * p_config ) +static void DeleteDecoderFifo( decoder_fifo_t * p_fifo ) { - intf_StatMsg( "input stats: killing decoder for 0x%x, type 0x%x, %d PES in FIFO", - p_config->i_id, p_config->i_type, - p_config->p_decoder_fifo->i_depth ); - /* Free all packets still in the decoder fifo. */ - input_DeletePES( p_config->p_decoder_fifo->p_packets_mgt, - p_config->p_decoder_fifo->p_first ); + vlc_object_detach( p_fifo ); - /* Destroy the lock and cond */ - vlc_cond_destroy( &p_config->p_decoder_fifo->data_wait ); - vlc_mutex_destroy( &p_config->p_decoder_fifo->data_lock ); + msg_Dbg( p_fifo, "killing decoder for 0x%x, fourcc `%4.4s', %d PES in FIFO", + p_fifo->i_id, (char*)&p_fifo->i_fourcc, p_fifo->i_depth ); - free( p_config->p_decoder_fifo ); + /* Free all packets still in the decoder fifo. */ + input_DeletePES( p_fifo->p_packets_mgt, + p_fifo->p_first ); - free( p_config ); + /* Destroy the lock and cond */ + vlc_cond_destroy( &p_fifo->data_wait ); + vlc_mutex_destroy( &p_fifo->data_lock ); }