From 74c8b349ffebfedd9dff54253308a12491f76682 Mon Sep 17 00:00:00 2001 From: David Rose Date: Sat, 19 Oct 2002 02:28:59 +0000 Subject: [PATCH] use zStreamBuf to handle compression/decompression interface --- panda/src/downloader/Sources.pp | 7 +- panda/src/downloader/decompressor.I | 19 - panda/src/downloader/decompressor.cxx | 439 +++++++----------- panda/src/downloader/decompressor.h | 60 +-- .../src/downloader/downloader_composite4.cxx | 1 - panda/src/downloader/zcompressor.I | 95 ---- panda/src/downloader/zcompressor.cxx | 242 ---------- panda/src/downloader/zcompressor.h | 90 ---- panda/src/downloadertools/pcompress.cxx | 76 +-- panda/src/downloadertools/pdecompress.cxx | 19 +- 10 files changed, 216 insertions(+), 832 deletions(-) delete mode 100644 panda/src/downloader/zcompressor.I delete mode 100644 panda/src/downloader/zcompressor.cxx delete mode 100644 panda/src/downloader/zcompressor.h diff --git a/panda/src/downloader/Sources.pp b/panda/src/downloader/Sources.pp index 2205a313e3..955cee2df1 100644 --- a/panda/src/downloader/Sources.pp +++ b/panda/src/downloader/Sources.pp @@ -26,7 +26,7 @@ socketStream.h socketStream.I \ urlSpec.I urlSpec.h \ $[if $[HAVE_NET], downloadDb.I downloadDb.h downloader.I downloader.h] \ - $[if $[HAVE_ZLIB], decompressor.h zcompressor.I zcompressor.h download_utils.h] \ + $[if $[HAVE_ZLIB], decompressor.h download_utils.h] \ $[if $[HAVE_CRYPTO], patcher.cxx patcher.h patcher.I] #define INCLUDED_SOURCES \ @@ -43,7 +43,7 @@ multiplexStream.cxx multiplexStreamBuf.cxx \ urlSpec.cxx \ $[if $[HAVE_NET], downloadDb.cxx downloader.cxx] \ - $[if $[HAVE_ZLIB], decompressor.cxx zcompressor.cxx download_utils.cxx] + $[if $[HAVE_ZLIB], decompressor.cxx download_utils.cxx] #define INSTALL_HEADERS \ asyncUtility.h asyncUtility.I \ @@ -63,8 +63,7 @@ multiplexStreamBuf.I multiplexStreamBuf.I \ patcher.h patcher.I \ socketStream.h socketStream.I \ - urlSpec.h urlSpec.I \ - zcompressor.I zcompressor.h + urlSpec.h urlSpec.I #define IGATESCAN all diff --git a/panda/src/downloader/decompressor.I b/panda/src/downloader/decompressor.I index a5c41820dd..6b12b78def 100644 --- a/panda/src/downloader/decompressor.I +++ b/panda/src/downloader/decompressor.I @@ -15,22 +15,3 @@ // panda3d@yahoogroups.com . // //////////////////////////////////////////////////////////////////// - -#include "config_downloader.h" - -//////////////////////////////////////////////////////////////////// -// Function: Decompressor::get_progress -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -INLINE float Decompressor:: -get_progress(void) const { - if (_initiated == false) { - downloader_cat.warning() - << "Decompressor::get_progress() - Decompression has not been " - << "initiated" << endl; - return 0.0; - } - nassertr(_source_file_length > 0, 0.0); - return ((float)_total_bytes_read / (float)_source_file_length); -} diff --git a/panda/src/downloader/decompressor.cxx b/panda/src/downloader/decompressor.cxx index c1e2134f57..df903417b3 100644 --- a/panda/src/downloader/decompressor.cxx +++ b/panda/src/downloader/decompressor.cxx @@ -18,69 +18,27 @@ // This file is compiled only if we have zlib installed. -//////////////////////////////////////////////////////////////////// -// Includes -//////////////////////////////////////////////////////////////////// - #include "config_downloader.h" +#include "error_utils.h" +#include "filename.h" +#include "zStream.h" + +#include "decompressor.h" + #include #include -#include -#include - -#include "decompressor.h" - - -//////////////////////////////////////////////////////////////////// -// Defines -//////////////////////////////////////////////////////////////////// - //////////////////////////////////////////////////////////////////// // Function: Decompressor::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// Decompressor:: -Decompressor(void) { - if (downloader_cat.is_debug()) - downloader_cat.debug() - << "Decompressor::constructor() - Creating buffer of size: " - << decompressor_buffer_size << endl; - PT(Buffer) buffer = new Buffer(decompressor_buffer_size); - init(buffer); -} - -//////////////////////////////////////////////////////////////////// -// Function: Decompressor::Constructor -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -Decompressor:: -Decompressor(PT(Buffer) buffer) { - init(buffer); -} - -//////////////////////////////////////////////////////////////////// -// Function: Decompressor::Constructor -// Access: Private -// Description: -//////////////////////////////////////////////////////////////////// -void Decompressor:: -init(PT(Buffer) buffer) { - if (downloader_cat.is_debug()) - downloader_cat.debug() - << "Decompressor constructor called" << endl; - _initiated = false; - nassertv(!buffer.is_null()); - _half_buffer_length = buffer->get_length()/2; - _buffer = buffer; - char *temp_name = tempnam(NULL, "dc"); - _temp_file_name = temp_name; - _temp_file_name.set_binary(); - delete temp_name; - _decompressor = new ZDecompressor(); +Decompressor() { + _source = NULL; + _decompress = NULL; + _dest = NULL; } //////////////////////////////////////////////////////////////////// @@ -89,267 +47,208 @@ init(PT(Buffer) buffer) { // Description: //////////////////////////////////////////////////////////////////// Decompressor:: -~Decompressor(void) { - if (downloader_cat.is_debug()) - downloader_cat.debug() - << "Decompressor destructor called" << endl; - _temp_file_name.unlink(); - if (_initiated == true) - cleanup(); +~Decompressor() { + cleanup(); } //////////////////////////////////////////////////////////////////// // Function: Decompressor::initiate // Access: Public -// Description: +// Description: Begins a background decompression of the named file +// (whose filename must end in ".pz") to a new file +// without the .pz extension. The source file is +// removed after successful completion. //////////////////////////////////////////////////////////////////// int Decompressor:: -initiate(Filename &source_file) { - Filename dest_file = source_file; +initiate(const Filename &source_file) { string extension = source_file.get_extension(); - if (extension == "pz") + if (extension == "pz") { + Filename dest_file = source_file; dest_file = source_file.get_fullpath_wo_extension(); - else { - if (downloader_cat.is_debug()) - downloader_cat.debug() - << "Decompressor::request_decompress() - Unknown file extension: ." - << extension << endl; - return EU_error_abort; - } - return initiate(source_file, dest_file); -} - -//////////////////////////////////////////////////////////////////// -// Function: Decompressor::initiate -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -int Decompressor:: -initiate(Filename &source_file, Filename &dest_file) { - - if (_initiated == true) { - downloader_cat.error() - << "Decompressor::initiate() - Decompression has already been initiated" - << endl; - return EU_error_abort; + return initiate(source_file, dest_file); } - // Open source file - _source_file = source_file; - _source_file.set_binary(); - if (!_source_file.open_read(_read_stream)) { - downloader_cat.error() - << "Decompressor::initiate() - Error opening source file: " - << _source_file << " : " << strerror(errno) << endl; - return get_write_error(); - } - - // Determine source file length - _read_stream.seekg(0, ios::end); - _source_file_length = _read_stream.tellg(); - if (_source_file_length == 0) { - downloader_cat.warning() - << "Decompressor::initiate() - Zero length file: " - << source_file << " : " << strerror(errno) << endl; - return get_write_error(); - } - _read_stream.seekg(0, ios::beg); - - // Open destination file - dest_file.set_binary(); - if (!dest_file.open_write(_write_stream)) { - downloader_cat.error() - << "Decompressor::initiate() - Error opening dest file: " - << source_file << " : " << strerror(errno) << endl; - return get_write_error(); - } - - // Read from the source file into the first half of the buffer, - // decompress into the second half of the buffer, write the second - // half of the buffer to disk, and repeat. - _total_bytes_read = 0; - _read_all_input = false; - _source_buffer_length = 0; - _initiated = true; - _decompressor = new ZDecompressor(); - _decompress_to_ram = false; - return EU_success; -} - -//////////////////////////////////////////////////////////////////// -// Function: Decompressor::initiate -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -int Decompressor:: -initiate(Ramfile &source_file) { - - if (_initiated == true) { - downloader_cat.error() - << "Decompressor::initiate() - Decompression has already been initiated" - << endl; - return EU_error_abort; - } - - // Open source file - _read_string_stream = new istringstream(source_file._data); - - // Determine source file length - _source_file_length = source_file._data.length(); - if (_source_file_length == 0) { - downloader_cat.warning() - << "Decompressor::initiate() - Zero length file: " - << strerror(errno) << endl; - return get_write_error(); - } - - // Open destination file - _write_string_stream = new ostringstream(); - - // Read from the source file into the first half of the buffer, - // decompress into the second half of the buffer, write the second - // half of the buffer to disk, and repeat. - _total_bytes_read = 0; - _read_all_input = false; - _source_buffer_length = 0; - _initiated = true; - _decompressor = new ZDecompressor(); - _decompress_to_ram = true; - return EU_success; -} - -//////////////////////////////////////////////////////////////////// -// Function: Decompressor::cleanup -// Access: Private -// Description: -//////////////////////////////////////////////////////////////////// -void Decompressor:: -cleanup(void) { - if (downloader_cat.is_debug()) + if (downloader_cat.is_debug()) { downloader_cat.debug() - << "Decompressor cleanup called" << endl; - if (_initiated == false) { + << "Unknown file extension for decompressor: ." + << extension << endl; + } + return EU_error_abort; +} + +//////////////////////////////////////////////////////////////////// +// Function: Decompressor::initiate +// Access: Public +// Description: Begins a background decompression from the named +// source file to the named destination file. The +// source file is removed after successful completion. +//////////////////////////////////////////////////////////////////// +int Decompressor:: +initiate(const Filename &source_file, const Filename &dest_file) { + cleanup(); + + // Open source file + _source_filename = Filename(source_file); + _source_filename.set_binary(); + + ifstream *source_fstream = new ifstream; + _source = source_fstream; + if (!_source_filename.open_read(*source_fstream)) { downloader_cat.error() - << "Decompressor::cleanup() - Decompression has not been " - << "initiated" << endl; - return; + << "Unable to read " << _source_filename << "\n"; + return get_write_error(); } - _initiated = false; - delete _decompressor; - _decompressor = NULL; - _read_stream.close(); - _write_stream.close(); - if (_decompress_to_ram == false) - _source_file.unlink(); + // Determine source file length + source_fstream->seekg(0, ios::end); + _source_length = source_fstream->tellg(); + if (_source_length == 0) { + downloader_cat.warning() + << "Zero length file: " << source_file << "\n"; + return EU_error_file_empty; + } + source_fstream->seekg(0, ios::beg); + + // Open destination file + Filename dest_filename(dest_file); + dest_filename.set_binary(); + + ofstream *dest_fstream = new ofstream; + _dest = dest_fstream; + if (!dest_filename.open_write(*dest_fstream)) { + downloader_cat.error() + << "Unable to write to " << dest_filename << "\n"; + return get_write_error(); + } + + // Now create the decompressor stream. + _decompress = new IDecompressStream(_source, false); + return EU_success; } //////////////////////////////////////////////////////////////////// // Function: Decompressor::run // Access: Public -// Description: +// Description: Called each frame to do the next bit of work in the +// background task. Returns EU_ok if a chunk is +// completed but there is more to go, or EU_success when +// we're all done. Any other return value indicates an +// error. //////////////////////////////////////////////////////////////////// int Decompressor:: -run(void) { - if (_initiated == false) { - downloader_cat.error() - << "Decompressor::run() - Decompression has not been initiated" - << endl; - return EU_error_abort; +run() { + if (_decompress == (istream *)NULL) { + // Hmm, we were already done. + return EU_success; } - - // See if there is anything left in the source file - if (_read_all_input == false) { - if (_decompress_to_ram == false) { - _read_stream.read(_buffer->_buffer, _half_buffer_length); - _source_buffer_length = _read_stream.gcount(); - _total_bytes_read += _source_buffer_length; - if (_read_stream.eof()) { - nassertr(_total_bytes_read == _source_file_length, false); - _read_all_input = true; - } - } else { - _read_string_stream->read(_buffer->_buffer, _half_buffer_length); - _source_buffer_length = _read_string_stream->gcount(); - _total_bytes_read += _source_buffer_length; - if (_read_string_stream->eof()) { - nassertr(_total_bytes_read == _source_file_length, false); - _read_all_input = true; - } + + // Read a bunch of characters from the decompress stream, but no + // more than decompressor_buffer_size. + int count = 0; + int ch = _decompress->get(); + while (!_decompress->eof() && !_decompress->fail()) { + _dest->put(ch); + if (++count >= decompressor_buffer_size) { + // That's enough for now. + return EU_ok; } + + ch = _decompress->get(); } - char *next_in = _buffer->_buffer; - int avail_in = _source_buffer_length; - char *dest_buffer = _buffer->_buffer + _source_buffer_length; - char *next_out = dest_buffer; - int dest_buffer_length = _buffer->get_length() - _source_buffer_length; - int avail_out = dest_buffer_length; - nassertr(avail_out > 0 && avail_in > 0, false); - - while (avail_in > 0) { - int ret; - if (_decompress_to_ram == false) - ret = _decompressor->decompress_to_stream(next_in, avail_in, - next_out, avail_out, dest_buffer, - dest_buffer_length, _write_stream); - else - ret = _decompressor->decompress_to_stream(next_in, avail_in, - next_out, avail_out, dest_buffer, - dest_buffer_length, *_write_string_stream); - if (ret == ZCompressorBase::S_error) - return EU_error_zlib; - if ((int)_decompressor->get_total_in() == _source_file_length && - avail_out == dest_buffer_length) { - cleanup(); - return EU_success; - } - } - - return EU_ok; + // All done! + cleanup(); + _source_filename.unlink(); + return EU_success; } //////////////////////////////////////////////////////////////////// // Function: Decompressor::decompress // Access: Public -// Description: +// Description: Performs a foreground decompression of the named +// file; does not return until the decompression is +// complete. //////////////////////////////////////////////////////////////////// bool Decompressor:: -decompress(Filename &source_file) { +decompress(const Filename &source_file) { int ret = initiate(source_file); if (ret < 0) return false; - for (;;) { - ret = run(); - if (ret == EU_success) - return true; - else if (ret < 0) - return false; + + int ch = _decompress->get(); + while (!_decompress->eof() && !_decompress->fail()) { + _dest->put(ch); + ch = _decompress->get(); } - return false; + + cleanup(); + return true; } //////////////////////////////////////////////////////////////////// // Function: Decompressor::decompress // Access: Public -// Description: +// Description: Does an in-memory decompression of the indicated +// Ramfile. The decompressed contents are written back +// into the same Ramfile on completion. //////////////////////////////////////////////////////////////////// bool Decompressor:: -decompress(Ramfile &source_file) { - int ret = initiate(source_file); - if (ret < 0) - return false; - for (;;) { - ret = run(); - if (ret == EU_success) { - source_file._data = _write_string_stream->str(); - delete _read_string_stream; - _read_string_stream = NULL; - delete _write_string_stream; - _write_string_stream = NULL; - return true; - } else if (ret < 0) - return false; +decompress(Ramfile &source_and_dest_file) { + istringstream source(source_and_dest_file._data); + ostringstream dest; + + IDecompressStream decompress(&source, false); + + int ch = decompress.get(); + while (!decompress.eof() && !decompress.fail()) { + dest.put(ch); + ch = decompress.get(); + } + + source_and_dest_file._pos = 0; + source_and_dest_file._data = dest.str(); + return true; +} + +//////////////////////////////////////////////////////////////////// +// Function: Decompressor::get_progress +// Access: Public +// Description: Returns the ratio through the decompression step +// in the background. +//////////////////////////////////////////////////////////////////// +float Decompressor:: +get_progress() const { + if (_decompress == (istream *)NULL) { + // Hmm, we were already done. + return 1.0f; + } + + nassertr(_source_length > 0, 0.0); + size_t source_pos = _source->tellg(); + + // We stop the scale at 0.99 because there may be a little bit more + // to do even after the decompressor has read all of the source. + return (0.99f * (float)source_pos / (float)_source_length); +} + +//////////////////////////////////////////////////////////////////// +// Function: Decompressor::cleanup +// Access: Private +// Description: Called to reset a previous decompressor state and +// clean up properly. +//////////////////////////////////////////////////////////////////// +void Decompressor:: +cleanup() { + if (_source != (istream *)NULL) { + delete _source; + _source = NULL; + } + if (_dest != (ostream *)NULL) { + delete _dest; + _dest = NULL; + } + if (_decompress != (istream *)NULL) { + delete _decompress; + _decompress = NULL; } - return false; } diff --git a/panda/src/downloader/decompressor.h b/panda/src/downloader/decompressor.h index db3ff39619..0dd4744bca 100644 --- a/panda/src/downloader/decompressor.h +++ b/panda/src/downloader/decompressor.h @@ -15,59 +15,45 @@ // panda3d@yahoogroups.com . // //////////////////////////////////////////////////////////////////// + #ifndef DECOMPRESSOR_H #define DECOMPRESSOR_H -// -//////////////////////////////////////////////////////////////////// -// Includes -//////////////////////////////////////////////////////////////////// -#include -#include -#include -#include -#include "zcompressor.h" + +#include "pandabase.h" +#include "filename.h" + +class Ramfile; //////////////////////////////////////////////////////////////////// // Class : Decompressor -// Description : +// Description : This manages run-time decompression of a +// zlib-compressed stream, as a background or foreground +// task. //////////////////////////////////////////////////////////////////// class EXPCL_PANDAEXPRESS Decompressor { PUBLISHED: - Decompressor(void); - Decompressor(PT(Buffer) buffer); - virtual ~Decompressor(void); + Decompressor(); + ~Decompressor(); - int initiate(Filename &source_file); - int initiate(Filename &source_file, Filename &dest_file); - int initiate(Ramfile &source_file); - int run(void); + int initiate(const Filename &source_file); + int initiate(const Filename &source_file, const Filename &dest_file); + int run(); - bool decompress(Filename &source_file); - bool decompress(Ramfile &source_file); + bool decompress(const Filename &source_file); + bool decompress(Ramfile &source_and_dest_file); - INLINE float get_progress(void) const; + float get_progress() const; private: - void init(PT(Buffer) buffer); void cleanup(void); - bool _initiated; - PT(Buffer) _buffer; - int _half_buffer_length; - Filename _temp_file_name; + Filename _source_filename; + + istream *_source; + istream *_decompress; + ostream *_dest; - Filename _source_file; - ifstream _read_stream; - ofstream _write_stream; - istringstream *_read_string_stream; - ostringstream *_write_string_stream; - int _source_file_length; - int _total_bytes_read; - bool _read_all_input; - bool _handled_all_input; - int _source_buffer_length; - ZDecompressor *_decompressor; - bool _decompress_to_ram; + size_t _source_length; }; #include "decompressor.I" diff --git a/panda/src/downloader/downloader_composite4.cxx b/panda/src/downloader/downloader_composite4.cxx index e1e6ed00d8..82a2191e19 100644 --- a/panda/src/downloader/downloader_composite4.cxx +++ b/panda/src/downloader/downloader_composite4.cxx @@ -1,4 +1,3 @@ #include "download_utils.cxx" #include "decompressor.cxx" -#include "zcompressor.cxx" diff --git a/panda/src/downloader/zcompressor.I b/panda/src/downloader/zcompressor.I deleted file mode 100644 index 7d248d9624..0000000000 --- a/panda/src/downloader/zcompressor.I +++ /dev/null @@ -1,95 +0,0 @@ -// Filename: zcompressor.I -// Created by: mike (09Jan97) -// -//////////////////////////////////////////////////////////////////// -// -// PANDA 3D SOFTWARE -// Copyright (c) 2001, Disney Enterprises, Inc. All rights reserved -// -// All use of this software is subject to the terms of the Panda 3d -// Software license. You should have received a copy of this license -// along with this source code; you will also find a current copy of -// the license at http://www.panda3d.org/license.txt . -// -// To contact the maintainers of this program write to -// panda3d@yahoogroups.com . -// -//////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////// -// Function: ZCompressorBase::get_total_in -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -INLINE ulong ZCompressorBase:: -get_total_in(void) const { - return (_stream->total_in); -} - -//////////////////////////////////////////////////////////////////// -// Function: ZCompressorBase::get_total_out -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -INLINE ulong ZCompressorBase:: -get_total_out(void) const { - return (_stream->total_out); -} - -//////////////////////////////////////////////////////////////////// -// Function: ZCompressorBase::reset -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -INLINE void ZCompressorBase:: -reset(void) { - reset_stream(_stream); -} - -//////////////////////////////////////////////////////////////////// -// Function: ZCompressorBase::reset_stream -// Access: Private -// Description: -//////////////////////////////////////////////////////////////////// -INLINE void ZCompressorBase:: -reset_stream(z_stream *strm) const { - strm->next_in = Z_NULL; - strm->avail_in = 0; - strm->total_in = 0; - strm->next_out = Z_NULL; - strm->avail_out = 0; - strm->total_out = 0; - strm->zalloc = Z_NULL; - strm->zfree = Z_NULL; - strm->opaque = Z_NULL; -} - -#ifndef CPPPARSER -//////////////////////////////////////////////////////////////////// -// Function: ZCompressorBase::put_stream -// Access: Private -// Description: -//////////////////////////////////////////////////////////////////// -INLINE void ZCompressorBase:: -put_stream(z_stream *strm, char *next_in, int avail_in, char *next_out, - int avail_out) const { - strm->next_in = (uchar *)next_in; - strm->avail_in = (ulong)avail_in; - strm->next_out = (uchar *)next_out; - strm->avail_out = (ulong)avail_out; -} - -//////////////////////////////////////////////////////////////////// -// Function: ZCompressorBase::get_stream -// Access: Private -// Description: -//////////////////////////////////////////////////////////////////// -INLINE void ZCompressorBase:: -get_stream(z_stream *strm, char *&next_in, int &avail_in, char *&next_out, - int &avail_out) const { - next_in = (char *)strm->next_in; - avail_in = (int)strm->avail_in; - next_out = (char *)strm->next_out; - avail_out = (int)strm->avail_out; -} -#endif diff --git a/panda/src/downloader/zcompressor.cxx b/panda/src/downloader/zcompressor.cxx deleted file mode 100644 index cfb42af077..0000000000 --- a/panda/src/downloader/zcompressor.cxx +++ /dev/null @@ -1,242 +0,0 @@ -// Filename: zcompressor.cxx -// Created by: mike (09Jan97) -// -//////////////////////////////////////////////////////////////////// -// -// PANDA 3D SOFTWARE -// Copyright (c) 2001, Disney Enterprises, Inc. All rights reserved -// -// All use of this software is subject to the terms of the Panda 3d -// Software license. You should have received a copy of this license -// along with this source code; you will also find a current copy of -// the license at http://www.panda3d.org/license.txt . -// -// To contact the maintainers of this program write to -// panda3d@yahoogroups.com . -// -//////////////////////////////////////////////////////////////////// - -// This file is compiled only if we have zlib installed. - -//////////////////////////////////////////////////////////////////// -// Includes -//////////////////////////////////////////////////////////////////// - -#include "config_downloader.h" -#include -#include "zcompressor.h" - -//////////////////////////////////////////////////////////////////// -// Defines -//////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////// -// Function: ZCompressor::Constructor -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -ZCompressor:: -ZCompressor(void) { - if (downloader_cat.is_debug()) - downloader_cat.debug() - << "ZCompressor constructor called" << endl; - _stream = new z_stream; - reset_stream(_stream); - int ret = deflateInit(_stream, 9); - if (ret == Z_OK) - downloader_cat.debug() - << "ZCompressor::ZCompressor() - Zlib deflate initialized" << endl; - else - handle_zerror(ret, _stream); -} - -//////////////////////////////////////////////////////////////////// -// Function: ZCompressor::Destructor -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -ZCompressor:: -~ZCompressor(void) { - if (downloader_cat.is_debug()) - downloader_cat.debug() - << "ZCompressor destructor called" << endl; - handle_zerror(deflateEnd(_stream), _stream); - delete _stream; -} - -//////////////////////////////////////////////////////////////////// -// Function: ZCompressor::compress -// Access: Public -// Description: Compress from next_in into next_out until avail_in -// is 0 or avail_out is 0 or an error occurs. -//////////////////////////////////////////////////////////////////// -int ZCompressor:: -compress(char *&next_in, int &avail_in, char *&next_out, int &avail_out, - bool finish) { - - int fin_flag = (finish == true) ? Z_FINISH : Z_NO_FLUSH; - - put_stream(_stream, next_in, avail_in, next_out, avail_out); - int ret = handle_zerror(deflate(_stream, fin_flag), _stream); - get_stream(_stream, next_in, avail_in, next_out, avail_out); - - return ret; -} - -//////////////////////////////////////////////////////////////////// -// Function: ZCompressor::compress_to_stream -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -int ZCompressor:: -compress_to_stream(char *&next_in, int &avail_in, char *&next_out, - int &avail_out, char *out_buffer, - int out_buffer_length, ofstream &write_stream, - bool finish) { - int ret = compress(next_in, avail_in, next_out, avail_out, finish); - if (ret == S_error) - return ret; - - // See if there is any output to write - int out_bytes = out_buffer_length - avail_out; - if (out_bytes > 0) { - write_stream.write(out_buffer, out_bytes); - next_out = out_buffer; - avail_out = out_buffer_length; - } - - return ret; -} - -//////////////////////////////////////////////////////////////////// -// Function: ZDecompressor::Constructor -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -ZDecompressor:: -ZDecompressor(void) { - if (downloader_cat.is_debug()) - downloader_cat.debug() - << "ZDecompressor constructor called" << endl; - _stream = new z_stream; - reset_stream(_stream); - int ret = inflateInit(_stream); - if (ret == Z_OK) - downloader_cat.debug() - << "ZDecompressor::ZDecompressor() - Zlib inflate initialized" << endl; - else - handle_zerror(ret, _stream); -} - -//////////////////////////////////////////////////////////////////// -// Function: ZDecompressor::Destructor -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -ZDecompressor:: -~ZDecompressor(void) { - if (downloader_cat.is_debug()) - downloader_cat.debug() - << "ZDecompressor destructor called" << endl; - handle_zerror(inflateEnd(_stream), _stream); -} - -//////////////////////////////////////////////////////////////////// -// Function: ZDecompressor::decompress -// Access: Public -// Description: Decompress from next_in into next_out until avail_in -// is 0 or avail_out is 0 or an error occurs. -//////////////////////////////////////////////////////////////////// -int ZDecompressor:: -decompress(char *&next_in, int &avail_in, char *&next_out, int &avail_out, - bool finish) { - - int fin_flag = (finish == true) ? Z_FINISH : Z_NO_FLUSH; - - put_stream(_stream, next_in, avail_in, next_out, avail_out); - int ret = handle_zerror(inflate(_stream, fin_flag), _stream); - get_stream(_stream, next_in, avail_in, next_out, avail_out); - - return ret; -} - -//////////////////////////////////////////////////////////////////// -// Function: ZDecompressor::decompress_to_stream -// Access: Public -// Description: -//////////////////////////////////////////////////////////////////// -int ZDecompressor:: -decompress_to_stream(char *&next_in, int &avail_in, char *&next_out, - int &avail_out, char *out_buffer, - int out_buffer_length, ostream &write_stream, - bool finish) { - int ret = decompress(next_in, avail_in, next_out, avail_out, finish); - if (ret == S_error) - return ret; - - // See if there is any output to write - int out_bytes = out_buffer_length - avail_out; - if (out_bytes > 0) { - write_stream.write(out_buffer, out_bytes); - next_out = out_buffer; - avail_out = out_buffer_length; - } - - return ret; -} - -//////////////////////////////////////////////////////////////////// -// Function: ZCompressorBase::handle_zerror -// Access: Private -// Description: -//////////////////////////////////////////////////////////////////// -int ZCompressorBase:: -handle_zerror(int code, const z_stream *strm) const { - if (code == Z_OK) - return S_ok; - else if (code == Z_STREAM_END) - return S_finished; - else { - downloader_cat.error() - << "ZCompressorBase::handle_zerror() - "; - switch (code) { - case Z_DATA_ERROR: - downloader_cat.error() - << "corrupt data"; - break; - case Z_NEED_DICT: - downloader_cat.error() - << "need a dictionary"; - break; - case Z_STREAM_ERROR: - downloader_cat.error() - << "next_in or next_out = NULL"; - break; - case Z_MEM_ERROR: - downloader_cat.error() - << "not enough memory"; - break; - case Z_BUF_ERROR: - downloader_cat.error() - << "no progress is possible"; - break; - case Z_VERSION_ERROR: - downloader_cat.error() - << "zlib version conflict"; - break; - default: - downloader_cat.error() - << "unknown error: " << code; - break; - } - if (strm != NULL) { - if (strm->msg != NULL) { - downloader_cat.error() - << " - zlib message: " << strm->msg; - } - } - downloader_cat.error() - << endl; - } - return S_error; -} diff --git a/panda/src/downloader/zcompressor.h b/panda/src/downloader/zcompressor.h deleted file mode 100644 index 85e6b7aa24..0000000000 --- a/panda/src/downloader/zcompressor.h +++ /dev/null @@ -1,90 +0,0 @@ -// Filename: zcompressor.h -// Created by: mike (09Jan97) -// -//////////////////////////////////////////////////////////////////// -// -// PANDA 3D SOFTWARE -// Copyright (c) 2001, Disney Enterprises, Inc. All rights reserved -// -// All use of this software is subject to the terms of the Panda 3d -// Software license. You should have received a copy of this license -// along with this source code; you will also find a current copy of -// the license at http://www.panda3d.org/license.txt . -// -// To contact the maintainers of this program write to -// panda3d@yahoogroups.com . -// -//////////////////////////////////////////////////////////////////// -#ifndef ZCOMPRESSOR_H -#define ZCOMPRESSOR_H -// -//////////////////////////////////////////////////////////////////// -// Includes -//////////////////////////////////////////////////////////////////// -#include -#include -#include "typedef.h" - -//////////////////////////////////////////////////////////////////// -// Class : ZCompressorBase -// Description : -//////////////////////////////////////////////////////////////////// -class EXPCL_PANDAEXPRESS ZCompressorBase { -public: - enum status { - S_ok, - S_finished, - S_error, - }; - - INLINE ulong get_total_in(void) const; - INLINE ulong get_total_out(void) const; - INLINE void reset(void); - INLINE void reset_stream(z_stream *strm) const; -#ifndef CPPPARSER - INLINE void put_stream(z_stream *strm, char *next_in, int avail_in, - char *next_out, int avail_out) const; - INLINE void get_stream(z_stream *strm, char *&next_in, int &avail_in, - char *&next_out, int &avail_out) const; -#endif - int handle_zerror(int code, const z_stream *strm = NULL) const; - -protected: - z_stream *_stream; -}; - -//////////////////////////////////////////////////////////////////// -// Class : ZCompressor -// Description : -//////////////////////////////////////////////////////////////////// -class EXPCL_PANDAEXPRESS ZCompressor : public ZCompressorBase { -public: - ZCompressor(void); - ~ZCompressor(void); - - int compress(char *&next_in, int &avail_in, char *&next_out, - int &avail_out, bool finish = false); - int compress_to_stream(char *&next_in, int &avail_in, char *&next_out, - int &avail_out, char *out_buffer, int out_buffer_length, - ofstream &write_stream, bool finish = false); -}; - -//////////////////////////////////////////////////////////////////// -// Class : ZDecompressor -// Description : -//////////////////////////////////////////////////////////////////// -class EXPCL_PANDAEXPRESS ZDecompressor : public ZCompressorBase { -public: - ZDecompressor(void); - ~ZDecompressor(void); - - int decompress(char *&next_in, int &avail_in, char *&next_out, - int &avail_out, bool finish = false); - int decompress_to_stream(char *&next_in, int &avail_in, char *&next_out, - int &avail_out, char *out_buffer, int out_buffer_length, - ostream &write_stream, bool finish = false); -}; - -#include "zcompressor.I" - -#endif diff --git a/panda/src/downloadertools/pcompress.cxx b/panda/src/downloadertools/pcompress.cxx index d38f1e2ae8..740643b0f0 100644 --- a/panda/src/downloadertools/pcompress.cxx +++ b/panda/src/downloadertools/pcompress.cxx @@ -16,15 +16,15 @@ // //////////////////////////////////////////////////////////////////// -#include -#include -#include +#include "filename.h" +#include "zStream.h" +#include "notify.h" int main(int argc, char *argv[]) { if (argc < 2) { cerr << "Usage: pcompress " << endl; - return 0; + return 1; } Filename source_file = argv[1]; @@ -37,7 +37,7 @@ main(int argc, char *argv[]) { source_file.set_binary(); if (!source_file.open_read(read_stream)) { cerr << "failed to open: " << source_file << endl; - return 0; + return 1; } // Determine source file length @@ -55,64 +55,16 @@ main(int argc, char *argv[]) { dest_file.set_binary(); if (!dest_file.open_write(write_stream)) { cerr << "failed to open: " << dest_file << endl; - return 0; + return 1; } - ZCompressor compressor; - int buffer_length = 1000000; - int half_buffer_length = buffer_length/2; - char *buffer = new char[buffer_length]; - - // Read from the source file into the first half of the buffer, - // decompress into the second half of the buffer, write the second - // half of the buffer to disk, and repeat. - int total_bytes_read = 0; - bool read_all_input = false; - bool handled_all_input = false; - int source_buffer_length; - int ret; - while (handled_all_input == false) { - - // See if there is anything left in the source file - if (read_all_input == false) { - read_stream.read(buffer, half_buffer_length); - source_buffer_length = read_stream.gcount(); - total_bytes_read += source_buffer_length; - if (read_stream.eof()) { - nassertr(total_bytes_read == source_file_length, false); - read_all_input = true; - } - } - - char *next_in = buffer; - int avail_in = source_buffer_length; - char *dest_buffer = buffer + source_buffer_length; - char *next_out = dest_buffer; - int dest_buffer_length = buffer_length - source_buffer_length; - int avail_out = dest_buffer_length; - nassertr(avail_out > 0 && avail_in > 0, false); - - // Consume all the input from the input buffer, writing to disk - // as we go to free output buffer space - while (avail_in > 0) { - ret = compressor.compress_to_stream(next_in, avail_in, - next_out, avail_out, dest_buffer, - dest_buffer_length, write_stream); - if (ret == ZCompressorBase::S_error) - return 0; - } - - // If all the input has been consumed, we need to keep processing - // output until it says it's finished - if (compressor.get_total_in() == source_file_length) { - while (ret != ZCompressorBase::S_finished) { - ret = compressor.compress_to_stream(next_in, avail_in, - next_out, avail_out, dest_buffer, - dest_buffer_length, write_stream, true); - if (ret == ZCompressorBase::S_error) - return 0; - } - handled_all_input = true; + { + OCompressStream compress(&write_stream, false); + + int ch = read_stream.get(); + while (!read_stream.eof() && !read_stream.fail()) { + compress.put(ch); + ch = read_stream.get(); } } @@ -120,5 +72,5 @@ main(int argc, char *argv[]) { write_stream.close(); source_file.unlink(); - return 1; + return 0; } diff --git a/panda/src/downloadertools/pdecompress.cxx b/panda/src/downloadertools/pdecompress.cxx index e06a9257ec..1a362aa8e3 100644 --- a/panda/src/downloadertools/pdecompress.cxx +++ b/panda/src/downloadertools/pdecompress.cxx @@ -16,27 +16,22 @@ // //////////////////////////////////////////////////////////////////// -#include -#include -#include +#include "filename.h" +#include "decompressor.h" int main(int argc, char *argv[]) { if (argc < 2) { cerr << "Usage: pdecompress " << endl; - return 0; + return 1; } Filename source_file = argv[1]; - -#ifdef TESTING_CODE Decompressor decompressor; -#else - PT(Buffer) buffer = new Buffer(1000000); - Decompressor decompressor(buffer); -#endif - if (decompressor.decompress(source_file) == false) + if (decompressor.decompress(source_file) == false) { cerr << "Decompress failed" << endl; + return 1; + } - return 1; + return 0; }