Octane v1.01.20 - The Open Compression Toolkit for C++

http://octane.sourceforge.net/

compressors/compressor.hpp

Go to the documentation of this file.

//---------------------------------------------------------------------------


//---------------------------------------------------------------------------
// forward declarations
class OctaneCompressor;
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// recursive header protection
#ifndef CompressorH
#define CompressorH
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// application includes
#include "../core/octaneclass.hpp"
#include "../core/compressormanager.hpp"
#include "../bitio/bitio.hpp"
// system includes
#include <string>
//---------------------------------------------------------------------------



//---------------------------------------------------------------------------
class OctaneCompressor : public OctaneClass
{
public:
        OctaneCompressor(bool registerme=false) {ResetStatistics();};
        virtual ~OctaneCompressor() {;};
public:
        //---------------------------------------------------------------------------
        // OCTANE PUBLIC API - RTTI AND HELP FUNCTIONS - these are supported by all derived classes
        virtual std::string GetName() {return GetInstantiatedName();};
        virtual std::string GetDescription() {return "Base Compressor";};
        virtual std::string GetHelpInformation() {return "";};
        virtual unsigned short int GetCompressorStateFileGUID() {return guid;};
        //---------------------------------------------------------------------------
public:
        //---------------------------------------------------------------------------
        // COMPRESSOR PUBLIC API - FACTORY FUNCTION / MAKE AN INSTANTIATION OF DERIVED COMPRESSOR
        virtual OctaneCompressor *MakeCompressorInstantiation()=0;
        virtual std::string GetClassName() {return "Compressor";};
        std::string GetInstantiatedName() {if (instantiatedname=="") return GetClassName()+std::string(".unnamed"); else return instantiatedname;};
        unsigned short int GetGuid() {return guid;};
        void SetInstantiatedName(std::string val) {instantiatedname=val;};
        void SetInfo(std::string compressorname,unsigned short int compressorguid);
        //---------------------------------------------------------------------------
public:
        //---------------------------------------------------------------------------
        // COMPRESSOR PUBLIC API - PREPARATION FOR COMPRESSING/DECOMPRESSING
        virtual void ResetState() {;};
        virtual void SynchronizeStateForNewStream() {;};
        virtual bool PrepareForCompression() {return true;};
        virtual void SetupAnyDefaultParser() {;};
        virtual bool IsReadyToCompress() {return true;};
        //---------------------------------------------------------------------------
public:
        //---------------------------------------------------------------------------
        // COMPRESSOR PUBLIC API - COMPRESSING/DECOMPRESSING WRAPPERS (NOT VIRTUAL!)
        bool Compress(bitreader &from, bitwriter &to, bool needtowriteheader, bool savedecompressstateinfo);
        bool Decompress(bitreader &from, bitwriter &to, bool needtoreadheader);
        bool CreateSymbolsAndModelsUsingStream(bitreader &from);
        bool Save(bitwriter &to,bool fortempdecompressiononly);
        bool Load(bitreader &from);
        bool LoadState(bitreader &from);
        //---------------------------------------------------------------------------
protected:
        //---------------------------------------------------------------------------
        // COMPRESSOR PROTECTED DERIVED COMPRESSION/DECOMPRESSING
        virtual bool DoProtectedCompress(bitreader &from, bitwriter &to)=0;
        virtual bool DoProtectedDecompress(bitreader &from, bitwriter &to)=0;
        //---------------------------------------------------------------------------
protected:
        //---------------------------------------------------------------------------
        // OCTANE PROTECTED DERIVED STATE LOADING AND SAVING
        virtual bool DoProtectedCreateSymbolsAndModelsUsingStream(bitreader &from) {return true;};
        virtual bool DoProtectedSaveState(bitwriter &to,bool fortempdecompressiononly) {return true;};
        virtual bool DoProtectedLoadState(bitreader &from) {return true;};
        //---------------------------------------------------------------------------
public:
        //---------------------------------------------------------------------------
        // COMPRESSOR PUBLIC API - STATISTICS REPORTING
        // These methods just wrap the calls below inside some timing/stats gathering functions
        void ResetStatistics();
        unsigned int GetStatistics_Cumulative_Compression_BytesRead() {return Cumulative_Compression_BytesRead;};
        unsigned int GetStatistics_Cumulative_Decompression_BytesRead() {return Cumulative_Decompression_BytesRead;};
        unsigned int GetStatistics_Cumulative_Compression_BytesWritten() {return Cumulative_Compression_BytesWritten;};
        unsigned int GetStatistics_Cumulative_Decompression_BytesWritten() {return Cumulative_Decompression_BytesWritten;};
        float GetStatistics_Cumulative_Compression_Bitrate() {if (Cumulative_Compression_BytesRead==0) return 0; else return (float)8.0*(float)Cumulative_Compression_BytesWritten/(float)Cumulative_Compression_BytesRead;};
        float GetStatistics_Cumulative_Decompression_Bitrate() {if (Cumulative_Decompression_BytesWritten==0) return 0; else return (float)8.0*(float)Cumulative_Decompression_BytesRead/(float)Cumulative_Decompression_BytesWritten;};
        float GetStatistics_Cumulative_Compression_Ratio() {if (Cumulative_Compression_BytesRead==0) return 0; else return (float)Cumulative_Compression_BytesWritten/(float)Cumulative_Compression_BytesRead;};
        float GetStatistics_Cumulative_Decompression_Ratio() {if (Cumulative_Decompression_BytesWritten==0) return 0; else return (float)Cumulative_Decompression_BytesRead/(float)Cumulative_Decompression_BytesWritten;};
        float GetStatistics_Cumulative_Compression_ExecutionTime() {return Cumulative_Compression_ExecutionTime;};
        float GetStatistics_Cumulative_Decompression_ExecutionTime() {return Cumulative_Decompression_ExecutionTime;};
        float GetStatistics_Cumulative_ExecutionTime() {return GetStatistics_Cumulative_Compression_ExecutionTime()+GetStatistics_Cumulative_Decompression_ExecutionTime();};
        int GetStatistics_Cumulative_ErrorCount() {return Cumulative_ErrorCount;};
        // last operation stats
        unsigned int GetStatistics_LastOperation_Compression_BytesRead() {return LastOperation_Compression_BytesRead;};
        unsigned int GetStatistics_LastOperation_Decompression_BytesRead() {return LastOperation_Decompression_BytesRead;};
        unsigned int GetStatistics_LastOperation_Compression_BytesWritten() {return LastOperation_Compression_BytesWritten;};
        unsigned int GetStatistics_LastOperation_Decompression_BytesWritten() {return LastOperation_Decompression_BytesWritten;};
        unsigned int GetStatistics_LastOperation_State_BytesRead() {return LastOperation_State_BytesRead;};
        unsigned int GetStatistics_LastOperation_State_BytesWritten() {return LastOperation_State_BytesWritten;};
        float GetStatistics_LastOperation_Compression_Bitrate() {if (LastOperation_Compression_BytesRead==0) return 0; else return (float)8.0*(float)LastOperation_Compression_BytesWritten/(float)LastOperation_Compression_BytesRead;};
        float GetStatistics_LastOperation_Decompression_Bitrate() {if (LastOperation_Decompression_BytesWritten==0) return 0; else return (float)8.0*(float)LastOperation_Decompression_BytesRead/(float)LastOperation_Decompression_BytesWritten;};
        float GetStatistics_LastOperation_Compression_Ratio() {if (LastOperation_Compression_BytesRead==0) return 0; else return (float)LastOperation_Compression_BytesWritten/(float)LastOperation_Compression_BytesRead;};
        float GetStatistics_LastOperation_Decompression_Ratio() {if (LastOperation_Decompression_BytesWritten==0) return 0; else return (float)LastOperation_Decompression_BytesRead/(float)LastOperation_Decompression_BytesWritten;};
        float GetStatistics_LastOperation_Compression_ExecutionTime() {return LastOperation_Compression_ExecutionTime;};
        float GetStatistics_LastOperation_Decompression_ExecutionTime() {return LastOperation_Decompression_ExecutionTime;};
        float GetStatistics_LastOperation_ExecutionTime() {return GetStatistics_LastOperation_Compression_ExecutionTime()+GetStatistics_LastOperation_Decompression_ExecutionTime();};
        float GetStatistics_LastOperation_State_ExecutionTime() {return LastOperation_State_ExecutionTime;};
        int GetStatistics_LastOperation_ErrorCount() {return LastOperation_ErrorCount;};
        void Add_LastOperation_Compression_BytesRead(int val) {LastOperation_Compression_BytesRead+=val;};
        void Add_LastOperation_Compression_BytesWritten(int val) {LastOperation_Compression_BytesWritten+=val;};
        void Add_LastOperation_Decompression_BytesRead(int val) {LastOperation_Decompression_BytesRead+=val;};
        void Add_LastOperation_Decompression_BytesWritten(int val) {LastOperation_Decompression_BytesWritten+=val;};
        //---------------------------------------------------------------------------
public:
        //---------------------------------------------------------------------------
        bool SaveCompressionHeader(bitwriter &to, bool savedecompressstateinfo);
        bool LoadCompressionHeader(bitreader &from);
        bool SaveGUID(bitwriter &to);
        static int LoadGUID(bitreader &from);
        //---------------------------------------------------------------------------
protected:
        std::string instantiatedname;
        unsigned short int guid;
private:
        // statistics tracking
        unsigned int Cumulative_Compression_BytesRead;
        unsigned int Cumulative_Decompression_BytesRead;
        unsigned int Cumulative_Compression_BytesWritten;
        unsigned int Cumulative_Decompression_BytesWritten;
        float Cumulative_Compression_Bitrate;
        float Cumulative_Decompression_Bitrate;
        float Cumulative_Compression_Ratio;
        float Cumulative_Decompression_Ratio;
        float Cumulative_Compression_ExecutionTime;
        float Cumulative_Decompression_ExecutionTime;
        int Cumulative_ErrorCount;
        unsigned int LastOperation_Compression_BytesRead;
        unsigned int LastOperation_Decompression_BytesRead;
        unsigned int LastOperation_Compression_BytesWritten;
        unsigned int LastOperation_Decompression_BytesWritten;
        unsigned int LastOperation_State_BytesRead;
        unsigned int LastOperation_State_BytesWritten;
        float LastOperation_Compression_Bitrate;
        float LastOperation_Decompression_Bitrate;
        float LastOperation_Compression_Ratio;
        float LastOperation_Decompression_Ratio;
        float LastOperation_Compression_ExecutionTime;
        float LastOperation_Decompression_ExecutionTime;
        float LastOperation_State_ExecutionTime;
        int LastOperation_ErrorCount;
};
//---------------------------------------------------------------------------



//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------

 

Generated on 20 May 2004 by doxygen 1.3.3