bitstream.c

jpeg快速算法,用于TI和philips的DSP开发

/*
 *********************************************************************
 * File name: bitstream.c
 * Version: 5.0(release v1.0)    Date: Jan 12, 2006
 * Author:  xiezm                Email: [e-mail]
 * Company: Wuxi Intech co., ltd.
 *
 * Project: Jpeg Decoder for Trio
 *********************************************************************
 */
#define BITSTREAM_GLOBALS

#include "cf6_chess.h"

#ifdef WIN32
#include <stdio.h>
#endif

#include "djpg.h"

int input_buffer1[BUFFER_SIZE];
int input_buffer2[BUFFER_SIZE];

void bitstream_fill_buffer(void)
{
#ifdef WIN32
	fread(input_buffer, 4, BUFFER_SIZE, INPUT);
	buffer_inop = input_buffer;//
#else
	int i;
	static int index = 1;
	int *pInput;
	if(index == 1)
	{
		pInput = input_buffer1;
		buffer_inop = (unsigned int *)input_buffer1;
		index = 2;
	}
	else if(index == 2)
	{
		pInput = input_buffer2;
		buffer_inop = (unsigned int *)input_buffer2;
		index = 1;
	}

	for(i=0;i<BUFFER_SIZE;i++)
	{
		pInput[i] = INPUT;// input_buffer[i] = INPUT;
	}
#endif

    buffer_inop = input_buffer;
	buffer_end = buffer_inop + BUFFER_SIZE - 1;
}

void bitstream_init(void)
{
    int i;

    bitstream_fill_buffer();
    
    is_stuff = 0;
    current = 0;
    bits_left = 0;
    next = 0;
    bits_next = 0;

    for(i=0;i<16;i++)
    {
        bits_mask[i] = (1<<i) - 1;
    }
}

unsigned int get_byte(void)
{
    if(0 == bits_left)
    {
        if(buffer_inop == buffer_end)
        {
            current = ((*buffer_inop)>>8) | ((*buffer_inop)<<8);
            bits_left = 16;
            bitstream_fill_buffer();
        }
        else
        {
            current = ((*buffer_inop)>>16) | ((*buffer_inop)&0x00ff00) | ((*buffer_inop)<<16);
            buffer_inop++;
    	    bits_left = 24;
        }
    }
    return((current >> (bits_left -= 8)) & 0x00ff);
}

unsigned int get_word(void)
{
    unsigned int ret_val;
    
    ret_val = get_byte();
    ret_val <<= 8;
    ret_val |= get_byte();

    return (ret_val);
}

//#define FF00
#ifdef FF00
inline void fill_op_word(unsigned int *op_word, unsigned int *bits_opword)
{
    if(buffer_inop == buffer_end)
    {
        *bits_opword = 16;
        *op_word = *buffer_inop;
        bitstream_fill_buffer();
        if(is_stuff && (0x00 == ((*op_word) & 0x00ff)))
        {
            *op_word >>= 8;
    	    *bits_opword = 8;
            if(0x00ff == (*op_word))
            {
                is_stuff = 1;
            }
            else
            {
                is_stuff = 0;
            }
            return;
        }
        else if(0x0000ff == (*op_word))
        {
            *bits_opword = 8;
			is_stuff = 0;
			return;
        }
		*op_word = (((*op_word) << 8) & 0x00ff00) | (((*op_word)>> 8 ) & 0x0000ff);
		if(0x00ff == ((*op_word) & 0x00ff))
		{
			is_stuff = 1;
		}
		else
		{
			is_stuff = 0;
		}
        return;
    }

    *bits_opword = 24;
    *op_word = (((*buffer_inop)>>16) | ((*buffer_inop)&0x00ff00) | ((*buffer_inop)<<16)) & 0x00ffffff;
    buffer_inop++;
    if(is_stuff && (0x00 == ((*op_word) >> 16)))
    {
        *bits_opword -= 8;
    }
    if(0x00ff00 == ((*op_word) >> 8))
    {
        *bits_opword -= 8;
        *op_word = (((*op_word) >> 8) & 0x00ff00) | ((*op_word) & 0x0000ff);
    }
    else if(0x00ff00 == ((*op_word) & 0x00ffff))
    {
        *bits_opword -= 8;		
        *op_word >>= 8;
        is_stuff = 0;
        return;
    }

    if(0x00ff == ((*op_word) & 0x00ff))
    {
        is_stuff = 1;
        return;
    }
    is_stuff = 0;
    
    return;
}
#else
inline void fill_op_word(unsigned int *op_word, unsigned int *bits_opword)
{
    if(buffer_inop == buffer_end)
    {
        *bits_opword = 16;
        *op_word = *buffer_inop;
        bitstream_fill_buffer();
		*op_word = (((*op_word) << 8) & 0x00ff00) | (((*op_word)>> 8 ) & 0x0000ff);

        return;
    }

    *bits_opword = 24;
    *op_word = (((*buffer_inop)>>16) | ((*buffer_inop)&0x00ff00) | ((*buffer_inop)<<16)) & 0x00ffffff;
    buffer_inop++;
     
    return;
}
#endif


void decode_bitstream_initial(void)
{
    if(0 == bits_left)
    {
        fill_op_word(&current, &bits_left);
    }
    else
    {
        if((16 == bits_left) && (0x00ff00 == (current & 0x00ffff)))
        {
            bits_left = 8;
            current >>= 8;
        }
        else if(0x00ff == (current & 0x00ff))
        {
            is_stuff = 1;
        }
    }

    fill_op_word(&next, &bits_next);
}

unsigned int get_bits(unsigned int num_bits)
{
    unsigned int result;
    
	if(num_bits <= bits_left)
    {
        return  (current >> (bits_left -= num_bits)) & bits_mask[num_bits];
		//return result;
    }

    num_bits -= bits_left;
    result = current & bits_mask[bits_left];

    current = next;
    bits_left = bits_next;
    fill_op_word(&next, &bits_next);

    if(num_bits <= bits_left)
    {
        result = (result << num_bits) | ((current >> (bits_left -= num_bits)) & bits_mask[num_bits]);
		return result;
    }

    num_bits -= bits_left;
    result =  (result << bits_left) | (current & bits_mask[bits_left]);

    current = next;
    bits_left = bits_next;
    fill_op_word(&next, &bits_next);

    result = (result << num_bits) | ((current >> (bits_left -= num_bits)) & bits_mask[num_bits]);
	return result;
}

unsigned int peek_byte(void)
{
    int b_num;

    if(8 <= bits_left)
    {
        return ((current >> (bits_left - 8)) & 0x00ff);
    }

    b_num = 8 - bits_left;
    return (((current << b_num) & 0x00ff) | ((next >> (bits_next - b_num)) & bits_mask[b_num]));
}

void drop_bits(unsigned int num_bits)
{
	if(bits_left >= num_bits)
	{
		bits_left -= num_bits;
		return;
	}
	
	num_bits -= bits_left;

    current = next;
    bits_left = bits_next;
    fill_op_word(&next, &bits_next);

	bits_left -= num_bits;
}