uint8_t *buf;
#define ALIGN(x) (((x) + BLOCK_ALIGN - 1) & ~(BLOCK_ALIGN - 1))
-#ifdef HAVE_POSIX_MEMALIGN
+#if 0 /*def HAVE_POSIX_MEMALIGN */
+ /* posix_memalign(,16,) is much slower than malloc() on glibc.
+ * -- Courmisch, September 2009, glibc 2.5 & 2.9 */
const size_t i_alloc = ALIGN(sizeof(*p_sys)) + (2 * BLOCK_PADDING)
+ ALIGN(i_size);
void *ptr;
if( (size_t)(p_block->p_buffer - p_start) < (size_t)i_prebody
|| (size_t)(p_end - p_block->p_buffer) < i_body )
{
- /* FIXME: this is really dumb, we should use realloc() */
block_t *p_rea = block_Alloc( requested );
if( p_rea )
{
memcpy( p_rea->p_buffer, p_block->p_buffer, p_block->i_buffer );
}
block_Release( p_block );
+ if( p_rea == NULL )
+ return NULL;
p_block = p_rea;
}
else
* XXX it might not preserve the alignment of p_buffer */
if( p_end - (p_block->p_buffer + i_body) > BLOCK_WASTE_SIZE )
{
- const ptrdiff_t i_prebody = p_block->p_buffer - p_start;
- const size_t i_new = requested + 1 * BLOCK_PADDING;
- block_sys_t *p_new = realloc( p_sys, sizeof (*p_sys) + i_new );
-
- if( p_new != NULL )
+ block_t *p_rea = block_Alloc( requested );
+ if( p_rea )
{
- p_sys = p_new;
- p_sys->i_allocated_buffer = i_new;
- p_block = &p_sys->self;
- p_block->p_buffer = &p_sys->p_allocated_buffer[i_prebody];
+ BlockMetaCopy( p_rea, p_block );
+ p_rea->p_buffer += i_prebody;
+ p_rea->i_buffer -= i_prebody;
+ memcpy( p_rea->p_buffer, p_block->p_buffer, p_block->i_buffer );
+ block_Release( p_block );
+ p_block = p_rea;
}
}
*
* @param ptr base address of the heap allocation (will be free()'d)
* @param addr base address of the useful buffer data
- * @param length bytes length of the useful buffer datan
+ * @param length bytes length of the useful buffer data
* @return NULL in case of error (ptr free()'d in that case), or a valid
* block_t pointer.
*/
#ifdef WIN32
+# include <io.h>
#ifdef UNDER_CE
#define _get_osfhandle(a) ((long) (a))
#endif
void block_FifoEmpty( block_fifo_t *p_fifo )
{
- block_t *b;
+ block_t *block;
vlc_mutex_lock( &p_fifo->lock );
- for( b = p_fifo->p_first; b != NULL; )
+ block = p_fifo->p_first;
+ if (block != NULL)
{
- block_t *p_next;
-
- p_next = b->p_next;
- block_Release( b );
- b = p_next;
+ p_fifo->i_depth = p_fifo->i_size = 0;
+ p_fifo->p_first = NULL;
+ p_fifo->pp_last = &p_fifo->p_first;
}
-
- p_fifo->i_depth = p_fifo->i_size = 0;
- p_fifo->p_first = NULL;
- p_fifo->pp_last = &p_fifo->p_first;
vlc_cond_broadcast( &p_fifo->wait_room );
vlc_mutex_unlock( &p_fifo->lock );
+
+ while (block != NULL)
+ {
+ block_t *buf;
+
+ buf = block->p_next;
+ block_Release (block);
+ block = buf;
+ }
}
/**
* Immediately queue one block at the end of a FIFO.
* @param fifo queue
* @param block head of a block list to queue (may be NULL)
+ * @return total number of bytes appended to the queue
*/
size_t block_FifoPut( block_fifo_t *p_fifo, block_t *p_block )
{
- size_t i_size = 0;
- vlc_mutex_lock( &p_fifo->lock );
+ size_t i_size = 0, i_depth = 0;
+ block_t *p_last;
- while (p_block != NULL)
+ if (p_block == NULL)
+ return 0;
+ for (p_last = p_block; ; p_last = p_last->p_next)
{
- i_size += p_block->i_buffer;
-
- *p_fifo->pp_last = p_block;
- p_fifo->pp_last = &p_block->p_next;
- p_fifo->i_depth++;
- p_fifo->i_size += p_block->i_buffer;
-
- p_block = p_block->p_next;
+ i_size += p_last->i_buffer;
+ i_depth++;
+ if (!p_last->p_next)
+ break;
}
- /* We queued one block: wake up one read-waiting thread */
+ vlc_mutex_lock (&p_fifo->lock);
+ *p_fifo->pp_last = p_block;
+ p_fifo->pp_last = &p_last->p_next;
+ p_fifo->i_depth += i_depth;
+ p_fifo->i_size += i_size;
+ /* We queued at least one block: wake up one read-waiting thread */
vlc_cond_signal( &p_fifo->wait );
vlc_mutex_unlock( &p_fifo->lock );
vlc_mutex_unlock( &p_fifo->lock );
}
+/**
+ * Dequeue the first block from the FIFO. If necessary, wait until there is
+ * one block in the queue. This function is (always) cancellation point.
+ *
+ * @return a valid block, or NULL if block_FifoWake() was called.
+ */
block_t *block_FifoGet( block_fifo_t *p_fifo )
{
block_t *b;
return b;
}
+/**
+ * Peeks the first block in the FIFO.
+ * If necessary, wait until there is one block.
+ * This function is (always) a cancellation point.
+ *
+ * @warning This function leaves the block in the FIFO.
+ * You need to protect against concurrent threads who could dequeue the block.
+ * Preferrably, there should be only one thread reading from the FIFO.
+ *
+ * @return a valid block.
+ */
block_t *block_FifoShow( block_fifo_t *p_fifo )
{
block_t *b;
projects / vlc / blobdiff