source: svn/zas_dstar/pdrivers/block.c @ 22

/******************************************************************************
 *_Copyright (c) 2009 Digital Stream Technology Inc. All Rights Reserved.
 *
 * Module:      pd_dmx.c
 *
 * Description
 *      Pseudo Driver for Demux
 *
 * @author Junku Park (hwatk@dstreamtech.com)
 * @version $Revision: 1.1 $
 *
 ******************************************************************************/

#include "dsthallocal.h"
#include "dsthalerror.h"
#include "dstoslayer.h"
#include "pd_dmx.h"
#include "pd_dmx_priv.h"

#include <stdio.h>
#include <stdlib.h>

#ifdef DMALLOC   
#include <dmalloc.h>   
#endif   

/******************************************************************************
 * Global variable declaration
 ******************************************************************************/

/******************************************************************************
 * Imported variable declaration
 ******************************************************************************/

/******************************************************************************
 * Imported function declaration
 ******************************************************************************/

/******************************************************************************
 * Local definitions
 ******************************************************************************/

/******************************************************************************
 * Local typedefs
 ******************************************************************************/
typedef struct block_sys_t block_sys_t;
struct block_sys_t
{
    block_t     self;
    int         i_allocated_buffer;
    DS_U8       p_allocated_buffer[];
};

/******************************************************************************
 * Local variables declaration
 ******************************************************************************/

/******************************************************************************
 * Local function prototypes
 ******************************************************************************/
void block_FifoEmpty( block_fifo_t *p_fifo );
static DS_U64 alloc_cnt = 0;
static DS_U64 total_siz = 0;

#if 0
___Block_Management___()
#endif
void block_Init( block_t *b, void *buf, int 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;
    b->i_osize = size;
//    b->pf_release = BlockNoRelease;
}

static void BlockRelease( block_t *p_block )
{
    total_siz -= p_block->i_osize;
    
    alloc_cnt--;
    free( p_block );
}

/* Memory alignment */
#define BLOCK_ALIGN        16
/* Initial size of reserved header and footer */
#define BLOCK_PADDING_SIZE 32
/* Maximum size of reserved footer before we release with realloc() */
#define BLOCK_WASTE_SIZE   2048

block_t *block_Alloc( int i_size )
{
    /* We do only one malloc
     * TODO: bench if doing 2 malloc but keeping a pool of buffer is better
     * TODO: use memalign
     * 16 -> align on 16
     * 2 * BLOCK_PADDING_SIZE -> pre + post padding
     */
    const int i_alloc = i_size + 2 * BLOCK_PADDING_SIZE + BLOCK_ALIGN;
    block_sys_t *p_sys = malloc( sizeof( *p_sys ) + i_alloc );

    alloc_cnt++;
    total_siz += i_size;
    
    if( p_sys == NULL )
        return NULL;

    /* Fill opaque data */
    p_sys->i_allocated_buffer = i_alloc;

    block_Init( &p_sys->self, p_sys->p_allocated_buffer + BLOCK_PADDING_SIZE
                + BLOCK_ALIGN
                - ((DS_U32)p_sys->p_allocated_buffer % BLOCK_ALIGN),
                i_size );
    p_sys->self.pf_release    = BlockRelease;

    return &p_sys->self;
}

block_t *block_Realloc( block_t *p_block, int i_prebody, int i_body )
{
    block_sys_t *p_sys = (block_sys_t *)p_block;
    int i_buffer_size = i_prebody + i_body;

    if( i_buffer_size <= 0 )
    {
        block_Release( p_block );
        return NULL;
    }

    if( p_block->pf_release != BlockRelease )
    {
        /* Special case when pf_release if overloaded
         * TODO if used one day, then implement it in a smarter way */
        block_t *p_dup = block_Duplicate( p_block );
        block_Release( p_block );
        if( !p_dup )
            return NULL;

        p_block = p_dup;
        p_sys = (block_sys_t *)p_block;
    }

    /* Adjust reserved header if there is enough room */
    if( p_block->p_buffer - i_prebody > p_sys->p_allocated_buffer &&
        p_block->p_buffer - i_prebody < p_sys->p_allocated_buffer +
        p_sys->i_allocated_buffer )
    {
        p_block->p_buffer -= i_prebody;
        p_block->i_buffer += i_prebody;
        i_prebody = 0;
    }

    /* Adjust payload size if there is enough room */
    if( p_block->p_buffer + i_body < p_sys->p_allocated_buffer +
        p_sys->i_allocated_buffer )
    {
        p_block->i_buffer = i_buffer_size;
        i_body = 0;
    }

    /* Not enough room, reallocate the buffer */
    if( i_body > 0 || i_prebody > 0 )
    {
        /* FIXME: this is really dumb, we should use realloc() */
        block_t *p_rea = block_New( NULL, i_buffer_size );

        if( p_rea )
        {
            p_rea->i_dts     = p_block->i_dts;
            p_rea->i_pts     = p_block->i_pts;
            p_rea->i_flags   = p_block->i_flags;
            p_rea->i_length  = p_block->i_length;
            p_rea->i_rate    = p_block->i_rate;
            p_rea->i_samples = p_block->i_samples;

            memcpy( p_rea->p_buffer + i_prebody, p_block->p_buffer,
                    __MIN( p_block->i_buffer, p_rea->i_buffer - i_prebody ) );
        }

        block_Release( p_block );

        return p_rea;
    }

    /* We have a very large reserved footer now? Release some of it.
     * XXX it may not keep the algniment of p_buffer */
    if( (p_sys->p_allocated_buffer + p_sys->i_allocated_buffer) -
        (p_block->p_buffer + p_block->i_buffer) > BLOCK_WASTE_SIZE )
    {
        const int i_prebody = p_block->p_buffer - p_sys->p_allocated_buffer;
        const int i_new = i_prebody + p_block->i_buffer + 1 * BLOCK_PADDING_SIZE;
        block_sys_t *p_new = realloc( p_sys, sizeof (*p_sys) + i_new );

        if( p_new != NULL )
        {
            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];
        }
    }
    return p_block;
}

void print_block_cnt(void)
{
    printf("alloc_cnt: %lld\n", alloc_cnt);
    printf("total_siz: %lld\n", total_siz);
}

#if 0
___FIFO_Management___()
#endif

/*****************************************************************************
 * block_fifo_t management
 *****************************************************************************/
struct block_fifo_t
{
    pthread_mutex_t      lock;                         /* fifo data lock */
    pthread_cond_t       wait;         /* fifo data conditional variable */

    block_t             *p_first;
    block_t            **pp_last;
    int                  i_depth;
    int                  i_size;
    DS_BOOL              b_force_wake;
};

block_fifo_t *block_FifoNew( void )
{
    block_fifo_t *p_fifo = malloc( sizeof( block_fifo_t ) );
    if( !p_fifo )
        return NULL;

    pthread_mutex_init( &p_fifo->lock, NULL );
    pthread_cond_init( &p_fifo->wait, NULL );
    p_fifo->p_first = NULL;
    p_fifo->pp_last = &p_fifo->p_first;
    p_fifo->i_depth = p_fifo->i_size = 0;
    p_fifo->b_force_wake = DS_FALSE;

    return p_fifo;
}

void block_FifoRelease( block_fifo_t *p_fifo )
{
    block_FifoEmpty( p_fifo );
    pthread_cond_destroy( &p_fifo->wait );
    pthread_mutex_destroy( &p_fifo->lock );
    free( p_fifo );
}

void block_FifoEmpty( block_fifo_t *p_fifo )
{
    block_t *b;

    pthread_mutex_lock( &p_fifo->lock );
    for( b = p_fifo->p_first; b != 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;
    pthread_mutex_unlock( &p_fifo->lock );
}

int block_FifoPut( block_fifo_t *p_fifo, block_t *p_block )
{
    int i_size = 0;
    pthread_mutex_lock( &p_fifo->lock );

    do
    {
        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;

    } while( p_block );

    /* warn there is data in this fifo */
    pthread_cond_signal( &p_fifo->wait );
    pthread_mutex_unlock( &p_fifo->lock );

    return i_size;
}

void block_FifoWake( block_fifo_t *p_fifo )
{
    pthread_mutex_lock( &p_fifo->lock );
    if( p_fifo->p_first == NULL )
        p_fifo->b_force_wake = DS_TRUE;
    pthread_cond_signal( &p_fifo->wait );
    pthread_mutex_unlock( &p_fifo->lock );
}

block_t *block_FifoGet( block_fifo_t *p_fifo )
{
    block_t *b;

    pthread_mutex_lock( &p_fifo->lock );

    /* Remember pthread_cond_wait() may cause spurious wakeups
     * (on both Win32 and POSIX) */
    while( ( p_fifo->p_first == NULL ) && !p_fifo->b_force_wake )
    {
        pthread_cond_wait( &p_fifo->wait, &p_fifo->lock );
    }

    b = p_fifo->p_first;

    p_fifo->b_force_wake = DS_FALSE;
    if( b == NULL )
    {
        /* Forced wakeup */
        pthread_mutex_unlock( &p_fifo->lock );
        return NULL;
    }

    p_fifo->p_first = b->p_next;
    p_fifo->i_depth--;
    p_fifo->i_size -= b->i_buffer;

    if( p_fifo->p_first == NULL )
    {
        p_fifo->pp_last = &p_fifo->p_first;
    }

    pthread_mutex_unlock( &p_fifo->lock );

    b->p_next = NULL;
    return b;
}

block_t *block_FifoShow( block_fifo_t *p_fifo )
{
    block_t *b;

    pthread_mutex_lock( &p_fifo->lock );

    if( p_fifo->p_first == NULL )
    {
        pthread_cond_wait( &p_fifo->wait, &p_fifo->lock );
    }

    b = p_fifo->p_first;

    pthread_mutex_unlock( &p_fifo->lock );

    return( b );
}

int block_FifoSize( const block_fifo_t *p_fifo )
{
    return p_fifo->i_size;
}

int block_FifoCount( const block_fifo_t *p_fifo )
{
    return p_fifo->i_depth;
}