/*  *	HT Editor *	cstream.cc * *	Copyright (C) 1999-2002 Sebastian Biallas (sb@biallas.net) * *	This program is free software; you can redistribute it and/or modify *	it under the terms of the GNU General Public License version 2 as *	published by the Free Software Foundation. * *	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 "cstream.h"#include "htdebug.h"#include "except.h"#include "endianess.h"# ifdef USE_MINILZO#  include "minilzo/minilzo.h"# elif HAVE_LZO_LZO1X_H#  include <lzo/lzo1x.h># elif HAVE_LZO1X_H#  include <lzo1x.h># endif#include "tools.h"#include <string.h>CompressedStream::CompressedStream(Stream *stream, bool own_stream)	: StreamLayer(stream, own_stream){	if ((stream->getAccessMode() & (IOAM_READ | IOAM_WRITE)) == (IOAM_READ | IOAM_WRITE)) {		// ht_compressed_stream cant be used for read and write access simultaneously		assert(0);	}	bufferpos = 0;	buffersize = COMPRESSED_STREAM_DEFAULT_GRANULARITY;	buffer = ht_malloc(buffersize);}CompressedStream::~CompressedStream(){	if (getAccessMode() & IOAM_WRITE) {		flush_compressed();	}	free(buffer);}void CompressedStream::flush_compressed(){	if (bufferpos) {		byte cbuf[bufferpos + bufferpos / 64 + 16 + 3];		byte workbuf[LZO1X_1_MEM_COMPRESS];		lzo_uint cbuf_len;		byte n[4];		memset(workbuf, 0, sizeof workbuf);				lzo1x_1_compress(buffer, bufferpos, cbuf, &cbuf_len, workbuf);		createForeignInt(n, bufferpos, 4, big_endian);		mStream->writex(n, 4);		createForeignInt(n, cbuf_len, 4, big_endian);		mStream->writex(n, 4);		mStream->writex(cbuf, cbuf_len);		bufferpos = 0;	}}void CompressedStream::flush_uncompressed(){	if (bufferpos == 0) {		free(buffer);		buffer = NULL;		uint cbuf_len;		uint uncompressed_len;		byte n[4];		mStream->readx(n, 4);		uncompressed_len = createHostInt(n, 4, big_endian);		mStream->readx(n, 4);		cbuf_len = createHostInt(n, 4, big_endian);				if (!uncompressed_len || uncompressed_len > COMPRESSED_STREAM_DEFAULT_GRANULARITY		 || !cbuf_len || cbuf_len > 2*COMPRESSED_STREAM_DEFAULT_GRANULARITY) throw IOException(EIO);		buffer = ht_malloc(uncompressed_len);		byte cbuf[cbuf_len];		mStream->readx(cbuf, cbuf_len);		lzo_uint dummy = uncompressed_len;				lzo1x_decompress_safe(cbuf, cbuf_len, buffer, &dummy, NULL);		if (dummy != uncompressed_len) throw IOException(EIO);		buffersize = uncompressed_len;		bufferpos = uncompressed_len;          	}}uint CompressedStream::read(void *aBuf, uint size){	uint ssize = size;	byte *buf = (byte *)aBuf;	while (size >= bufferpos) {		memcpy(buf, buffer+buffersize-bufferpos, bufferpos);		buf += bufferpos;		size -= bufferpos;		bufferpos = 0;		if (size) {			try {				flush_uncompressed();			} catch (const EOFException &) {				return ssize - size;			}		} else break;	}	if (size) {		memcpy(buf, buffer+buffersize-bufferpos, size);		bufferpos -= size;	}	return ssize;}uint CompressedStream::write(const void *aBuf, uint size){	uint ssize = size;	const byte *buf = (const byte *)aBuf;	while (bufferpos+size >= buffersize) {		memcpy(buffer+bufferpos, buf, buffersize-bufferpos);		size -= buffersize-bufferpos;		buf += buffersize-bufferpos;		bufferpos = buffersize;		if (size) {			try {				flush_compressed();			} catch (const EOFException &) {				return ssize - size;			}		} else break;	}	if (size) {		memcpy(buffer+bufferpos, buf, size);		bufferpos += size;	}	return ssize;}