Commit eee7f389 authored by Stéphane Borel's avatar Stéphane Borel

*** empty log message ***

parent 8ee76f64
/******************************************************************************
* parser_fifo.h: interface for parsers PES fifo
* (c)1999 VideoLAN
******************************************************************************
* Required headers:
* - "config.h"
* - "common.h"
* - "vlc_thread.h"
* - "input.h"
******************************************************************************/
/******************************************************************************
* Macros
******************************************************************************/
/* ?? move to inline functions */
#define PARSER_FIFO_ISEMPTY( fifo ) ( (fifo).i_start == (fifo).i_end )
#define PARSER_FIFO_ISFULL( fifo ) ( ( ( (fifo).i_end + 1 - (fifo).i_start ) \
& FIFO_SIZE ) == 0 )
#define PARSER_FIFO_START( fifo ) ( (fifo).buffer[ (fifo).i_start ] )
#define PARSER_FIFO_INCSTART( fifo ) ( (fifo).i_start = ((fifo).i_start + 1) \
& FIFO_SIZE )
#define PARSER_FIFO_END( fifo ) ( (fifo).buffer[ (fifo).i_end ] )
#define PARSER_FIFO_INCEND( fifo ) ( (fifo).i_end = ((fifo).i_end + 1) \
& FIFO_SIZE )
/******************************************************************************
* parser_fifo_t
******************************************************************************
* This rotative FIFO contains PES packets that are to be decoded...
******************************************************************************/
typedef struct
{
vlc_mutex_t data_lock; /* fifo data lock */
vlc_cond_t data_wait; /* fifo data conditional variable */
/* buffer is an array of PES packets pointers */
pes_packet_t * buffer[FIFO_SIZE + 1];
int i_start;
int i_end;
} parser_fifo_t;
/******************************************************************************
* bit_fifo_t : bit fifo descriptor
******************************************************************************
* This type describes a bit fifo used to store bits while working with the
* input stream at the bit level.
******************************************************************************/
typedef struct bit_fifo_s
{
/* This unsigned integer allows us to work at the bit level. This buffer
* can contain 32 bits, and the used space can be found on the MSb's side
* and the available space on the LSb's side. */
u32 buffer;
/* Number of bits available in the bit buffer */
int i_available;
} bit_fifo_t;
/******************************************************************************
* bit_stream_t : bit stream descriptor
******************************************************************************
* This type, based on a PES stream, includes all the structures needed to
* handle the input stream like a bit stream.
******************************************************************************/
typedef struct bit_stream_s
{
/*
* Input structures
*/
/* The input thread feeds the stream with fresh PES packets */
input_thread_t * p_input;
/* The parser fifo contains the data of the PES stream */
parser_fifo_t * p_parser_fifo;
/*
* Byte structures
*/
/* Current TS packet (in the current PES packet of the PES stream) */
ts_packet_t * p_ts;
/* Index of the next byte that is to be read (in the current TS packet) */
unsigned int i_byte;
/*
* Bit structures
*/
bit_fifo_t fifo;
} bit_stream_t;
/*****************************************************************************
* GetByte : reads the next byte in the input stream
*****************************************************************************/
static __inline__ byte_t GetByte( bit_stream_t * p_bit_stream )
{
/* Is the input thread dying ? */
if ( p_bit_stream->p_input->b_die )
{
return( 0 );
}
/* Are there some bytes left in the current TS packet ? */
if ( p_bit_stream->i_byte < p_bit_stream->p_ts->i_payload_end )
{
return( p_bit_stream->p_ts->buffer[ p_bit_stream->i_byte++ ] );
}
else
{
/* We are looking for the next TS packet that contains real data,
* and not just a PES header */
do
{
/* We were reading the last TS packet of this PES packet... It's
* time to jump to the next PES packet */
if ( p_bit_stream->p_ts->p_next_ts == NULL )
{
/* We are going to read/write the start and end indexes of the
* parser fifo and to use the fifo's conditional variable,
* that's why we need to take the lock before */
vlc_mutex_lock( &p_bit_stream->p_parser_fifo->data_lock );
/* We should increase the start index of the parser fifo, but
* if we do this now, the input thread could overwrite the
* pointer to the current PES packet, and we weren't able to
* give it back to the netlist. That's why we free the PES
* packet first. */
input_NetlistFreePES( p_bit_stream->p_input, PARSER_FIFO_START(*p_bit_stream->p_parser_fifo) );
PARSER_FIFO_INCSTART( *p_bit_stream->p_parser_fifo );
while ( PARSER_FIFO_ISEMPTY(*p_bit_stream->p_parser_fifo) )
{
vlc_cond_wait( &p_bit_stream->p_parser_fifo->data_wait,
&p_bit_stream->p_parser_fifo->data_lock );
if ( p_bit_stream->p_input->b_die )
{
vlc_mutex_unlock( &(p_bit_stream->p_parser_fifo->data_lock) );
return( 0 );
}
}
/* The next byte could be found in the next PES packet */
p_bit_stream->p_ts = PARSER_FIFO_START( *p_bit_stream->p_parser_fifo )->p_first_ts;
/* We can release the fifo's data lock */
vlc_mutex_unlock( &p_bit_stream->p_parser_fifo->data_lock );
}
/* Perhaps the next TS packet of the current PES packet contains
* real data (ie its payload's size is greater than 0) */
else
{
p_bit_stream->p_ts = p_bit_stream->p_ts->p_next_ts;
}
} while ( p_bit_stream->p_ts->i_payload_start == p_bit_stream->p_ts->i_payload_end );
/* We've found a TS packet which contains interesting data... As we
* return the payload's first byte, we set i_byte to the following
* one */
p_bit_stream->i_byte = p_bit_stream->p_ts->i_payload_start;
return( p_bit_stream->p_ts->buffer[ p_bit_stream->i_byte++ ] );
}
}
/******************************************************************************
* NeedBits : reads i_bits new bits in the bit stream and stores them in the
* bit buffer
******************************************************************************
* - i_bits must be less or equal 32 !
* - There is something important to notice with that function : if the number
* of bits available in the bit buffer when calling NeedBits() is greater than
* 24 (i_available > 24) but less than the number of needed bits
* (i_available < i_bits), the byte returned by GetByte() will be shifted with
* a negative value and the number of bits available in the bit buffer will be
* set to more than 32 !
******************************************************************************/
static __inline__ void NeedBits( bit_stream_t * p_bit_stream, int i_bits )
{
while ( p_bit_stream->fifo.i_available < i_bits )
{
p_bit_stream->fifo.buffer |= ((u32)GetByte( p_bit_stream )) << (24 - p_bit_stream->fifo.i_available);
p_bit_stream->fifo.i_available += 8;
}
}
/******************************************************************************
* DumpBits : removes i_bits bits from the bit buffer
******************************************************************************
* - i_bits <= i_available
* - i_bits < 32 (because (u32 << 32) <=> (u32 = u32))
******************************************************************************/
static __inline__ void DumpBits( bit_stream_t * p_bit_stream, int i_bits )
{
p_bit_stream->fifo.buffer <<= i_bits;
p_bit_stream->fifo.i_available -= i_bits;
}
/*******************************************************************************
* video_decoder.h : video decoder thread
* video_parser.h : video parser thread
* (c)1999 VideoLAN
*******************************************************************************
*******************************************************************************
......@@ -11,15 +11,15 @@
* "input.h"
* "video.h"
* "video_output.h"
* "decoder_fifo.h"
* "parser_fifo.h"
*******************************************************************************/
/*******************************************************************************
* vdec_thread_t: video decoder thread descriptor
* vpar_thread_t: video parser thread descriptor
*******************************************************************************
* ??
*******************************************************************************/
typedef struct vdec_thread_s
typedef struct vpar_thread_s
{
/* Thread properties and locks */
boolean_t b_die; /* `die' flag */
......@@ -35,7 +35,7 @@ typedef struct vdec_thread_s
/* Input properties */
decoder_fifo_t fifo; /* PES input fifo */
parser_fifo_t fifo; /* PES input fifo */
/* The bit stream structure handles the PES stream at the bit level */
bit_stream_t bit_stream;
......@@ -58,16 +58,16 @@ typedef struct vdec_thread_s
count_t c_decoded_p_pictures; /* number of P pictures decoded */
count_t c_decoded_b_pictures; /* number of B pictures decoded */
#endif
} vdec_thread_t;
} vpar_thread_t;
/*******************************************************************************
* Prototypes
*******************************************************************************/
/* Thread management functions */
vdec_thread_t * vdec_CreateThread ( /* video_cfg_t *p_cfg, */ input_thread_t *p_input /*,
vpar_thread_t * vpar_CreateThread ( /* video_cfg_t *p_cfg, */ input_thread_t *p_input /*,
vout_thread_t *p_vout, int *pi_status */ );
void vdec_DestroyThread ( vdec_thread_t *p_vdec /*, int *pi_status */ );
void vpar_DestroyThread ( vpar_thread_t *p_vpar /*, int *pi_status */ );
/* Time management functions */
/* ?? */
......
/*******************************************************************************
* video_decoder.c : video decoder thread
* video_parser.c : video parser thread
* (c)1999 VideoLAN
*******************************************************************************/
......@@ -23,7 +23,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"
......@@ -31,97 +31,99 @@
#include "video.h"
#include "video_output.h"
#include "video_decoder.h"
#include "video_parser.h"
#include "parser_fifo.h"
/*
* Local prototypes
*/
//static int CheckConfiguration ( video_cfg_t *p_cfg );
static int InitThread ( vdec_thread_t *p_vdec );
static void RunThread ( vdec_thread_t *p_vdec );
static void ErrorThread ( vdec_thread_t *p_vdec );
static void EndThread ( vdec_thread_t *p_vdec );
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 );
/*******************************************************************************
* vdec_CreateThread: create a generic decoder thread
* vpar_CreateThread: create a generic parser thread
*******************************************************************************
* This function creates a new video decoder thread, and returns a pointer
* 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:
* ??
*******************************************************************************/
vdec_thread_t * vpar_CreateThread( /* video_cfg_t *p_cfg, */ input_thread_t *p_input /*,
vpar_thread_t * vpar_CreateThread( /* video_cfg_t *p_cfg, */ input_thread_t *p_input /*,
vout_thread_t *p_vout, int *pi_status */ )
{
vdec_thread_t * p_vdec;
vpar_thread_t * p_vpar;
intf_DbgMsg("vdec debug: creating video decoder thread\n");
intf_DbgMsg("vpar debug: creating video parser thread\n");
/* Allocate the memory needed to store the thread's structure */
if ( (p_vdec = (vdec_thread_t *)malloc( sizeof(vdec_thread_t) )) == NULL )
if ( (p_vpar = (vpar_thread_t *)malloc( sizeof(vpar_thread_t) )) == NULL )
{
intf_ErrMsg("adec error: not enough memory for vdec_CreateThread() to create the new thread\n");
intf_ErrMsg("vpar error: not enough memory for vpar_CreateThread() to create the new thread\n");
return( NULL );
}
/*
* Initialize the thread properties
*/
p_vdec->b_die = 0;
p_vdec->b_error = 0;
p_vpar->b_die = 0;
p_vpar->b_error = 0;
/*
* Initialize the input properties
*/
/* Initialize the decoder fifo's data lock and conditional variable and set * its buffer as empty */
vlc_mutex_init( &p_vdec->fifo.data_lock );
vlc_cond_init( &p_vdec->fifo.data_wait );
p_vdec->fifo.i_start = 0;
p_vdec->fifo.i_end = 0;
/* Initialize the parser 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_vdec->bit_stream.p_input = p_input;
p_vdec->bit_stream.p_decoder_fifo = &p_vdec->fifo;
p_vdec->bit_stream.fifo.buffer = 0;
p_vdec->bit_stream.fifo.i_available = 0;
p_vpar->bit_stream.p_input = p_input;
p_vpar->bit_stream.p_parser_fifo = &p_vpar->fifo;
p_vpar->bit_stream.fifo.buffer = 0;
p_vpar->bit_stream.fifo.i_available = 0;
/* Spawn the video decoder thread */
if ( vlc_thread_create(&p_vdec->thread_id, "video decoder", (vlc_thread_func)RunThread, (void *)p_vdec) )
/* Spawn the video parser thread */
if ( vlc_thread_create(&p_vpar->thread_id, "video parser", (vlc_thread_func)RunThread, (void *)p_vpar) )
{
intf_ErrMsg("vdec error: can't spawn video decoder thread\n");
free( p_vdec );
intf_ErrMsg("vpar error: can't spawn video parser thread\n");
free( p_vpar );
return( NULL );
}
intf_DbgMsg("vdec debug: video decoder thread (%p) created\n", p_vdec);
return( p_vdec );
intf_DbgMsg("vpar debug: video parser thread (%p) created\n", p_vpar);
return( p_vpar );
}
/*******************************************************************************
* vdec_DestroyThread: destroy a generic decoder thread
* 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 vdec_DestroyThread( vdec_thread_t *p_vdec /*, int *pi_status */ )
void vpar g_DestroyThread( vpar_thread_t *p_vpar /*, int *pi_status */ )
{
intf_DbgMsg("vdec debug: requesting termination of video decoder thread %p\n", p_vdec);
intf_DbgMsg("vpar debug: requesting termination of video parser thread %p\n", p_vpar);
/* Ask thread to kill itself */
p_vdec->b_die = 1;
/* Make sure the decoder thread leaves the GetByte() function */
vlc_mutex_lock( &(p_vdec->fifo.data_lock) );
vlc_cond_signal( &(p_vdec->fifo.data_wait) );
vlc_mutex_unlock( &(p_vdec->fifo.data_lock) );
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 decoder thread to exit */
/* Waiting for the parser thread to exit */
/* Remove this as soon as the "status" flag is implemented */
vlc_thread_join( p_vdec->thread_id );
vlc_thread_join( p_vpar->thread_id );
}
/* following functions are local */
/*******************************************************************************
* CheckConfiguration: check vdec_CreateThread() configuration
* CheckConfiguration: check vpar_CreateThread() configuration
*******************************************************************************
* Set default parameters where required. In DEBUG mode, check if configuration
* is valid.
......@@ -136,89 +138,89 @@ static int CheckConfiguration( video_cfg_t *p_cfg )
#endif
/*******************************************************************************
* InitThread: initialize vdec output thread
* 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( vdec_thread_t *p_vdec )
static int InitThread( vpar_thread_t *p_vpar )
{
intf_DbgMsg("vdec debug: initializing video decoder thread %p\n", p_vdec);
intf_DbgMsg("vpar debug: initializing video parser thread %p\n", p_vpar);
/* Our first job is to initialize the bit stream structure with the
* beginning of the input stream */
vlc_mutex_lock( &p_vdec->fifo.data_lock );
while ( DECODER_FIFO_ISEMPTY(p_vdec->fifo) )
vlc_mutex_lock( &p_vpar->fifo.data_lock );
while ( PARSER_FIFO_ISEMPTY(p_vpar->fifo) )
{
vlc_cond_wait( &p_vdec->fifo.data_wait, &p_vdec->fifo.data_lock );
vlc_cond_wait( &p_vpar->fifo.data_wait, &p_vpar->fifo.data_lock );
}
p_vdec->bit_stream.p_ts = DECODER_FIFO_START( p_vdec->fifo )->p_first_ts;
p_vdec->bit_stream.i_byte = p_vdec->bit_stream.p_ts->i_payload_start;
vlc_mutex_unlock( &p_vdec->fifo.data_lock );
p_vpar->bit_stream.p_ts = PARSER_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 );
#if 0
/* ?? */
/* Create video stream */
p_vdec->i_stream = vout_CreateStream( p_vdec->p_vout );
if( p_vdec->i_stream < 0 ) /* error */
p_vpar->i_stream = vout_CreateStream( p_vpar->p_vout );
if( p_vpar->i_stream < 0 ) /* error */
{
return( 1 );
}
/* Initialize decoding data */
/* Initialize parsing data */
/* ?? */
#endif
/* Initialize other properties */
#ifdef STATS
p_vdec->c_loops = 0;
p_vdec->c_idle_loops = 0;
p_vdec->c_pictures = 0;
p_vdec->c_i_pictures = 0;
p_vdec->c_p_pictures = 0;
p_vdec->c_b_pictures = 0;
p_vdec->c_decoded_pictures = 0;
p_vdec->c_decoded_i_pictures = 0;
p_vdec->c_decoded_p_pictures = 0;
p_vdec->c_decoded_b_pictures = 0;
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;
#endif
/* Mark thread as running and return */
intf_DbgMsg("vdec debug: InitThread(%p) succeeded\n", p_vdec);
intf_DbgMsg("vpar debug: InitThread(%p) succeeded\n", p_vpar);
return( 0 );
}
/*******************************************************************************
* RunThread: generic decoder thread
* RunThread: generic parser thread
*******************************************************************************
* Generic decoder thread. This function does only returns when the thread is
* Generic parser thread. This function does only returns when the thread is
* terminated.
*******************************************************************************/
static void RunThread( vdec_thread_t *p_vdec )
static void RunThread( vpar_thread_t *p_vpar )
{
intf_DbgMsg("vdec debug: running video decoder thread (%p) (pid == %i)\n", p_vdec, getpid());
intf_DbgMsg("vpar debug: running video parser thread (%p) (pid == %i)\n", p_vpar, getpid());
/*
* Initialize thread and free configuration
*/
p_vdec->b_error = InitThread( p_vdec );
if( p_vdec->b_error )
p_vpar->b_error = InitThread( p_vpar );
if( p_vpar->b_error )
{
return;
}
p_vdec->b_run = 1;
p_vpar->b_run = 1;
/* REMOVE ME !!!!! */
p_vdec->b_error = 1;
p_vpar->b_error = 1;
/*
* Main loop - it is not executed if an error occured during
* initialization
*/
while( (!p_vdec->b_die) && (!p_vdec->b_error) )
while( (!p_vpar->b_die) && (!p_vpar->b_error) )
{
/* ?? */
}
......@@ -226,14 +228,14 @@ p_vdec->b_error = 1;
/*
* Error loop
*/
if( p_vdec->b_error )
if( p_vpar->b_error )
{
ErrorThread( p_vdec );
ErrorThread( p_vpar );
}
/* End of thread */
EndThread( p_vdec );
p_vdec->b_run = 0;
EndThread( p_vpar );
p_vpar->b_run = 0;
}
/*******************************************************************************
......@@ -243,25 +245,25 @@ p_vdec->b_error = 1;
* thread can still receive feed, but must be ready to terminate as soon as
* possible.
*******************************************************************************/
static void ErrorThread( vdec_thread_t *p_vdec )
static void ErrorThread( vpar_thread_t *p_vpar )
{
/* Wait until a `die' order */
while( !p_vdec->b_die )
while( !p_vpar->b_die )
{
/* We take the lock, because we are going to read/write the start/end
* indexes of the decoder fifo */
vlc_mutex_lock( &p_vdec->fifo.data_lock );
* indexes of the parser fifo */
vlc_mutex_lock( &p_vpar->fifo.data_lock );
/* ?? trash all trashable PES packets */
while( !DECODER_FIFO_ISEMPTY(p_vdec->fifo) )
while( !PARSER_FIFO_ISEMPTY(p_vpar->fifo) )
{
input_NetlistFreePES( p_vdec->bit_stream.p_input, DECODER_FIFO_START(p_vdec->fifo) );
DECODER_FIFO_INCSTART( p_vdec->fifo );
input_NetlistFreePES( p_vpar->bit_stream.p_input, PARSER_FIFO_START(p_vpar->fifo) );
PARSER_FIFO_INCSTART( p_vpar->fifo );
}
vlc_mutex_unlock( &p_vdec->fifo.data_lock );
vlc_mutex_unlock( &p_vpar->fifo.data_lock );
/* Sleep a while */
msleep( VDEC_IDLE_SLEEP );
msleep( VPAR_IDLE_SLEEP );
}
}
......@@ -271,9 +273,9 @@ static void ErrorThread( vdec_thread_t *p_vdec )
* This function is called when the thread ends after a sucessfull
* initialization.
*******************************************************************************/
static void EndThread( vdec_thread_t *p_vdec )
static void EndThread( vpar_thread_t *p_vpar )
{
intf_DbgMsg("vdec debug: destroying video decoder thread %p\n", p_vdec);
intf_DbgMsg("vpar debug: destroying video parser thread %p\n", p_vpar);
#ifdef DEBUG
/* Check for remaining PES packets */
......@@ -281,8 +283,8 @@ static void EndThread( vdec_thread_t *p_vdec )
#endif
/* Destroy thread structures allocated by InitThread */
// vout_DestroyStream( p_vdec->p_vout, p_vdec->i_stream );
// vout_DestroyStream( p_vpar->p_vout, p_vpar->i_stream );
/* ?? */
intf_DbgMsg("vdec debug: EndThread(%p)\n", p_vdec);
intf_DbgMsg("vpar debug: EndThread(%p)\n", p_vpar);
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment