Changeset 18188c24971c0fa187494500b865fc12f3955d8d

Timestamp:

18/01/01 18:40:06 (8 years ago)

Author:

Christophe Massiot <massiot@videolan.org>

git-committer:

Christophe Massiot <massiot@videolan.org> 979839606 +0000

git-parent:

[647cca0ebb2e897a570018ba80483bb81a7d90c6]

git-author:

Christophe Massiot <massiot@videolan.org> 979839606 +0000

Message:

* 32-bit aligned bitstream (not that fast).

Files:

• include/common.h (modified) (3 diffs)
• include/input_ext-dec.h (modified) (11 diffs)
• src/input/input.h (modified) (2 diffs)
• src/input/input_ext-dec.c (modified) (3 diffs)
• src/video_parser/vpar_synchro.c (modified) (2 diffs)

include/common.h

@@ -4 +4 @@
- *****************************************************************************
- * Copyright (C) 1998, 1999, 2000 VideoLAN
-5 2001/01/18 05:13:22 sam
+6 2001/01/18 17:40:06 massiot
- *
- * Authors: Samuel Hocevar <sam@via.ecp.fr>
@@ -156 +156 @@
-#endif
-
-/*
- * This is stolen from the livid source who stole it from the kernel
- */
-
-#if defined(SYS_BEOS)
-#   define swab32(x) B_BENDIAN_TO_HOST_INT32(x)
-#else
-#   ifdef WORDS_BIG_ENDIAN
-#       define swab32(x) (x)
-#   else
-#       if defined (HAVE_X86_BSWAP)
-static __inline__ const u32 __i386_swab32( u32 x )
-{
-    __asm__("bswap %0" : "=r" (x) : "0" (x));
-    return x;
-}
-#           define swab32(x) __i386_swab32(x)
-#       else
-#           define swab32(x)                                                 \
-            ( ( (u32)(((u8*)&x)[0]) << 24 ) | ( (u32)(((u8*)&x)[1]) << 16 ) |\
-              ( (u32)(((u8*)&x)[2]) << 8 )  | ( (u32)(((u8*)&x)[3])) )
-#       endif
-#   endif
-#endif
-
-/* MSB (big endian)/LSB (little endian) conversions - network order is always
- * MSB, and should be used for both network communications and files. Note that
@@ -205 +180 @@
-
-/* Macros with automatic casts */
-
-
+
+
+
-

include/input_ext-dec.h

@@ -3 +3 @@
- *****************************************************************************
- * Copyright (C) 1999, 2000 VideoLAN
-4 2001/01/13 12:57:19 sam
+5 2001/01/18 17:40:06 massiot
- *
- * Authors:
@@ -114 +114 @@
- * input stream at the bit level.
- *****************************************************************************/
-        /* only u32 is supported at the moment */
+
-
-typedef struct bit_fifo_s
@@ -173 +173 @@
-
-/*
-
-
-
+
+
+
+
+
+
+
+
+
- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-#endif
-
-/*****************************************************************************
+ * Protoypes from input_ext-dec.c
+ *****************************************************************************/
+u32  UnalignedShowBits( struct bit_stream_s *, unsigned int );
+void UnalignedRemoveBits( struct bit_stream_s * );
+u32  UnalignedGetBits( struct bit_stream_s *, unsigned int );
+
+/*****************************************************************************
+ * AlignWord : fill in the bit buffer so that the byte pointer be aligned
+ * on a word boundary (XXX: there must be at least sizeof(WORD_TYPE) - 1
+ * empty bytes in the bit buffer)
+ *****************************************************************************/
+static __inline__ void AlignWord( bit_stream_t * p_bit_stream )
+{
+    while( (p_bit_stream->p_byte - p_bit_stream->p_data->p_buffer)
+             & (sizeof(WORD_TYPE) - 1) )
+    {
+        if( p_bit_stream->p_byte < p_bit_stream->p_end )
+        {
+            p_bit_stream->fifo.buffer |= *(p_bit_stream->p_byte++)
+                << (8 * sizeof(WORD_TYPE) - 8
+                     - p_bit_stream->fifo.i_available);
+            p_bit_stream->fifo.i_available += 8;
+        }
+        else
+        {
+            p_bit_stream->pf_next_data_packet( p_bit_stream );
+            p_bit_stream->fifo.buffer |= *(p_bit_stream->p_byte++)
+                << (8 * sizeof(WORD_TYPE) - 8
+                     - p_bit_stream->fifo.i_available);
+            p_bit_stream->fifo.i_available += 8;
+        }
+    }
+}
+
+/*****************************************************************************
- * ShowBits : return i_bits bits from the bit stream
- *****************************************************************************/
-
-
+
+
+
+
+
+
+
+
-    if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
-    {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-                    >> (8 * sizeof(WORD_TYPE) - i_bits) );
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-}
-
@@ -289 +253 @@
- *              XXX: do not use for 32 bits, see RemoveBits32
- *****************************************************************************/
-
+
+
-{
-    p_bit_stream->fifo.i_available -= i_bits;
@@ -298 +263 @@
-        return;
-    }
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -307 +280 @@
- *                refill it)
- *****************************************************************************/
+#if (WORD_TYPE == u32)
-static __inline__ void RemoveBits32( bit_stream_t * p_bit_stream )
-{
-
-
-
+
+
+
+
+
-                            << (32 - p_bit_stream->fifo.i_available);
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-/*****************************************************************************
@@ -324 +308 @@
- *           XXX: do not use for 32 bits, see GetBits32
- *****************************************************************************/
-
+
+
-{
-    u32             i_result;
-
-
-
-
-
+
+
+
+
+
-        p_bit_stream->fifo.buffer <<= i_bits;
-        return( i_result );
-    }
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-                                     + p_bit_stream->fifo.i_available);
-
-
-
-
+
+
+
+
+
+
-}
-
@@ -350 +343 @@
- * GetBits32 : returns 32 bits from the bit stream and removes them
- *****************************************************************************/
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-        i_result = p_bit_stream->fifo.buffer;
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-                             >> (p_bit_stream->fifo.i_available);
-
-
+
+
+
+
+
+
-        return( i_result );
-    }
-
-
-
-
-
+
+
+
+
+
+
-
-/*****************************************************************************
@@ -380 +389 @@
-}
-
-
-/*
- * Philosophy of the third implementation : the decoder asks for n bytes,
- * and we will copy them in its buffer.
- */
-
-/*****************************************************************************
@@ -397 +401 @@
-{
-    ptrdiff_t           i_available;
+
+    if( p_bit_stream->fifo.i_available )
+    {
+        *((WORD_TYPE *)p_buffer) = WORD_AT( p_bit_stream->fifo.buffer );
+        p_buffer += p_bit_stream->fifo.i_available >> 3;
+        i_buf_len -= p_bit_stream->fifo.i_available >> 3;
+        p_bit_stream->fifo.buffer = 0;
+        p_bit_stream->fifo.i_available = 0;
+    }
-
-    if( (i_available = p_bit_stream->p_end - p_bit_stream->p_byte)
@@ -423 +436 @@
-        }
-    }
+
+    if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
+    {
+        AlignWord( p_bit_stream );
+    }
+}
+
+
+/*
+ * The following functions are now deprecated.
+ */
+
+static __inline__ byte_t _GetByte( bit_stream_t * p_bit_stream )
+{
+    if ( p_bit_stream->p_byte >= p_bit_stream->p_end )
+    {
+        p_bit_stream->pf_next_data_packet( p_bit_stream );
+    }
+
+    return( *(p_bit_stream->p_byte++) );
+}
+
+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 |= ((WORD_TYPE)_GetByte( p_bit_stream ))
+                                     << (8 * sizeof(WORD_TYPE) - 8
+                                            - p_bit_stream->fifo.i_available);
+        p_bit_stream->fifo.i_available += 8;
+    }
+}
+
+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;
-}
-

src/input/input.h

@@ -3 +3 @@
- *****************************************************************************
- * Copyright (C) 1999, 2000 VideoLAN
-0 2001/01/15 08:07:31 sam
+1 2001/01/18 17:40:06 massiot
- *
- * Authors:
@@ -119 +119 @@
-    }
-
-    /* XXX FIXME SARASS TODO: remove the following one-liner kludge when
-     * we have bitstream IV, we won't need it anymore */
-    ((WORD_TYPE *)p_pad_data->p_payload_start)++;
-
-    memset( p_pad_data->p_buffer, 0, PADDING_PACKET_SIZE );
-    p_pad_data->b_discard_payload = 1;

src/input/input_ext-dec.c

@@ -73 +73 @@
-void NextDataPacket( bit_stream_t * p_bit_stream )
-{
-    WORD_TYPE           buffer_left;
-    ptrdiff_t           i_bytes_left;
-    decoder_fifo_t *    p_fifo = p_bit_stream->p_decoder_fifo;
-    boolean_t           b_new_pes;
-
-    /* Put the remaining bytes (not aligned on a word boundary) in a
-     * temporary buffer. */
-    i_bytes_left = p_bit_stream->p_end - p_bit_stream->p_byte;
-    buffer_left = *((WORD_TYPE *)p_bit_stream->p_end - 1);
-
-    /* We are looking for the next data packet that contains real data,
@@ -134 +127 @@
-        p_bit_stream->pf_bitstream_callback( p_bit_stream, b_new_pes );
-    }
+}
+
+void OldKludge( bit_stream_t * p_bit_stream )
+{
+    WORD_TYPE           buffer_left;
+    ptrdiff_t           i_bytes_left;
+
+    /* Put the remaining bytes (not aligned on a word boundary) in a
+     * temporary buffer. */
+    i_bytes_left = p_bit_stream->p_end - p_bit_stream->p_byte;
+    buffer_left = *((WORD_TYPE *)p_bit_stream->p_end - 1);
+
+    p_bit_stream->pf_next_data_packet( p_bit_stream );
-
-    /* Copy remaining bits of the previous packet */
@@ -139 +145 @@
-    p_bit_stream->p_byte -= i_bytes_left;
-}
+
+/*****************************************************************************
+ * UnalignedShowBits : return i_bits bits from the bit stream, even when
+ * not aligned on a word boundary
+ *****************************************************************************/
+u32 UnalignedShowBits( bit_stream_t * p_bit_stream, unsigned int i_bits )
+{
+    /* We just fill in the bit buffer. */
+    while( p_bit_stream->fifo.i_available < i_bits )
+    {
+        if( p_bit_stream->p_byte < p_bit_stream->p_end )
+        {
+            p_bit_stream->fifo.buffer |= *(p_bit_stream->p_byte++)
+                                            << (8 * sizeof(WORD_TYPE) - 8
+                                            - p_bit_stream->fifo.i_available);
+            p_bit_stream->fifo.i_available += 8;
+        }
+        else
+        {
+            p_bit_stream->pf_next_data_packet( p_bit_stream );
+            p_bit_stream->fifo.buffer |= *(p_bit_stream->p_byte++)
+                                            << (8 * sizeof(WORD_TYPE) - 8
+                                            - p_bit_stream->fifo.i_available);
+            p_bit_stream->fifo.i_available += 8;
+        }
+    }
+    return( p_bit_stream->fifo.buffer >> (8 * sizeof(WORD_TYPE) - i_bits) );
+}
+
+/*****************************************************************************
+ * UnalignedGetBits : returns i_bits bits from the bit stream and removes
+ * them from the buffer, even when the bit stream is not aligned on a word
+ * boundary
+ *****************************************************************************/
+u32 UnalignedGetBits( bit_stream_t * p_bit_stream, unsigned int i_bits )
+{
+    u32         i_result;
+
+    i_result = p_bit_stream->fifo.buffer
+                    >> (8 * sizeof(WORD_TYPE) - i_bits);
+    i_bits -= p_bit_stream->fifo.i_available;
+
+    /* Gather missing bytes. */
+    while( i_bits >= 8 )
+    {
+        if( p_bit_stream->p_byte < p_bit_stream->p_end )
+        {
+            i_result |= *(p_bit_stream->p_byte++) << (i_bits - 8);
+            i_bits -= 8;
+        }
+        else
+        {
+            p_bit_stream->pf_next_data_packet( p_bit_stream );
+            i_result |= *(p_bit_stream->p_byte++) << (i_bits - 8);
+            i_bits -= 8;
+        }
+    }
+
+    /* Gather missing bits. */
+    if( i_bits > 0 )
+    {
+        unsigned int    i_tmp = 8 - i_bits;
+
+        if( p_bit_stream->p_byte < p_bit_stream->p_end )
+        {
+            i_result |= *p_bit_stream->p_byte >> i_tmp;
+            p_bit_stream->fifo.buffer = *(p_bit_stream->p_byte++)
+                 << ( sizeof(WORD_TYPE) * 8 - i_tmp );
+            p_bit_stream->fifo.i_available = i_tmp;
+        }
+        else
+        {
+            p_bit_stream->pf_next_data_packet( p_bit_stream );
+            i_result |= *p_bit_stream->p_byte >> i_tmp;
+            p_bit_stream->fifo.buffer = *(p_bit_stream->p_byte++)
+                 << ( sizeof(WORD_TYPE) * 8 - i_tmp );
+            p_bit_stream->fifo.i_available = i_tmp;
+        }
+    }
+    else
+    {
+        p_bit_stream->fifo.i_available = 0;
+        p_bit_stream->fifo.buffer = 0;
+    }
+
+    if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
+    {
+        /* Get aligned on a word boundary. Otherwise it is safer
+         * to do it the next time.
+         * NB : we _will_ get aligned, because we have at most 
+         * sizeof(WORD_TYPE) - 1 bytes to store, and at least
+         * sizeof(WORD_TYPE) - 1 empty bytes in the bit buffer. */
+        AlignWord( p_bit_stream );
+    }
+
+    return( i_result );
+}
+
+/*****************************************************************************
+ * UnalignedRemoveBits : removes i_bits (== -i_available) from the bit
+ * buffer, even when the bit stream is not aligned on a word boundary
+ *****************************************************************************/
+void UnalignedRemoveBits( bit_stream_t * p_bit_stream )
+{
+    /* First remove all unnecessary bytes. */
+    while( p_bit_stream->fifo.i_available <= -8 )
+    {
+        if( p_bit_stream->p_byte < p_bit_stream->p_end )
+        {
+            p_bit_stream->p_byte++;
+            p_bit_stream->fifo.i_available += 8;
+        }
+        else
+        {
+            p_bit_stream->pf_next_data_packet( p_bit_stream );
+            p_bit_stream->p_byte++;
+            p_bit_stream->fifo.i_available += 8;
+        }
+    }
+
+    /* Remove unnecessary bits. */
+    if( p_bit_stream->fifo.i_available < 0 )
+    {
+        if( p_bit_stream->p_byte < p_bit_stream->p_end )
+        {
+            p_bit_stream->fifo.buffer = *(p_bit_stream->p_byte++)
+                 << ( sizeof(WORD_TYPE) * 8 - 8
+                         - p_bit_stream->fifo.i_available );
+            p_bit_stream->fifo.i_available += 8;
+        }
+        else
+        {
+            p_bit_stream->pf_next_data_packet( p_bit_stream );
+            p_bit_stream->fifo.buffer = *(p_bit_stream->p_byte++)
+                 << ( sizeof(WORD_TYPE) * 8 - 8
+                         - p_bit_stream->fifo.i_available );
+            p_bit_stream->fifo.i_available += 8;
+        }
+    }
+    else
+    {
+        p_bit_stream->fifo.buffer = 0;
+    }
+
+    if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
+    {
+        /* Get aligned on a word boundary. Otherwise it is safer
+         * to do it the next time.
+         * NB : we _will_ get aligned, because we have at most 
+         * sizeof(WORD_TYPE) - 1 bytes to store, and at least
+         * sizeof(WORD_TYPE) - 1 empty bytes in the bit buffer. */
+        AlignWord( p_bit_stream );
+    }
+}
+

src/video_parser/vpar_synchro.c

@@ -3 +3 @@
- *****************************************************************************
- * Copyright (C) 1999, 2000 VideoLAN
-8 2001/01/18 05:13:23 sam
+9 2001/01/18 17:40:06 massiot
- *
- * Authors: Christophe Massiot <massiot@via.ecp.fr>
@@ -223 +223 @@
-#define S                           p_vpar->synchro
-        /* VPAR_SYNCHRO_DEFAULT */
-
+
+
-        boolean_t       b_decode = 0;
-#ifdef DEBUG_VPAR