Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wxZlibStreams fixes; allow them to be used as deflate [de]compressor in gz/zip files (patch 792562)

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@23945 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2003-09-26 20:07:22 +00:00
parent 6bb7cee4e9
commit 0915d0b2e2
6 changed files with 222 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

239
src/common/zstream.cpp
View File

@@ -1,8 +1,8 @@
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// Name: zstream.cpp
// Purpose: Compressed stream classes
// Author: Guilhem Lavaux
// Modified by:
// Modified by: Mike Wetherell
// Created: 11/07/98
// RCS-ID: $Id$
// Copyright: (c) Guilhem Lavaux
@@ -37,34 +37,46 @@
#include "zlib.h"
#endif
#define ZSTREAM_BUFFER_SIZE 1024
enum {
#ifdef __WIN16__
ZSTREAM_BUFFER_SIZE = 4096
#else
ZSTREAM_BUFFER_SIZE = 16384
#endif
};
//////////////////////
// wxZlibInputStream
//////////////////////
wxZlibInputStream::wxZlibInputStream(wxInputStream& stream)
wxZlibInputStream::wxZlibInputStream(wxInputStream& stream, int flags)
: wxFilterInputStream(stream)
{
// I need a private stream buffer.
m_inflate = new z_stream_s;
m_inflate->zalloc = (alloc_func)0;
m_inflate->zfree = (free_func)0;
m_inflate->opaque = (voidpf)0;
int err = inflateInit(m_inflate);
if (err != Z_OK) {
inflateEnd(m_inflate);
delete m_inflate;
return;
}
m_inflate = NULL;
m_z_buffer = new unsigned char[ZSTREAM_BUFFER_SIZE];
m_z_size = ZSTREAM_BUFFER_SIZE;
m_pos = 0;
m_inflate->avail_in = 0;
m_inflate->next_in = NULL;
if (m_z_buffer) {
m_inflate = new z_stream_s;
if (m_inflate) {
m_inflate->zalloc = (alloc_func)0;
m_inflate->zfree = (free_func)0;
m_inflate->opaque = (voidpf)0;
m_inflate->avail_in = 0;
m_inflate->next_in = NULL;
m_inflate->next_out = NULL;
int bits = (flags & wxZLIB_NO_HEADER) ? -MAX_WBITS : MAX_WBITS;
if (inflateInit2(m_inflate, bits) == Z_OK)
return;
}
}
wxLogError(_("Can't initialize zlib inflate stream."));
m_lasterror = wxSTREAM_READ_ERROR;
}
wxZlibInputStream::~wxZlibInputStream()
@@ -77,150 +89,175 @@ wxZlibInputStream::~wxZlibInputStream()
size_t wxZlibInputStream::OnSysRead(void *buffer, size_t size)
{
int err;
wxASSERT_MSG(m_inflate && m_z_buffer, wxT("Inflate stream not open"));
if (!m_inflate || !m_z_buffer)
m_lasterror = wxSTREAM_READ_ERROR;
if (!IsOk() || !size)
return 0;
int err = Z_OK;
m_inflate->next_out = (unsigned char *)buffer;
m_inflate->avail_out = size;
while (m_inflate->avail_out > 0) {
while (err == Z_OK && m_inflate->avail_out > 0) {
if (m_inflate->avail_in == 0) {
m_parent_i_stream->Read(m_z_buffer, wxMin(m_z_size, size));
m_parent_i_stream->Read(m_z_buffer, m_z_size);
m_inflate->next_in = m_z_buffer;
m_inflate->avail_in = m_parent_i_stream->LastRead();
wxStreamError err = m_parent_i_stream->GetLastError();
if ( err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF)
{
m_lasterror = err;
return 0; // failed to read anything
}
if ( m_inflate->avail_in == 0 )
{
// EOF
m_lasterror = wxSTREAM_EOF;
break;
if (m_inflate->avail_in == 0) {
if (m_parent_i_stream->Eof())
wxLogError(_("Can't read inflate stream: unexpected EOF in underlying stream."));
m_lasterror = wxSTREAM_READ_ERROR;
break;
}
}
err = inflate(m_inflate, Z_FINISH);
if (err == Z_STREAM_END)
return (size - m_inflate->avail_out);
err = inflate(m_inflate, Z_NO_FLUSH);
}
return size-m_inflate->avail_out;
if (err == Z_STREAM_END) {
// Unread any data taken from past the end of the deflate stream, so that
// any additional data can be read from the underlying stream (the crc
// in a gzip for example)
if (m_inflate->avail_in) {
m_parent_i_stream->Ungetch(m_inflate->next_in, m_inflate->avail_in);
m_inflate->avail_in = 0;
}
m_lasterror = wxSTREAM_EOF;
} else if (err != Z_OK) {
wxLogError(_("Can't read from inflate stream (zlib error %d)."), err);
m_lasterror = wxSTREAM_READ_ERROR;
}
size -= m_inflate->avail_out;
m_pos += size;
return size;
}
//////////////////////
// wxZlibOutputStream
//////////////////////
wxZlibOutputStream::wxZlibOutputStream(wxOutputStream& stream, int level)
wxZlibOutputStream::wxZlibOutputStream(wxOutputStream& stream,
int level,
int flags)
: wxFilterOutputStream(stream)
{
int err;
m_deflate = new z_stream_s;
m_deflate->zalloc = (alloc_func)0;
m_deflate->zfree = (free_func)0;
m_deflate->opaque = (voidpf)0;
m_deflate = NULL;
m_z_buffer = new unsigned char[ZSTREAM_BUFFER_SIZE];
m_z_size = ZSTREAM_BUFFER_SIZE;
m_pos = 0;
if ( level == -1 )
{
level = Z_DEFAULT_COMPRESSION;
level = Z_DEFAULT_COMPRESSION;
}
else
{
wxASSERT_MSG(level >= 0 && level <= 9, wxT("wxZlibOutputStream compression level must be between 0 and 9!"));
}
err = deflateInit(m_deflate, level);
if (err != Z_OK) {
deflateEnd(m_deflate);
return;
if (m_z_buffer) {
m_deflate = new z_stream_s;
if (m_deflate) {
m_deflate->zalloc = (alloc_func)0;
m_deflate->zfree = (free_func)0;
m_deflate->opaque = (voidpf)0;
m_deflate->avail_in = 0;
m_deflate->next_out = m_z_buffer;
m_deflate->avail_out = m_z_size;
int bits = (flags & wxZLIB_NO_HEADER) ? -MAX_WBITS : MAX_WBITS;
if (deflateInit2(m_deflate, level, Z_DEFLATED, bits,
8, Z_DEFAULT_STRATEGY) == Z_OK)
return;
}
}
m_z_buffer = new unsigned char[ZSTREAM_BUFFER_SIZE];
m_z_size = ZSTREAM_BUFFER_SIZE;
m_deflate->avail_in = 0;
m_deflate->next_out = m_z_buffer;
m_deflate->avail_out = m_z_size;
wxLogError(_("Can't initialize zlib deflate stream."));
m_lasterror = wxSTREAM_WRITE_ERROR;
}
wxZlibOutputStream::~wxZlibOutputStream()
{
int err;
Sync();
err = deflate(m_deflate, Z_FINISH);
if (err != Z_STREAM_END)
{
wxLogDebug( wxT("wxZlibOutputStream: an error occured while closing the stream.\n") );
return;
}
if (m_deflate && m_z_buffer)
DoFlush(true);
deflateEnd(m_deflate);
delete m_deflate;
delete[] m_z_buffer;
}
void wxZlibOutputStream::Sync()
void wxZlibOutputStream::DoFlush(bool final)
{
int err;
wxASSERT_MSG(m_deflate && m_z_buffer, wxT("Deflate stream not open"));
m_parent_o_stream->Write(m_z_buffer, m_z_size-m_deflate->avail_out);
m_deflate->next_out = m_z_buffer;
m_deflate->avail_out = m_z_size;
err = deflate(m_deflate, Z_FULL_FLUSH);
if (err != Z_OK) {
if (!m_deflate || !m_z_buffer)
m_lasterror = wxSTREAM_WRITE_ERROR;
if (!IsOk())
return;
}
// Fixed by "Stefan Csomor" <csomor@advancedconcepts.ch>
while( m_deflate->avail_out == 0 )
{
m_parent_o_stream->Write(m_z_buffer, m_z_size );
m_deflate->next_out = m_z_buffer;
m_deflate->avail_out = m_z_size;
err = deflate(m_deflate, Z_FULL_FLUSH);
if (err != Z_OK) {
return;
}
}
// End
int err = Z_OK;
bool done = false;
m_parent_o_stream->Write(m_z_buffer, m_z_size-m_deflate->avail_out);
m_deflate->next_out = m_z_buffer;
m_deflate->avail_out = m_z_size;
while (err == Z_OK || err == Z_STREAM_END) {
size_t len = m_z_size - m_deflate->avail_out;
if (len) {
if (m_parent_o_stream->Write(m_z_buffer, len).LastWrite() != len) {
m_lasterror = wxSTREAM_WRITE_ERROR;
wxLogDebug(wxT("wxZlibOutputStream: Error writing to underlying stream"));
break;
}
m_deflate->next_out = m_z_buffer;
m_deflate->avail_out = m_z_size;
}
if (done)
break;
err = deflate(m_deflate, final ? Z_FINISH : Z_FULL_FLUSH);
done = m_deflate->avail_out != 0 || err == Z_STREAM_END;
}
}
size_t wxZlibOutputStream::OnSysWrite(const void *buffer, size_t size)
{
int err;
wxASSERT_MSG(m_deflate && m_z_buffer, wxT("Deflate stream not open"));
if (!m_deflate || !m_z_buffer)
m_lasterror = wxSTREAM_WRITE_ERROR;
if (!IsOk() || !size)
return 0;
int err = Z_OK;
m_deflate->next_in = (unsigned char *)buffer;
m_deflate->avail_in = size;
while (m_deflate->avail_in > 0) {
while (err == Z_OK && m_deflate->avail_in > 0) {
if (m_deflate->avail_out == 0) {
m_parent_o_stream->Write(m_z_buffer, m_z_size);
if ( !*m_parent_o_stream )
return (size - m_deflate->avail_in);
if (m_parent_o_stream->LastWrite() != m_z_size) {
m_lasterror = wxSTREAM_WRITE_ERROR;
wxLogDebug(wxT("wxZlibOutputStream: Error writing to underlying stream"));
break;
}
m_deflate->next_out = m_z_buffer;
m_deflate->avail_out = m_z_size;
}
err = deflate(m_deflate, Z_NO_FLUSH);
if (err != Z_OK)
return (size - m_deflate->avail_in);
}
if (err != Z_OK) {
m_lasterror = wxSTREAM_WRITE_ERROR;
wxLogError(_("Can't write to deflate stream (zlib error %d)."), err);
}
size -= m_deflate->avail_in;
m_pos += size;
return size;
}