]> git.sesse.net Git - vlc/blobdiff - src/input/stream.c
Removed stream immediate.
[vlc] / src / input / stream.c
index 94f638399e55137198cebf07d0b5282158f8b923..661f2c54993e7439182948d6cc5ee7d8a516443c 100644 (file)
 #endif
 
 #include <dirent.h>
+#include <assert.h>
 
 #include <vlc_common.h>
 #include <vlc_strings.h>
 #include <vlc_osd.h>
 #include <vlc_charset.h>
 
-#include <assert.h>
+#include <libvlc.h>
+
+#include "access.h"
+#include "stream.h"
 
 #include "input_internal.h"
 
@@ -43,7 +47,6 @@
  *  - compute cost for seek
  *  - improve stream mode seeking with closest segments
  *  - ...
- *  - Maybe remove (block/stream) in favour of immediate
  */
 
 /* Two methods:
 #   define STREAM_CACHE_SIZE  (4*STREAM_CACHE_TRACK*1024*1024)
 #endif
 
-/* How many data we try to prebuffer */
-#define STREAM_CACHE_PREBUFFER_SIZE (32767)
-/* Maximum time we take to pre-buffer */
-#define STREAM_CACHE_PREBUFFER_LENGTH (100*1000)
+/* How many data we try to prebuffer
+ * XXX it should be small to avoid useless latency but big enough for
+ * efficient demux probing */
+#define STREAM_CACHE_PREBUFFER_SIZE (128)
 
 /* Method1: Simple, for pf_block.
  *  We get blocks and put them in the linked list.
  *  We release blocks once the total size is bigger than CACHE_BLOCK_SIZE
  */
-#define STREAM_DATA_WAIT 40000       /* Time between before a pf_block retry */
 
 /* Method2: A bit more complex, for pf_read
  *  - We use ring buffers, only one if unseekable, all if seekable
@@ -91,7 +93,7 @@
  *        - compute a good value for i_read_size
  *        - ?
  */
-#define STREAM_READ_ATONCE 32767
+#define STREAM_READ_ATONCE 1024
 #define STREAM_CACHE_TRACK_SIZE (STREAM_CACHE_SIZE/STREAM_CACHE_TRACK)
 
 typedef struct
@@ -112,9 +114,8 @@ typedef struct
 
 } access_entry_t;
 
-typedef enum stream_read_method_t
+typedef enum
 {
-    STREAM_METHOD_IMMEDIATE,
     STREAM_METHOD_BLOCK,
     STREAM_METHOD_STREAM
 } stream_read_method_t;
@@ -156,13 +157,6 @@ struct stream_sys_t
 
     } stream;
 
-    /* Method 3: for pf_read */
-    struct
-    {
-        int64_t i_end;
-        uint8_t *p_buffer;
-    } immediate;
-
     /* Peek temporary buffer */
     unsigned int i_peek;
     uint8_t *p_peek;
@@ -216,11 +210,6 @@ static int  AStreamSeekStream( stream_t *s, int64_t i_pos );
 static void AStreamPrebufferStream( stream_t *s );
 static int  AReadStream( stream_t *s, void *p_read, unsigned int i_read );
 
-/* Method 3 */
-static int  AStreamReadImmediate( stream_t *s, void *p_read, unsigned int i_read );
-static int  AStreamPeekImmediate( stream_t *s, const uint8_t **pp_peek, unsigned int i_read );
-static int  AStreamSeekImmediate( stream_t *s, int64_t i_pos );
-
 /* Common */
 static int AStreamControl( stream_t *s, int i_query, va_list );
 static void AStreamDestroy( stream_t *s );
@@ -230,34 +219,12 @@ static int  ARecordSetState( stream_t *s, bool b_record, const char *psz_extensi
 static void ARecordWrite( stream_t *s, const uint8_t *p_buffer, size_t i_buffer );
 
 /****************************************************************************
- * Method 3 helpers:
+ * stream_CommonNew: create an empty stream structure
  ****************************************************************************/
-
-static inline int64_t stream_buffered_size( stream_t *s )
-{
-    return s->p_sys->immediate.i_end;
-}
-
-static inline void stream_buffer_empty( stream_t *s, int length )
-{
-    length = __MAX( stream_buffered_size( s ), length );
-    if( length )
-    {
-        memmove( s->p_sys->immediate.p_buffer,
-                 s->p_sys->immediate.p_buffer + length,
-                 stream_buffered_size( s ) - length );
-    }
-    s->p_sys->immediate.i_end -= length;
-}
-
-static inline void stream_buffer_fill( stream_t *s, int length )
-{
-    s->p_sys->immediate.i_end += length;
-}
-
-static inline uint8_t * stream_buffer( stream_t *s )
+stream_t *stream_CommonNew( vlc_object_t *p_obj )
 {
-    return s->p_sys->immediate.p_buffer;
+    return (stream_t *)vlc_custom_create( p_obj, sizeof(stream_t),
+                                          VLC_OBJECT_GENERIC, "stream" );
 }
 
 /****************************************************************************
@@ -298,11 +265,19 @@ stream_t *__stream_UrlNew( vlc_object_t *p_parent, const char *psz_url )
 
 stream_t *stream_AccessNew( access_t *p_access, bool b_quick )
 {
-    stream_t *s = vlc_stream_create( VLC_OBJECT(p_access) );
+    stream_t *s = stream_CommonNew( VLC_OBJECT(p_access) );
     stream_sys_t *p_sys;
     char *psz_list = NULL;
 
-    if( !s ) return NULL;
+    if( !s )
+        return NULL;
+
+    s->p_sys = p_sys = malloc( sizeof( stream_sys_t ) );
+    if( !p_sys )
+    {
+        vlc_object_release( s );
+        return NULL;
+    }
 
     /* Attach it now, needed for b_die */
     vlc_object_attach( s, p_access );
@@ -312,10 +287,6 @@ stream_t *stream_AccessNew( access_t *p_access, bool b_quick )
     s->pf_control = AStreamControl;
     s->pf_destroy = AStreamDestroy;
 
-    s->p_sys = p_sys = malloc( sizeof( stream_sys_t ) );
-    if( p_sys == NULL )
-        goto error;
-
     /* UTF16 and UTF32 text file conversion */
     s->i_char_width = 1;
     s->b_little_endian = false;
@@ -325,8 +296,6 @@ stream_t *stream_AccessNew( access_t *p_access, bool b_quick )
     p_sys->p_access = p_access;
     if( p_access->pf_block )
         p_sys->method = STREAM_METHOD_BLOCK;
-    else if( var_CreateGetBool( s, "use-stream-immediate" ) )
-        p_sys->method = STREAM_METHOD_IMMEDIATE;
     else
         p_sys->method = STREAM_METHOD_STREAM;
 
@@ -433,28 +402,6 @@ stream_t *stream_AccessNew( access_t *p_access, bool b_quick )
             goto error;
         }
     }
-    else if( p_sys->method == STREAM_METHOD_IMMEDIATE )
-    {
-        msg_Dbg( s, "Using AStream*Immediate" );
-
-        s->pf_read = AStreamReadImmediate;
-        s->pf_peek = AStreamPeekImmediate;
-
-        /* Allocate/Setup our tracks (useful to peek)*/
-        p_sys->immediate.i_end = 0;
-        p_sys->immediate.p_buffer = malloc( STREAM_CACHE_SIZE );
-
-        msg_Dbg( s, "p_buffer %p-%p",
-                 p_sys->immediate.p_buffer,
-                 &p_sys->immediate.p_buffer[STREAM_CACHE_SIZE] );
-
-        if( p_sys->immediate.p_buffer == NULL )
-        {
-            msg_Err( s, "Out of memory when allocating stream cache (%d bytes)",
-                        STREAM_CACHE_SIZE );
-            goto error;
-        }
-    }
     else
     {
         int i;
@@ -471,11 +418,7 @@ stream_t *stream_AccessNew( access_t *p_access, bool b_quick )
         p_sys->stream.i_tk     = 0;
         p_sys->stream.p_buffer = malloc( STREAM_CACHE_SIZE );
         if( p_sys->stream.p_buffer == NULL )
-        {
-            msg_Err( s, "Out of memory when allocating stream cache (%d bytes)",
-                        STREAM_CACHE_SIZE );
             goto error;
-        }
         p_sys->stream.i_used   = 0;
         access_Control( p_access, ACCESS_GET_MTU,
                          &p_sys->stream.i_read_size );
@@ -538,8 +481,6 @@ static void AStreamDestroy( stream_t *s )
 
     if( p_sys->method == STREAM_METHOD_BLOCK )
         block_ChainRelease( p_sys->block.p_first );
-    else if( p_sys->method == STREAM_METHOD_IMMEDIATE )
-        free( p_sys->immediate.p_buffer );
     else
         free( p_sys->stream.p_buffer );
 
@@ -591,10 +532,6 @@ void stream_AccessReset( stream_t *s )
         /* Do the prebuffering */
         AStreamPrebufferBlock( s );
     }
-    else if( p_sys->method == STREAM_METHOD_IMMEDIATE )
-    {
-        stream_buffer_empty( s, stream_buffered_size( s ) );
-    }
     else
     {
         int i;
@@ -687,8 +624,6 @@ static int AStreamControl( stream_t *s, int i_query, va_list args )
             {
             case STREAM_METHOD_BLOCK:
                 return AStreamSeekBlock( s, i_64 );
-            case STREAM_METHOD_IMMEDIATE:
-                return AStreamSeekImmediate( s, i_64 );
             case STREAM_METHOD_STREAM:
                 return AStreamSeekStream( s, i_64 );
             default:
@@ -837,12 +772,11 @@ static void AStreamPrebufferBlock( stream_t *s )
     i_start = mdate();
     for( ;; )
     {
-        int64_t i_date = mdate();
+        const int64_t i_date = mdate();
         bool b_eof;
         block_t *b;
 
-        if( s->b_die || p_sys->block.i_size > STREAM_CACHE_PREBUFFER_SIZE ||
-            ( i_first > 0 && i_first + STREAM_CACHE_PREBUFFER_LENGTH < i_date ) )
+        if( s->b_die || p_sys->block.i_size > STREAM_CACHE_PREBUFFER_SIZE )
         {
             int64_t i_byterate;
 
@@ -863,9 +797,8 @@ static void AStreamPrebufferBlock( stream_t *s )
         /* Fetch a block */
         if( ( b = AReadBlock( s, &b_eof ) ) == NULL )
         {
-            if( b_eof ) break;
-
-            msleep( STREAM_DATA_WAIT );
+            if( b_eof )
+                break;
             continue;
         }
 
@@ -880,20 +813,12 @@ static void AStreamPrebufferBlock( stream_t *s )
             b = b->p_next;
         }
 
-        if( p_access->info.b_prebuffered )
-        {
-            /* Access has already prebufferred - update stats and exit */
-            p_sys->stat.i_bytes = p_sys->block.i_size;
-            p_sys->stat.i_read_time = mdate() - i_start;
-            break;
-        }
-
         if( i_first == 0 )
         {
             i_first = mdate();
-            msg_Dbg( s, "received first data for our buffer");
+            msg_Dbg( s, "received first data after %d ms",
+                     (int)((i_first-i_start)/1000) );
         }
-
     }
 
     p_sys->block.p_current = p_sys->block.p_first;
@@ -1201,15 +1126,14 @@ static int AStreamRefillBlock( stream_t *s )
     {
         bool b_eof;
 
-        if( s->b_die ) return VLC_EGENERIC;
-
+        if( s->b_die )
+            return VLC_EGENERIC;
 
         /* Fetch a block */
-        if( ( b = AReadBlock( s, &b_eof ) ) ) break;
-
-        if( b_eof ) return VLC_EGENERIC;
-
-        msleep( STREAM_DATA_WAIT );
+        if( ( b = AReadBlock( s, &b_eof ) ) )
+            break;
+        if( b_eof )
+            return VLC_EGENERIC;
     }
 
     while( b )
@@ -1309,6 +1233,9 @@ static int AStreamReadStream( stream_t *s, void *p_read, unsigned int i_read )
         if( tk->i_start + p_sys->stream.i_offset >= tk->i_end ||
             p_sys->stream.i_used >= p_sys->stream.i_read_size )
         {
+            if( p_sys->stream.i_used < i_read - i_data )
+                p_sys->stream.i_used = __MIN( i_read - i_data, STREAM_READ_ATONCE * 10 );
+
             if( AStreamRefillStream( s ) )
             {
                 /* EOF */
@@ -1563,12 +1490,12 @@ static int AStreamRefillStream( stream_t *s )
         /* msg_Dbg( s, "AStreamRefillStream: read=%d", i_read ); */
         if( i_read <  0 )
         {
-            msleep( STREAM_DATA_WAIT );
             continue;
         }
         else if( i_read == 0 )
         {
-            if( !b_read ) return VLC_EGENERIC;
+            if( !b_read )
+                return VLC_EGENERIC;
             return VLC_SUCCESS;
         }
         b_read = true;
@@ -1605,11 +1532,8 @@ static void AStreamPrebufferStream( stream_t *s )
 
     int64_t i_first = 0;
     int64_t i_start;
-    int64_t i_prebuffer = p_sys->b_quick ? STREAM_CACHE_TRACK_SIZE /100 :
-        ( (p_access->info.i_title > 1 || p_access->info.i_seekpoint > 1) ?
-          STREAM_CACHE_PREBUFFER_SIZE : STREAM_CACHE_TRACK_SIZE / 3 );
 
-    msg_Dbg( s, "pre-buffering..." );
+    msg_Dbg( s, "pre buffering" );
     i_start = mdate();
     for( ;; )
     {
@@ -1618,8 +1542,7 @@ static void AStreamPrebufferStream( stream_t *s )
         int64_t i_date = mdate();
         int i_read;
 
-        if( s->b_die || tk->i_end >= i_prebuffer ||
-            (i_first > 0 && i_first + STREAM_CACHE_PREBUFFER_LENGTH < i_date) )
+        if( s->b_die || tk->i_end >= STREAM_CACHE_PREBUFFER_SIZE )
         {
             int64_t i_byterate;
 
@@ -1642,20 +1565,15 @@ static void AStreamPrebufferStream( stream_t *s )
         i_read = __MIN( p_sys->stream.i_read_size, i_read );
         i_read = AReadStream( s, &tk->p_buffer[tk->i_end], i_read );
         if( i_read <  0 )
-        {
-            msleep( STREAM_DATA_WAIT );
             continue;
-        }
         else if( i_read == 0 )
-        {
-            /* EOF */
-            break;
-        }
+            break;  /* EOF */
 
         if( i_first == 0 )
         {
             i_first = mdate();
-            msg_Dbg( s, "received first data for our buffer");
+            msg_Dbg( s, "received first data after %d ms",
+                     (int)((i_first-i_start)/1000) );
         }
 
         tk->i_end += i_read;
@@ -1664,145 +1582,6 @@ static void AStreamPrebufferStream( stream_t *s )
     }
 }
 
-/****************************************************************************
- * Method 3:
- ****************************************************************************/
-
-static int AStreamReadImmediate( stream_t *s, void *p_read, unsigned int i_read )
-{
-    stream_sys_t *p_sys = s->p_sys;
-    uint8_t *p_data= (uint8_t*)p_read;
-    uint8_t *p_record = p_data;
-    unsigned int i_data;
-
-#ifdef STREAM_DEBUG
-    msg_Dbg( s, "AStreamReadImmediate p_read=%p i_read=%d",
-             p_read, i_read );
-#endif
-
-    if( p_sys->record.b_active && !p_data )
-        p_record = p_data = malloc( i_read );
-
-    /* First, check if we already have some data in the buffer,
-     * that we could copy directly */
-    i_data = __MIN( stream_buffered_size( s ), i_read );
-    if( i_data > 0 )
-    {
-#ifdef STREAM_DEBUG
-        msg_Dbg( s, "AStreamReadImmediate: copy %u from %p", i_data, stream_buffer( s ) );
-#endif
-
-        assert( i_data <= STREAM_CACHE_SIZE );
-
-        if( p_data )
-        {
-            memcpy( p_data, stream_buffer( s ), i_data );
-            p_data += i_data;
-        }
-    }
-
-    /* Now that we've read our buffer we don't need its i_copy bytes */
-    stream_buffer_empty( s, i_data );
-
-    /* Now check if we have still to really read some data */
-    while( i_data < i_read )
-    {
-        const unsigned int i_to_read = i_read - i_data;
-        int i_result;
-
-        if( p_data )
-        {
-            i_result = AReadStream( s, p_data, i_to_read );
-        }
-        else
-        {
-            void *p_dummy = malloc( i_to_read );
-
-            if( !p_dummy )
-                break;
-
-            i_result = AReadStream( s, p_dummy, i_to_read );
-
-            free( p_dummy );
-        }
-        if( i_result <= 0 )
-            break;
-
-        p_sys->i_pos += i_data;
-        if( p_data )
-            p_data += i_result;
-        i_data += i_result;
-    }
-
-    if( p_sys->record.b_active )
-    {
-        if( i_data > 0 && p_record != NULL)
-            ARecordWrite( s, p_record, i_data );
-        if( !p_read )
-            free( p_record );
-    }
-    return i_data;
-}
-
-static int AStreamPeekImmediate( stream_t *s, const uint8_t **pp_peek, unsigned int i_read )
-{
-#ifdef STREAM_DEBUG
-    msg_Dbg( s, "AStreamPeekImmediate: %d  size=%"PRId64,
-             i_read, size_buffered_size( s ) );
-#endif
-
-    /* Avoid problem, but that shouldn't happen
-     * FIXME yes it can */
-    if( i_read > STREAM_CACHE_SIZE / 2 )
-        i_read = STREAM_CACHE_SIZE / 2;
-
-    int i_to_read = i_read - stream_buffered_size( s );
-    if( i_to_read > 0 )
-    {
-#ifdef STREAM_DEBUG
-        msg_Dbg( s, "AStreamPeekImmediate: Reading %d",
-             i_to_read );
-#endif
-        i_to_read = AReadStream( s, stream_buffer( s ) + stream_buffered_size( s ),
-                                 i_to_read );
-
-        if( i_to_read > 0 )
-            stream_buffer_fill( s, i_to_read );
-    }
-
-    *pp_peek = stream_buffer( s );
-
-    return __MIN( stream_buffered_size( s ), i_read );
-}
-
-static int AStreamSeekImmediate( stream_t *s, int64_t i_pos )
-{
-    stream_sys_t *p_sys = s->p_sys;
-    access_t     *p_access = p_sys->p_access;
-    bool   b_aseek;
-
-#ifdef STREAM_DEBUG
-    msg_Dbg( s, "AStreamSeekImmediate to %"PRId64" pos=%"PRId64
-             i_pos, p_sys->i_pos );
-#endif
-
-    access_Control( p_access, ACCESS_CAN_SEEK, &b_aseek );
-    if( !b_aseek )
-    {
-        /* We can't do nothing */
-        msg_Dbg( s, "AStreamSeekImmediate: can't seek" );
-        return VLC_EGENERIC;
-    }
-
-    /* Just reset our buffer */
-    stream_buffer_empty( s, stream_buffered_size( s ) );
-
-    if( ASeek( s, i_pos ) )
-        return VLC_EGENERIC;
-
-    return VLC_SUCCESS;
-}
-
 /****************************************************************************
  * stream_ReadLine:
  ****************************************************************************/
@@ -1831,29 +1610,26 @@ char *stream_ReadLine( stream_t *s )
 
         /* BOM detection */
         i_pos = stream_Tell( s );
-        if( i_pos == 0 && i_data > 4 )
+        if( i_pos == 0 && i_data >= 3 )
         {
             int i_bom_size = 0;
-            char *psz_encoding = NULL;
+            const char *psz_encoding = NULL;
 
-            if( p_data[0] == 0xEF && p_data[1] == 0xBB && p_data[2] == 0xBF )
+            if( !memcmp( p_data, "\xEF\xBB\xBF", 3 ) )
             {
-                psz_encoding = strdup( "UTF-8" );
+                psz_encoding = "UTF-8";
                 i_bom_size = 3;
             }
-            else if( p_data[0] == 0xFF && p_data[1] == 0xFE )
+            else if( !memcmp( p_data, "\xFF\xFE", 2 ) )
             {
-                if( p_data[2] || p_data[3] )
-                {
-                    psz_encoding = strdup( "UTF-16LE" );
-                    s->b_little_endian = true;
-                    s->i_char_width = 2;
-                    i_bom_size = 2;
-                }
+                psz_encoding = "UTF-16LE";
+                s->b_little_endian = true;
+                s->i_char_width = 2;
+                i_bom_size = 2;
             }
-            else if( p_data[0] == 0xFE && p_data[1] == 0xFF )
+            else if( !memcmp( p_data, "\xFE\xFF", 2 ) )
             {
-                psz_encoding = strdup( "UTF-16BE" );
+                psz_encoding = "UTF-16BE";
                 s->i_char_width = 2;
                 i_bom_size = 2;
             }
@@ -1886,7 +1662,6 @@ char *stream_ReadLine( stream_t *s )
                     var_SetString( p_input, "subsdec-encoding", "UTF-8" );
                     vlc_object_release( p_input );
                 }
-                free( psz_encoding );
             }
         }
 
@@ -2117,7 +1892,7 @@ static block_t *AReadBlock( stream_t *s, bool *pb_eof )
         return p_block;
     }
 
-    p_block = p_sys->p_list_access->pf_block( p_access );
+    p_block = p_sys->p_list_access->pf_block( p_sys->p_list_access );
     if( p_access->b_die )
         vlc_object_kill( s );
     b_eof = p_sys->p_list_access->info.b_eof;