source: svn/trunk/newcon3bcm2_21bu/magnum/commonutils/udp/budp_bitread.c @ 2

/***************************************************************************
 *     Copyright (c) 2003-2010, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile: budp_bitread.c $
 * $brcm_Revision: Hydra_Software_Devel/1 $
 * $brcm_Date: 7/27/10 5:05p $
 *
 * Module Description:
 *
 * Revision History:
 *
 ***************************************************************************/

#include "bstd.h"
#include "berr.h"
#include "budp.h"
#include "budp_bitread.h"

BDBG_MODULE(BUDP_Bitread);

/***************************************************************************
* Private data structures
***************************************************************************/

/***************************************************************************
* Forward declarations of static (private) functions
***************************************************************************/


/***************************************************************************
* Implementation of "BUDP_Bitread_" API functions
***************************************************************************/


/* Swap 4 byte unsigned integers */
#define SWAP_U_INT_4(tni4)                         \
 (((((tni4)>>24)&0xff  ) |   (((tni4)&0xff  )<<24) |   \
   (((tni4)>>8 )&0xff00) |   (((tni4)&0xff00)<<8 )))  
/***************************************************************************
 *
 */
BERR_Code BUDP_Bitread_Init ( 
        BUDP_Bitread_Context* pContext, 
        bool                     bByteswap,
        void*                    userdata_start
) 
{
   
        uint32_t temp;
        uint32_t address = (uint32_t)userdata_start;
        uint32_t rem = address & 0x00000003;

        BDBG_ENTER(BUDP_Bitread_Open);

        if(!pContext)
        {
                BDBG_ERR(("Invalid parameter\n"));
                BDBG_LEAVE(BUDP_Bitread_Open);
                return BERR_TRACE(BERR_INVALID_PARAMETER);
        }

        /* Take care of misalignment */
        address -= rem;

        /* Initialize the context */
        pContext->userdata  = (uint32_t*)address;  /* aligned on dword */
    pContext->bByteswap = bByteswap;           /* set the Endianess */
        temp = *pContext->userdata++;
    if(pContext->bByteswap)
        pContext->cache = SWAP_U_INT_4(temp);
    else
        pContext->cache = temp;

    /* make sure alignment did not cause too much to be read */
    pContext->bitsleft  = 8 * (4 - rem); 
        pContext->cache <<= (8 * rem);

        BDBG_LEAVE(BUDP_Bitread_Open);
        return BERR_SUCCESS;
}


/***************************************************************************
 *
 */
uint32_t BUDP_Bitread_Read (
        BUDP_Bitread_Context* pContext,
        unsigned int                nbits
) 
{
        uint32_t result = 0;

        BDBG_ENTER(BUDP_Bitread_Read);

        /* check parameters */
        BDBG_ASSERT (pContext != NULL);

        /* NOT OPTIMIZED!  SLOW! */
        while (nbits-- > 0)
        {
                if (pContext->bitsleft == 0)
                {
                        uint32_t temp = *pContext->userdata++;
                        if (pContext->bByteswap)
                pContext->cache = SWAP_U_INT_4(temp);
            else
                pContext->cache = temp;
                
                        pContext->bitsleft = 32;
                }
                result = (result << 1) | ((pContext->cache >> 31) & 0x1);
                pContext->cache <<= 1;
                --pContext->bitsleft;
        } 
        BDBG_LEAVE(BUDP_Bitread_Read);
        return result;
}

/***************************************************************************
 *
 */
uint32_t BUDP_Bitread_Byte (BUDP_Bitread_Context* pContext)

{
    uint32_t result = 0;

    BDBG_ENTER(BUDP_Bitread_Byte);

    /* check parameters */
    BDBG_ASSERT (pContext != NULL);
    if (pContext->bitsleft < 8)
        {
        result = BUDP_Bitread_Read (pContext, 8); 

        }
    else
    {
        result = (pContext->cache >> 24 ) & 0xff;
        pContext->cache <<= 8;
        pContext->bitsleft -= 8;
    }
    
    BDBG_LEAVE(BUDP_Bitread_Byte);
    return result;
}

/***************************************************************************
 *
 */
uint32_t BUDP_Bitread_GetByteOffset(BUDP_Bitread_Context* pContext)

{
    uint32_t result;

    BDBG_ENTER(BUDP_Bitread_Byte);

    /* check parameters */
    BDBG_ASSERT (pContext != NULL);

        result = 
                sizeof(pContext->userdata[0]) * 
                        (pContext->userdata - pContext->userdata_start);
        result += (32 - pContext->bitsleft) / 8;
    
    BDBG_LEAVE(BUDP_Bitread_Byte);
    return result;
}

/***************************************************************************
 *
 */
uint32_t BUDP_Bitread_next_start_code(
        BUDP_Bitread_Context* pContext, size_t length, size_t* pBytesParsed)
{
        uint8_t saved[4];
        bool found = false;
        size_t bytesParsed = 0;

        /* 
         * Go to first MPEG startcode 
         */

        /* MPEG start codes are byte aligned, so make it so. */
        if (pContext->bitsleft & 0x7)
        {
                pContext->bitsleft &= ~(0x7);
                --length;
                ++bytesParsed;
        }

        /* Special case: not enough data */
        if (length < 4)
        {
                while (length-- > 0)
                {
                        (void)BUDP_Bitread_Byte (pContext);
                        ++bytesParsed;
                }
                *pBytesParsed = bytesParsed;
                return 0x0;
        }

        /* Initialize */
        saved[0] = 0x0;
    saved[1] = BUDP_Bitread_Byte (pContext);
    saved[2] = BUDP_Bitread_Byte (pContext);
    saved[3] = BUDP_Bitread_Byte (pContext);
        length -= 3;
        bytesParsed += 3;

    while (length > 0)
    {
        /* Read in another byte */
        saved[0] = saved[1];
        saved[1] = saved[2];
        saved[2] = saved[3];
        saved[3] = BUDP_Bitread_Byte (pContext);
                --length;
                ++bytesParsed;

        if ((saved[0] == 0x00) &&
            (saved[1] == 0x00) &&
            (saved[2] == 0x01)    )
        {
            /* Found it! */
                        found = true;
            break;
        }
    }

        *pBytesParsed = bytesParsed;
    if (found)
    {
        /* found the pattern before the end of stream */
        return 
                        ((uint32_t)saved[3] << 24) |
                        ((uint32_t)saved[2] << 16) |
                        ((uint32_t)saved[1] <<  8) |
                        ((uint32_t)saved[0]      ) ;
    }
    else
    {
        /* Didn't find any start code */
        return 0x0;
    }

}

/* End of File */