Cleanup custom block allocation

include/vlc_block.h

@@ -78,6 +78,8 @@ typedef struct block_sys_t block_sys_t;
 #define BLOCK_FLAG_PRIVATE_MASK  0xffff0000
 #define BLOCK_FLAG_PRIVATE_SHIFT 16
 
+typedef void (*block_free_t) (block_t *);
+
 struct block_t
 {
     block_t     *p_next;
@@ -95,10 +97,8 @@ struct block_t
     size_t      i_buffer;
     uint8_t     *p_buffer;
 
-    /* This way the block_Release can be overloaded
-     * Don't mess with it now, if you need it the ask on ML
-     */
-    void        (*pf_release)   ( block_t * );
+    /* Rudimentary support for overloading block (de)allocation. */
+    block_free_t pf_release;
 };
 
 /****************************************************************************
@@ -117,10 +117,16 @@ struct block_t
  *      and decrease are supported). Use it as it is optimised.
  * - block_Duplicate : create a copy of a block.
  ****************************************************************************/
-#define block_New( a, b ) __block_New( NULL, b )
-VLC_EXPORT( block_t *,  __block_New,        ( vlc_object_t *, size_t ) );
+VLC_EXPORT( void,      block_Init,    ( block_t *, void *, size_t ) );
+VLC_EXPORT( block_t *, block_Alloc,   ( size_t ) );
 VLC_EXPORT( block_t *, block_Realloc, ( block_t *, ssize_t i_pre, size_t i_body ) );
 
+static inline block_t *block_New( void *dummy, size_t size )
+{
+    (void)dummy;
+    return block_Alloc (size);
+}
+
 static inline block_t *block_Duplicate( block_t *p_block )
 {
     block_t *p_dup = block_New( NULL, p_block->i_buffer );

modules/access/screen/win32.c

@@ -205,14 +205,10 @@ static block_t *CaptureBlockNew( demux_t *p_demux )
         DeleteObject( hbmp );
         return NULL;
     }
-    memset( &p_block->self, 0, sizeof( block_t->self ) );
-
     /* Fill all fields */
     i_buffer = (p_sys->fmt.video.i_bits_per_pixel + 7) / 8 *
         p_sys->fmt.video.i_width * p_sys->fmt.video.i_height;
-    p_block->self.p_next     = NULL;
-    p_block->self.i_buffer   = i_buffer;
-    p_block->self.p_buffer   = p_buffer;
+    block_Init( &p_block->self, p_buffer, i_buffer );
     p_block->self.pf_release = CaptureBlockRelease;
     p_block->hbmp            = hbmp;
 

src/libvlc.sym

@@ -71,7 +71,8 @@ block_FifoRelease
 block_FifoShow
 block_FifoCount
 block_FifoSize
-__block_New
+block_Init
+block_Alloc
 block_Realloc
 config_ChainCreate
 config_ChainDestroy

src/misc/block.c

@@ -38,10 +38,36 @@ struct block_sys_t
     uint8_t     p_allocated_buffer[0];
 };
 
+#ifndef NDEBUG
+static void BlockNoRelease( block_t *b )
+{
+    fprintf( stderr, "block %p has no release callback! This is a bug!\n", b );
+    abort();
+}
+#endif
+
+void block_Init( block_t *restrict b, void *buf, size_t size )
+{
+    /* Fill all fields to their default */
+    b->p_next = b->p_prev = NULL;
+    b->i_flags = 0;
+    b->i_pts = b->i_dts = b->i_length = 0;
+    b->i_rate = 0;
+    b->p_buffer = buf;
+    b->i_buffer = size;
+#ifndef NDEBUG
+    b->pf_release = BlockNoRelease;
+#endif
+}
+
+static void BlockRelease( block_t *p_block )
+{
+    free( p_block );
+}
+
 #define BLOCK_PADDING_SIZE 32
-static void BlockRelease( block_t * );
 
-block_t *__block_New( vlc_object_t *p_obj, size_t i_size )
+block_t *block_Alloc( size_t i_size )
 {
     /* We do only one malloc
      * TODO bench if doing 2 malloc but keeping a pool of buffer is better
@@ -57,18 +83,8 @@ block_t *__block_New( vlc_object_t *p_obj, size_t i_size )
     /* Fill opaque data */
     p_sys->i_allocated_buffer = i_alloc;
 
-    /* Fill all fields */
-    p_sys->self.p_next      = NULL;
-    p_sys->self.p_prev      = NULL;
-    p_sys->self.i_flags     = 0;
-    p_sys->self.i_pts       = 0;
-    p_sys->self.i_dts       = 0;
-    p_sys->self.i_length    = 0;
-    p_sys->self.i_rate      = 0;
-    p_sys->self.i_buffer    = i_size;
-    p_sys->self.p_buffer    =
-        &p_sys->p_allocated_buffer[BLOCK_PADDING_SIZE +
-            16 - ((uintptr_t)p_sys->p_allocated_buffer % 16 )];
+    block_Init( &p_sys->self, p_sys->p_allocated_buffer + BLOCK_PADDING_SIZE
+                + 16 - ((uintptr_t)p_sys->p_allocated_buffer % 16 ), i_size );
     p_sys->self.pf_release    = BlockRelease;
 
     return &p_sys->self;
@@ -139,12 +155,6 @@ block_t *block_Realloc( block_t *p_block, ssize_t i_prebody, size_t i_body )
     return p_block;
 }
 
-static void BlockRelease( block_t *p_block )
-{
-    free( p_block );
-}
-
-
 /*****************************************************************************
  * block_fifo_t management
  *****************************************************************************/