source: svn/newcon3bcm2_21bu/BSEAV/lib/utils/biobits.c

/***************************************************************************
 *     Copyright (c) 2006, 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: biobits.c $
 * $brcm_Revision: 2 $
 * $brcm_Date: 8/31/06 9:45a $
 *
 * Module Description:
 *
 * Bit stream utility
 * 
 * Revision History:
 *
 * $brcm_Log: /BSEAV/lib/asf/biobits.c $
 * 
 * 2   8/31/06 9:45a vsilyaev
 * PR 23826: Fixed bub in end of vector condition
 * 
 * 1   7/28/06 4:09p vsilyaev
 * PR 22578: Bitstream utility
 * 
 * 
 *******************************************************************************/
#include "bstd.h"
#include "biobits.h"

BDBG_MODULE(biobits);

void
bio_bitstream_init(bio_bitstream *bs, bio_cursor *cursor)
{
        bs->cursor = cursor;
        bs->cache = 0;
        bs->cache_pos = -1; /* invalid */
}

void
bio_bitstream_dump(bio_bitstream *bs)
{
        BSTD_UNUSED(bs);
        BDBG_WRN(("bio_bitstream: cache %#x cache_pos %d", bs->cache, bs->cache_pos));
        return;
}

bool
bio_bitstream_eof(bio_bitstream *bs)
{
        return bs->cache_pos == -1 && bio_cursor_eof(bs->cursor);
}

static int
bio_bitstream_refill(bio_bitstream *bs)
{
        bio_cursor *c = bs->cursor;

        BDBG_ASSERT(bs->cache_pos==-1);
#if B_IOVEC_FAST        
        if (c->left>=4) {
                bs->cache = (uint32_t)c->cursor[3] |
                                        ((uint32_t)(c->cursor[2])<<8) |
                                        ((uint32_t)(c->cursor[1])<<16) |
                                        ((uint32_t)(c->cursor[0])<<24);
                bs->cache_pos=31;
                c->cursor += 4;
                c->left -= 4;
                return 0;
        } 
#endif
        {
                int next;
                uint32_t cache;
                
                next = bio_cursor_next(c);
                if (next==BIO_EOF) {
                        return BIO_EOF;
                }
                cache = (uint32_t)next;
                next = bio_cursor_next(c);
                if (next==BIO_EOF) {
                        bs->cache = cache;
                        bs->cache_pos = 7; 
                        return 0;
                }
                cache = (cache << 8) | (uint32_t)next;

                next = bio_cursor_next(c);
                if (next==BIO_EOF) {
                        bs->cache = cache;
                        bs->cache_pos = 15; 
                        return 0;
                }
                cache = (cache << 8) | (uint32_t)next;

                next = bio_cursor_next(c);
                if (next==BIO_EOF) {
                        bs->cache = cache;
                        bs->cache_pos = 23; 
                        return 0;
                }
                bs->cache = (cache << 8) | (uint32_t)next;
                bs->cache_pos = 31; 
        }
        return 0;
}

int
bio_bitstream_show(bio_bitstream *bs)
{
        int bit;

        if(bs->cache_pos==-1) {
                if (bio_bitstream_refill(bs)==BIO_EOF) {
                        return BIO_EOF;
                }
        }
        bit = (bs->cache >> bs->cache_pos)&1;
        return bit;
}

int
bio_bitstream_bit(bio_bitstream *bs)
{
        int bit;
        
        bit = bio_bitstream_show(bs);
        if (bit!=BIO_EOF) {
                bs->cache_pos--;
        }
        return bit;
}

int
bio_bitstream_drop(bio_bitstream *bs)
{
        return bio_bitstream_bit(bs);
}

unsigned
bio_bitstream_bits(bio_bitstream *bs, unsigned nbits)
{
        uint32_t bits;
        int pos;

        BDBG_ASSERT(nbits<=31);
        BDBG_ASSERT(nbits>0);
        pos = bs->cache_pos - nbits;
        nbits--;
        if( bs->cache_pos>=(int)nbits) {
                bits = bs->cache >> (bs->cache_pos-nbits) & ((uint32_t)(-1)>>(31-nbits));
                bs->cache_pos = pos;
        } else {
                for(bits=0;;) {
                        bits |= (unsigned) bio_bitstream_bit(bs);
                        if (nbits==0) {
                                break;
                        }
                        nbits--;
                        bits <<=1;
                }
        }
        return bits;
}

void
bio_bitstream_drop_bits(bio_bitstream *bs, unsigned nbits)
{
        bio_bitstream_bits(bs, nbits);
        return;
}