stream.c

压缩算法的C语言源程序

/*
	int stream_putw(int ch, STREAM *stream):
	Writes a word to the stream
*/
int stream_putw(int ch,STREAM *stream)
{
	stream_putc(ch,stream);
	stream_putc(ch >> 8,stream);

	return ch;
}

/*
	int stream_putd(int ch, STREAM *stream):
	Writes a dword to the stream
*/
int stream_putd(int ch,STREAM *stream)
{
	stream_putc(ch,stream);
	stream_putc(ch >> 8,stream);
	stream_putc(ch >> 16,stream);
	stream_putc(ch >> 24,stream);

	return ch;
}

/*
	int stream_read(void *buffer,unsigned size,unsigned n,STREAM *stream):
	Reads a size of bytes from the stream to the buffer
*/
int stream_read(void *buffer,unsigned size,unsigned n,STREAM *stream)
{
	register unsigned int totalsize = size*n;
	int bytesread = 0;

	if(!size) return 0;
   if((stream->flag & MODETYPE) == F_WRITE) return 0;

	if(stream->position + totalsize > stream->limit)
		totalsize = stream->limit - stream->position;

	switch(stream->flag & FPTYPE) {
		case F_FDHANDLE:
         lseek(stream->handle.fd,stream->position + stream->base,SEEK_SET);
         bytesread += read(stream->handle.fd,buffer,totalsize);
         stream->position += bytesread;
			reload_streambuf(stream);
			break;
		case F_FPHANDLE:
			bytesread = fread(buffer,1,totalsize,stream->handle.fp);
			break;
		case F_MPHANDLE:
			memcpy(buffer,stream->handle.mp + stream->position + stream->base,totalsize);
			bytesread = totalsize;
			break;
	}

	if(!bytesread) stream->flag |= F_EOF;
	return bytesread / size;
}

/*
	int stream_write(void *buffer,unsigned size,unsigned n,STREAM *stream):
	Writes a size of bytes from the buffer to the stream
*/
int stream_write(void *buffer,unsigned size,unsigned n,STREAM *stream)
{
	register unsigned int totalsize = size*n;
	int byteswritten = 0;

	if(!size) return 0;
   if((stream->flag & MODETYPE) == F_READ) return 0;

	if((stream->position + totalsize) > stream->limit)
		totalsize = stream->limit - stream->position;

	switch(stream->flag & FPTYPE) {
		case F_FDHANDLE:
			flush_streambuf(stream);
			byteswritten = write(stream->handle.fd,buffer,totalsize);
			break;
		case F_FPHANDLE:
			byteswritten = fwrite(buffer,1,totalsize,stream->handle.fp);
			break;
		case F_MPHANDLE:
			memcpy(stream->handle.mp + stream->position + stream->base,buffer,totalsize);
			byteswritten = totalsize;
			break;
	}

   stream->position += byteswritten;
	if(!byteswritten) stream->flag |= F_EOF;
	return byteswritten / size;
}

/*
	int stream_seek(STREAM *stream,long offset,int whence):
	Updates the file position to offset relative to whence
*/
int stream_seek(STREAM *stream,long offset,int whence)
{
	int newpos = -1;
	switch(whence) {
		case SEEK_SET: newpos = offset + stream->base; break;
		case SEEK_CUR: newpos = stream->position + stream->base + offset; break;
		case SEEK_END:
			if((stream->flag & MODETYPE) == F_READ)
				newpos = stream_length(stream) + offset;
			else
				newpos = stream->position;
			break;
	}

	switch(stream->flag & FPTYPE) {
		case F_FDHANDLE:
			if(whence == SEEK_END)
				newpos = lseek(stream->handle.fd,offset,SEEK_END);
			else
				newpos = lseek(stream->handle.fd,newpos,SEEK_SET);

			stream->position = newpos - stream->base;
			reload_streambuf(stream);
			break;
		case F_FPHANDLE:
			newpos = fseek(stream->handle.fp,offset + (whence == SEEK_SET ? stream->base : 0),whence);
			stream->position = newpos - stream->base;
			break;
		case F_MPHANDLE:
			stream->position = newpos;
			break;
	}

	stream->flag &= ~F_EOF;
	return stream->position;
}

/*
	int stream_tell(STREAM *stream):
	Returns the current stream position
*/
int stream_tell(STREAM *stream)
{
	return stream->position;
}

/*
	int stream_length(STREAM *stream):
	Returns the length of the stream
*/
int stream_length(STREAM *stream)
{
	return stream->limit;
}

/*
	int stream_eof(STREAM *stream):
	Returns TRUE if it is the EOF of the stream, otherwise returns FALSE
*/
int stream_eof(STREAM *stream)
{
	return (stream->flag & F_EOF) == F_EOF;
}

/*
	int stream_flush(STREAM *stream):
	Flushes the stream
*/
int stream_flush(STREAM *stream)
{
	switch(stream->flag & FPTYPE) {
		case F_FDHANDLE:
			if((stream->flag & MODETYPE) == F_WRITE) flush_streambuf(stream);
			else reload_streambuf(stream);
			break;
		case F_FPHANDLE:
			return fflush(stream->handle.fp);
	}

	return 0;
}

/*
	dword stream_read_bitl(STREAM *stream,dword size):
	Reads size bits from the stream in MSB order
*/
dword stream_read_bitl(STREAM *stream,dword size)
{
	dword code;

	while(stream->bitsinbuf < size) {
		stream->bitbuffer <<= 8;
		stream->bitbuffer |= (byte)stream_getc(stream);
		stream->bitsinbuf += 8;
	}
	stream->bitsinbuf -= size;
	code = stream->bitbuffer >> stream->bitsinbuf;
	stream->bitbuffer &= ((1 << stream->bitsinbuf) - 1);
   code &= (1 << size) - 1;

	return code;
}

/*
	dword stream_read_bitr(STREAM *stream,dword size):
	Read size bits fromt the stream in LSB order
*/
dword stream_read_bitr(STREAM *stream,dword size)
{
	dword code;

	while(stream->bitsinbuf < size) {
		stream->bitbuffer |= (byte)stream_getc(stream) << stream->bitsinbuf;
		stream->bitsinbuf += 8;
	}
	stream->bitsinbuf -= size;
	code = stream->bitbuffer & ((1 << size) - 1);
	stream->bitbuffer >>= size;

   return code;
}

/*
	void stream_unread_bitl(STREAM *stream,dword code,dword size):
	Places bits back into the bitbuffer in MSB ordering
*/
void stream_unread_bitl(STREAM *stream,dword code,dword size)
{
	if(!size) return;

	code &= (1 << size) - 1;
	stream->bitbuffer |= (code << stream->bitsinbuf);
	stream->bitsinbuf += size;
}

/*
	void stream_unread_bitr(STREAM *stream,dword code,dword size):
	Places bits back into the bitbuffer in LSB ordering
*/
void stream_unread_bitr(STREAM *stream,dword code,dword size)
{
	if(!size) return;

	code &= (1 << size) - 1;
	stream->bitbuffer <<= size;
	stream->bitbuffer |= code;
	stream->bitsinbuf += size;
}

/*
	void stream_write_bitl(STREAM *stream,dword code,dword size):
	Writes size bits to the stream in MSB ordering
*/
void stream_write_bitl(STREAM *stream,dword code,dword size)
{
	code &= (1 << size) - 1;

	stream->bitbuffer = (stream->bitbuffer << size) | code;
	stream->bitsinbuf += size;
	while(stream->bitsinbuf >= 8) {
		stream->bitsinbuf -= 8;
		stream_putc(stream->bitbuffer >> stream->bitsinbuf,stream);
		stream->bitbuffer &= ((1 << stream->bitsinbuf) - 1);
	}
}

/*
	void stream_write_bitr(STREAM *stream,dword code,dword size):
	Writes size bits to the stream in LSB ordering
*/
void stream_write_bitr(STREAM *stream,dword code,dword size)
{
	code &= (1 << size) - 1;

	stream->bitbuffer |= code << stream->bitsinbuf;
	stream->bitsinbuf += size;
	while(stream->bitsinbuf >= 8){
		stream->bitsinbuf -= 8;
		stream_putc(stream->bitbuffer,stream);
		stream->bitbuffer = (stream->bitbuffer >> 8) & ((1 << stream->bitsinbuf) - 1);
	}
}

/*
	void stream_flush_write_bufferl(STREAM *stream):
	Flushes the remaining bytes out of the bitbuffer MSB
*/
void stream_flush_write_bufferl(STREAM *stream)
{
	if(stream->bitsinbuf > 0)
		stream_putc(stream->bitbuffer << (8 - stream->bitsinbuf),stream);
	stream->bitbuffer = stream->bitsinbuf = 0;
}

/*
	void stream_flush_write_bufferr(STREAM *stream):
	Flushes the remaining bytes out of the bitbuffer LSB
*/
void stream_flush_write_bufferr(STREAM *stream)
{
	if(stream->bitsinbuf > 0) stream_putc(stream->bitbuffer,stream);
	stream->bitbuffer = stream->bitsinbuf = 0;
}

/*
	dword stream_flush_read_buffer(STREAM *stream):
	Return the remaining bits left in the bitbuffer
*/
dword stream_flush_read_buffer(STREAM *stream)
{
	dword code;

	code = stream->bitbuffer;
	stream->bitbuffer = stream->bitsinbuf = 0;

   return code;
}

/*
	void reload_streambuf(STREAM *stream):
	Reloads the file buffer with data
*/
void reload_streambuf(STREAM *stream)
{
	if((stream->flag & FPTYPE) == F_FDHANDLE) {
		read(stream->handle.fd,stream->fdbuf,STREAM_BUF_SIZE);
		stream->bufpos = 0;
	}
}

/*
	void flush_streambuf(STREAM *stream):
	Write the file buffer to output
*/
void flush_streambuf(STREAM *stream)
{
	if((stream->flag & FPTYPE) == F_FDHANDLE) {
		write(stream->handle.fd,stream->fdbuf,stream->bufpos);
		stream->bufpos = 0;
	}
}