PGFtypes.h

Go to the documentation of this file.

/*
 * The Progressive Graphics File; http://www.libpgf.org
 * 
 * $Date: 2007-06-11 10:56:17 +0200 (Mo, 11 Jun 2007) $
 * $Revision: 299 $
 * 
 * This file Copyright (C) 2006 xeraina GmbH, Switzerland
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 * 
 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */


#ifndef PGF_PGFTYPES_H
#define PGF_PGFTYPES_H

#include "PGFplatform.h"

//-------------------------------------------------------------------------------
//      Codec versions
//
// Version 2:   modified data structure PGFHeader (backward compatibility assured)
// Version 4:   DataT: INT32 instead of INT16, allows 30 bit per pixel and channel (backward compatibility assured)
// Version 5:   ROI, new block-reordering scheme (backward compatibility assured)
// Version 6:   modified data structure PGFPreHeader: hSize (header size) is now a UINT32 instead of a UINT16 (backward compatibility assured)
// Version 7:   last two bytes in header are now used for extended version numbers; new data representation for bitmaps (backward compatibility assured)
//
//-------------------------------------------------------------------------------
#define PGFMajorNumber          7
#define PGFYear                         21              // leading zeros are possible
#define PGFWeek                         07              // leading zeros are possible

#define PPCAT_NX(A, B) A ## B
#define PPCAT(A, B) PPCAT_NX(A, B)
#define STRINGIZE_NX(A) #A
#define STRINGIZE(A) STRINGIZE_NX(A)

//#define PGFCodecVersionID             0x072102
#define PGFCodecVersionID PPCAT(PPCAT(PPCAT(0x0, PGFMajorNumber), PGFYear), PGFWeek)
//#define PGFCodecVersion               "7.21.02"               ///< Major number, Minor number: Year (2) Week (2)
#define PGFCodecVersion STRINGIZE(PPCAT(PPCAT(PPCAT(PPCAT(PGFMajorNumber, .), PGFYear), .), PGFWeek))

//-------------------------------------------------------------------------------
//      Image constants
//-------------------------------------------------------------------------------
#define PGFMagic                        "PGF"                           
#define MaxLevel                        30                                      
#define NSubbands                       4                                       
#define MaxChannels                     8                                       
#define DownsampleThreshold 3                                   
#define ColorTableLen           256                                     
// version flags
#define Version2                        2                                       
#define PGF32                           4                                       
#define PGFROI                          8                                       
#define Version5                        16                                      
#define Version6                        32                                      
#define Version7                        64                                      
// version numbers
#ifdef __PGF32SUPPORT__
#define PGFVersion                      (Version2 | PGF32 | Version5 | Version6 | Version7)     
#else
#define PGFVersion                      (Version2 |         Version5 | Version6 | Version7)     
#endif

//-------------------------------------------------------------------------------
//      Coder constants
//-------------------------------------------------------------------------------
#define BufferSize                      16384                           
#define RLblockSizeLen          15                                      
#define LinBlockSize            8                                       
#define InterBlockSize          4                                       
#ifdef __PGF32SUPPORT__
        #define MaxBitPlanes    31                                      
#else
        #define MaxBitPlanes    15                                      
#endif
#define MaxBitPlanesLog         5                                       
#define MaxQuality                      MaxBitPlanes            

//-------------------------------------------------------------------------------
// Types
//-------------------------------------------------------------------------------
enum Orientation                { LL = 0, HL = 1, LH = 2, HH = 3 };
enum ProgressMode               { PM_Relative, PM_Absolute };
enum UserdataPolicy             { UP_Skip = 0, UP_CachePrefix = 1, UP_CacheAll = 2 };


#pragma pack(1)
struct PGFMagicVersion {
        char magic[3];                          
        UINT8 version;                          
        // total: 4 Bytes
};

struct PGFPreHeader : PGFMagicVersion {
        UINT32 hSize;                           
        // total: 8 Bytes
};

struct PGFVersionNumber {
        PGFVersionNumber(UINT8 _major, UINT8 _year, UINT8 _week) : major(_major), year(_year), week(_week) {}

#ifdef PGF_USE_BIG_ENDIAN
        UINT16 week  : 6;       
        UINT16 year  : 6;       
        UINT16 major : 4;       
#else
        UINT16 major : 4;       
        UINT16 year  : 6;       
        UINT16 week  : 6;       
#endif // PGF_USE_BIG_ENDIAN
        // total: 2 Bytes
};

struct PGFHeader {
        PGFHeader() : width(0), height(0), nLevels(0), quality(0), bpp(0), channels(0), mode(ImageModeUnknown), usedBitsPerChannel(0), version(0, 0, 0) {}
        UINT32 width;                           
        UINT32 height;                          
        UINT8 nLevels;                          
        UINT8 quality;                          
        UINT8 bpp;                                      
        UINT8 channels;                         
        UINT8 mode;                                     
        UINT8 usedBitsPerChannel;       
        PGFVersionNumber version;       
        // total: 16 Bytes
};

struct PGFPostHeader {
        RGBQUAD clut[ColorTableLen];
        UINT8 *userData;                        
        UINT32 userDataLen;                     
        UINT32 cachedUserDataLen;       
};

union ROIBlockHeader {
        UINT16 val; 
        struct RBH {
#ifdef PGF_USE_BIG_ENDIAN
                UINT16 tileEnd   :                              1;      
                UINT16 bufferSize: RLblockSizeLen;      
#else
                UINT16 bufferSize: RLblockSizeLen;      
                UINT16 tileEnd   :                              1;      
#endif // PGF_USE_BIG_ENDIAN
        } rbh;  
        // total: 2 Bytes

        ROIBlockHeader(UINT16 v) { val = v; }

        ROIBlockHeader(UINT32 size, bool end) { ASSERT(size < (1 << RLblockSizeLen)); rbh.bufferSize = size; rbh.tileEnd = end; }
};

#pragma pack()

struct IOException {
        OSError error;                          
        
        IOException() : error(NoError) {}
        
        IOException(OSError err) : error(err) {}
};

struct PGFRect {
        UINT32 left, top, right, bottom;

        PGFRect() : left(0), top(0), right(0), bottom(0) {}
        
        PGFRect(UINT32 x, UINT32 y, UINT32 width, UINT32 height) : left(x), top(y), right(x + width), bottom(y + height) {}

#ifdef WIN32
        PGFRect(const RECT& rect) : left(rect.left), top(rect.top), right(rect.right), bottom(rect.bottom) {
                ASSERT(rect.left >= 0 && rect.right >= 0 && rect.left <= rect.right);
                ASSERT(rect.top >= 0 && rect.bottom >= 0 && rect.top <= rect.bottom);
        }
        
        PGFRect& operator=(const RECT& rect) {
                left = rect.left; top = rect.top; right = rect.right; bottom = rect.bottom;
                return *this;
        }
        
        operator RECT() {
                RECT rect = { (LONG)left, (LONG)top, (LONG)right, (LONG)bottom };
                return rect;
        }
#endif

        UINT32 Width() const                                    { return right - left; }
        
        UINT32 Height() const                                   { return bottom - top; }
        
        bool IsInside(UINT32 x, UINT32 y) const { return (x >= left && x < right && y >= top && y < bottom); }
};

#ifdef __PGF32SUPPORT__
typedef INT32 DataT;
#else
typedef INT16 DataT;
#endif

typedef void (*RefreshCB)(void *p);

//-------------------------------------------------------------------------------
// Image constants
//-------------------------------------------------------------------------------
#define MagicVersionSize        sizeof(PGFMagicVersion)
#define PreHeaderSize           sizeof(PGFPreHeader)
#define HeaderSize                      sizeof(PGFHeader)
#define ColorTableSize          (ColorTableLen*sizeof(RGBQUAD))
#define DataTSize                       sizeof(DataT)
#define MaxUserDataSize         0x7FFFFFFF

#endif //PGF_PGFTYPES_H