Added a new packet allocation method that punish one's mother in PS input.

I hope there won't be too many segfaults because of it ;)
A few parameters must be adjusted to optimize this method; I'll do it later
because Proba Stat sucks ;)

diff --git a/include/input_ext-dec.h b/include/input_ext-dec.h
index 3c28efd8edf353d633149aa312108f5c849c0d16..05a4796fd1b60184974196add638fa220a42014b 100644 (file)
--- a/include/input_ext-dec.h
+++ b/include/input_ext-dec.h
@@ -2,7 +2,7 @@
  * input_ext-dec.h: structures exported to the VideoLAN decoders
  *****************************************************************************
  * Copyright (C) 1999, 2000 VideoLAN
- * $Id: input_ext-dec.h,v 1.25 2001/03/06 19:33:58 massiot Exp $
+ * $Id: input_ext-dec.h,v 1.26 2001/04/05 14:00:28 asmax Exp $
  *
  * Authors: Christophe Massiot <massiot@via.ecp.fr>
  *          Michel Kaempf <maxx@via.ecp.fr>
@@ -33,6 +33,7 @@ typedef struct data_packet_s
 {
     /* Nothing before this line, the code relies on that */
     byte_t *                p_buffer;                     /* raw data packet */
+    long                   l_size;                         /* buffer length */
 
     /* Decoders information */
     byte_t *                p_payload_start;

diff --git a/plugins/mpeg/input_ps.c b/plugins/mpeg/input_ps.c
index b9190e360daba5e7656f804063057e76bd618467..6f80ffaee0cd75df5d8af2a48b2cceefe66c4b33 100644 (file)
--- a/plugins/mpeg/input_ps.c
+++ b/plugins/mpeg/input_ps.c
@@ -2,9 +2,10 @@
  * input_ps.c: PS demux and packet management
  *****************************************************************************
  * Copyright (C) 1998, 1999, 2000 VideoLAN
- * $Id: input_ps.c,v 1.11 2001/03/15 01:42:20 sam Exp $
+ * $Id: input_ps.c,v 1.12 2001/04/05 14:00:28 asmax Exp $
  *
  * Authors: Christophe Massiot <massiot@via.ecp.fr>
+ *          Cyril Deguet <asmax@via.ecp.fr>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -142,6 +143,7 @@ static int PSProbe( probedata_t *p_data )
 static void PSInit( input_thread_t * p_input )
 {
     thread_ps_data_t *  p_method;
+    packet_cache_t *   p_packet_cache;
 
     if( (p_method =
          (thread_ps_data_t *)malloc( sizeof(thread_ps_data_t) )) == NULL )
@@ -150,10 +152,62 @@ static void PSInit( input_thread_t * p_input )
         p_input->b_error = 1;
         return;
     }
-
     p_input->p_plugin_data = (void *)p_method;
-    p_input->p_method_data = NULL;
-
+    
+    /* creates the packet cache structure */
+    p_packet_cache = malloc( sizeof(packet_cache_t) );
+    if ( p_packet_cache == NULL )
+    {
+        intf_ErrMsg( "Out of memory" );
+        p_input->b_error = 1;
+        return;
+    }
+    p_input->p_method_data = (void *)p_packet_cache;
+    
+    /* allocates the data cache */
+    p_packet_cache->data.p_stack = malloc( DATA_CACHE_SIZE * 
+        sizeof(data_packet_t*) );
+    if ( p_packet_cache->data.p_stack == NULL )
+    {
+        intf_ErrMsg( "Out of memory" );
+       p_input->b_error = 1;
+       return;
+    }
+    p_packet_cache->data.l_index = 0;
+    
+    /* allocates the PES cache */
+    p_packet_cache->pes.p_stack = malloc( PES_CACHE_SIZE * 
+        sizeof(pes_packet_t*) );
+    if ( p_packet_cache->pes.p_stack == NULL )
+    {
+        intf_ErrMsg( "Out of memory" );
+        p_input->b_error = 1;
+        return;
+    }
+    p_packet_cache->pes.l_index = 0;
+    
+    /* allocates the small buffer cache */
+    p_packet_cache->small.p_stack = malloc( SMALL_CACHE_SIZE * 
+        sizeof(packet_buffer_t) );
+    if ( p_packet_cache->small.p_stack == NULL )
+    {
+        intf_ErrMsg( "Out of memory" );
+        p_input->b_error = 1;
+        return;
+    }
+    p_packet_cache->small.l_index = 0;
+    
+    /* allocates the large buffer cache */
+    p_packet_cache->large.p_stack = malloc( LARGE_CACHE_SIZE * 
+        sizeof(packet_buffer_t) );
+    if ( p_packet_cache->large.p_stack == NULL )
+    {
+        intf_ErrMsg( "Out of memory" );
+        p_input->b_error = 1;
+        return;
+    }
+    p_packet_cache->large.l_index = 0;
+    
     /* Re-open the socket as a buffered FILE stream */
     if( (p_method->stream = fdopen( p_input->i_handle, "r" )) == NULL )
     {
@@ -420,7 +474,8 @@ static int PSRead( input_thread_t * p_input,
         }
 
         /* Fetch a packet of the appropriate size. */
-        if( (p_data = NewPacket( p_input, i_packet_size + 6 )) == NULL )
+        if( (p_data = NewPacket( p_input->p_method_data, i_packet_size + 6 )) 
+            == NULL )
         {
             intf_ErrMsg( "Out of memory" );
             return( -1 );
@@ -453,6 +508,7 @@ static int PSRead( input_thread_t * p_input,
 
         /* Give the packet to the other input stages. */
         pp_packets[i_packet] = p_data;
+//fprintf(stderr, "read2 %li %li\n", p_data, p_data->l_size);
     }
 
     return( 0 );
@@ -477,96 +533,286 @@ static void PSSeek( input_thread_t * p_input, off_t i_position )
  * Packet management utilities
  */
 
+
 /*****************************************************************************
  * NewPacket: allocates a data packet
  *****************************************************************************/
-static struct data_packet_s * NewPacket( void * p_garbage,
-                                         size_t i_size )
-{
-    data_packet_t * p_data;
-
-    /* Safety check */
-    if( i_size > INPUT_MAX_PACKET_SIZE )
+static struct data_packet_s * NewPacket( void * p_packet_cache,
+                                         size_t l_size )
+{ 
+    packet_cache_t *   p_cache;
+    data_packet_t *    p_data;
+    long               l_index;
+
+    if ( (p_cache = (packet_cache_t *)p_packet_cache) == NULL )
     {
-        intf_ErrMsg( "Packet too big (%d)", i_size );
+        intf_ErrMsg( "PPacket cache not initialized" );
         return NULL;
     }
-
-    if( (p_data = (data_packet_t *)malloc( sizeof(data_packet_t) )) == NULL )
+    /* Safety check */
+    if( l_size > INPUT_MAX_PACKET_SIZE )
     {
-        intf_DbgMsg( "Out of memory" );
+        intf_ErrMsg( "Packet too big (%d)", l_size );
         return NULL;
     }
 
-    if( (p_data->p_buffer = (byte_t *)malloc( i_size )) == NULL )
+    /* Checks whether the data cache is empty */
+    if( p_cache->data.l_index == 0 )
     {
-        intf_DbgMsg( "Out of memory" );
-        free( p_data );
-        return NULL;
+        /* Allocates a new packet */
+        if ( (p_data = malloc( sizeof(data_packet_t) )) == NULL )
+        {
+            intf_DbgMsg( "Out of memory" );
+            return NULL;
+        }
+    }
+    else
+    {
+        /* Takes the packet out from the cache */
+        if( (p_data = p_cache->data.p_stack[ -- p_cache->data.l_index ]) 
+            == NULL )
+        {
+            intf_DbgMsg( "NULL packet in the data cache" );
+            return NULL;
+        }
+    }
+    
+    if( l_size < MAX_SMALL_SIZE )
+    {
+        /* Small buffer */  
+   
+        /* Checks whether the buffer cache is empty */
+        if( p_cache->small.l_index == 0 )
+        {
+           /* Allocates a new packet */
+            if ( (p_data->p_buffer = malloc( l_size )) == NULL )
+            {
+                intf_DbgMsg( "Out of memory" );
+                free( p_data );
+                return NULL;
+            }
+            p_data->l_size = l_size;
+        }
+        else
+        {
+            /* Takes the packet out from the cache */
+            l_index = -- p_cache->small.l_index;    
+            if( (p_data->p_buffer = p_cache->small.p_stack[l_index].p_data)
+                == NULL )
+            {
+                intf_DbgMsg( "NULL packet in the small buffer cache" );
+                free( p_data );
+                return NULL;
+            }
+               /* Reallocates the packet if it is too small or too large */
+            if( p_cache->small.p_stack[l_index].l_size < l_size ||
+                p_cache->small.p_stack[l_index].l_size > 2*l_size )
+            {
+                p_data->p_buffer = realloc( p_data->p_buffer, l_size );
+                p_data->l_size = l_size;
+            }
+            else
+            {
+                p_data->l_size = p_cache->small.p_stack[l_index].l_size;
+            }
+        }
+    }
+    else
+    {
+        /* Large buffer */  
+   
+        /* Checks whether the buffer cache is empty */
+        if( p_cache->large.l_index == 0 )
+        {
+           /* Allocates a new packet */
+            if ( (p_data->p_buffer = malloc( l_size )) == NULL )
+            {
+                intf_DbgMsg( "Out of memory" );
+                free( p_data );
+                return NULL;
+            }
+            p_data->l_size = l_size;
+        }
+        else
+        {
+            /* Takes the packet out from the cache */
+            l_index = -- p_cache->large.l_index;    
+            if( (p_data->p_buffer = p_cache->large.p_stack[l_index].p_data)
+                == NULL )
+            {
+                intf_DbgMsg( "NULL packet in the small buffer cache" );
+                free( p_data );
+                return NULL;
+            }
+               /* Reallocates the packet if it is too small or too large */
+            if( p_cache->large.p_stack[l_index].l_size < l_size ||
+                p_cache->large.p_stack[l_index].l_size > 2*l_size )
+            {
+                p_data->p_buffer = realloc( p_data->p_buffer, l_size );
+                p_data->l_size = l_size;
+            }
+            else
+            {
+                p_data->l_size = p_cache->large.p_stack[l_index].l_size;
+            }
+           }
     }
 
     /* Initialize data */
     p_data->p_next = NULL;
     p_data->b_discard_payload = 0;
-
     p_data->p_payload_start = p_data->p_buffer;
-    p_data->p_payload_end = p_data->p_buffer + i_size;
+    p_data->p_payload_end = p_data->p_buffer + l_size;
 
+//fprintf(stderr, "addr: %li %li buf %li\n", p_data, p_data->l_size, p_data->p_buffer);
     return( p_data );
+       
 }
 
+
 /*****************************************************************************
  * NewPES: allocates a pes packet
  *****************************************************************************/
-static pes_packet_t * NewPES( void * p_garbage )
+static pes_packet_t * NewPES( void * p_packet_cache )
 {
-    pes_packet_t * p_pes;
+    packet_cache_t *   p_cache;
+    pes_packet_t *     p_pes;
 
-    if( (p_pes = (pes_packet_t *)malloc( sizeof(pes_packet_t) )) == NULL )
+    if ( (p_cache = (packet_cache_t *)p_packet_cache) == NULL )
     {
-        intf_DbgMsg( "Out of memory" );
+        intf_ErrMsg( "Packet cache not initialized" );
         return NULL;
     }
-
+    /* Checks whether the PES cache is empty */
+    if( p_cache->pes.l_index == 0 )
+    {
+        /* Allocates a new packet */
+        if ( (p_pes = malloc( sizeof(pes_packet_t) )) == NULL )
+        {
+            intf_DbgMsg( "Out of memory" );
+            return NULL;
+        }
+    }
+    else
+    {
+        /* Takes the packet out from the cache */
+        if( (p_pes = p_cache->pes.p_stack[ -- p_cache->pes.l_index ]) 
+            == NULL )
+        {
+            intf_DbgMsg( "NULL packet in the data cache" );
+            return NULL;
+        }
+    }
+       
     p_pes->b_data_alignment = p_pes->b_discontinuity =
         p_pes->i_pts = p_pes->i_dts = 0;
     p_pes->i_pes_size = 0;
     p_pes->p_first = NULL;
 
     return( p_pes );
+    
 }
 
 /*****************************************************************************
  * DeletePacket: deletes a data packet
  *****************************************************************************/
-static void DeletePacket( void * p_garbage,
+static void DeletePacket( void * p_packet_cache,
                           data_packet_t * p_data )
 {
-    ASSERT(p_data);
-    ASSERT(p_data->p_buffer);
-    free( p_data->p_buffer );
-    free( p_data );
+    packet_cache_t *   p_cache;
+       
+    if ( (p_cache = (packet_cache_t *)p_packet_cache) == NULL )
+    {
+        intf_ErrMsg( "Packet cache not initialized" );
+        return;
+    }
+
+       ASSERT( p_data );
+
+    /* Checks whether the data cache is full */
+    if ( p_cache->data.l_index < DATA_CACHE_SIZE )
+    {
+        /* Cache not full: store the packet in it */
+        p_cache->data.p_stack[ p_cache->data.l_index ++ ] = p_data;
+        /* Small buffer or large buffer? */
+        if ( p_data->l_size < MAX_SMALL_SIZE )
+        {
+            /* Checks whether the small buffer cache is full */
+            if ( p_cache->small.l_index < SMALL_CACHE_SIZE )
+            {
+                p_cache->small.p_stack[ p_cache->small.l_index ].l_size = 
+                    p_data->l_size;
+                p_cache->small.p_stack[ p_cache->small.l_index ++ ].p_data = 
+                    p_data->p_buffer;
+            }
+            else
+            {
+                ASSERT( p_data->p_buffer );
+                free( p_data->p_buffer );
+            }
+        }
+       else
+        {
+            /* Checks whether the large buffer cache is full */
+            if ( p_cache->large.l_index < LARGE_CACHE_SIZE )
+            {
+                p_cache->large.p_stack[ p_cache->large.l_index ].l_size = 
+                    p_data->l_size;
+                p_cache->large.p_stack[ p_cache->large.l_index ++ ].p_data = 
+                    p_data->p_buffer;
+            }
+            else
+            {
+                ASSERT( p_data->p_buffer );
+                free( p_data->p_buffer );
+            }
+        }
+    }
+    else
+    {
+        /* Cache full: the packet must be freed */
+        free( p_data->p_buffer );
+       free( p_data );
+    }
+
 }
 
 /*****************************************************************************
  * DeletePES: deletes a PES packet and associated data packets
  *****************************************************************************/
-static void DeletePES( void * p_garbage, pes_packet_t * p_pes )
+static void DeletePES( void * p_packet_cache, pes_packet_t * p_pes )
 {
+    packet_cache_t *    p_cache;
     data_packet_t *     p_data;
     data_packet_t *     p_next;
 
+    if ( (p_cache = (packet_cache_t *)p_packet_cache) == NULL )
+    {
+        intf_ErrMsg( "Packet cache not initialized" );
+        return;
+    }
+
+    ASSERT( p_pes);
+
     p_data = p_pes->p_first;
 
     while( p_data != NULL )
     {
         p_next = p_data->p_next;
-        free( p_data->p_buffer );
-        free( p_data );
+        DeletePacket( p_cache, p_data );
         p_data = p_next;
     }
 
-    free( p_pes );
+    /* Checks whether the PES cache is full */
+    if ( p_cache->pes.l_index < PES_CACHE_SIZE )
+    {
+       /* Cache not full: store the packet in it */
+        p_cache->pes.p_stack[ p_cache->pes.l_index ++ ] = p_pes;
+    }
+    else
+    {
+        /* Cache full: the packet must be freed */
+        free( p_pes );
+    }
 }
 
-

diff --git a/plugins/mpeg/input_ps.h b/plugins/mpeg/input_ps.h
index 86ce47825b1ce0253111025cb4484ed3e528ab81..ba2786a05c7cdb171656745fab2b1ec39c2653f0 100644 (file)
--- a/plugins/mpeg/input_ps.h
+++ b/plugins/mpeg/input_ps.h
@@ -2,9 +2,10 @@
  * input_ps.h: thread structure of the PS plugin
  *****************************************************************************
  * Copyright (C) 1999, 2000 VideoLAN
- * $Id: input_ps.h,v 1.2 2001/03/21 13:42:34 sam Exp $
+ * $Id: input_ps.h,v 1.3 2001/04/05 14:00:28 asmax Exp $
  *
  * Authors: Christophe Massiot <massiot@via.ecp.fr>
+ *          Cyril Deguet <asmax@via.ecp.fr>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -29,3 +30,55 @@ typedef struct thread_ps_data_s
     /* We're necessarily reading a file. */
     FILE *                  stream;
 } thread_ps_data_t;
+
+
+#define DATA_CACHE_SIZE 150
+#define PES_CACHE_SIZE 150
+#define SMALL_CACHE_SIZE 150
+#define LARGE_CACHE_SIZE 300
+#define MAX_SMALL_SIZE 50     // frontier between small and large packets
+
+typedef struct
+{
+    data_packet_t **        p_stack;
+    long                    l_index;
+} data_packet_cache_t;
+
+
+typedef struct
+{
+    pes_packet_t **         p_stack;
+    long                    l_index;
+} pes_packet_cache_t;
+
+
+typedef struct
+{
+    byte_t *                p_data;
+    long                    l_size;
+} packet_buffer_t;
+
+
+typedef struct
+{
+    packet_buffer_t *       p_stack;
+    long                    l_index;
+} small_buffer_cache_t;
+
+
+typedef struct
+{
+    packet_buffer_t *       p_stack;
+    long                    l_index;
+} large_buffer_cache_t;
+
+
+typedef struct
+{
+    data_packet_cache_t     data;
+    pes_packet_cache_t      pes;
+    small_buffer_cache_t    small;
+    large_buffer_cache_t    large;
+} packet_cache_t;
+
+

diff --git a/src/input/mpeg_system.c b/src/input/mpeg_system.c
index 73b463e10cdcde2d111401b9de0990bec860d953..c7f144b96baae852585d097358b873aaa5edc70f 100644 (file)
--- a/src/input/mpeg_system.c
+++ b/src/input/mpeg_system.c
@@ -2,7 +2,7 @@
  * mpeg_system.c: TS, PS and PES management
  *****************************************************************************
  * Copyright (C) 1998, 1999, 2000 VideoLAN
- * $Id: mpeg_system.c,v 1.45 2001/03/15 01:42:20 sam Exp $
+ * $Id: mpeg_system.c,v 1.46 2001/04/05 14:00:28 asmax Exp $
  *
  * Authors: Christophe Massiot <massiot@via.ecp.fr>
  *          Michel Lespinasse <walken@via.ecp.fr>
@@ -657,6 +657,7 @@ es_descriptor_t * input_ParsePS( input_thread_t * p_input,
     es_descriptor_t *   p_es = NULL;
 
     i_code = p_data->p_payload_start[3];
+
     if( i_code > 0xBC ) /* ES start code */
     {
         u16                 i_id;