/****************************************************************************//* *	bitstr.c -- BitStream files handling * *	Author  :   St閜hane TAVENARD * *	(C) Copyright 1997-1998 St閜hane TAVENARD *	    All Rights Reserved * *	This program is free software; you can redistribute it and/or modify *	it under the terms of the GNU General Public License as published by *	the Free Software Foundation; either version 2 of the License, or *	(at your option) any later version. *	 *	This program is distributed in the hope that it will be useful, *	but WITHOUT ANY WARRANTY; without even the implied warranty of *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the *	GNU General Public License for more details. *	 *	You should have received a copy of the GNU General Public License *	along with this program; if not, write to the Free Software *	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *//****************************************************************************/#include "defs.h"#include <stdio.h>#include <stdlib.h>#include <string.h>#include "bitstr.h"/****************************************************************************//* *	Default file I/O functions. */static long def_open(char *stream_name, long buffer_size, long *stream_size){	FILE *file_ptr;	file_ptr = fopen(stream_name, "rb");	if ((file_ptr) && (buffer_size > 0))		setvbuf(file_ptr, NULL, _IOFBF, buffer_size);	*stream_size = 0;	if (file_ptr) {		if (!fseek(file_ptr, 0, SEEK_END)) {			*stream_size = ftell(file_ptr);			fseek(file_ptr, 0, SEEK_SET);		}	}	return((long) file_ptr);}/****************************************************************************/static void def_close( long handle ){	if (handle)		fclose((FILE *) handle);}/****************************************************************************/static long def_read(long handle, void *buffer, long num_bytes){	long read_size = -1;	if (handle)		read_size = fread(buffer, 1, num_bytes, (FILE *) handle);	return(read_size);}/****************************************************************************/static int def_seek(long handle, long abs_byte_seek_pos){	int err = 0;	if (handle)		err = fseek((FILE *) handle, abs_byte_seek_pos, SEEK_SET);	return(err);}/****************************************************************************//* *	End of default file I/O functions. */void BSTR_close(BITSTREAM *bitstream){	if (bitstream) {		if (bitstream->buffer)			//ffree(bitstream->buffer);			free(bitstream->buffer);		if (bitstream->file_handle) {			if (bitstream->baccess.close)				bitstream->baccess.close(bitstream->file_handle);		}		free(bitstream);	}}/****************************************************************************//* *	Open a BitStream for read *	Inputs: *		bs_access = specify how to access to the bitstream (functions) *		if NULL, use standard file i/o *		filename = name of the bitstream *		buffer_size = # of bytes read for each access */BITSTREAM *BSTR_open(BITSTREAM_ACCESS *bs_access, char *filename, long buffer_size){	BITSTREAM *bs;	bs = (BITSTREAM *) malloc(sizeof(BITSTREAM));	if (!bs)		return NULL;	memset(bs, 0, sizeof(BITSTREAM));	if (bs_access) {		bs->baccess = *bs_access;	} else {		bs->baccess.open = def_open;		bs->baccess.close = def_close;		bs->baccess.read = def_read;		bs->baccess.seek = def_seek;	}	// Buffer size must be 4-bytes aligned	buffer_size &= ~3;		bs->buffer = malloc(buffer_size);	//bs->buffer = fmalloc(buffer_size);	if (!bs->buffer) {		BSTR_close(bs);		return(NULL);	}	bs->buffer_size = buffer_size;	if (!bs->baccess.open) {		BSTR_close(bs);		return(NULL);	}	bs->file_handle = bs->baccess.open(filename, buffer_size, &bs->bitstream_size);	if (!bs->file_handle) {		BSTR_close(bs);		return(NULL);	}	bs->buffer_ptr = bs->buffer; // #10	bs->buffer_len = 0; // #10	bs->buffer_pos = 0; // #10	return(bs);}/****************************************************************************/static int fill_buffer(BITSTREAM *bitstream){#ifdef BSTR_MSBF	bitstream->buffer[0] = 0;#else	bitstream->buffer[1] = bitstream->buffer[2] = bitstream->buffer[3] = 0;#endif	if (bitstream->end_of_stream)		return 1;	if (!bitstream->baccess.read)		return 1;	bitstream->remain_bytes = bitstream->baccess.read(		bitstream->file_handle, bitstream->buffer,		bitstream->buffer_size );	bitstream->buffer_len = bitstream->remain_bytes; // #10	bitstream->buffer_pos += (long)bitstream->buffer_ptr - (long)bitstream->buffer; // #10	bitstream->buffer_ptr = bitstream->buffer;	bitstream->cache_size = 0;	if (bitstream->remain_bytes <= 0) {		bitstream->end_of_stream = 1;		return(1); /* empty */	} else if (bitstream->remain_bytes < 4) {		bitstream->remain_bytes = 4;	}	return(0);}/****************************************************************************/#ifdef BSTR_MSBF#define FILL_CACHE(b) { \	if (b->remain_bytes <= 0) \		fill_buffer(b); \	b->remain_bytes -= 4; \	b->bit_cache = *b->buffer_ptr++; \}#else#define FILL_CACHE(b) { \	if (b->remain_bytes <= 0) \		fill_buffer(b); \	b->remain_bytes -= 4; \	b->bit_cache = (((unsigned long)b->buffer_ptr[0])<<24) | \		(((unsigned long)b->buffer_ptr[1])<<16)| \		(((unsigned long)b->buffer_ptr[2])<<8) | \		((unsigned long)b->buffer_ptr[3]); b->buffer_ptr+=4; \}#endif/****************************************************************************/int BSTR_seek(BITSTREAM *bitstream, long seek_byte_pos){	int err;	// Optimize seek if inside current buffer	long offset_pos = seek_byte_pos - bitstream->buffer_pos;	if (bitstream->buffer_len > 0) {		if ((offset_pos >= 0) && (offset_pos < bitstream->buffer_len)) {			// Use current buffer			long remain = offset_pos & 3; // Remainder			offset_pos &= ~3; // align to 32 bit			bitstream->remain_bytes = bitstream->buffer_len - offset_pos;#ifdef BSTR_MSBF			bitstream->buffer_ptr = bitstream->buffer + (offset_pos>>2);#else			bitstream->buffer_ptr = bitstream->buffer + offset_pos;#endif         		bitstream->cache_size = 0;         		bitstream->bits = 0;         		FILL_CACHE(bitstream);         		bitstream->cache_size = 32;         		// Skip remainder         		while(remain--)				BSTR_read_byte(bitstream);         		return(0);		}	}	if (bitstream->baccess.seek) {		err = bitstream->baccess.seek(bitstream->file_handle, seek_byte_pos);		if (err)			return(err);	}	bitstream->remain_bytes = 0;	bitstream->buffer_ptr = bitstream->buffer;	bitstream->end_of_stream = 0;	bitstream->cache_size = 0;	bitstream->bits = 0;	bitstream->buffer_len = 0; // #10	bitstream->buffer_pos = seek_byte_pos; // #10	return(0);}/****************************************************************************/long BSTR_pos(BITSTREAM *bitstream){	return(bitstream->buffer_pos + (long)bitstream->buffer_ptr -		(long)bitstream->buffer - (bitstream->cache_size >> 3));}/****************************************************************************/unsigned long BSTR_read_byte(BITSTREAM *b){	if (b->cache_size < 8) {		FILL_CACHE(b);		b->cache_size = 32;	}	if (b->cache_size & 7) { // Not aligned		b->bit_cache <<= b->cache_size & 7;		b->cache_size &= ~7;	}	b->bits = b->bit_cache >> 24;	b->bit_cache <<= 8;	b->cache_size -= 8;	return(b->bits);}/****************************************************************************/unsigned int BSTR_read_bytes(BITSTREAM *b, unsigned int count, char *buffer){	if (count == 0)		return 0;	if (b->cache_size & 7) { // Not aligned		b->bit_cache <<= b->cache_size & 7;		b->cache_size &= ~7;	}	while ((b->cache_size > 0) && (count-- > 0 )) {		*buffer++ = b->bit_cache >> 24;		b->bit_cache <<= 8;		b->cache_size -= 8;	}	while (count > 3) {		int to_fill;		if (b->remain_bytes <= 0) {			if (fill_buffer(b))				return 0;		}		to_fill = count & ~3; // Important 4-bytes aligned		// Note: b->remain_bytes is always 4-bytes aligned		if (to_fill > b->remain_bytes)			to_fill = b->remain_bytes;				memcpy(buffer, b->buffer_ptr, to_fill);			count -= to_fill;			buffer += to_fill;			b->remain_bytes -= to_fill;#ifdef BSTR_MSBF			// This is a INT32 pointer here.			b->buffer_ptr += to_fill>>2;#else			b->buffer_ptr += to_fill;#endif		}	// Not 4 bytes aligned -> use cached read	while (count > 0) {		*buffer++ = BSTR_read_byte(b);		count--;	}	b->bits = (unsigned int)*(buffer-1);	return(1);}/****************************************************************************/unsigned long BSTR_read_bit_cache(BITSTREAM *b){	unsigned long bits;	FILL_CACHE(b);	b->cache_size = 31;	bits = (b->bit_cache & 0x80000000) ? 1 : 0;	b->bit_cache <<= 1;	return(bits);}/****************************************************************************/unsigned long BSTR_read_bits_cache(BITSTREAM *b, unsigned int count){	unsigned long bits;	bits = b->bit_cache >> (32 - count);	count -= b->cache_size;	FILL_CACHE(b);	b->cache_size = 32 - count;	bits |= b->bit_cache >> (32 - count);	b->bit_cache <<= count;	return(bits);}/****************************************************************************/