core/ASCOfficePDFReader/Stream.h

#ifndef _STREAM_H
#define _STREAM_H

#include <stdio.h>
#include "Object.h"

#include "zlib.h"

#pragma comment(lib, "zlib.lib")

class BaseStream;

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

enum StreamType 
{
	strFile,
	strASCIIHex,
	strASCII85,
	strLZW,
	strRunLength,
	strCCITTFax,
	strDCT,
	strFlate,
	strJBIG2,
	strJPX,
	strWeird			// internal-use stream types
};

enum StreamColorSpaceMode 
{
	streamCSNone,
	streamCSDeviceGray,
	streamCSDeviceRGB,
	streamCSDeviceCMYK
};

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

enum CryptAlgorithm 
{
	cryptRC4,
	cryptAES
};

//------------------------------------------------------------------------
// Stream (îñíîâíîé êëàññ)
//------------------------------------------------------------------------

class Stream 
{
public:

	Stream();

	virtual ~Stream();

	// Ñ÷åò÷èê ññûëîê.
	int AddRef() 
	{ 
		return ++m_nRef; 
	}
	int Release() 
	{ 
		return --m_nRef; 
	}

	// Òèï ïîòîêà.
	virtual StreamType GetType() = 0;

	// Ñáðàñûâàåì âñå ïàðàìåòðû(ê íà÷àëüíûì).
	virtual void Reset() = 0;

	// Çàêðûâàåì ïîòîê.
	virtual void Close();

	// Ïåðåäâèãàåìñÿ ê ñëåäóþùåìó ñèìâîëó â ïîòîêå.
	virtual int GetChar() = 0;

	// Ñìîòðèì íà ñëåäóþùèé ñèìâîë â ïîòîêå.
	virtual int LookChar() = 0;

	// GetChar áóç èñïîëüçîâàíèÿ Predictor.
	// Èñïîëüçóåòñÿ òîëüêî â StreamPredictor.
	virtual int GetRawChar();

	// Ñëåäóþùàÿ ñòðîêà â ïîòîêå.
	virtual char *GetLine(char *sBuffer, int nSize);

	// Òåêóùàÿ ïîçèöèÿ â ïîòîêå.
	virtual int GetPos() = 0;

	// Óñòàíàâëèâàåì òåêóùóþ ïîçèöèþ â ïîòîêå. Åñëè nDirection - 
	// îòðèöàòåëüíî, òîãäà ïîçèöèþ îòñ÷èòâàåì îò êîíöà ïîòîêà, à 
	// åñëè ïîëîæèòåëüíî, òîãäà îò íà÷àëà.
	virtual void SetPos(unsigned int unPos, int nDirection = 0) = 0;

	// PostScript'îå íàçâàíèå ôèëüòðà.
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent);

	// Ìîæåò ëè ïîòîê ñîäåðæàòü íåïå÷àòûåìûå ñèìâîëû?
	virtual BOOL IsBinary(BOOL bLast = TRUE) = 0;

	virtual BaseStream *GetBaseStream() = 0;

	// Ïîòîê ïîñëå ïîñëåäíåãî äåêîäèðîâàíèÿ (ýòî ìîæåò áûòü BaseStream 
	// èëè DecryptStream).
	virtual Stream *GetUndecodedStream() = 0;

	// Ñëîâàðü ñâÿçàííûé ñ äàííûì ïîòîêîì.
	virtual Dict *GetDict() = 0;

	// Encoding filter?
	virtual BOOL IsEncoder() 
	{ 
		return FALSE; 
	}

	// Ïîëó÷èòü ïàðàìåòðû èçîáðàæåíèÿ, îïðåäåëåííîãî ñîäåðæèìûì äàííîãî ïîòîêà.
	virtual void GetImageParams(int *pnBitsPerComponent, StreamColorSpaceMode *peCSMode) 
	{
	}

	// Âîçâðàùåòñÿ ñëåäóþùèé ïîòîê èç ñòåêà.
	virtual Stream *GetNextStream() 
	{ 
		return NULL; 
	}

	// Ïðèìåíÿåì ôèëüòðû ê äàííîìó ïîòîêó, îïèñàííûå â ïàðàìåòðàõ ñëîâàðÿ.
	// Âîçâðàùàåòñÿ íîâûé ïîòîê.
	Stream *AddFilters(Object *pDict);

private:

	Stream *ApplyFilter(char *sName, Stream *pStream, Object *pParams);

private:

	int m_nRef; // ñ÷åò÷èê ññûëîê

};

//------------------------------------------------------------------------
// BaseStream
//
// Ýòî îñíîâíîé êëàññ äëÿ âñåõ ïîòîêîâ è ÷òåíèÿ èç ôàéëà.
//------------------------------------------------------------------------

class BaseStream: public Stream
{
public:

	BaseStream(Object *pDict);
	virtual ~BaseStream();
	virtual Stream *MakeSubStream(unsigned int unStart, BOOL bLimited, unsigned int unLength, Object *pDict) = 0;
	virtual void SetPos(unsigned int unPos, int nDirection = 0) = 0;
	virtual BOOL IsBinary(BOOL bLast = TRUE) 
	{ 
		return bLast; 
	}
	virtual BaseStream *GetBaseStream() 
	{ 
		return this; 
	}
	virtual Stream *GetUndecodedStream() 
	{ 
		return this; 
	}
	virtual Dict *GetDict() 
	{ 
		return m_pDict.GetDict(); 
	}
	virtual StringExt *GetFileName() 
	{ 
		return NULL; 
	}

	// Çàïðàøèâàåì/óñòàíàâëèâàåì ïîçèöèþ ïåðâîãî áàéòà â ïîòîêå ôàéëà.
	virtual unsigned int GetStartPos() = 0;
	virtual void         SetStartPos(int nDelta) = 0;

private:

	Object m_pDict;
};

//------------------------------------------------------------------------
// FilterStream
//
// Ýòî îñíîâíîé êëàññ äëÿ âñåõ ïîòîêîâ, ê êîòîðûì ïðèìåíå ôèëüòð.
//------------------------------------------------------------------------

class FilterStream: public Stream 
{
public:

	FilterStream(Stream *pStream);
	virtual ~FilterStream();
	virtual void Close();
	virtual int GetPos() 
	{ 
		return m_pStream->GetPos(); 
	}
	virtual void SetPos(unsigned int unPos, int nDirection = 0);
	virtual BaseStream *GetBaseStream() 
	{ 
		return m_pStream->GetBaseStream(); 
	}
	virtual Stream *GetUndecodedStream() 
	{ 
		return m_pStream->GetUndecodedStream(); 
	}
	virtual Dict *GetDict() 
	{ 
		return m_pStream->GetDict(); 
	}
	virtual Stream *GetNextStream() 
	{ 
		return m_pStream; 
	}

protected:

	Stream *m_pStream;
};

//------------------------------------------------------------------------
// ImageStream
//------------------------------------------------------------------------

class ImageStream 
{
public:

	// Ñîçäàåì Image object ïî êàðòèíêå ñ çàäàííûìè ïàðàìåòðàìè( òóò èìåþòñÿ ââèäó 
	// ðåàëüíûå ïàðàìåòðû êàðòèíêè, à íå òå ÷òî ìîãóò ïðèéòè â Predictor).
	ImageStream(Stream *pStream, int nWidth, int nComponents, int nBitsPerComponent);

	~ImageStream();

	void Reset();

	// Ñ÷èòûâàåì ñëåäóþùèé ïèêñåë èç ïîòîêà. pPixel äîëæíî óêàçûâàòü íà ìåñòî äîñòàòî÷íîå,
	// äëÿ õðàíåíèÿ êàê ìèíèìóì m_nComponentsPerPixel ýëåìåíòîâ.
	BOOL GetPixel(unsigned char *pPixel);

	unsigned char *GetNextLine();

	void SkipLine();

private:

	Stream        *m_pStream;             // Îñíîâíîé ïîòîê
	int            m_nWidth;              // Êîëè÷åñòâî ïèêñåëåé â ñòðîêå
	int            m_nComponentsPerPixel; // Êîëè÷åñòâî êîìïîíåíò íà îäèí ïèêñåë
	int            m_nBitsPerComponent;   // Êîëè÷åñòâî áèò â êîìïîíåíòå
	int            m_nComponentsPerLine;  // Êîëè÷åñòâî êîìïîíåíò â îäíîé ñòðîêå
	unsigned char *m_pLineBuffer;         // Áóôôåð äëÿ îäíîé ñòðîêè èçîáðàæåíèÿ
	int            m_nLinePos;            // Òåêóùàÿ ïîçèöèÿ â m_pLineBuffer
};

//------------------------------------------------------------------------
// StreamPredictor (Predictor - äîïîëíèòåëüíûé ôèëüòð äëÿ êàðòèíîê)
//------------------------------------------------------------------------

class StreamPredictor 
{
public:

	// Ñîçäàåì Predictor object. Ïàðàìåòðû, êîòîðûå çàäàþòñÿ çäåñü, ìîãóò  
	// íå ñîâïàäàòü ñ ðåàëüíûìè ïàðàìåòðàìè êàðòèíêè.
	StreamPredictor(Stream *pStream, int nPredictor, int nWidth, int nComponents, int nBitsPerComponent);

	~StreamPredictor();

	BOOL CheckValidate() 
	{ 
		return m_bSuccess; 
	}


	int LookChar();
	int GetChar();

private:

	BOOL GetNextLine();

private:

	Stream *m_pStream;             // Îñíîâíîé ïîòîê
	int     m_nPredictor;          // Predictor
	int     m_nWidth;              // Êîëè÷åñòâî ïèêñåëåé â ñòðîêå
	int     m_nComponentsPerPixel; // Êîëè÷åñòâî êîìïîíåíò íà îäèí ïèêñåë
	int     m_nBitsPerComponent;   // Êîëè÷åñòâî áèò â êîìïîíåíòå
	int     m_nComponentsPerLine;  // Êîëè÷åñòâî êîìïîíåíò â îäíîé ñòðîêå
	int     m_nBytesPerPixel;      // Êîëè÷åñòâî áàéò â îäíîì ïèêñåëå
	int     m_nBytesPerLine;       // Êîëè÷åñòâî áàéò â ñòðîêå
	unsigned char *m_pLineBuffer;  // Áóôôåð äëÿ îäíîé ñòðîêè èçîáðàæåíèÿ
	int     m_nLinePos;            // Òåêóùàÿ ïîçèöèÿ â m_pLineBuffer

	BOOL    m_bSuccess;
};

//------------------------------------------------------------------------
// FileStream
//------------------------------------------------------------------------

#define FileStreamBufferSize 1024

class FileStream: public BaseStream 
{
public:

	FileStream(FILE *pFile, unsigned int unStart, BOOL bLimited, unsigned int nLength, Object *pDict);
	virtual ~FileStream();
	
	virtual Stream *MakeSubStream(unsigned int unStart, BOOL bLimited, unsigned int nLength, Object *pDict);
	virtual StreamType GetType() 
	{ 
		return strFile; 
	}
	virtual void Reset();
	virtual void Close();
	inline virtual int GetChar()
    { 
		return ( m_pBufferPointer >= m_pBufferEnd && !FillBuffer()) ? EOF : (*m_pBufferPointer++ & 0xff); 
	}
	inline virtual int LookChar()
    { 
		return ( m_pBufferPointer >= m_pBufferEnd && !FillBuffer()) ? EOF : (*m_pBufferPointer & 0xff); 
	}
	inline virtual int GetPos() 
	{
		return m_unBufferPos + (m_pBufferPointer - m_sBuffer); 
	}
	virtual void SetPos(unsigned int unPos, int nDirection = 0);
	virtual unsigned int GetStartPos() 
	{ 
		return m_unStart; 
	}
	virtual void SetStartPos(int nDelta);

private:

	BOOL FillBuffer();

private:

	FILE        *m_pFile;
	unsigned int m_unStart;
	BOOL         m_bLimited;
	unsigned int m_unLength;
	char         m_sBuffer[FileStreamBufferSize];
	char        *m_pBufferPointer;
	char        *m_pBufferEnd;
	unsigned int m_unBufferPos;
	int          m_nSavePos;
	BOOL         m_bSaved;
};
//------------------------------------------------------------------------
// MemoryStream
//------------------------------------------------------------------------

class MemoryStream: public BaseStream 
{
public:

	MemoryStream(char *sBuffer, unsigned int unStart, unsigned int unLength, Object *pDict);
	virtual ~MemoryStream();
	virtual Stream *MakeSubStream(unsigned int unStart, BOOL bLimited, unsigned int unLength, Object *pDict);
	virtual StreamType GetType() 
	{ 
		return strWeird; 
	}
	virtual void Reset();
	virtual void Close();
	virtual int GetChar()
    { 
		return ( m_pBufferPointer < m_pBufferEnd ) ? (*m_pBufferPointer++ & 0xff) : EOF; 
	}
	virtual int LookChar()
    { 
		return ( m_pBufferPointer < m_pBufferEnd ) ? (*m_pBufferPointer & 0xff) : EOF; 
	}
	virtual int GetPos() 
	{ 
		return (int)( m_pBufferPointer - m_sBuffer); 
	}
	virtual void SetPos(unsigned int unPos, int nDirection = 0);
	virtual unsigned int GetStartPos() 
	{
		return m_unStart; 
	}
	virtual void SetStartPos(int delta);

private:

	char        *m_sBuffer;
	unsigned int m_unStart;
	unsigned int m_unLength;
	char        *m_pBufferEnd;
	char        *m_pBufferPointer;
	BOOL         m_bNeedFree;
};

//------------------------------------------------------------------------
// EmbedStream
//
// Ñïåöèàëüíûé òèï ïîòîêà, èñïîëüçóåìûé äëÿ âíóòðåííûèõ(âíåäðåííûõ) ïîòîêîâ
// (Inline images). ×èòàåì íàïðÿìóþ èç Base stream -- ïîñëå óäàëåíèÿ 
// EmbedStream, ÷òåíèå èç Base stream áóäåò ñîâåðøàòüñÿ äëÿ  îñòàâøåéñÿ ÷àñòè
// ïîòîêà. Ýòî ñîâåðåøííî ïîäðóãîìó, ÷åì ïðîñòî ñîçäàòü íîâûé ïîòîê
// FileStream (èñïîëüçóÿ MakeSubStream).
//------------------------------------------------------------------------

class EmbedStream: public BaseStream 
{
public:

	EmbedStream(Stream *pStream, Object *pDict, BOOL bLimited, unsigned int unLength);
	virtual ~EmbedStream();
	virtual Stream *MakeSubStream(unsigned int unStart, BOOL bLimited, unsigned int unLength, Object *pDict);
	virtual StreamType GetType() 
	{ 
		return m_pStream->GetType(); 
	}
	virtual void Reset() 
	{
	}
	virtual void Close(){};
	virtual int GetChar();
	virtual int LookChar();
	virtual int GetPos() 
	{ 
		return m_pStream->GetPos(); 
	}
	virtual void SetPos(unsigned int unPos, int nDirection = 0);
	virtual unsigned int GetStartPos();
	virtual void SetStartPos(int nDelta);

private:

	Stream      *m_pStream;
	BOOL         m_bLimited;
	unsigned int m_unLength;
};

//------------------------------------------------------------------------
// ASCIIHexStream
//------------------------------------------------------------------------

class ASCIIHexStream: public FilterStream 
{
public:

	ASCIIHexStream(Stream *pStream);
	virtual ~ASCIIHexStream();
	virtual StreamType GetType() 
	{ 
		return strASCIIHex; 
	}
	virtual void Reset();
	virtual int GetChar()
    { 
		int nChar = LookChar(); 
		m_nBuffer = EOF; 
		return nChar; 
	}
	virtual int LookChar();
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent);
	virtual BOOL IsBinary(BOOL bLast = TRUE);

private:

	int  m_nBuffer;
	BOOL m_bEOF;
};

//------------------------------------------------------------------------
// ASCII85Stream
//------------------------------------------------------------------------

class ASCII85Stream: public FilterStream 
{
public:

	ASCII85Stream(Stream *pStream);
	virtual ~ASCII85Stream();
	virtual StreamType GetType() 
	{ 
		return strASCII85; 
	}
	virtual void Reset();
	virtual int GetChar()
    { 
		int nChar = LookChar(); 
		++m_nIndex; 
		return nChar; 
	}
	virtual int LookChar();
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent);
	virtual BOOL IsBinary(BOOL bLast = TRUE);

private:

	int  m_arrC[5]; // Èìåíà ìàññèâîâ C è B âçÿòû èç ñïåöèôèêàöèè
	int  m_arrB[4];
	int  m_nIndex;
	int  m_nCount;
	BOOL m_bEOF;
};

//------------------------------------------------------------------------
// LZWStream
//------------------------------------------------------------------------

class LZWStream: public FilterStream 
{
public:

	LZWStream(Stream *pStream, int nPredictor, int nColumns, int nColors, int nBitPerPixel, int nEarlyChange);
	virtual ~LZWStream();
	virtual StreamType GetType() 
	{ 
		return strLZW; 
	}
	virtual void Reset();
	virtual int GetChar();
	virtual int LookChar();
	virtual int GetRawChar();
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent);
	virtual BOOL IsBinary(BOOL bLast = TRUE);

private:

	BOOL ProcessNextCode();
	void ClearTable();
	int  GetCode();

private:

	StreamPredictor *m_pPredictor;         // Predictor (åùå îäèí äîïîëíèòåëüíûé ôèëüòð)
	int              m_nEarlyChange;       // Ïàðàìåòð è ñëîâàðÿ äëÿ LZW ôèëüòðà
	BOOL             m_bEOF;               // Êîíåö ïîòîêà?
	int              m_nInputBuffer;       // Input buffer
	int              m_nInputBits;         // Êîëè÷åñòâî áèò â áóôôåðå
	struct 
	{
		int           nLength;
		int           nHead;
		unsigned char unTail;
	}  m_pTable[4097];       // Òàáëèöà äëÿ äåêîäèðîâàíèÿ
	int              m_nNextCode;          // Ñëåäóþùèé êîä
	int              m_nNextBits;          // ×èñëî áèò â ñëåäóþùåì êîäå
	int              m_nPrevCode;          // Ïðåäûäóùèé êîä â ïîòîêå
	int              m_nNewChar;           // Íîâûé ñèìâîë, êîòîðûé ìû äîáàâèì â òàáëèöó
	unsigned char    m_arrCurBuffer[4097]; // Áóôôåð äëÿ òåêóùåé ïîñëåäîâàòåëüíîñòè
	int              m_nCurLength;         // Äëèíà òåêóùåé ïîñëåäîâàòåëüíîñòè
	int              m_nCurPos;            // Ïîçèöèÿ â òåêóùåé ïîñëåäîâàòåëüíîñòè
	BOOL             m_bFirst;             // ßâëÿåòñÿ ëè äàííûé êîä ïåðâûì ïîñëå î÷èùåíèÿ òàáëèöû
};

//------------------------------------------------------------------------
// RunLengthStream
//------------------------------------------------------------------------

class RunLengthStream: public FilterStream 
{
public:

	RunLengthStream(Stream *pStream);
	virtual ~RunLengthStream();
	virtual StreamType GetType() 
	{ 
		return strRunLength; 
	}
	virtual void Reset();
	virtual int GetChar()
	{ 
		return ( m_pBufferPointer >= m_pEndOfBuffer && !FillBuffer()) ? EOF : (*m_pBufferPointer++ & 0xff); 
	}
	virtual int LookChar()
	{ 
		return ( m_pBufferPointer >= m_pEndOfBuffer && !FillBuffer()) ? EOF : (*m_pBufferPointer & 0xff); 
	}
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent);
	virtual BOOL IsBinary(BOOL bLast = TRUE);

private:

	BOOL FillBuffer();

private:

	char  m_sBuffer[128];   // Áóôåð
	char *m_pBufferPointer; // Óêàçàòåëü íà ñëåäóþùèé ñèìâîë â áóôåðå
	char *m_pEndOfBuffer;   // Óêàçàòåëü íà êîíåö áóôåðà
	BOOL  m_bEOF;
};

//------------------------------------------------------------------------
// CCITTFaxStream
//------------------------------------------------------------------------

struct CCITTCodeTable;

class CCITTFaxStream: public FilterStream 
{
public:

	CCITTFaxStream(Stream *pStream, int nK, BOOL bEndOfLine, BOOL bByteAlign, int nColumns, int nRows, BOOL bEndOfBlock, BOOL bBlackIs1);
	virtual ~CCITTFaxStream();
	virtual StreamType GetType() 
	{ 
		return strCCITTFax; 
	}
	virtual void Reset();
	virtual int GetChar()
    { 
		int nChar = LookChar(); 
		m_nCharBuffer = EOF; 
		return nChar; 
	}
	virtual int LookChar();
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent);
	virtual BOOL IsBinary(BOOL bLast = TRUE);

private:

	short Get2DCode();
	short GetWhiteCode();
	short GetBlackCode();
	short LookBits(int nCount);
	void  SkipBits(int nCount) 
	{ 
		if ( ( m_nInputBits -= nCount ) < 0 ) 
			m_nInputBits = 0; 
	}

private:

	int    m_nK;           // Ïàðàìåòð 'K', îïðåäåëÿþùèé òèï êîäèðîâêè
	BOOL   m_bEndOfLine;   // Ïàðàìåòð 'EndOfLine'
	BOOL   m_bByteAlign;   // Ïàðàìåòð 'EncodedByteAlign'
	int    m_nColumns;     // Ïàðàìåòð 'Columns'
	int    m_nRows;        // Ïàðàìåòð 'Rows'
	BOOL   m_bEndOfBlock;  // Ïàðàìåòð 'EndOfBlock'
	BOOL   m_bBlackIs1;    // Ïàðàìåòð 'BlackIs1'

	BOOL   m_bEOF;         // 
	BOOL   m_bNextLine2D;  // True, åñëè ñëåäóþùàÿ ñòðîêà èñïîëüçóåò êîäèðîâêó 2D
	int    m_mCurRow;      // Òåêóùàÿ ñòðîêà
	int    m_nInputBuffer; // Input buffer
	int    m_nInputBits;   // Êîëè÷åñòâî áèò â Input buffer
	short *m_pRefLine;     // Ññûëî÷íàÿ ñòðîêà, ìåíÿþùóþ ýëåìåíòû
	int    m_nCurPosRL;    // Òåêóùàÿ ïîçèöèÿ â m_pRefLine
	short *m_pCodingLine;  // Êîäèðóþùàÿ ñòðîêà, ìåíÿþùàÿ ýëåìåíòû
	int    m_nCurPosCL;    // Òåêóùàÿ ïîçèöèÿ â m_pCodingLine 
	int    m_nOutputBits;  //
	int    m_nCharBuffer;  // 
};

//------------------------------------------------------------------------
// DCTStream
//------------------------------------------------------------------------

struct DCTCompInfo 
{
	int nID;            // ID äàííîãî ýëåìåíòà
	int nXResolution;   // Ðàçðåøåíèå ïî ãîðèçîíòàëè
	int nYResolution;   // Ðàçðåøåíèå ïî âåðòèêàëè
	int nQuantTableNum; // Íîìåð òàáëèöû êâàíòîâàíèÿ
	int nPrevDC;        // 
};

struct DCTScanInfo 
{
	BOOL arrbComponent[4];  // arrbComponent[i] = true, åñëè i-àÿ êîìïîíåíòà âêëþ÷åíà â äàííóá ñòðóêòóðó
	int  nComponentsCount;  // êîëè÷åñòâî êîìïîíåíò â äàííîé ñòðóêòóðå
	int  arrDCHuffTable[4];	// íîìåðà òàáëèö DC Huffman
	int  arrACHuffTable[4]; // íîìåðà òàáëèö AC Huffman
	int  nFirstKoef;        // ïåðâûé DCT êîýôôèöèåíò
	int  nLastKoef;         // ïîñëåäíèé DCT êîýôôèöèåíò
	int  nApproxH;
	int  nApproxL;
};

struct DCTHuffTable 
{
  unsigned char  arrunFirstSymbol[17]; // Ïåðâûé ñèìâîë â äàííîé ãðóïïå
  unsigned short arrunFirstCode[17];   // Ïåðâûé êîä â äàííîé ãðóïïå
  unsigned short arrunCodesCount[17];  // Êîëè÷åñòâî êîäîâ â äàííîé ãðóïïå
  unsigned char  arrunSymbols[256];    // Ñàìè ñèìâîëû
};

class DCTStream: public FilterStream 
{
public:

	DCTStream(Stream *pStream, int nColorTransform);
	virtual ~DCTStream();
	virtual StreamType GetType() 
	{ 
		return strDCT; 
	}
	virtual void Reset();
	virtual void Close();
	virtual int GetChar();
	virtual int LookChar();
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent);
	virtual BOOL IsBinary(BOOL bLast = TRUE);
	Stream *GetRawStream() 
	{ 
		return m_pStream; 
	}

private:

	void Restart();
	BOOL ReadMCURow();
	void ReadScan();
	BOOL ReadDataUnit(DCTHuffTable *pDCHuffTable, DCTHuffTable *pACHuffTable, int *pnPrevDC, int arrData[64]);
	BOOL ReadProgressiveDataUnit(DCTHuffTable *pDCHuffTable, DCTHuffTable *pACHuffTable, int *pnPrevDC, int arrData[64]);
	void DecodeImage();
	void TransformDataUnit(unsigned short *pQuantTable, int arrDataIn[64], unsigned char arrDataOut[64]);
	int  ReadHuffSymbol(DCTHuffTable *pTable);
	int  ReadAmp(int nSize);
	int  ReadBit();
	BOOL ReadHeader();
	BOOL ReadBaselineSOF();
	BOOL ReadProgressiveSOF();
	BOOL ReadScanInfo();
	BOOL ReadQuantTables();
	BOOL ReadHuffmanTables();
	BOOL ReadRestartInterval();
	BOOL ReadJFIFMarker();
	BOOL ReadAdobeMarker();
	BOOL ReadTrailer();
	int  ReadMarker();
	int  Read16();

private:

  BOOL           m_bProgressive;          // True, åñëè ìîä progressive
  BOOL           m_bInterleaved;          // True, åñëè ìîä interleaved
  int            m_nWidth;                // øèðèíà èçîáðàæåíèÿ
  int            m_nHeight;               // âûñîòà èçîáðàæåíèÿ
  int            m_nMCUWidth;             // øèðèíà min coding unit(MCU)
  int            m_nMCUHeight;            // âûñîòà min coding unit(MCU)
  int            m_nBufferWidth;          // øèðèíà FrameBuffer
  int            m_nBufferHeight;         // âûñîòà FrameBuffer
  DCTCompInfo    m_arrCompInfo[4];	      // Ñòðóêòóðà Info äëÿ êàæäîé êîìïîíåíòû
  DCTScanInfo    m_oCurScanInfo;          // Ñòðóêòóðà Info äëÿ òåêóùåãî Scan
  int            m_nComponentsCount;      // Êîëè÷åñòâî êîìïîíåíò èçîáðàæåíèÿ
  int            m_nColorTransform;       // Ïðåîáðàçîâàíèÿ ïðîñòðàíñòâà öâåòîâ:
								          // -1 = íåïîðåäåëåíî
								          //  0 = íåò ïðåîáðàçîâàíèÿ
								          //  1 = YUV/YUVK -> RGB/CMYK
  BOOL           m_bJFIFMarker;           // True, åñëè åñòü ìàðêåð APP0 JFIF 
  BOOL           m_bAdobeMarker;          // True, åñëè åñòü ìàðêåð APP14 Adobe 
  int            m_nRestartInterval;      // â MCU
  unsigned short m_arrQuantTables[4][64]; // Òàáëèöû êâàíòîâàíèÿ
  int            m_nQuantTablesCount;     // êîëè÷åñòâî òàáëèöû êâàíòîâàíèÿ
  DCTHuffTable   m_arrDCHuffTables[4];    // Òàáëèöû DC Huffman
  DCTHuffTable   m_arrACHuffTables[4];    // Òàáëèöû AC Huffman
  int            m_nDCHuffTablesCount;    // Êîëè÷åñòâî òàáëèö DC Huffman
  int            m_nACHuffTablesCount;    // Êîëè÷åñòâî òàáëèö AC Huffman
  unsigned char *m_pppRowBuffer[4][32];   // Áóôåð äëÿ MCU (non-progressive mode)
  int           *m_ppFrameBuffer[4];      // Áóôåð äëÿ ôðýéìà (progressive mode)

  int            m_nCurComponent;         // Òåêóùèå ïàðàìåòðû äëÿ êðòèíêè/MCU
  int            m_nX;                    //
  int            m_nY;                    //
  int            m_nDY;                   //

  int            m_nRestartCtr;           // êîëè÷åñòâî îñòàâèøõñÿ MCU äî ðåñòàðòà
  int            m_nRestartMarker;        //
  int            m_nEOBRun;               // êîëè÷åñòâî îñòàâøèõñÿ EOB(end-of-block) â òåêóùåé ãðóïïå

  int            m_nInputBuffer;          // Áóôåð äëÿ êîäîâ ðàçíîé äëèíû
  int            m_nInputBits;            // ×èñëî êîððåêòíûõ áèò â Input buffer

};

//------------------------------------------------------------------------
// FlateZlibStream
//------------------------------------------------------------------------

#define flateZlibWindow             32768   // Ðàçìåð áóôåðà
#define flateZlibMask               32767   // (flateZlibWindow - 1)

class FlateZlibStream: public FilterStream 
{
public:

	FlateZlibStream(Stream *pStream, int nPredictor, int nWidth, int nComponents, int nBitsPerComponent);
	virtual ~FlateZlibStream();
	virtual StreamType GetType() 
	{ 
		return strFlate; 
	}
	virtual void Reset();
	virtual int GetChar();
	virtual int LookChar();
	virtual int GetRawChar();
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent);
	virtual BOOL IsBinary(BOOL bLast = TRUE);

private:

	void ReadSome();

private:

	z_stream          m_oZStream;                     // Zlib ïîòîê 
	StreamPredictor  *m_pPredictor;                   // Predictor
	unsigned int      m_nInSize;                      // Ðàçìåð âõîäíîãî áóôôåðà
	unsigned char     m_arrInBuffer[flateZlibWindow]; // Âõîäíîé áóôôåð
	unsigned char     m_arrBuffer[flateZlibWindow];   // Áóôåð äëÿ ðåçóëüòàòà äåêîäèðîâàíèÿ
	int               m_nBufferCurPos;                // Òåêóùàÿ ïîçèöèÿ â áóôåðå
	int               m_nRemain;                      // ×èñëî êîððåêòíûõ áàéò â áóôåðå
	BOOL              m_bEndOfBlock;                  // True, êîãäà äîñòèãëè êîíöà áëîêà
	BOOL              m_bEOF;                         // True, êîãäà äîñòèãëè êîíöà ïîòîêà
};


//------------------------------------------------------------------------
// FlateStream
//------------------------------------------------------------------------

#define flateWindow             32768   // Ðàçìåð áóôåðà
#define flateMask               (flateWindow-1)
#define flateMaxHuffman         15      // ìàêèìàëüíàÿ äëèíà êîäà Huffman
#define flateMaxCodeLenCodes    19      // max # code length codes
#define flateMaxLitCodes        288     // max # literal codes
#define flateMaxDistCodes       30      // max # distance codes

struct FlateHuffmanCode 
{
	unsigned short nLength;   // äëèíà êîäà â áèòàõ
	unsigned short nValue;    // çíà÷åíèå äàííîãî êîäó
};

struct FlateHuffmanTable 
{
	FlateHuffmanCode *pCodes;  // òàáëèöà êîäîâ
	int               nMaxLen; // ìàêèìàëüíàÿ äëèíà êîäà
};

struct FlateDecode 
{
	int nExtraBitsCount; // êîëè÷åñòâî äîïîëíèòåëüíûõ áèò
	int nFirst;          // ïåðâàÿ äëèíà
};

class FlateStream: public FilterStream 
{
public:

	FlateStream(Stream *pStream, int nPredictor, int nWidth, int nComponents, int nBitsPerComponent);
	virtual ~FlateStream();
	virtual StreamType GetType() 
	{ 
		return strFlate; 
	}
	virtual void Reset();
	virtual int GetChar();
	virtual int LookChar();
	virtual int GetRawChar();
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent);
	virtual BOOL IsBinary(BOOL bLast = TRUE);

private:

	void ReadSome();
	BOOL StartBlock();
	void LoadFixedCodes();
	BOOL ReadDynamicCodes();
	void ConvertHuffmanCodes(int *pLengths, int nCount, FlateHuffmanTable *pTable);
	int  GetHuffmanCodeWord(FlateHuffmanTable *pTable);
	int  GetCodeWord(int nBits);

private:

	StreamPredictor  *m_pPredictor;              // Predictor
	unsigned char     m_arrBuffer[flateWindow];  // Áóôåð äëÿ ðåçóëüòàòà äåêîäèðîâàíèÿ
	int               m_nBufferCurPos;           // Òåêóùàÿ ïîçèöèÿ â áóôåðå
	int               m_nRemain;                 // ×èñëî êîððåêòíûõ áàéò â áóôåðå
	int               m_nCodeBuffer;             // Áåôåð èñõîäíûõ êîäîâ
	int               m_nCodeSize;               // ×èñëî áèò â m_nCodeBuffer
	int				  m_arrCodeLengths[flateMaxLitCodes + flateMaxDistCodes]; // Äëèíû êîäîâ(è äëÿ ñàìèõ ñëîâ è äëÿ ðàññòîÿíèé)
	FlateHuffmanTable m_oLiteratCodeTable;       // Òàáëèöà áóêâåííûõ êîäîâ
	FlateHuffmanTable m_oDistanceCodeTable;      // Òàáëèöà êîäîâ-ðàññòîÿíèé
	BOOL              m_bCompressedBlock;        // True, åñëè ÷èòàåì ñæàòûé áëîê
	int               m_nUncompBlockLen;         // Îñòàâøàÿñÿ äëèíà íåñæàòîãî áëîêà
	BOOL              m_bEndOfBlock;             // True, êîãäà äîñòèãëè êîíöà áëîêà
	BOOL              m_bEOF;                    // True, êîãäà äîñòèãëè êîíöà ïîòîêà

	static int               m_arrCodeLenCodeMap[flateMaxCodeLenCodes]; // 
	static FlateDecode       m_arrLengthDecode[flateMaxLitCodes-257];   // 
	static FlateDecode       m_arrDistanceDecode[flateMaxDistCodes];    // 
	static FlateHuffmanTable m_oFixedLiteralCodeTable;   // 
	static FlateHuffmanTable m_oFixedDistanceCodeTable;  // 
};

//------------------------------------------------------------------------
// EOFStream
//------------------------------------------------------------------------

class EOFStream: public FilterStream 
{
public:

	EOFStream(Stream *pStream);
	virtual ~EOFStream();
	virtual StreamType GetType() 
	{ 
		return strWeird; 
	}
	virtual void Reset() 
	{
	}
	virtual int GetChar() 
	{ 
		return EOF; 
	}
	virtual int LookChar() 
	{
		return EOF; 
	}
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent)  
	{ 
		return NULL; 
	}
	virtual BOOL IsBinary(BOOL bLast = TRUE) 
	{ 
		return FALSE; 
	}
};

//------------------------------------------------------------------------
// FixedLengthEncoder
//------------------------------------------------------------------------

class FixedLengthEncoder: public FilterStream 
{
public:

	FixedLengthEncoder(Stream *pStream, int nLength);
	~FixedLengthEncoder();
	virtual StreamType GetType() 
	{ 
		return strWeird; 
	}
	virtual void Reset();
	virtual int GetChar();
	virtual int LookChar();
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent) 
	{ 
		return NULL; 
	}
	virtual BOOL IsBinary(BOOL bLast = TRUE);
	virtual BOOL IsEncoder() 
	{ 
		return TRUE; 
	}

private:

	int m_nLength;
	int m_nCount;
};

//------------------------------------------------------------------------
// ASCIIHexEncoder
//------------------------------------------------------------------------

class ASCIIHexEncoder: public FilterStream 
{
public:

	ASCIIHexEncoder(Stream *pStream);
	virtual ~ASCIIHexEncoder();
	virtual StreamType GetType() 
	{ 
		return strWeird; 
	}
	virtual void Reset();
	virtual int GetChar()
    { 
		return ( m_pBufferPointer >= m_pBufferEnd && !FillBuffer() ) ? EOF : (*m_pBufferPointer++ & 0xff); 
	}
	virtual int LookChar()
    { 
		return ( m_pBufferPointer >= m_pBufferEnd && !FillBuffer() ) ? EOF : (*m_pBufferPointer & 0xff); 
	}
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent) 
	{ 
		return NULL; 
	}
	virtual BOOL IsBinary(BOOL bLast = TRUE) 
	{ 
		return FALSE; 
	}
	virtual BOOL IsEncoder() 
	{ 
		return TRUE; 
	}

private:

	BOOL FillBuffer();

private:

	char  m_sBuffer[4];
	char *m_pBufferPointer;
	char *m_pBufferEnd;
	int   m_nLineLength;
	BOOL  m_bEOF;
};

//------------------------------------------------------------------------
// ASCII85Encoder
//------------------------------------------------------------------------

class ASCII85Encoder: public FilterStream 
{
public:

	ASCII85Encoder(Stream *pStream);
	virtual ~ASCII85Encoder();
	virtual StreamType GetType() 
	{ 
		return strWeird; 
	}
	virtual void Reset();
	virtual int GetChar()
    { 
		return ( m_pBufferPointer >= m_pBufferEnd && !FillBuffer()) ? EOF : (*m_pBufferPointer++ & 0xff); 
	}
	virtual int LookChar()
    { 
		return ( m_pBufferPointer >= m_pBufferEnd && !FillBuffer()) ? EOF : (*m_pBufferPointer & 0xff); 
	}
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent) 
	{ 
		return NULL; 
	}
	virtual BOOL IsBinary(BOOL bLast = TRUE) 
	{ 
		return FALSE; 
	}
	virtual BOOL IsEncoder() 
	{ 
		return TRUE; 
	}
private:

	BOOL FillBuffer();

private:

	char  m_sBuffer[8];
	char *m_pBufferPointer;
	char *m_pBufferEnd;
	int   m_nLineLength;
	BOOL  m_bEOF;
};

//------------------------------------------------------------------------
// RunLengthEncoder
//------------------------------------------------------------------------

class RunLengthEncoder: public FilterStream 
{
public:

	RunLengthEncoder(Stream *pStream);
	virtual ~RunLengthEncoder();
	virtual StreamType GetType() 
	{ 
		return strWeird; 
	}
	virtual void Reset();
	virtual int GetChar()
	{ 
		return ( m_pBufferPointer >= m_pBufferEnd && !FillBuffer()) ? EOF : (*m_pBufferPointer++ & 0xff); 
	}
	virtual int LookChar()
    { 
		return ( m_pBufferPointer >= m_pBufferEnd && !FillBuffer()) ? EOF : (*m_pBufferPointer & 0xff); 
	}
	virtual StringExt *GetPSFilter(int nPSLevel, char *sIndent) 
	{ 
		return NULL; 
	}
	virtual BOOL IsBinary(BOOL bLast = TRUE) 
	{
		return TRUE; 
	}
	virtual BOOL IsEncoder() 
	{
		return TRUE; 
	}

private:

	BOOL FillBuffer();

private:

	char  m_sBuffer[131];
	char *m_pBufferPointer;
	char *m_pBufferEnd;
	char *m_pNextEnd;
	BOOL  m_bEOF;
};

#endif /* _STREAM_H */