*** empty log message ***

include/parser_fifo.h

+/******************************************************************************
+ * 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;
+}

include/video_parser.h

 /*******************************************************************************
- * 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 */
 /* ?? */