source: svn/branches/kctv/zas_dstar/pdrivers/pd_dmx_priv.h

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

#ifndef __PD_DMX_PRIV_H__
#define __PD_DMX_PRIV_H__

#include <string.h>

#if 0
___Block_APIs___()
#endif
enum {
    BLOCK_FLAG_CORRUPTED = 0x8000,
};

typedef struct block_t block_t;
typedef void (*block_free_t) (block_t *);

typedef struct block_fifo_t block_fifo_t;

struct block_t
{
    block_t     *p_next;
    block_t     *p_prev;

    DS_U32      i_flags;

    DS_S64      i_pts;
    DS_S64      i_dts;
    DS_S64      i_length;

    int         i_samples; /* Used for audio */
    int         i_rate;

    DS_U64      i_buffer;
    DS_U8      *p_buffer;

    DS_U64      i_osize;    /* Origianl size */
    /* Rudimentary support for overloading block (de)allocation. */
    block_free_t pf_release;
};

void block_Init( block_t *, void *, int );
block_t *block_Alloc( int );
block_t *block_Realloc( block_t *, int i_pre, int i_body );

static inline void block_Release( block_t *p_block )
{
    p_block->pf_release( p_block );
}

static inline block_t *block_Duplicate( block_t *p_block )
{
    block_t *p_dup = block_Alloc( p_block->i_buffer );
    if( p_dup == NULL )
        return NULL;

    p_dup->i_dts     = p_block->i_dts;
    p_dup->i_pts     = p_block->i_pts;
    p_dup->i_flags   = p_block->i_flags;
    p_dup->i_length  = p_block->i_length;
    p_dup->i_rate    = p_block->i_rate;
    p_dup->i_samples = p_block->i_samples;
    memcpy( p_dup->p_buffer, p_block->p_buffer, p_block->i_buffer );

    return p_dup;
}

static inline void block_ChainAppend( block_t **pp_list, block_t *p_block )
{
    if( *pp_list == NULL )
    {
        *pp_list = p_block;
    }
    else
    {
        block_t *p = *pp_list;

        while( p->p_next ) p = p->p_next;
        p->p_next = p_block;
    }
}

static inline void block_ChainLastAppend( block_t ***ppp_last, block_t *p_block )
{
    block_t *p_last = p_block;

    **ppp_last = p_block;

    while( p_last->p_next ) p_last = p_last->p_next;
    *ppp_last = &p_last->p_next;
}

static inline void block_ChainRelease( block_t *p_block )
{
    while( p_block )
    {
        block_t *p_next = p_block->p_next;
        block_Release( p_block );
        p_block = p_next;
    }
}

#ifndef __MIN
#define __MIN(x,y)  ((x)>(y) ? (y) : (x))
#endif

static int block_ChainExtract( block_t *p_list, void *p_data, int i_max )
{
    int  i_total = 0;
    DS_U8 *p = (DS_U8 *)p_data;

    while( p_list && i_max )
    {
        int i_copy = __MIN( i_max, p_list->i_buffer );
        memcpy( p, p_list->p_buffer, i_copy );
        i_max   -= i_copy;
        i_total += i_copy;
        p       += i_copy;

        p_list = p_list->p_next;
    }
    return i_total;
}

static inline block_t *block_ChainGather( block_t *p_list )
{
    int  i_total = 0;
    DS_S64 i_length = 0;
    block_t *b, *g;

    if( p_list->p_next == NULL )
        return p_list;  /* Already gathered */

    for( b = p_list; b != NULL; b = b->p_next )
    {
        i_total += b->i_buffer;
        i_length += b->i_length;
    }

    g = block_Alloc( i_total );
    block_ChainExtract( p_list, g->p_buffer, g->i_buffer );

    g->i_flags = p_list->i_flags;
    g->i_pts   = p_list->i_pts;
    g->i_dts   = p_list->i_dts;
    g->i_length = i_length;

    /* free p_list */
    block_ChainRelease( p_list );
    return g;
}

#define block_New( dummy, size ) block_Alloc(size)

#if 0
___FIFO_APIs___()
#endif

block_fifo_t *block_FifoNew( void );
void block_FifoRelease( block_fifo_t *p_fifo );
void block_FifoEmpty( block_fifo_t *p_fifo );
int block_FifoPut( block_fifo_t *p_fifo, block_t *p_block );
void block_FifoWake( block_fifo_t *p_fifo );
block_t *block_FifoGet( block_fifo_t *p_fifo );
block_t *block_FifoShow( block_fifo_t *p_fifo );
int block_FifoSize( const block_fifo_t *p_fifo );
int block_FifoCount( const block_fifo_t *p_fifo );

#if 0
___Utility_APIs___()
#endif
static inline DS_U16 U16_AT( const void * _p )
{
    const DS_U8 * p = (const DS_U8 *)_p;
    return ( ((DS_U16)p[0] << 8) | p[1] );
}

static inline DS_U32 U32_AT( const void * _p )
{
    const DS_U8 * p = (const DS_U8 *)_p;
    return ( ((DS_U32)p[0] << 24) | ((DS_U32)p[1] << 16) | ((DS_U32)p[2] << 8) | p[3] );
}

static inline DS_U64 U64_AT( const void * _p )
{
    const DS_U8 * p = (const DS_U8 *)_p;
    return ( ((DS_U64)p[0] << 56) | ((DS_U64)p[1] << 48)
              | ((DS_U64)p[2] << 40) | ((DS_U64)p[3] << 32)
              | ((DS_U64)p[4] << 24) | ((DS_U64)p[5] << 16)
              | ((DS_U64)p[6] << 8) | p[7] );
}

static inline DS_U16 GetWLE( const void * _p )
{
    const DS_U8 * p = (const DS_U8 *)_p;
    return ( ((DS_U16)p[1] << 8) | p[0] );
}

static inline DS_U32 GetDWLE( const void * _p )
{
    const DS_U8 * p = (const DS_U8 *)_p;
    return ( ((DS_U32)p[3] << 24) | ((DS_U32)p[2] << 16)
              | ((DS_U32)p[1] << 8) | p[0] );
}

static inline DS_U64 GetQWLE( const void * _p )
{
    const DS_U8 * p = (const DS_U8 *)_p;
    return ( ((DS_U64)p[7] << 56) | ((DS_U64)p[6] << 48)
              | ((DS_U64)p[5] << 40) | ((DS_U64)p[4] << 32)
              | ((DS_U64)p[3] << 24) | ((DS_U64)p[2] << 16)
              | ((DS_U64)p[1] << 8) | p[0] );
}

#define GetWBE( p )     U16_AT( p )
#define GetDWBE( p )    U32_AT( p )
#define GetQWBE( p )    U64_AT( p )


#endif /* __PD_DMX_PRIV_H__ */