Noise and mirrors

[melted] / src / framework / mlt_pool.c

diff --git a/src/framework/mlt_pool.c b/src/framework/mlt_pool.c
index 16d1e1d..72e11ba 100644 (file)
--- a/src/framework/mlt_pool.c
+++ b/src/framework/mlt_pool.c
@@ -22,6 +22,7 @@
 #include "mlt_deque.h"
 
 #include <stdlib.h>
+#include <malloc.h>
 #include <string.h>
 #include <pthread.h>
 
@@ -45,6 +46,7 @@ typedef struct mlt_pool_s
 typedef struct mlt_release_s
 {
        mlt_pool pool;
+       int references;
 }
 *mlt_release;
 
@@ -92,11 +94,14 @@ static void *pool_fetch( mlt_pool this )
                {
                        // Pop the top of the stack
                        ptr = mlt_deque_pop_back( this->stack );
+
+                       // Assign the reference
+                       ( ( mlt_release )ptr )->references = 1;
                }
                else
                {
                        // We need to generate a release item
-                       mlt_release release = malloc( sizeof( struct mlt_release_s ) + this->size );
+                       mlt_release release = memalign( 16, this->size );
 
                        // Initialise it
                        if ( release != NULL )
@@ -104,6 +109,9 @@ static void *pool_fetch( mlt_pool this )
                                // Assign the pool
                                release->pool = this;
 
+                               // Assign the reference
+                               release->references = 1;
+
                                // Determine the ptr
                                ptr = ( void * )release + sizeof( struct mlt_release_s );
                        }
@@ -126,7 +134,7 @@ static void pool_return( void *ptr )
        if ( ptr != NULL )
        {
                // Get the release pointer
-               mlt_release that = ( void * )ptr - sizeof( struct mlt_release_s );
+               mlt_release that = ptr - sizeof( struct mlt_release_s );
 
                // Get the pool
                mlt_pool this = that->pool;
@@ -220,15 +228,15 @@ void *mlt_pool_alloc( int size )
        mlt_pool pool = NULL;
 
        // Determines the index of the pool to use
-       int index = 0;
+       int index = 8;
 
        // Minimum size pooled is 256 bytes
-       size = size >> 8;
+       size = size + sizeof( mlt_release );
        while ( ( 1 << index ) < size )
                index ++;
 
        // Now get the pool at the index
-       pool = mlt_properties_get_data_at( pools, index + 1, NULL );
+       pool = mlt_properties_get_data_at( pools, index - 8, NULL );
 
        // Now get the real item
        return pool_fetch( pool );
@@ -237,33 +245,42 @@ void *mlt_pool_alloc( int size )
 /** Allocate size bytes from the pool.
 */
 
-void *mlt_pool_allocate( int size, void **release )
+void *mlt_pool_realloc( void *ptr, int size )
 {
-       // This is the real release structure we'll return
-       void *real = NULL;
-
-       // This will be used to obtain the pool to use
-       mlt_pool pool = NULL;
+       // Result to return
+       void *result = NULL;
 
-       // Determines the index of the pool to use
-       int index = 0;
+       // Check if we actually have an address
+       if ( ptr != NULL )
+       {
+               // Get the release pointer
+               mlt_release that = ptr - sizeof( struct mlt_release_s );
 
-       // Minimum size pooled is 256 bytes
-       size = size >> 8;
-       while ( ( 1 << index ) < size )
-               index ++;
+               // If the current pool this ptr belongs to is big enough
+               if ( size > that->pool->size - sizeof( struct mlt_release_s ) )
+               {
+                       // Allocate
+                       result = mlt_pool_alloc( size );
 
-       // Now get the pool at the index
-       pool = mlt_properties_get_data_at( pools, index + 1, NULL );
+                       // Copy
+                       memcpy( result, ptr, that->pool->size - sizeof( struct mlt_release_s ) );
 
-       // Now get the real item
-       real = pool_fetch( pool );
+                       // Release
+                       mlt_pool_release( ptr );
+               }
+               else
+               {
+                       // Nothing to do
+                       result = ptr;
+               }
+       }
+       else
+       {
+               // Simply allocate
+               result = mlt_pool_alloc( size );
+       }
 
-       // Assign to release
-       *release = real;
-       
-       // Otherwise return a NULL to indicate failure
-       return real;
+       return result;
 }
 
 /** Release the allocated memory.