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"

//-------------------------------------------------------------------------------
//  Constraints
//-------------------------------------------------------------------------------
// BufferSize <= UINT16_MAX

//-------------------------------------------------------------------------------
//  Codec versions
//
// Version 2:   modified data structure PGFHeader (backward compatibility assured)
// Version 4:   DataT: INT32 instead of INT16, allows 31 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)
//
//-------------------------------------------------------------------------------
#define PGFCodecVersion     "6.14.12"           
#define PGFCodecVersionID   0x061412            

//-------------------------------------------------------------------------------
//  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                  
// version numbers
#ifdef __PGF32SUPPORT__
#define PGFVersion          (Version2 | PGF32 | Version5 | Version6)    
#else
#define PGFVersion          (Version2 |         Version5 | Version6)    
#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 };


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

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

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

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

union ROIBlockHeader {
    ROIBlockHeader(UINT16 v) { val = v; }
    ROIBlockHeader(UINT32 size, bool end)   { ASSERT(size < (1 << RLblockSizeLen)); rbh.bufferSize = size; rbh.tileEnd = end; }
    
    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
};

#pragma pack()

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

    OSError error;              
};

struct PGFRect {
    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) {}

    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); }

    UINT32 left, top, right, 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)

#endif //PGF_PGFTYPES_H