PGFimage.h

Go to the documentation of this file.

/*
 * The Progressive Graphics File; http://www.libpgf.org
 * 
 * $Date: 2007-02-03 13:04:21 +0100 (Sa, 03 Feb 2007) $
 * $Revision: 280 $
 * 
 * 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_PGFIMAGE_H
#define PGF_PGFIMAGE_H

#include "PGFstream.h"

// types
enum ProgressMode { PM_Relative, PM_Absolute };

// prototypes
class CDecoder;
class CEncoder;
class CWaveletTransform;

class CPGFImage {
public:
    
    CPGFImage();

    virtual ~CPGFImage();

    virtual void Close();

    virtual void Destroy();

    void Open(CPGFStream* stream) THROW_;

    bool IsOpen() const { return m_decoder != NULL; }

    void Read(int level = 0, CallbackPtr cb = NULL, void *data = NULL) THROW_;

#ifdef __PGFROISUPPORT__
    void Read(PGFRect& rect, int level = 0, CallbackPtr cb = NULL, void *data = NULL) THROW_;
#endif

    void ReadPreview() THROW_                                       { Read(Levels() - 1); }

    void Reconstruct(int level = 0) THROW_;

    void GetBitmap(int pitch, UINT8* buff, BYTE bpp, int channelMap[] = NULL, CallbackPtr cb = NULL, void *data = NULL) const THROW_; // throws IOException

    void GetYUV(int pitch, DataT* buff, BYTE bpp, int channelMap[] = NULL, CallbackPtr cb = NULL, void *data = NULL) const THROW_; // throws IOException

    void ImportBitmap(int pitch, UINT8 *buff, BYTE bpp, int channelMap[] = NULL, CallbackPtr cb = NULL, void *data = NULL) THROW_;

    void ImportYUV(int pitch, DataT *buff, BYTE bpp, int channelMap[] = NULL, CallbackPtr cb = NULL, void *data = NULL) THROW_;

    void Write(CPGFStream* stream, UINT32* nWrittenBytes = NULL, CallbackPtr cb = NULL, void *data = NULL) THROW_;

    UINT32 WriteHeader(CPGFStream* stream) THROW_;

    UINT32 WriteImage(CPGFStream* stream, CallbackPtr cb = NULL, void *data = NULL) THROW_;

#ifdef __PGFROISUPPORT__
    UINT32 Write(int level, CallbackPtr cb = NULL, void *data = NULL) THROW_;
#endif

    void ConfigureEncoder(bool useOMP = true, bool favorSpeedOverSize = false) { m_useOMPinEncoder = useOMP; m_favorSpeedOverSize = favorSpeedOverSize; }

    void ConfigureDecoder(bool useOMP = true, bool skipUserData = false) { m_useOMPinDecoder = useOMP; m_skipUserData = skipUserData; }

    void ResetStreamPos() THROW_;

    void SetChannel(DataT* channel, int c = 0)                      { ASSERT(c >= 0 && c < MaxChannels); m_channel[c] = channel; }

    void SetHeader(const PGFHeader& header, BYTE flags = 0, UINT8* userData = 0, UINT32 userDataLength = 0) THROW_; // throws IOException

    void SetMaxValue(UINT32 maxValue);

    void SetProgressMode(ProgressMode pm)                           { m_progressMode = pm; }

    void SetRefreshCallback(RefreshCB callback, void* arg)          { m_cb = callback; m_cbArg = arg; }

    void SetColorTable(UINT32 iFirstColor, UINT32 nColors, const RGBQUAD* prgbColors) THROW_;

    DataT* GetChannel(int c = 0)                                    { ASSERT(c >= 0 && c < MaxChannels); return m_channel[c]; }

    void GetColorTable(UINT32 iFirstColor, UINT32 nColors, RGBQUAD* prgbColors) const THROW_;

    // Returns address of internal color table
    const RGBQUAD* GetColorTable() const                            { return m_postHeader.clut; }

    const PGFHeader* GetHeader() const                              { return &m_header; }

    UINT32 GetMaxValue() const                                      { return (1 << m_header.usedBitsPerChannel) - 1; }

    UINT64 GetUserDataPos() const                                   { return m_userDataPos; }                                   

    const UINT8* GetUserData(UINT32& size) const;

    UINT32 GetEncodedHeaderLength() const;

    UINT32 GetEncodedLevelLength(int level) const                   { ASSERT(level >= 0 && level < m_header.nLevels); return m_levelLength[m_header.nLevels - level - 1]; }

    UINT32 ReadEncodedHeader(UINT8* target, UINT32 targetLen) const THROW_;

    UINT32 ReadEncodedData(int level, UINT8* target, UINT32 targetLen) const THROW_;

    UINT32 ChannelWidth(int c = 0) const                            { ASSERT(c >= 0 && c < MaxChannels); return m_width[c]; }

    UINT32 ChannelHeight(int c = 0) const                           { ASSERT(c >= 0 && c < MaxChannels); return m_height[c]; }

    BYTE ChannelDepth() const                                       { return CurrentChannelDepth(m_preHeader.version); }

    UINT32 Width(int level = 0) const                               { ASSERT(level >= 0); return LevelWidth(m_header.width, level); }

    UINT32 Height(int level = 0) const                              { ASSERT(level >= 0); return LevelHeight(m_header.height, level); }

    BYTE Level() const                                              { return (BYTE)m_currentLevel; }

    BYTE Levels() const                                             { return m_header.nLevels; }

    BYTE Quality() const                                            { return m_header.quality; }

    BYTE Channels() const                                           { return m_header.channels; }
    
    BYTE Mode() const                                               { return m_header.mode; }

    BYTE BPP() const                                                { return m_header.bpp; }

    bool ROIisSupported() const                                     { return (m_preHeader.version & PGFROI) == PGFROI; }

    BYTE UsedBitsPerChannel() const;

    BYTE Version() const                                            { return CurrentVersion(m_preHeader.version); }

    //class methods

    static bool ImportIsSupported(BYTE mode);

    static UINT32 LevelWidth(UINT32 width, int level)               { ASSERT(level >= 0); UINT32 w = (width >> level); return ((w << level) == width) ? w : w + 1; }

    static UINT32 LevelHeight(UINT32 height, int level)             { ASSERT(level >= 0); UINT32 h = (height >> level); return ((h << level) == height) ? h : h + 1; }

    static BYTE CurrentVersion(BYTE version = PGFVersion);

    static BYTE CurrentChannelDepth(BYTE version = PGFVersion)      { return (version & PGF32) ? 32 : 16; }

protected:
    CWaveletTransform* m_wtChannel[MaxChannels];    
    DataT* m_channel[MaxChannels];                  
    CDecoder* m_decoder;            
    CEncoder* m_encoder;            
    UINT32* m_levelLength;          
    UINT32 m_width[MaxChannels];    
    UINT32 m_height[MaxChannels];   
    PGFPreHeader m_preHeader;       
    PGFHeader m_header;             
    PGFPostHeader m_postHeader;     
    UINT64 m_userDataPos;           
    int m_currentLevel;             
    BYTE m_quant;                   
    bool m_downsample;              
    bool m_favorSpeedOverSize;      
    bool m_useOMPinEncoder;         
    bool m_useOMPinDecoder;         
    bool m_skipUserData;            
#ifdef __PGFROISUPPORT__
    bool m_streamReinitialized;     
    PGFRect m_roi;                  
#endif

private:    
    RefreshCB m_cb;                 
    void *m_cbArg;                  
    double m_percent;               
    ProgressMode m_progressMode;    

    void ComputeLevels();
    void CompleteHeader();
    void RgbToYuv(int pitch, UINT8* rgbBuff, BYTE bpp, int channelMap[], CallbackPtr cb, void *data) THROW_;
    void Downsample(int nChannel);
    UINT32 UpdatePostHeaderSize() THROW_;
    void WriteLevel() THROW_;

#ifdef __PGFROISUPPORT__
    void SetROI(PGFRect rect);
#endif

    UINT8 Clamp4(DataT v) const {
        if (v & 0xFFFFFFF0) return (v < 0) ? (UINT8)0: (UINT8)15; else return (UINT8)v;
    }   
    UINT16 Clamp6(DataT v) const {
        if (v & 0xFFFFFFC0) return (v < 0) ? (UINT16)0: (UINT16)63; else return (UINT16)v;
    }   
    UINT8 Clamp8(DataT v) const {
        // needs only one test in the normal case
        if (v & 0xFFFFFF00) return (v < 0) ? (UINT8)0 : (UINT8)255; else return (UINT8)v;
    }
    UINT16 Clamp16(DataT v) const {
        if (v & 0xFFFF0000) return (v < 0) ? (UINT16)0: (UINT16)65535; else return (UINT16)v;
    }   
    UINT32 Clamp31(DataT v) const {
        return (v < 0) ? 0 : (UINT32)v;
    }   
};

#endif //PGF_PGFIMAGE_H