libpgf 6.14.12
PGF - Progressive Graphics File
Public Member Functions | Static Public Member Functions | Protected Attributes | Private Member Functions | Private Attributes | List of all members
CPGFImage Class Reference

PGF main class. More...

#include <PGFimage.h>

Public Member Functions

 CPGFImage ()
 Standard constructor: It is used to create a PGF instance for opening and reading. More...
 
virtual ~CPGFImage ()
 Destructor: Destroy internal data structures. More...
 
virtual void Close ()
 
virtual void Destroy ()
 
void Open (CPGFStream *stream) THROW_
 
bool IsOpen () const
 Returns true if the PGF has been opened and not closed. More...
 
void Read (int level=0, CallbackPtr cb=NULL, void *data=NULL) THROW_
 
void Read (PGFRect &rect, int level=0, CallbackPtr cb=NULL, void *data=NULL) THROW_
 
void ReadPreview () THROW_
 
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_
 
void GetYUV (int pitch, DataT *buff, BYTE bpp, int channelMap[]=NULL, CallbackPtr cb=NULL, void *data=NULL) const THROW_
 
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_
 
UINT32 Write (int level, CallbackPtr cb=NULL, void *data=NULL) THROW_
 
void ConfigureEncoder (bool useOMP=true, bool favorSpeedOverSize=false)
 
void ConfigureDecoder (bool useOMP=true, bool skipUserData=false)
 
void ResetStreamPos () THROW_
 Reset stream position to start of PGF pre-header. More...
 
void SetChannel (DataT *channel, int c=0)
 
void SetHeader (const PGFHeader &header, BYTE flags=0, UINT8 *userData=0, UINT32 userDataLength=0) THROW_
 
void SetMaxValue (UINT32 maxValue)
 
void SetProgressMode (ProgressMode pm)
 
void SetRefreshCallback (RefreshCB callback, void *arg)
 
void SetColorTable (UINT32 iFirstColor, UINT32 nColors, const RGBQUAD *prgbColors) THROW_
 
DataT * GetChannel (int c=0)
 
void GetColorTable (UINT32 iFirstColor, UINT32 nColors, RGBQUAD *prgbColors) const THROW_
 
const RGBQUAD * GetColorTable () const
 
const PGFHeader * GetHeader () const
 
UINT32 GetMaxValue () const
 
UINT64 GetUserDataPos () const
 
const UINT8 * GetUserData (UINT32 &size) const
 
UINT32 GetEncodedHeaderLength () const
 
UINT32 GetEncodedLevelLength (int level) const
 
UINT32 ReadEncodedHeader (UINT8 *target, UINT32 targetLen) const THROW_
 
UINT32 ReadEncodedData (int level, UINT8 *target, UINT32 targetLen) const THROW_
 
UINT32 ChannelWidth (int c=0) const
 
UINT32 ChannelHeight (int c=0) const
 
BYTE ChannelDepth () const
 
UINT32 Width (int level=0) const
 
UINT32 Height (int level=0) const
 
BYTE Level () const
 
BYTE Levels () const
 
BYTE Quality () const
 
BYTE Channels () const
 
BYTE Mode () const
 
BYTE BPP () const
 
bool ROIisSupported () const
 
BYTE UsedBitsPerChannel () const
 
BYTE Version () const
 

Static Public Member Functions

static bool ImportIsSupported (BYTE mode)
 
static UINT32 LevelWidth (UINT32 width, int level)
 
static UINT32 LevelHeight (UINT32 height, int level)
 
static BYTE CurrentVersion (BYTE version=PGFVersion)
 Return version. More...
 
static BYTE CurrentChannelDepth (BYTE version=PGFVersion)
 

Protected Attributes

CWaveletTransform * m_wtChannel [MaxChannels]
 wavelet transformed color channels More...
 
DataT * m_channel [MaxChannels]
 untransformed channels in YUV format More...
 
CDecoder * m_decoder
 PGF decoder. More...
 
CEncoder * m_encoder
 PGF encoder. More...
 
UINT32 * m_levelLength
 length of each level in bytes; first level starts immediately after this array More...
 
UINT32 m_width [MaxChannels]
 width of each channel at current level More...
 
UINT32 m_height [MaxChannels]
 height of each channel at current level More...
 
PGFPreHeader m_preHeader
 PGF pre-header. More...
 
PGFHeader m_header
 PGF file header. More...
 
PGFPostHeader m_postHeader
 PGF post-header. More...
 
UINT64 m_userDataPos
 stream position of user data More...
 
int m_currentLevel
 transform level of current image More...
 
BYTE m_quant
 quantization parameter More...
 
bool m_downsample
 chrominance channels are downsampled More...
 
bool m_favorSpeedOverSize
 favor encoding speed over compression ratio More...
 
bool m_useOMPinEncoder
 use Open MP in encoder More...
 
bool m_useOMPinDecoder
 use Open MP in decoder More...
 
bool m_skipUserData
 skip user data (metadata) during open More...
 
bool m_streamReinitialized
 stream has been reinitialized More...
 
PGFRect m_roi
 region of interest More...
 

Private Member Functions

void ComputeLevels ()
 
bool 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_
 
void SetROI (PGFRect rect)
 
UINT8 Clamp4 (DataT v) const
 
UINT16 Clamp6 (DataT v) const
 
UINT8 Clamp8 (DataT v) const
 
UINT16 Clamp16 (DataT v) const
 
UINT32 Clamp31 (DataT v) const
 

Private Attributes

RefreshCB m_cb
 pointer to refresh callback procedure More...
 
void * m_cbArg
 refresh callback argument More...
 
double m_percent
 progress [0..1] More...
 
ProgressMode m_progressMode
 progress mode used in Read and Write; PM_Relative is default mode More...
 

Detailed Description

PGF main class.

PGF image class is the main class. You always need a PGF object for encoding or decoding image data. Decoding: pgf.Open(...) pgf.Read(...) pgf.GetBitmap(...) Encoding: pgf.SetHeader(...) pgf.ImportBitmap(...) pgf.Write(...)

Author
C. Stamm, R. Spuler

Definition at line 57 of file PGFimage.h.

Constructor & Destructor Documentation

◆ CPGFImage()

CPGFImage::CPGFImage ( )

Standard constructor: It is used to create a PGF instance for opening and reading.

Definition at line 55 of file PGFimage.cpp.

56: m_decoder(0)
57, m_encoder(0)
58, m_levelLength(0)
59, m_currentLevel(0)
60, m_quant(0)
61, m_userDataPos(0)
62, m_downsample(false)
63, m_favorSpeedOverSize(false)
64, m_useOMPinEncoder(true)
65, m_useOMPinDecoder(true)
66, m_skipUserData(false)
67#ifdef __PGFROISUPPORT__
68, m_streamReinitialized(false)
69#endif
70, m_cb(0)
71, m_cbArg(0)
72, m_progressMode(PM_Relative)
73, m_percent(0)
74{
75
76 // init preHeader
77 memcpy(m_preHeader.magic, PGFMagic, 3);
78 m_preHeader.version = PGFVersion;
79 m_preHeader.hSize = 0;
80
81 // init postHeader
82 m_postHeader.userData = 0;
83 m_postHeader.userDataLen = 0;
84
85 // init channels
86 for (int i=0; i < MaxChannels; i++) {
87 m_channel[i] = 0;
88 m_wtChannel[i] = 0;
89 }
90
91 // set image width and height
92 m_width[0] = 0;
93 m_height[0] = 0;
94}
PM_Relative
@ PM_Relative
Definition: PGFimage.h:36
PGFMagic
#define PGFMagic
PGF identification.
Definition: PGFtypes.h:55
MaxChannels
#define MaxChannels
maximum number of (color) channels
Definition: PGFtypes.h:58
PGFVersion
#define PGFVersion
current standard version
Definition: PGFtypes.h:69
CPGFImage::m_useOMPinDecoder
bool m_useOMPinDecoder
use Open MP in decoder
Definition: PGFimage.h:527
CPGFImage::m_decoder
CDecoder * m_decoder
PGF decoder.
Definition: PGFimage.h:513
CPGFImage::m_useOMPinEncoder
bool m_useOMPinEncoder
use Open MP in encoder
Definition: PGFimage.h:526
CPGFImage::m_levelLength
UINT32 * m_levelLength
length of each level in bytes; first level starts immediately after this array
Definition: PGFimage.h:515
CPGFImage::m_height
UINT32 m_height[MaxChannels]
height of each channel at current level
Definition: PGFimage.h:517
CPGFImage::m_currentLevel
int m_currentLevel
transform level of current image
Definition: PGFimage.h:522
CPGFImage::m_channel
DataT * m_channel[MaxChannels]
untransformed channels in YUV format
Definition: PGFimage.h:512
CPGFImage::m_cbArg
void * m_cbArg
refresh callback argument
Definition: PGFimage.h:536
CPGFImage::m_quant
BYTE m_quant
quantization parameter
Definition: PGFimage.h:523
CPGFImage::m_favorSpeedOverSize
bool m_favorSpeedOverSize
favor encoding speed over compression ratio
Definition: PGFimage.h:525
CPGFImage::m_encoder
CEncoder * m_encoder
PGF encoder.
Definition: PGFimage.h:514
CPGFImage::m_progressMode
ProgressMode m_progressMode
progress mode used in Read and Write; PM_Relative is default mode
Definition: PGFimage.h:538
CPGFImage::m_downsample
bool m_downsample
chrominance channels are downsampled
Definition: PGFimage.h:524
CPGFImage::m_width
UINT32 m_width[MaxChannels]
width of each channel at current level
Definition: PGFimage.h:516
CPGFImage::m_postHeader
PGFPostHeader m_postHeader
PGF post-header.
Definition: PGFimage.h:520
CPGFImage::m_cb
RefreshCB m_cb
pointer to refresh callback procedure
Definition: PGFimage.h:535
CPGFImage::m_userDataPos
UINT64 m_userDataPos
stream position of user data
Definition: PGFimage.h:521
CPGFImage::m_skipUserData
bool m_skipUserData
skip user data (metadata) during open
Definition: PGFimage.h:528
CPGFImage::m_preHeader
PGFPreHeader m_preHeader
PGF pre-header.
Definition: PGFimage.h:518
CPGFImage::m_percent
double m_percent
progress [0..1]
Definition: PGFimage.h:537
CPGFImage::m_wtChannel
CWaveletTransform * m_wtChannel[MaxChannels]
wavelet transformed color channels
Definition: PGFimage.h:511
CPGFImage::m_streamReinitialized
bool m_streamReinitialized
stream has been reinitialized
Definition: PGFimage.h:530
PGFMagicVersion::magic
char magic[3]
PGF identification = "PGF".
Definition: PGFtypes.h:105
PGFMagicVersion::version
UINT8 version
PGF version.
Definition: PGFtypes.h:106
PGFPostHeader::userDataLen
UINT32 userDataLen
user data size in bytes
Definition: PGFtypes.h:144
PGFPostHeader::userData
UINT8 * userData
user data of size userDataLen
Definition: PGFtypes.h:143
PGFPreHeader::hSize
UINT32 hSize
total size of PGFHeader, [ColorTable], and [UserData] in bytes
Definition: PGFtypes.h:115

◆ ~CPGFImage()

CPGFImage::~CPGFImage ( )
virtual

Destructor: Destroy internal data structures.

Definition at line 98 of file PGFimage.cpp.

98 {
99 Destroy();
100}
CPGFImage::Destroy
virtual void Destroy()
Definition: PGFimage.cpp:105

Member Function Documentation

◆ BPP()

BYTE CPGFImage::BPP ( ) const
inline

Return the number of bits per pixel. Valid values can be 1, 8, 12, 16, 24, 32, 48, 64.

Returns
Number of bits per pixel.

Definition at line 460 of file PGFimage.h.

460{ return m_header.bpp; }
CPGFImage::m_header
PGFHeader m_header
PGF file header.
Definition: PGFimage.h:519
PGFHeader::bpp
UINT8 bpp
bits per pixel
Definition: PGFtypes.h:129

◆ ChannelDepth()

BYTE CPGFImage::ChannelDepth ( ) const
inline

Return bits per channel of the image's encoder.

Returns
Bits per channel

Definition at line 409 of file PGFimage.h.

409{ return CurrentChannelDepth(m_preHeader.version); }
CPGFImage::CurrentChannelDepth
static BYTE CurrentChannelDepth(BYTE version=PGFVersion)
Definition: PGFimage.h:508

◆ ChannelHeight()

UINT32 CPGFImage::ChannelHeight ( int  c = 0) const
inline

Return current image height of given channel in pixels. The returned height depends on the levels read so far and on ROI.

Parameters
cA channel index
Returns
Channel height in pixels

Definition at line 404 of file PGFimage.h.

404{ ASSERT(c >= 0 && c < MaxChannels); return m_height[c]; }

◆ Channels()

BYTE CPGFImage::Channels ( ) const
inline

Return the number of image channels. An image of type RGB contains 3 image channels (B, G, R).

Returns
Number of image channels

Definition at line 447 of file PGFimage.h.

447{ return m_header.channels; }
PGFHeader::channels
UINT8 channels
number of channels
Definition: PGFtypes.h:130

◆ ChannelWidth()

UINT32 CPGFImage::ChannelWidth ( int  c = 0) const
inline

Return current image width of given channel in pixels. The returned width depends on the levels read so far and on ROI.

Parameters
cA channel index
Returns
Channel width in pixels

Definition at line 397 of file PGFimage.h.

397{ ASSERT(c >= 0 && c < MaxChannels); return m_width[c]; }

◆ Clamp16()

UINT16 CPGFImage::Clamp16 ( DataT  v) const
inlineprivate

Definition at line 561 of file PGFimage.h.

561 {
562 if (v & 0xFFFF0000) return (v < 0) ? (UINT16)0: (UINT16)65535; else return (UINT16)v;
563 }

◆ Clamp31()

UINT32 CPGFImage::Clamp31 ( DataT  v) const
inlineprivate

Definition at line 564 of file PGFimage.h.

564 {
565 return (v < 0) ? 0 : (UINT32)v;
566 }

◆ Clamp4()

UINT8 CPGFImage::Clamp4 ( DataT  v) const
inlineprivate

Definition at line 551 of file PGFimage.h.

551 {
552 if (v & 0xFFFFFFF0) return (v < 0) ? (UINT8)0: (UINT8)15; else return (UINT8)v;
553 }

◆ Clamp6()

UINT16 CPGFImage::Clamp6 ( DataT  v) const
inlineprivate

Definition at line 554 of file PGFimage.h.

554 {
555 if (v & 0xFFFFFFC0) return (v < 0) ? (UINT16)0: (UINT16)63; else return (UINT16)v;
556 }

◆ Clamp8()

UINT8 CPGFImage::Clamp8 ( DataT  v) const
inlineprivate

Definition at line 557 of file PGFimage.h.

557 {
558 // needs only one test in the normal case
559 if (v & 0xFFFFFF00) return (v < 0) ? (UINT8)0 : (UINT8)255; else return (UINT8)v;
560 }

◆ Close()

void CPGFImage::Close ( )
virtual

Close PGF image after opening and reading. Destructor calls this method during destruction.

Definition at line 122 of file PGFimage.cpp.

122 {
123 delete m_decoder; m_decoder = 0;
124}

◆ CompleteHeader()

bool CPGFImage::CompleteHeader ( )
private

Definition at line 208 of file PGFimage.cpp.

208 {
209 if (m_header.mode == ImageModeUnknown) {
210 // undefined mode
211 switch(m_header.bpp) {
212 case 1: m_header.mode = ImageModeBitmap; break;
213 case 8: m_header.mode = ImageModeGrayScale; break;
214 case 12: m_header.mode = ImageModeRGB12; break;
215 case 16: m_header.mode = ImageModeRGB16; break;
216 case 24: m_header.mode = ImageModeRGBColor; break;
217 case 32: m_header.mode = ImageModeRGBA; break;
218 case 48: m_header.mode = ImageModeRGB48; break;
219 default: m_header.mode = ImageModeRGBColor; break;
220 }
221 }
222 if (!m_header.bpp) {
223 // undefined bpp
224 switch(m_header.mode) {
225 case ImageModeBitmap:
226 m_header.bpp = 1;
227 break;
228 case ImageModeIndexedColor:
229 case ImageModeGrayScale:
230 m_header.bpp = 8;
231 break;
232 case ImageModeRGB12:
233 m_header.bpp = 12;
234 break;
235 case ImageModeRGB16:
236 case ImageModeGray16:
237 m_header.bpp = 16;
238 break;
239 case ImageModeRGBColor:
240 case ImageModeLabColor:
241 m_header.bpp = 24;
242 break;
243 case ImageModeRGBA:
244 case ImageModeCMYKColor:
245 case ImageModeGray32:
246 m_header.bpp = 32;
247 break;
248 case ImageModeRGB48:
249 case ImageModeLab48:
250 m_header.bpp = 48;
251 break;
252 case ImageModeCMYK64:
253 m_header.bpp = 64;
254 break;
255 default:
256 ASSERT(false);
257 m_header.bpp = 24;
258 }
259 }
260 if (m_header.mode == ImageModeRGBColor && m_header.bpp == 32) {
261 // change mode
262 m_header.mode = ImageModeRGBA;
263 }
264
265 if (m_header.mode == ImageModeBitmap && m_header.bpp != 1) return false;
266 if (m_header.mode == ImageModeIndexedColor && m_header.bpp != 8) return false;
267 if (m_header.mode == ImageModeGrayScale && m_header.bpp != 8) return false;
268 if (m_header.mode == ImageModeGray16 && m_header.bpp != 16) return false;
269 if (m_header.mode == ImageModeGray32 && m_header.bpp != 32) return false;
270 if (m_header.mode == ImageModeRGBColor && m_header.bpp != 24) return false;
271 if (m_header.mode == ImageModeRGBA && m_header.bpp != 32) return false;
272 if (m_header.mode == ImageModeRGB12 && m_header.bpp != 12) return false;
273 if (m_header.mode == ImageModeRGB16 && m_header.bpp != 16) return false;
274 if (m_header.mode == ImageModeRGB48 && m_header.bpp != 48) return false;
275 if (m_header.mode == ImageModeLabColor && m_header.bpp != 24) return false;
276 if (m_header.mode == ImageModeLab48 && m_header.bpp != 48) return false;
277 if (m_header.mode == ImageModeCMYKColor && m_header.bpp != 32) return false;
278 if (m_header.mode == ImageModeCMYK64 && m_header.bpp != 64) return false;
279
280 // set number of channels
281 if (!m_header.channels) {
282 switch(m_header.mode) {
283 case ImageModeBitmap:
284 case ImageModeIndexedColor:
285 case ImageModeGrayScale:
286 case ImageModeGray16:
287 case ImageModeGray32:
288 m_header.channels = 1;
289 break;
290 case ImageModeRGBColor:
291 case ImageModeRGB12:
292 case ImageModeRGB16:
293 case ImageModeRGB48:
294 case ImageModeLabColor:
295 case ImageModeLab48:
296 m_header.channels = 3;
297 break;
298 case ImageModeRGBA:
299 case ImageModeCMYKColor:
300 case ImageModeCMYK64:
301 m_header.channels = 4;
302 break;
303 default:
304 return false;
305 }
306 }
307
308 // store used bits per channel
309 UINT8 bpc = m_header.bpp/m_header.channels;
310 if (bpc > 31) bpc = 31;
311 if (!m_header.usedBitsPerChannel || m_header.usedBitsPerChannel > bpc) {
312 m_header.usedBitsPerChannel = bpc;
313 }
314
315 return true;
316}
ImageModeRGBColor
#define ImageModeRGBColor
Definition: PGFplatform.h:101
ImageModeRGB12
#define ImageModeRGB12
Definition: PGFplatform.h:117
ImageModeGray32
#define ImageModeGray32
Definition: PGFplatform.h:116
ImageModeUnknown
#define ImageModeUnknown
Definition: PGFplatform.h:119
ImageModeBitmap
#define ImageModeBitmap
Definition: PGFplatform.h:98
ImageModeLabColor
#define ImageModeLabColor
Definition: PGFplatform.h:107
ImageModeRGB16
#define ImageModeRGB16
Definition: PGFplatform.h:118
ImageModeRGBA
#define ImageModeRGBA
Definition: PGFplatform.h:115
ImageModeRGB48
#define ImageModeRGB48
Definition: PGFplatform.h:109
ImageModeCMYK64
#define ImageModeCMYK64
Definition: PGFplatform.h:111
ImageModeGrayScale
#define ImageModeGrayScale
Definition: PGFplatform.h:99
ImageModeLab48
#define ImageModeLab48
Definition: PGFplatform.h:110
ImageModeGray16
#define ImageModeGray16
Definition: PGFplatform.h:108
ImageModeIndexedColor
#define ImageModeIndexedColor
Definition: PGFplatform.h:100
ImageModeCMYKColor
#define ImageModeCMYKColor
Definition: PGFplatform.h:102
PGFHeader::mode
UINT8 mode
image mode according to Adobe's image modes
Definition: PGFtypes.h:131
PGFHeader::usedBitsPerChannel
UINT8 usedBitsPerChannel
number of used bits per channel in 16- and 32-bit per channel modes
Definition: PGFtypes.h:132

◆ ComputeLevels()

void CPGFImage::ComputeLevels ( )
private

Definition at line 805 of file PGFimage.cpp.

805 {
806 const int maxThumbnailWidth = 20*FilterWidth;
807 const int m = __min(m_header.width, m_header.height);
808 int s = m;
809
810 if (m_header.nLevels < 1 || m_header.nLevels > MaxLevel) {
811 m_header.nLevels = 1;
812 // compute a good value depending on the size of the image
813 while (s > maxThumbnailWidth) {
814 m_header.nLevels++;
815 s = s/2;
816 }
817 }
818
819 int levels = m_header.nLevels; // we need a signed value during level reduction
820
821 // reduce number of levels if the image size is smaller than FilterWidth*2^levels
822 s = FilterWidth*(1 << levels); // must be at least the double filter size because of subsampling
823 while (m < s) {
824 levels--;
825 s = s/2;
826 }
827 if (levels > MaxLevel) m_header.nLevels = MaxLevel;
828 else if (levels < 0) m_header.nLevels = 0;
829 else m_header.nLevels = (UINT8)levels;
830
831 // used in Write when PM_Absolute
832 m_percent = pow(0.25, m_header.nLevels);
833
834 ASSERT(0 <= m_header.nLevels && m_header.nLevels <= MaxLevel);
835}
__min
#define __min(x, y)
Definition: PGFplatform.h:91
MaxLevel
#define MaxLevel
maximum number of transform levels
Definition: PGFtypes.h:56
FilterWidth
#define FilterWidth
number of coefficients of the row wavelet filter
Definition: WaveletTransform.h:37
PGFHeader::height
UINT32 height
image height in pixels
Definition: PGFtypes.h:126
PGFHeader::width
UINT32 width
image width in pixels
Definition: PGFtypes.h:125
PGFHeader::nLevels
UINT8 nLevels
number of DWT levels
Definition: PGFtypes.h:127

◆ ConfigureDecoder()

void CPGFImage::ConfigureDecoder ( bool  useOMP = true,
bool  skipUserData = false 
)
inline

Configures the decoder.

Parameters
useOMPUse parallel threading with Open MP during decoding. Default value: true. Influences the decoding only if the codec has been compiled with OpenMP support.
skipUserDataThe file might contain user data (metadata). User data ist usually read during Open and stored in memory. Set this flag to false when storing in memory is not needed.

Definition at line 266 of file PGFimage.h.

266{ m_useOMPinDecoder = useOMP; m_skipUserData = skipUserData; }

◆ ConfigureEncoder()

void CPGFImage::ConfigureEncoder ( bool  useOMP = true,
bool  favorSpeedOverSize = false 
)
inline

Configures the encoder.

Parameters
useOMPUse parallel threading with Open MP during encoding. Default value: true. Influences the encoding only if the codec has been compiled with OpenMP support.
favorSpeedOverSizeFavors encoding speed over compression ratio. Default value: false

Definition at line 260 of file PGFimage.h.

260{ m_useOMPinEncoder = useOMP; m_favorSpeedOverSize = favorSpeedOverSize; }

◆ CurrentChannelDepth()

static BYTE CPGFImage::CurrentChannelDepth ( BYTE  version = PGFVersion)
inlinestatic

Compute and return codec version.

Returns
current PGF codec version

Definition at line 508 of file PGFimage.h.

508{ return (version & PGF32) ? 32 : 16; }
PGF32
#define PGF32
32 bit values are used -> allows at maximum 31 bits, otherwise 16 bit values are used -> allows at ma...
Definition: PGFtypes.h:63

◆ CurrentVersion()

BYTE CPGFImage::CurrentVersion ( BYTE  version = PGFVersion)
static

Return version.

Compute and return codec version.

Returns
current PGF codec version

Definition at line 721 of file PGFimage.cpp.

721 {
722 if (version & Version6) return 6;
723 if (version & Version5) return 5;
724 if (version & Version2) return 2;
725 return 1;
726}
Version5
#define Version5
new coding scheme since major version 5
Definition: PGFtypes.h:65
Version2
#define Version2
data structure PGFHeader of major version 2
Definition: PGFtypes.h:62
Version6
#define Version6
new HeaderSize: 32 bits instead of 16 bits
Definition: PGFtypes.h:66

◆ Destroy()

void CPGFImage::Destroy ( )
virtual

Destroy internal data structures. Destructor calls this method during destruction.

Definition at line 105 of file PGFimage.cpp.

105 {
106 Close();
107
108 for (int i=0; i < m_header.channels; i++) {
109 delete m_wtChannel[i]; m_wtChannel[i]=0; // also deletes m_channel
110 m_channel[i] = 0;
111 }
112 delete[] m_postHeader.userData; m_postHeader.userData = 0; m_postHeader.userDataLen = 0;
113 delete[] m_levelLength; m_levelLength = 0;
114 delete m_encoder; m_encoder = NULL;
115
116 m_userDataPos = 0;
117}
CPGFImage::Close
virtual void Close()
Definition: PGFimage.cpp:122

◆ Downsample()

void CPGFImage::Downsample ( int  nChannel)
private

Definition at line 761 of file PGFimage.cpp.

761 {
762 ASSERT(ch > 0);
763
764 const int w = m_width[0];
765 const int w2 = w/2;
766 const int h2 = m_height[0]/2;
767 const int oddW = w%2; // don't use bool -> problems with MaxSpeed optimization
768 const int oddH = m_height[0]%2; // "
769 int loPos = 0;
770 int hiPos = w;
771 int sampledPos = 0;
772 DataT* buff = m_channel[ch]; ASSERT(buff);
773
774 for (int i=0; i < h2; i++) {
775 for (int j=0; j < w2; j++) {
776 // compute average of pixel block
777 buff[sampledPos] = (buff[loPos] + buff[loPos + 1] + buff[hiPos] + buff[hiPos + 1]) >> 2;
778 loPos += 2; hiPos += 2;
779 sampledPos++;
780 }
781 if (oddW) {
782 buff[sampledPos] = (buff[loPos] + buff[hiPos]) >> 1;
783 loPos++; hiPos++;
784 sampledPos++;
785 }
786 loPos += w; hiPos += w;
787 }
788 if (oddH) {
789 for (int j=0; j < w2; j++) {
790 buff[sampledPos] = (buff[loPos] + buff[loPos+1]) >> 1;
791 loPos += 2; hiPos += 2;
792 sampledPos++;
793 }
794 if (oddW) {
795 buff[sampledPos] = buff[loPos];
796 }
797 }
798
799 // downsampled image has half width and half height
800 m_width[ch] = (m_width[ch] + 1)/2;
801 m_height[ch] = (m_height[ch] + 1)/2;
802}
DataT
INT32 DataT
Definition: PGFtypes.h:219

◆ GetBitmap()

void CPGFImage::GetBitmap ( int  pitch,
UINT8 *  buff,
BYTE  bpp,
int  channelMap[] = NULL,
CallbackPtr  cb = NULL,
void *  data = NULL 
) const

Get image data in interleaved format: (ordering of RGB data is BGR[A]) Upsampling, YUV to RGB transform and interleaving are done here to reduce the number of passes over the data. The absolute value of pitch is the number of bytes of an image row of the given image buffer. If pitch is negative, then the image buffer must point to the last row of a bottom-up image (first byte on last row). if pitch is positive, then the image buffer must point to the first row of a top-down image (first byte). The sequence of output channels in the output image buffer does not need to be the same as provided by PGF. In case of different sequences you have to provide a channelMap of size of expected channels (depending on image mode). For example, PGF provides a channel sequence BGR in RGB color mode. If your provided image buffer expects a channel sequence ARGB, then the channelMap looks like { 3, 2, 1, 0 }. It might throw an IOException.

Parameters
pitchThe number of bytes of a row of the image buffer.
buffAn image buffer.
bppThe number of bits per pixel used in image buffer.
channelMapA integer array containing the mapping of PGF channel ordering to expected channel ordering.
cbA pointer to a callback procedure. The procedure is called after each copied buffer row. If cb returns true, then it stops proceeding.
dataData Pointer to C++ class container to host callback procedure.

Definition at line 1721 of file PGFimage.cpp.

1721 {
1722 ASSERT(buff);
1723 UINT32 w = m_width[0];
1724 UINT32 h = m_height[0];
1725 UINT8* targetBuff = 0; // used if ROI is used
1726 UINT8* buffStart = 0; // used if ROI is used
1727 int targetPitch = 0; // used if ROI is used
1728
1729#ifdef __PGFROISUPPORT__
1730 const PGFRect& roi = (ROIisSupported()) ? m_wtChannel[0]->GetROI(m_currentLevel) : PGFRect(0, 0, w, h); // roi is usually larger than m_roi
1731 const PGFRect levelRoi(LevelWidth(m_roi.left, m_currentLevel), LevelHeight(m_roi.top, m_currentLevel), LevelWidth(m_roi.Width(), m_currentLevel), LevelHeight(m_roi.Height(), m_currentLevel));
1732 ASSERT(w <= roi.Width() && h <= roi.Height());
1733 ASSERT(roi.left <= levelRoi.left && levelRoi.right <= roi.right);
1734 ASSERT(roi.top <= levelRoi.top && levelRoi.bottom <= roi.bottom);
1735
1736 if (ROIisSupported() && (levelRoi.Width() < w || levelRoi.Height() < h)) {
1737 // ROI is used -> create a temporary image buffer for roi
1738 // compute pitch
1739 targetPitch = pitch;
1740 pitch = AlignWordPos(w*bpp)/8;
1741
1742 // create temporary output buffer
1743 targetBuff = buff;
1744 buff = buffStart = new(std::nothrow) UINT8[pitch*h];
1745 if (!buff) ReturnWithError(InsufficientMemory);
1746 }
1747#endif
1748
1749 const bool wOdd = (1 == w%2);
1750
1751 const double dP = 1.0/h;
1752 int defMap[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; ASSERT(sizeof(defMap)/sizeof(defMap[0]) == MaxChannels);
1753 if (channelMap == NULL) channelMap = defMap;
1754 int sampledPos = 0, yPos = 0;
1755 DataT uAvg, vAvg;
1756 double percent = 0;
1757 UINT32 i, j;
1758
1759 switch(m_header.mode) {
1760 case ImageModeBitmap:
1761 {
1762 ASSERT(m_header.channels == 1);
1763 ASSERT(m_header.bpp == 1);
1764 ASSERT(bpp == 1);
1765
1766 const UINT32 w2 = (w + 7)/8;
1767 DataT* y = m_channel[0]; ASSERT(y);
1768
1769 for (i=0; i < h; i++) {
1770
1771 for (j=0; j < w2; j++) {
1772 buff[j] = Clamp8(y[yPos++] + YUVoffset8);
1773 }
1774 yPos += w - w2;
1775
1776 //UINT32 cnt = w;
1777 //for (j=0; j < w2; j++) {
1778 // buff[j] = 0;
1779 // for (int k=0; k < 8; k++) {
1780 // if (cnt) {
1781 // buff[j] <<= 1;
1782 // buff[j] |= (1 & (y[yPos++] - YUVoffset8));
1783 // cnt--;
1784 // }
1785 // }
1786 //}
1787 buff += pitch;
1788
1789 if (cb) {
1790 percent += dP;
1791 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1792 }
1793 }
1794 break;
1795 }
1796 case ImageModeIndexedColor:
1797 case ImageModeGrayScale:
1798 case ImageModeHSLColor:
1799 case ImageModeHSBColor:
1800 {
1801 ASSERT(m_header.channels >= 1);
1802 ASSERT(m_header.bpp == m_header.channels*8);
1803 ASSERT(bpp%8 == 0);
1804
1805 int cnt, channels = bpp/8; ASSERT(channels >= m_header.channels);
1806
1807 for (i=0; i < h; i++) {
1808 cnt = 0;
1809 for (j=0; j < w; j++) {
1810 for (int c=0; c < m_header.channels; c++) {
1811 buff[cnt + channelMap[c]] = Clamp8(m_channel[c][yPos] + YUVoffset8);
1812 }
1813 cnt += channels;
1814 yPos++;
1815 }
1816 buff += pitch;
1817
1818 if (cb) {
1819 percent += dP;
1820 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1821 }
1822 }
1823 break;
1824 }
1825 case ImageModeGray16:
1826 {
1827 ASSERT(m_header.channels >= 1);
1828 ASSERT(m_header.bpp == m_header.channels*16);
1829
1830 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
1831 int cnt, channels;
1832
1833 if (bpp%16 == 0) {
1834 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
1835 UINT16 *buff16 = (UINT16 *)buff;
1836 int pitch16 = pitch/2;
1837 channels = bpp/16; ASSERT(channels >= m_header.channels);
1838
1839 for (i=0; i < h; i++) {
1840 cnt = 0;
1841 for (j=0; j < w; j++) {
1842 for (int c=0; c < m_header.channels; c++) {
1843 buff16[cnt + channelMap[c]] = Clamp16((m_channel[c][yPos] + yuvOffset16) << shift);
1844 }
1845 cnt += channels;
1846 yPos++;
1847 }
1848 buff16 += pitch16;
1849
1850 if (cb) {
1851 percent += dP;
1852 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1853 }
1854 }
1855 } else {
1856 ASSERT(bpp%8 == 0);
1857 const int shift = __max(0, UsedBitsPerChannel() - 8);
1858 channels = bpp/8; ASSERT(channels >= m_header.channels);
1859
1860 for (i=0; i < h; i++) {
1861 cnt = 0;
1862 for (j=0; j < w; j++) {
1863 for (int c=0; c < m_header.channels; c++) {
1864 buff[cnt + channelMap[c]] = Clamp8((m_channel[c][yPos] + yuvOffset16) >> shift);
1865 }
1866 cnt += channels;
1867 yPos++;
1868 }
1869 buff += pitch;
1870
1871 if (cb) {
1872 percent += dP;
1873 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1874 }
1875 }
1876 }
1877 break;
1878 }
1879 case ImageModeRGBColor:
1880 {
1881 ASSERT(m_header.channels == 3);
1882 ASSERT(m_header.bpp == m_header.channels*8);
1883 ASSERT(bpp%8 == 0);
1884 ASSERT(bpp >= m_header.bpp);
1885
1886 DataT* y = m_channel[0]; ASSERT(y);
1887 DataT* u = m_channel[1]; ASSERT(u);
1888 DataT* v = m_channel[2]; ASSERT(v);
1889 UINT8 *buffg = &buff[channelMap[1]],
1890 *buffr = &buff[channelMap[2]],
1891 *buffb = &buff[channelMap[0]];
1892 UINT8 g;
1893 int cnt, channels = bpp/8;
1894 if(m_downsample){
1895 for (i=0; i < h; i++) {
1896 if (i%2) sampledPos -= (w + 1)/2;
1897 cnt = 0;
1898 for (j=0; j < w; j++) {
1899 // image was downsampled
1900 uAvg = u[sampledPos];
1901 vAvg = v[sampledPos];
1902 // Yuv
1903 buffg[cnt] = g = Clamp8(y[yPos] + YUVoffset8 - ((uAvg + vAvg ) >> 2)); // must be logical shift operator
1904 buffr[cnt] = Clamp8(uAvg + g);
1905 buffb[cnt] = Clamp8(vAvg + g);
1906 yPos++;
1907 cnt += channels;
1908 if (j%2) sampledPos++;
1909 }
1910 buffb += pitch;
1911 buffg += pitch;
1912 buffr += pitch;
1913 if (wOdd) sampledPos++;
1914 if (cb) {
1915 percent += dP;
1916 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1917 }
1918 }
1919 }else{
1920 for (i=0; i < h; i++) {
1921 cnt = 0;
1922 for (j = 0; j < w; j++) {
1923 uAvg = u[yPos];
1924 vAvg = v[yPos];
1925 // Yuv
1926 buffg[cnt] = g = Clamp8(y[yPos] + YUVoffset8 - ((uAvg + vAvg ) >> 2)); // must be logical shift operator
1927 buffr[cnt] = Clamp8(uAvg + g);
1928 buffb[cnt] = Clamp8(vAvg + g);
1929 yPos++;
1930 cnt += channels;
1931 }
1932 buffb += pitch;
1933 buffg += pitch;
1934 buffr += pitch;
1935
1936 if (cb) {
1937 percent += dP;
1938 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1939 }
1940 }
1941 }
1942 break;
1943 }
1944 case ImageModeRGB48:
1945 {
1946 ASSERT(m_header.channels == 3);
1947 ASSERT(m_header.bpp == 48);
1948
1949 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
1950
1951 DataT* y = m_channel[0]; ASSERT(y);
1952 DataT* u = m_channel[1]; ASSERT(u);
1953 DataT* v = m_channel[2]; ASSERT(v);
1954 int cnt, channels;
1955 DataT g;
1956
1957 if (bpp >= 48 && bpp%16 == 0) {
1958 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
1959 UINT16 *buff16 = (UINT16 *)buff;
1960 int pitch16 = pitch/2;
1961 channels = bpp/16; ASSERT(channels >= m_header.channels);
1962
1963 for (i=0; i < h; i++) {
1964 if (i%2) sampledPos -= (w + 1)/2;
1965 cnt = 0;
1966 for (j=0; j < w; j++) {
1967 if (m_downsample) {
1968 // image was downsampled
1969 uAvg = u[sampledPos];
1970 vAvg = v[sampledPos];
1971 } else {
1972 uAvg = u[yPos];
1973 vAvg = v[yPos];
1974 }
1975 // Yuv
1976 g = y[yPos] + yuvOffset16 - ((uAvg + vAvg ) >> 2); // must be logical shift operator
1977 buff16[cnt + channelMap[1]] = Clamp16(g << shift);
1978 buff16[cnt + channelMap[2]] = Clamp16((uAvg + g) << shift);
1979 buff16[cnt + channelMap[0]] = Clamp16((vAvg + g) << shift);
1980 yPos++;
1981 cnt += channels;
1982 if (j%2) sampledPos++;
1983 }
1984 buff16 += pitch16;
1985 if (wOdd) sampledPos++;
1986
1987 if (cb) {
1988 percent += dP;
1989 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1990 }
1991 }
1992 } else {
1993 ASSERT(bpp%8 == 0);
1994 const int shift = __max(0, UsedBitsPerChannel() - 8);
1995 channels = bpp/8; ASSERT(channels >= m_header.channels);
1996
1997 for (i=0; i < h; i++) {
1998 if (i%2) sampledPos -= (w + 1)/2;
1999 cnt = 0;
2000 for (j=0; j < w; j++) {
2001 if (m_downsample) {
2002 // image was downsampled
2003 uAvg = u[sampledPos];
2004 vAvg = v[sampledPos];
2005 } else {
2006 uAvg = u[yPos];
2007 vAvg = v[yPos];
2008 }
2009 // Yuv
2010 g = y[yPos] + yuvOffset16 - ((uAvg + vAvg ) >> 2); // must be logical shift operator
2011 buff[cnt + channelMap[1]] = Clamp8(g >> shift);
2012 buff[cnt + channelMap[2]] = Clamp8((uAvg + g) >> shift);
2013 buff[cnt + channelMap[0]] = Clamp8((vAvg + g) >> shift);
2014 yPos++;
2015 cnt += channels;
2016 if (j%2) sampledPos++;
2017 }
2018 buff += pitch;
2019 if (wOdd) sampledPos++;
2020
2021 if (cb) {
2022 percent += dP;
2023 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2024 }
2025 }
2026 }
2027 break;
2028 }
2029 case ImageModeLabColor:
2030 {
2031 ASSERT(m_header.channels == 3);
2032 ASSERT(m_header.bpp == m_header.channels*8);
2033 ASSERT(bpp%8 == 0);
2034
2035 DataT* l = m_channel[0]; ASSERT(l);
2036 DataT* a = m_channel[1]; ASSERT(a);
2037 DataT* b = m_channel[2]; ASSERT(b);
2038 int cnt, channels = bpp/8; ASSERT(channels >= m_header.channels);
2039
2040 for (i=0; i < h; i++) {
2041 if (i%2) sampledPos -= (w + 1)/2;
2042 cnt = 0;
2043 for (j=0; j < w; j++) {
2044 if (m_downsample) {
2045 // image was downsampled
2046 uAvg = a[sampledPos];
2047 vAvg = b[sampledPos];
2048 } else {
2049 uAvg = a[yPos];
2050 vAvg = b[yPos];
2051 }
2052 buff[cnt + channelMap[0]] = Clamp8(l[yPos] + YUVoffset8);
2053 buff[cnt + channelMap[1]] = Clamp8(uAvg + YUVoffset8);
2054 buff[cnt + channelMap[2]] = Clamp8(vAvg + YUVoffset8);
2055 cnt += channels;
2056 yPos++;
2057 if (j%2) sampledPos++;
2058 }
2059 buff += pitch;
2060 if (wOdd) sampledPos++;
2061
2062 if (cb) {
2063 percent += dP;
2064 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2065 }
2066 }
2067 break;
2068 }
2069 case ImageModeLab48:
2070 {
2071 ASSERT(m_header.channels == 3);
2072 ASSERT(m_header.bpp == m_header.channels*16);
2073
2074 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
2075
2076 DataT* l = m_channel[0]; ASSERT(l);
2077 DataT* a = m_channel[1]; ASSERT(a);
2078 DataT* b = m_channel[2]; ASSERT(b);
2079 int cnt, channels;
2080
2081 if (bpp%16 == 0) {
2082 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
2083 UINT16 *buff16 = (UINT16 *)buff;
2084 int pitch16 = pitch/2;
2085 channels = bpp/16; ASSERT(channels >= m_header.channels);
2086
2087 for (i=0; i < h; i++) {
2088 if (i%2) sampledPos -= (w + 1)/2;
2089 cnt = 0;
2090 for (j=0; j < w; j++) {
2091 if (m_downsample) {
2092 // image was downsampled
2093 uAvg = a[sampledPos];
2094 vAvg = b[sampledPos];
2095 } else {
2096 uAvg = a[yPos];
2097 vAvg = b[yPos];
2098 }
2099 buff16[cnt + channelMap[0]] = Clamp16((l[yPos] + yuvOffset16) << shift);
2100 buff16[cnt + channelMap[1]] = Clamp16((uAvg + yuvOffset16) << shift);
2101 buff16[cnt + channelMap[2]] = Clamp16((vAvg + yuvOffset16) << shift);
2102 cnt += channels;
2103 yPos++;
2104 if (j%2) sampledPos++;
2105 }
2106 buff16 += pitch16;
2107 if (wOdd) sampledPos++;
2108
2109 if (cb) {
2110 percent += dP;
2111 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2112 }
2113 }
2114 } else {
2115 ASSERT(bpp%8 == 0);
2116 const int shift = __max(0, UsedBitsPerChannel() - 8);
2117 channels = bpp/8; ASSERT(channels >= m_header.channels);
2118
2119 for (i=0; i < h; i++) {
2120 if (i%2) sampledPos -= (w + 1)/2;
2121 cnt = 0;
2122 for (j=0; j < w; j++) {
2123 if (m_downsample) {
2124 // image was downsampled
2125 uAvg = a[sampledPos];
2126 vAvg = b[sampledPos];
2127 } else {
2128 uAvg = a[yPos];
2129 vAvg = b[yPos];
2130 }
2131 buff[cnt + channelMap[0]] = Clamp8((l[yPos] + yuvOffset16) >> shift);
2132 buff[cnt + channelMap[1]] = Clamp8((uAvg + yuvOffset16) >> shift);
2133 buff[cnt + channelMap[2]] = Clamp8((vAvg + yuvOffset16) >> shift);
2134 cnt += channels;
2135 yPos++;
2136 if (j%2) sampledPos++;
2137 }
2138 buff += pitch;
2139 if (wOdd) sampledPos++;
2140
2141 if (cb) {
2142 percent += dP;
2143 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2144 }
2145 }
2146 }
2147 break;
2148 }
2149 case ImageModeRGBA:
2150 case ImageModeCMYKColor:
2151 {
2152 ASSERT(m_header.channels == 4);
2153 ASSERT(m_header.bpp == m_header.channels*8);
2154 ASSERT(bpp%8 == 0);
2155
2156 DataT* y = m_channel[0]; ASSERT(y);
2157 DataT* u = m_channel[1]; ASSERT(u);
2158 DataT* v = m_channel[2]; ASSERT(v);
2159 DataT* a = m_channel[3]; ASSERT(a);
2160 UINT8 g, aAvg;
2161 int cnt, channels = bpp/8; ASSERT(channels >= m_header.channels);
2162
2163 for (i=0; i < h; i++) {
2164 if (i%2) sampledPos -= (w + 1)/2;
2165 cnt = 0;
2166 for (j=0; j < w; j++) {
2167 if (m_downsample) {
2168 // image was downsampled
2169 uAvg = u[sampledPos];
2170 vAvg = v[sampledPos];
2171 aAvg = Clamp8(a[sampledPos] + YUVoffset8);
2172 } else {
2173 uAvg = u[yPos];
2174 vAvg = v[yPos];
2175 aAvg = Clamp8(a[yPos] + YUVoffset8);
2176 }
2177 // Yuv
2178 buff[cnt + channelMap[1]] = g = Clamp8(y[yPos] + YUVoffset8 - ((uAvg + vAvg ) >> 2)); // must be logical shift operator
2179 buff[cnt + channelMap[2]] = Clamp8(uAvg + g);
2180 buff[cnt + channelMap[0]] = Clamp8(vAvg + g);
2181 buff[cnt + channelMap[3]] = aAvg;
2182 yPos++;
2183 cnt += channels;
2184 if (j%2) sampledPos++;
2185 }
2186 buff += pitch;
2187 if (wOdd) sampledPos++;
2188
2189 if (cb) {
2190 percent += dP;
2191 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2192 }
2193 }
2194 break;
2195 }
2196 case ImageModeCMYK64:
2197 {
2198 ASSERT(m_header.channels == 4);
2199 ASSERT(m_header.bpp == 64);
2200
2201 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
2202
2203 DataT* y = m_channel[0]; ASSERT(y);
2204 DataT* u = m_channel[1]; ASSERT(u);
2205 DataT* v = m_channel[2]; ASSERT(v);
2206 DataT* a = m_channel[3]; ASSERT(a);
2207 DataT g, aAvg;
2208 int cnt, channels;
2209
2210 if (bpp%16 == 0) {
2211 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
2212 UINT16 *buff16 = (UINT16 *)buff;
2213 int pitch16 = pitch/2;
2214 channels = bpp/16; ASSERT(channels >= m_header.channels);
2215
2216 for (i=0; i < h; i++) {
2217 if (i%2) sampledPos -= (w + 1)/2;
2218 cnt = 0;
2219 for (j=0; j < w; j++) {
2220 if (m_downsample) {
2221 // image was downsampled
2222 uAvg = u[sampledPos];
2223 vAvg = v[sampledPos];
2224 aAvg = a[sampledPos] + yuvOffset16;
2225 } else {
2226 uAvg = u[yPos];
2227 vAvg = v[yPos];
2228 aAvg = a[yPos] + yuvOffset16;
2229 }
2230 // Yuv
2231 g = y[yPos] + yuvOffset16 - ((uAvg + vAvg ) >> 2); // must be logical shift operator
2232 buff16[cnt + channelMap[1]] = Clamp16(g << shift);
2233 buff16[cnt + channelMap[2]] = Clamp16((uAvg + g) << shift);
2234 buff16[cnt + channelMap[0]] = Clamp16((vAvg + g) << shift);
2235 buff16[cnt + channelMap[3]] = Clamp16(aAvg << shift);
2236 yPos++;
2237 cnt += channels;
2238 if (j%2) sampledPos++;
2239 }
2240 buff16 += pitch16;
2241 if (wOdd) sampledPos++;
2242
2243 if (cb) {
2244 percent += dP;
2245 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2246 }
2247 }
2248 } else {
2249 ASSERT(bpp%8 == 0);
2250 const int shift = __max(0, UsedBitsPerChannel() - 8);
2251 channels = bpp/8; ASSERT(channels >= m_header.channels);
2252
2253 for (i=0; i < h; i++) {
2254 if (i%2) sampledPos -= (w + 1)/2;
2255 cnt = 0;
2256 for (j=0; j < w; j++) {
2257 if (m_downsample) {
2258 // image was downsampled
2259 uAvg = u[sampledPos];
2260 vAvg = v[sampledPos];
2261 aAvg = a[sampledPos] + yuvOffset16;
2262 } else {
2263 uAvg = u[yPos];
2264 vAvg = v[yPos];
2265 aAvg = a[yPos] + yuvOffset16;
2266 }
2267 // Yuv
2268 g = y[yPos] + yuvOffset16 - ((uAvg + vAvg ) >> 2); // must be logical shift operator
2269 buff[cnt + channelMap[1]] = Clamp8(g >> shift);
2270 buff[cnt + channelMap[2]] = Clamp8((uAvg + g) >> shift);
2271 buff[cnt + channelMap[0]] = Clamp8((vAvg + g) >> shift);
2272 buff[cnt + channelMap[3]] = Clamp8(aAvg >> shift);
2273 yPos++;
2274 cnt += channels;
2275 if (j%2) sampledPos++;
2276 }
2277 buff += pitch;
2278 if (wOdd) sampledPos++;
2279
2280 if (cb) {
2281 percent += dP;
2282 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2283 }
2284 }
2285 }
2286 break;
2287 }
2288#ifdef __PGF32SUPPORT__
2289 case ImageModeGray32:
2290 {
2291 ASSERT(m_header.channels == 1);
2292 ASSERT(m_header.bpp == 32);
2293
2294 const int yuvOffset31 = 1 << (UsedBitsPerChannel() - 1);
2295
2296 DataT* y = m_channel[0]; ASSERT(y);
2297
2298 if (bpp == 32) {
2299 const int shift = 31 - UsedBitsPerChannel(); ASSERT(shift >= 0);
2300 UINT32 *buff32 = (UINT32 *)buff;
2301 int pitch32 = pitch/4;
2302
2303 for (i=0; i < h; i++) {
2304 for (j=0; j < w; j++) {
2305 buff32[j] = Clamp31((y[yPos++] + yuvOffset31) << shift);
2306 }
2307 buff32 += pitch32;
2308
2309 if (cb) {
2310 percent += dP;
2311 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2312 }
2313 }
2314 } else if (bpp == 16) {
2315 const int usedBits = UsedBitsPerChannel();
2316 UINT16 *buff16 = (UINT16 *)buff;
2317 int pitch16 = pitch/2;
2318
2319 if (usedBits < 16) {
2320 const int shift = 16 - usedBits;
2321 for (i=0; i < h; i++) {
2322 for (j=0; j < w; j++) {
2323 buff16[j] = Clamp16((y[yPos++] + yuvOffset31) << shift);
2324 }
2325 buff16 += pitch16;
2326
2327 if (cb) {
2328 percent += dP;
2329 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2330 }
2331 }
2332 } else {
2333 const int shift = __max(0, usedBits - 16);
2334 for (i=0; i < h; i++) {
2335 for (j=0; j < w; j++) {
2336 buff16[j] = Clamp16((y[yPos++] + yuvOffset31) >> shift);
2337 }
2338 buff16 += pitch16;
2339
2340 if (cb) {
2341 percent += dP;
2342 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2343 }
2344 }
2345 }
2346 } else {
2347 ASSERT(bpp == 8);
2348 const int shift = __max(0, UsedBitsPerChannel() - 8);
2349
2350 for (i=0; i < h; i++) {
2351 for (j=0; j < w; j++) {
2352 buff[j] = Clamp8((y[yPos++] + yuvOffset31) >> shift);
2353 }
2354 buff += pitch;
2355
2356 if (cb) {
2357 percent += dP;
2358 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2359 }
2360 }
2361 }
2362 break;
2363 }
2364#endif
2365 case ImageModeRGB12:
2366 {
2367 ASSERT(m_header.channels == 3);
2368 ASSERT(m_header.bpp == m_header.channels*4);
2369 ASSERT(bpp == m_header.channels*4);
2370 ASSERT(!m_downsample);
2371
2372 DataT* y = m_channel[0]; ASSERT(y);
2373 DataT* u = m_channel[1]; ASSERT(u);
2374 DataT* v = m_channel[2]; ASSERT(v);
2375 UINT16 yval;
2376 int cnt;
2377
2378 for (i=0; i < h; i++) {
2379 cnt = 0;
2380 for (j=0; j < w; j++) {
2381 // Yuv
2382 uAvg = u[yPos];
2383 vAvg = v[yPos];
2384 yval = Clamp4(y[yPos++] + YUVoffset4 - ((uAvg + vAvg ) >> 2)); // must be logical shift operator
2385 if (j%2 == 0) {
2386 buff[cnt] = UINT8(Clamp4(vAvg + yval) | (yval << 4));
2387 cnt++;
2388 buff[cnt] = Clamp4(uAvg + yval);
2389 } else {
2390 buff[cnt] |= Clamp4(vAvg + yval) << 4;
2391 cnt++;
2392 buff[cnt] = UINT8(yval | (Clamp4(uAvg + yval) << 4));
2393 cnt++;
2394 }
2395 }
2396 buff += pitch;
2397
2398 if (cb) {
2399 percent += dP;
2400 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2401 }
2402 }
2403 break;
2404 }
2405 case ImageModeRGB16:
2406 {
2407 ASSERT(m_header.channels == 3);
2408 ASSERT(m_header.bpp == 16);
2409 ASSERT(bpp == 16);
2410 ASSERT(!m_downsample);
2411
2412 DataT* y = m_channel[0]; ASSERT(y);
2413 DataT* u = m_channel[1]; ASSERT(u);
2414 DataT* v = m_channel[2]; ASSERT(v);
2415 UINT16 yval;
2416 UINT16 *buff16 = (UINT16 *)buff;
2417 int pitch16 = pitch/2;
2418
2419 for (i=0; i < h; i++) {
2420 for (j=0; j < w; j++) {
2421 // Yuv
2422 uAvg = u[yPos];
2423 vAvg = v[yPos];
2424 yval = Clamp6(y[yPos++] + YUVoffset6 - ((uAvg + vAvg ) >> 2)); // must be logical shift operator
2425 buff16[j] = (yval << 5) | ((Clamp6(uAvg + yval) >> 1) << 11) | (Clamp6(vAvg + yval) >> 1);
2426 }
2427 buff16 += pitch16;
2428
2429 if (cb) {
2430 percent += dP;
2431 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2432 }
2433 }
2434 break;
2435 }
2436 default:
2437 ASSERT(false);
2438 }
2439
2440#ifdef __PGFROISUPPORT__
2441 if (targetBuff) {
2442 // copy valid ROI (m_roi) from temporary buffer (roi) to target buffer
2443 if (bpp%8 == 0) {
2444 BYTE bypp = bpp/8;
2445 buff = buffStart + (levelRoi.top - roi.top)*pitch + (levelRoi.left - roi.left)*bypp;
2446 w = levelRoi.Width()*bypp;
2447 h = levelRoi.Height();
2448
2449 for (i=0; i < h; i++) {
2450 for (j=0; j < w; j++) {
2451 targetBuff[j] = buff[j];
2452 }
2453 targetBuff += targetPitch;
2454 buff += pitch;
2455 }
2456 } else {
2457 // to do
2458 }
2459
2460 delete[] buffStart; buffStart = 0;
2461 }
2462#endif
2463}
AlignWordPos
UINT32 AlignWordPos(UINT32 pos)
Definition: BitStream.h:260
YUVoffset8
#define YUVoffset8
Definition: PGFimage.cpp:37
YUVoffset4
#define YUVoffset4
Definition: PGFimage.cpp:35
YUVoffset6
#define YUVoffset6
Definition: PGFimage.cpp:36
ImageModeHSLColor
#define ImageModeHSLColor
Definition: PGFplatform.h:103
ImageModeHSBColor
#define ImageModeHSBColor
Definition: PGFplatform.h:104
__max
#define __max(x, y)
Definition: PGFplatform.h:92
CPGFImage::Clamp31
UINT32 Clamp31(DataT v) const
Definition: PGFimage.h:564
CPGFImage::Clamp6
UINT16 Clamp6(DataT v) const
Definition: PGFimage.h:554
CPGFImage::LevelWidth
static UINT32 LevelWidth(UINT32 width, int level)
Definition: PGFimage.h:491
CPGFImage::LevelHeight
static UINT32 LevelHeight(UINT32 height, int level)
Definition: PGFimage.h:498
CPGFImage::Clamp16
UINT16 Clamp16(DataT v) const
Definition: PGFimage.h:561
CPGFImage::UsedBitsPerChannel
BYTE UsedBitsPerChannel() const
Definition: PGFimage.cpp:709
CPGFImage::Clamp8
UINT8 Clamp8(DataT v) const
Definition: PGFimage.h:557
CPGFImage::m_roi
PGFRect m_roi
region of interest
Definition: PGFimage.h:531
CPGFImage::ROIisSupported
bool ROIisSupported() const
Definition: PGFimage.h:465
CPGFImage::Clamp4
UINT8 Clamp4(DataT v) const
Definition: PGFimage.h:551
PGFRect
Rectangle.
Definition: PGFtypes.h:194
PGFRect::Height
UINT32 Height() const
Definition: PGFtypes.h:207
PGFRect::Width
UINT32 Width() const
Definition: PGFtypes.h:205
PGFRect::top
UINT32 top
Definition: PGFtypes.h:215
PGFRect::bottom
UINT32 bottom
Definition: PGFtypes.h:215
PGFRect::right
UINT32 right
Definition: PGFtypes.h:215
PGFRect::left
UINT32 left
Definition: PGFtypes.h:215

◆ GetChannel()

DataT * CPGFImage::GetChannel ( int  c = 0)
inline

Return an internal YUV image channel.

Parameters
cA channel index
Returns
An internal YUV image channel

Definition at line 321 of file PGFimage.h.

321{ ASSERT(c >= 0 && c < MaxChannels); return m_channel[c]; }

◆ GetColorTable() [1/2]

const RGBQUAD * CPGFImage::GetColorTable ( ) const
inline
Returns
Address of color table

Definition at line 334 of file PGFimage.h.

334{ return m_postHeader.clut; }
PGFPostHeader::clut
RGBQUAD clut[ColorTableLen]
color table for indexed color images
Definition: PGFtypes.h:142

◆ GetColorTable() [2/2]

void CPGFImage::GetColorTable ( UINT32  iFirstColor,
UINT32  nColors,
RGBQUAD *  prgbColors 
) const

Retrieves red, green, blue (RGB) color values from a range of entries in the palette of the DIB section. It might throw an IOException.

Parameters
iFirstColorThe color table index of the first entry to retrieve.
nColorsThe number of color table entries to retrieve.
prgbColorsA pointer to the array of RGBQUAD structures to retrieve the color table entries.

Definition at line 1293 of file PGFimage.cpp.

1293 {
1294 if (iFirstColor + nColors > ColorTableLen) ReturnWithError(ColorTableError);
1295
1296 for (UINT32 i=iFirstColor, j=0; j < nColors; i++, j++) {
1297 prgbColors[j] = m_postHeader.clut[i];
1298 }
1299}
ColorTableLen
#define ColorTableLen
size of color lookup table (clut)
Definition: PGFtypes.h:60

◆ GetEncodedHeaderLength()

UINT32 CPGFImage::GetEncodedHeaderLength ( ) const

Return the length of all encoded headers in bytes. Precondition: The PGF image has been opened with a call of Open(...).

Returns
The length of all encoded headers in bytes

Definition at line 614 of file PGFimage.cpp.

614 {
615 ASSERT(m_decoder);
616 return m_decoder->GetEncodedHeaderLength();
617}
CDecoder::GetEncodedHeaderLength
UINT32 GetEncodedHeaderLength() const
Definition: Decoder.h:137

◆ GetEncodedLevelLength()

UINT32 CPGFImage::GetEncodedLevelLength ( int  level) const
inline

Return the length of an encoded PGF level in bytes. Precondition: The PGF image has been opened with a call of Open(...).

Parameters
levelThe image level
Returns
The length of a PGF level in bytes

Definition at line 370 of file PGFimage.h.

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

◆ GetHeader()

const PGFHeader * CPGFImage::GetHeader ( ) const
inline

Return the PGF header structure.

Returns
A PGF header structure

Definition at line 339 of file PGFimage.h.

339{ return &m_header; }

◆ GetMaxValue()

UINT32 CPGFImage::GetMaxValue ( ) const
inline

Get maximum intensity value for image modes with more than eight bits per channel. Don't call this method before the PGF header has been read.

Returns
The maximum intensity value.

Definition at line 345 of file PGFimage.h.

345{ return (1 << m_header.usedBitsPerChannel) - 1; }

◆ GetUserData()

const UINT8 * CPGFImage::GetUserData ( UINT32 &  size) const

Return user data and size of user data. Precondition: The PGF image has been opened with a call of Open(...).

Parameters
size[out] Size of user data in bytes.
Returns
A pointer to user data or NULL if there is no user data.

Definition at line 323 of file PGFimage.cpp.

323 {
324 size = m_postHeader.userDataLen;
325 return m_postHeader.userData;
326}

◆ GetUserDataPos()

UINT64 CPGFImage::GetUserDataPos ( ) const
inline

Return the stream position of the user data or 0. Precondition: The PGF image has been opened with a call of Open(...).

Definition at line 350 of file PGFimage.h.

350{ return m_userDataPos; }

◆ GetYUV()

void CPGFImage::GetYUV ( int  pitch,
DataT *  buff,
BYTE  bpp,
int  channelMap[] = NULL,
CallbackPtr  cb = NULL,
void *  data = NULL 
) const

Get YUV image data in interleaved format: (ordering is YUV[A]) The absolute value of pitch is the number of bytes of an image row of the given image buffer. If pitch is negative, then the image buffer must point to the last row of a bottom-up image (first byte on last row). if pitch is positive, then the image buffer must point to the first row of a top-down image (first byte). The sequence of output channels in the output image buffer does not need to be the same as provided by PGF. In case of different sequences you have to provide a channelMap of size of expected channels (depending on image mode). For example, PGF provides a channel sequence BGR in RGB color mode. If your provided image buffer expects a channel sequence VUY, then the channelMap looks like { 2, 1, 0 }. It might throw an IOException.

Parameters
pitchThe number of bytes of a row of the image buffer.
buffAn image buffer.
bppThe number of bits per pixel used in image buffer.
channelMapA integer array containing the mapping of PGF channel ordering to expected channel ordering.
cbA pointer to a callback procedure. The procedure is called after each copied buffer row. If cb returns true, then it stops proceeding.
dataData Pointer to C++ class container to host callback procedure.

Get YUV image data in interleaved format: (ordering is YUV[A]) The absolute value of pitch is the number of bytes of an image row of the given image buffer. If pitch is negative, then the image buffer must point to the last row of a bottom-up image (first byte on last row). if pitch is positive, then the image buffer must point to the first row of a top-down image (first byte). The sequence of output channels in the output image buffer does not need to be the same as provided by PGF. In case of different sequences you have to provide a channelMap of size of expected channels (depending on image mode). For example, PGF provides a channel sequence BGR in RGB color mode. If your provided image buffer expects a channel sequence VUY, then the channelMap looks like { 2, 1, 0 }. It might throw an IOException.

Parameters
pitchThe number of bytes of a row of the image buffer.
buffAn image buffer.
bppThe number of bits per pixel used in image buffer.
channelMapA integer array containing the mapping of PGF channel ordering to expected channel ordering.
cbA pointer to a callback procedure. The procedure is called after each copied buffer row. If cb returns true, then it stops proceeding.

Definition at line 2479 of file PGFimage.cpp.

2479 {
2480 ASSERT(buff);
2481 const UINT32 w = m_width[0];
2482 const UINT32 h = m_height[0];
2483 const bool wOdd = (1 == w%2);
2484 const int dataBits = DataTSize*8; ASSERT(dataBits == 16 || dataBits == 32);
2485 const int pitch2 = pitch/DataTSize;
2486 const int yuvOffset = (dataBits == 16) ? YUVoffset8 : YUVoffset16;
2487 const double dP = 1.0/h;
2488
2489 int defMap[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; ASSERT(sizeof(defMap)/sizeof(defMap[0]) == MaxChannels);
2490 if (channelMap == NULL) channelMap = defMap;
2491 int sampledPos = 0, yPos = 0;
2492 DataT uAvg, vAvg;
2493 double percent = 0;
2494 UINT32 i, j;
2495
2496 if (m_header.channels == 3) {
2497 ASSERT(bpp%dataBits == 0);
2498
2499 DataT* y = m_channel[0]; ASSERT(y);
2500 DataT* u = m_channel[1]; ASSERT(u);
2501 DataT* v = m_channel[2]; ASSERT(v);
2502 int cnt, channels = bpp/dataBits; ASSERT(channels >= m_header.channels);
2503
2504 for (i=0; i < h; i++) {
2505 if (i%2) sampledPos -= (w + 1)/2;
2506 cnt = 0;
2507 for (j=0; j < w; j++) {
2508 if (m_downsample) {
2509 // image was downsampled
2510 uAvg = u[sampledPos];
2511 vAvg = v[sampledPos];
2512 } else {
2513 uAvg = u[yPos];
2514 vAvg = v[yPos];
2515 }
2516 buff[cnt + channelMap[0]] = y[yPos];
2517 buff[cnt + channelMap[1]] = uAvg;
2518 buff[cnt + channelMap[2]] = vAvg;
2519 yPos++;
2520 cnt += channels;
2521 if (j%2) sampledPos++;
2522 }
2523 buff += pitch2;
2524 if (wOdd) sampledPos++;
2525
2526 if (cb) {
2527 percent += dP;
2528 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2529 }
2530 }
2531 } else if (m_header.channels == 4) {
2532 ASSERT(m_header.bpp == m_header.channels*8);
2533 ASSERT(bpp%dataBits == 0);
2534
2535 DataT* y = m_channel[0]; ASSERT(y);
2536 DataT* u = m_channel[1]; ASSERT(u);
2537 DataT* v = m_channel[2]; ASSERT(v);
2538 DataT* a = m_channel[3]; ASSERT(a);
2539 UINT8 aAvg;
2540 int cnt, channels = bpp/dataBits; ASSERT(channels >= m_header.channels);
2541
2542 for (i=0; i < h; i++) {
2543 if (i%2) sampledPos -= (w + 1)/2;
2544 cnt = 0;
2545 for (j=0; j < w; j++) {
2546 if (m_downsample) {
2547 // image was downsampled
2548 uAvg = u[sampledPos];
2549 vAvg = v[sampledPos];
2550 aAvg = Clamp8(a[sampledPos] + yuvOffset);
2551 } else {
2552 uAvg = u[yPos];
2553 vAvg = v[yPos];
2554 aAvg = Clamp8(a[yPos] + yuvOffset);
2555 }
2556 // Yuv
2557 buff[cnt + channelMap[0]] = y[yPos];
2558 buff[cnt + channelMap[1]] = uAvg;
2559 buff[cnt + channelMap[2]] = vAvg;
2560 buff[cnt + channelMap[3]] = aAvg;
2561 yPos++;
2562 cnt += channels;
2563 if (j%2) sampledPos++;
2564 }
2565 buff += pitch2;
2566 if (wOdd) sampledPos++;
2567
2568 if (cb) {
2569 percent += dP;
2570 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2571 }
2572 }
2573 }
2574}
YUVoffset16
#define YUVoffset16
Definition: PGFimage.cpp:38
DataTSize
#define DataTSize
Definition: PGFtypes.h:233

◆ Height()

UINT32 CPGFImage::Height ( int  level = 0) const
inline

Return image height of channel 0 at given level in pixels. The returned height is independent of any Read-operations and ROI.

Parameters
levelA level
Returns
Image level height in pixels

Definition at line 423 of file PGFimage.h.

423{ ASSERT(level >= 0); return LevelHeight(m_header.height, level); }

◆ ImportBitmap()

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

Import an image from a specified image buffer. This method is usually called before Write(...) and after SetHeader(...). The absolute value of pitch is the number of bytes of an image row. If pitch is negative, then buff points to the last row of a bottom-up image (first byte on last row). If pitch is positive, then buff points to the first row of a top-down image (first byte). The sequence of input channels in the input image buffer does not need to be the same as expected from PGF. In case of different sequences you have to provide a channelMap of size of expected channels (depending on image mode). For example, PGF expects in RGB color mode a channel sequence BGR. If your provided image buffer contains a channel sequence ARGB, then the channelMap looks like { 3, 2, 1, 0 }. It might throw an IOException.

Parameters
pitchThe number of bytes of a row of the image buffer.
buffAn image buffer.
bppThe number of bits per pixel used in image buffer.
channelMapA integer array containing the mapping of input channel ordering to expected channel ordering.
cbA pointer to a callback procedure. The procedure is called after each imported buffer row. If cb returns true, then it stops proceeding.
dataData Pointer to C++ class container to host callback procedure.

Definition at line 744 of file PGFimage.cpp.

744 {
745 ASSERT(buff);
746 ASSERT(m_channel[0]);
747
748 // color transform
749 RgbToYuv(pitch, buff, bpp, channelMap, cb, data);
750
751 if (m_downsample) {
752 // Subsampling of the chrominance and alpha channels
753 for (int i=1; i < m_header.channels; i++) {
754 Downsample(i);
755 }
756 }
757}
CPGFImage::RgbToYuv
void RgbToYuv(int pitch, UINT8 *rgbBuff, BYTE bpp, int channelMap[], CallbackPtr cb, void *data) THROW_
Definition: PGFimage.cpp:1332
CPGFImage::Downsample
void Downsample(int nChannel)
Definition: PGFimage.cpp:761

◆ ImportIsSupported()

bool CPGFImage::ImportIsSupported ( BYTE  mode)
static

Check for valid import image mode.

Parameters
modeImage mode
Returns
True if an image of given mode can be imported with ImportBitmap(...)

Definition at line 1248 of file PGFimage.cpp.

1248 {
1249 size_t size = DataTSize;
1250
1251 if (size >= 2) {
1252 switch(mode) {
1253 case ImageModeBitmap:
1254 case ImageModeIndexedColor:
1255 case ImageModeGrayScale:
1256 case ImageModeRGBColor:
1257 case ImageModeCMYKColor:
1258 case ImageModeHSLColor:
1259 case ImageModeHSBColor:
1260 //case ImageModeDuotone:
1261 case ImageModeLabColor:
1262 case ImageModeRGB12:
1263 case ImageModeRGB16:
1264 case ImageModeRGBA:
1265 return true;
1266 }
1267 }
1268 if (size >= 3) {
1269 switch(mode) {
1270 case ImageModeGray16:
1271 case ImageModeRGB48:
1272 case ImageModeLab48:
1273 case ImageModeCMYK64:
1274 //case ImageModeDuotone16:
1275 return true;
1276 }
1277 }
1278 if (size >=4) {
1279 switch(mode) {
1280 case ImageModeGray32:
1281 return true;
1282 }
1283 }
1284 return false;
1285}

◆ ImportYUV()

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

Import a YUV image from a specified image buffer. The absolute value of pitch is the number of bytes of an image row. If pitch is negative, then buff points to the last row of a bottom-up image (first byte on last row). If pitch is positive, then buff points to the first row of a top-down image (first byte). The sequence of input channels in the input image buffer does not need to be the same as expected from PGF. In case of different sequences you have to provide a channelMap of size of expected channels (depending on image mode). For example, PGF expects in RGB color mode a channel sequence BGR. If your provided image buffer contains a channel sequence VUY, then the channelMap looks like { 2, 1, 0 }. It might throw an IOException.

Parameters
pitchThe number of bytes of a row of the image buffer.
buffAn image buffer.
bppThe number of bits per pixel used in image buffer.
channelMapA integer array containing the mapping of input channel ordering to expected channel ordering.
cbA pointer to a callback procedure. The procedure is called after each imported buffer row. If cb returns true, then it stops proceeding.
dataData Pointer to C++ class container to host callback procedure.

Import a YUV image from a specified image buffer. The absolute value of pitch is the number of bytes of an image row. If pitch is negative, then buff points to the last row of a bottom-up image (first byte on last row). If pitch is positive, then buff points to the first row of a top-down image (first byte). The sequence of input channels in the input image buffer does not need to be the same as expected from PGF. In case of different sequences you have to provide a channelMap of size of expected channels (depending on image mode). For example, PGF expects in RGB color mode a channel sequence BGR. If your provided image buffer contains a channel sequence VUY, then the channelMap looks like { 2, 1, 0 }. It might throw an IOException.

Parameters
pitchThe number of bytes of a row of the image buffer.
buffAn image buffer.
bppThe number of bits per pixel used in image buffer.
channelMapA integer array containing the mapping of input channel ordering to expected channel ordering.
cbA pointer to a callback procedure. The procedure is called after each imported buffer row. If cb returns true, then it stops proceeding.

Definition at line 2590 of file PGFimage.cpp.

2590 {
2591 ASSERT(buff);
2592 const double dP = 1.0/m_header.height;
2593 const int dataBits = DataTSize*8; ASSERT(dataBits == 16 || dataBits == 32);
2594 const int pitch2 = pitch/DataTSize;
2595 const int yuvOffset = (dataBits == 16) ? YUVoffset8 : YUVoffset16;
2596
2597 int yPos = 0, cnt = 0;
2598 double percent = 0;
2599 int defMap[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; ASSERT(sizeof(defMap)/sizeof(defMap[0]) == MaxChannels);
2600
2601 if (channelMap == NULL) channelMap = defMap;
2602
2603 if (m_header.channels == 3) {
2604 ASSERT(bpp%dataBits == 0);
2605
2606 DataT* y = m_channel[0]; ASSERT(y);
2607 DataT* u = m_channel[1]; ASSERT(u);
2608 DataT* v = m_channel[2]; ASSERT(v);
2609 const int channels = bpp/dataBits; ASSERT(channels >= m_header.channels);
2610
2611 for (UINT32 h=0; h < m_header.height; h++) {
2612 if (cb) {
2613 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2614 percent += dP;
2615 }
2616
2617 cnt = 0;
2618 for (UINT32 w=0; w < m_header.width; w++) {
2619 y[yPos] = buff[cnt + channelMap[0]];
2620 u[yPos] = buff[cnt + channelMap[1]];
2621 v[yPos] = buff[cnt + channelMap[2]];
2622 yPos++;
2623 cnt += channels;
2624 }
2625 buff += pitch2;
2626 }
2627 } else if (m_header.channels == 4) {
2628 ASSERT(bpp%dataBits == 0);
2629
2630 DataT* y = m_channel[0]; ASSERT(y);
2631 DataT* u = m_channel[1]; ASSERT(u);
2632 DataT* v = m_channel[2]; ASSERT(v);
2633 DataT* a = m_channel[3]; ASSERT(a);
2634 const int channels = bpp/dataBits; ASSERT(channels >= m_header.channels);
2635
2636 for (UINT32 h=0; h < m_header.height; h++) {
2637 if (cb) {
2638 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
2639 percent += dP;
2640 }
2641
2642 cnt = 0;
2643 for (UINT32 w=0; w < m_header.width; w++) {
2644 y[yPos] = buff[cnt + channelMap[0]];
2645 u[yPos] = buff[cnt + channelMap[1]];
2646 v[yPos] = buff[cnt + channelMap[2]];
2647 a[yPos] = buff[cnt + channelMap[3]] - yuvOffset;
2648 yPos++;
2649 cnt += channels;
2650 }
2651 buff += pitch2;
2652 }
2653 }
2654
2655 if (m_downsample) {
2656 // Subsampling of the chrominance and alpha channels
2657 for (int i=1; i < m_header.channels; i++) {
2658 Downsample(i);
2659 }
2660 }
2661}

◆ IsOpen()

bool CPGFImage::IsOpen ( ) const
inline

Returns true if the PGF has been opened and not closed.

Definition at line 87 of file PGFimage.h.

87{ return m_decoder != NULL; }

◆ Level()

BYTE CPGFImage::Level ( ) const
inline

Return current image level. Since Read(...) can be used to read each image level separately, it is helpful to know the current level. The current level immediately after Open(...) is Levels().

Returns
Current image level

Definition at line 430 of file PGFimage.h.

430{ return (BYTE)m_currentLevel; }

◆ LevelHeight()

static UINT32 CPGFImage::LevelHeight ( UINT32  height,
int  level 
)
inlinestatic

Compute and return image height at given level.

Parameters
heightOriginal image height (at level 0)
levelAn image level
Returns
Image level height in pixels

Definition at line 498 of file PGFimage.h.

498{ ASSERT(level >= 0); UINT32 h = (height >> level); return ((h << level) == height) ? h : h + 1; }

◆ Levels()

BYTE CPGFImage::Levels ( ) const
inline

Return the number of image levels.

Returns
Number of image levels

Definition at line 435 of file PGFimage.h.

435{ return m_header.nLevels; }

◆ LevelWidth()

static UINT32 CPGFImage::LevelWidth ( UINT32  width,
int  level 
)
inlinestatic

Compute and return image width at given level.

Parameters
widthOriginal image width (at level 0)
levelAn image level
Returns
Image level width in pixels

Definition at line 491 of file PGFimage.h.

491{ ASSERT(level >= 0); UINT32 w = (width >> level); return ((w << level) == width) ? w : w + 1; }

◆ Mode()

BYTE CPGFImage::Mode ( ) const
inline

Return the image mode. An image mode is a predefined constant value (see also PGFtypes.h) compatible with Adobe Photoshop. It represents an image type and format.

Returns
Image mode

Definition at line 454 of file PGFimage.h.

454{ return m_header.mode; }

◆ Open()

void CPGFImage::Open ( CPGFStream *  stream)

Open a PGF image at current stream position: read pre-header, header, and ckeck image type. Precondition: The stream has been opened for reading. It might throw an IOException.

Parameters
streamA PGF stream

Definition at line 131 of file PGFimage.cpp.

131 {
132 ASSERT(stream);
133
134 // create decoder and read PGFPreHeader PGFHeader PGFPostHeader LevelLengths
135 m_decoder = new CDecoder(stream, m_preHeader, m_header, m_postHeader, m_levelLength,
136 m_userDataPos, m_useOMPinDecoder, m_skipUserData);
137
138 if (m_header.nLevels > MaxLevel) ReturnWithError(FormatCannotRead);
139
140 // set current level
141 m_currentLevel = m_header.nLevels;
142
143 // set image width and height
144 m_width[0] = m_header.width;
145 m_height[0] = m_header.height;
146
147 // complete header
148 if (!CompleteHeader()) ReturnWithError(FormatCannotRead);
149
150 // interpret quant parameter
151 if (m_header.quality > DownsampleThreshold &&
152 (m_header.mode == ImageModeRGBColor ||
153 m_header.mode == ImageModeRGBA ||
154 m_header.mode == ImageModeRGB48 ||
155 m_header.mode == ImageModeCMYKColor ||
156 m_header.mode == ImageModeCMYK64 ||
157 m_header.mode == ImageModeLabColor ||
158 m_header.mode == ImageModeLab48)) {
159 m_downsample = true;
160 m_quant = m_header.quality - 1;
161 } else {
162 m_downsample = false;
163 m_quant = m_header.quality;
164 }
165
166 // set channel dimensions (chrominance is subsampled by factor 2)
167 if (m_downsample) {
168 for (int i=1; i < m_header.channels; i++) {
169 m_width[i] = (m_width[0] + 1)/2;
170 m_height[i] = (m_height[0] + 1)/2;
171 }
172 } else {
173 for (int i=1; i < m_header.channels; i++) {
174 m_width[i] = m_width[0];
175 m_height[i] = m_height[0];
176 }
177 }
178
179 if (m_header.nLevels > 0) {
180 // init wavelet subbands
181 for (int i=0; i < m_header.channels; i++) {
182 m_wtChannel[i] = new CWaveletTransform(m_width[i], m_height[i], m_header.nLevels);
183 }
184
185 // used in Read when PM_Absolute
186 m_percent = pow(0.25, m_header.nLevels);
187
188 } else {
189 // very small image: we don't use DWT and encoding
190
191 // read channels
192 for (int c=0; c < m_header.channels; c++) {
193 const UINT32 size = m_width[c]*m_height[c];
194 m_channel[c] = new(std::nothrow) DataT[size];
195 if (!m_channel[c]) ReturnWithError(InsufficientMemory);
196
197 // read channel data from stream
198 for (UINT32 i=0; i < size; i++) {
199 int count = DataTSize;
200 stream->Read(&count, &m_channel[c][i]);
201 if (count != DataTSize) ReturnWithError(MissingData);
202 }
203 }
204 }
205}
DownsampleThreshold
#define DownsampleThreshold
if quality is larger than this threshold than downsampling is used
Definition: PGFtypes.h:59
CDecoder
PGF decoder.
Definition: Decoder.h:46
CPGFImage::CompleteHeader
bool CompleteHeader()
Definition: PGFimage.cpp:208
CPGFStream::Read
virtual void Read(int *count, void *buffer)=0
CWaveletTransform
PGF wavelet transform.
Definition: WaveletTransform.h:84
PGFHeader::quality
UINT8 quality
quantization parameter: 0=lossless, 4=standard, 6=poor quality
Definition: PGFtypes.h:128

◆ Quality()

BYTE CPGFImage::Quality ( ) const
inline

Return the PGF quality. The quality is inbetween 0 and MaxQuality. PGF quality 0 means lossless quality.

Returns
PGF quality

Definition at line 441 of file PGFimage.h.

441{ return m_header.quality; }

◆ Read() [1/2]

void CPGFImage::Read ( int  level = 0,
CallbackPtr  cb = NULL,
void *  data = NULL 
)

Read and decode some levels of a PGF image at current stream position. A PGF image is structered in levels, numbered between 0 and Levels() - 1. Each level can be seen as a single image, containing the same content as all other levels, but in a different size (width, height). The image size at level i is double the size (width, height) of the image at level i+1. The image at level 0 contains the original size. Precondition: The PGF image has been opened with a call of Open(...). It might throw an IOException.

Parameters
level[0, nLevels) The image level of the resulting image in the internal image buffer.
cbA pointer to a callback procedure. The procedure is called after reading a single level. If cb returns true, then it stops proceeding.
dataData Pointer to C++ class container to host callback procedure.

Definition at line 385 of file PGFimage.cpp.

385 {
386 ASSERT((level >= 0 && level < m_header.nLevels) || m_header.nLevels == 0); // m_header.nLevels == 0: image didn't use wavelet transform
387 ASSERT(m_decoder);
388
389#ifdef __PGFROISUPPORT__
390 if (ROIisSupported() && m_header.nLevels > 0) {
391 // new encoding scheme supporting ROI
392 PGFRect rect(0, 0, m_header.width, m_header.height);
393 Read(rect, level, cb, data);
394 return;
395 }
396#endif
397
398 if (m_header.nLevels == 0) {
399 if (level == 0) {
400 // the data has already been read during open
401 // now update progress
402 if (cb) {
403 if ((*cb)(1.0, true, data)) ReturnWithError(EscapePressed);
404 }
405 }
406 } else {
407 const int levelDiff = m_currentLevel - level;
408 double percent = (m_progressMode == PM_Relative) ? pow(0.25, levelDiff) : m_percent;
409
410 // encoding scheme without ROI
411 while (m_currentLevel > level) {
412 for (int i=0; i < m_header.channels; i++) {
413 ASSERT(m_wtChannel[i]);
414 // decode file and write stream to m_wtChannel
415 if (m_currentLevel == m_header.nLevels) {
416 // last level also has LL band
417 m_wtChannel[i]->GetSubband(m_currentLevel, LL)->PlaceTile(*m_decoder, m_quant);
418 }
419 if (m_preHeader.version & Version5) {
420 // since version 5
421 m_wtChannel[i]->GetSubband(m_currentLevel, HL)->PlaceTile(*m_decoder, m_quant);
422 m_wtChannel[i]->GetSubband(m_currentLevel, LH)->PlaceTile(*m_decoder, m_quant);
423 } else {
424 // until version 4
425 m_decoder->DecodeInterleaved(m_wtChannel[i], m_currentLevel, m_quant);
426 }
427 m_wtChannel[i]->GetSubband(m_currentLevel, HH)->PlaceTile(*m_decoder, m_quant);
428 }
429
430 volatile OSError error = NoError; // volatile prevents optimizations
431#ifdef LIBPGF_USE_OPENMP
432 #pragma omp parallel for default(shared)
433#endif
434 for (int i=0; i < m_header.channels; i++) {
435 // inverse transform from m_wtChannel to m_channel
436 if (error == NoError) {
437 OSError err = m_wtChannel[i]->InverseTransform(m_currentLevel, &m_width[i], &m_height[i], &m_channel[i]);
438 if (err != NoError) error = err;
439 }
440 ASSERT(m_channel[i]);
441 }
442 if (error != NoError) ReturnWithError(error);
443
444 // set new level: must be done before refresh callback
445 m_currentLevel--;
446
447 // now we have to refresh the display
448 if (m_cb) m_cb(m_cbArg);
449
450 // now update progress
451 if (cb) {
452 percent *= 4;
453 if (m_progressMode == PM_Absolute) m_percent = percent;
454 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
455 }
456 }
457 }
458
459 // automatically closing
460 if (m_currentLevel == 0) Close();
461}
PM_Absolute
@ PM_Absolute
Definition: PGFimage.h:36
LL
@ LL
Definition: PGFtypes.h:92
HL
@ HL
Definition: PGFtypes.h:92
LH
@ LH
Definition: PGFtypes.h:92
HH
@ HH
Definition: PGFtypes.h:92
CDecoder::DecodeInterleaved
void DecodeInterleaved(CWaveletTransform *wtChannel, int level, int quantParam) THROW_
Definition: Decoder.cpp:319
CPGFImage::Read
void Read(int level=0, CallbackPtr cb=NULL, void *data=NULL) THROW_
Definition: PGFimage.cpp:385
CSubband::PlaceTile
void PlaceTile(CDecoder &decoder, int quantParam, bool tile=false, UINT32 tileX=0, UINT32 tileY=0) THROW_
Definition: Subband.cpp:202
CWaveletTransform::InverseTransform
OSError InverseTransform(int level, UINT32 *width, UINT32 *height, DataT **data)
Definition: WaveletTransform.cpp:245
CWaveletTransform::GetSubband
CSubband * GetSubband(int level, Orientation orientation)
Definition: WaveletTransform.h:122

◆ Read() [2/2]

void CPGFImage::Read ( PGFRect &  rect,
int  level = 0,
CallbackPtr  cb = NULL,
void *  data = NULL 
)

Read a rectangular region of interest of a PGF image at current stream position. The origin of the coordinate axis is the top-left corner of the image. All coordinates are measured in pixels. It might throw an IOException.

Parameters
rect[inout] Rectangular region of interest (ROI). The rect might be cropped.
level[0, nLevels) The image level of the resulting image in the internal image buffer.
cbA pointer to a callback procedure. The procedure is called after reading a single level. If cb returns true, then it stops proceeding.
dataData Pointer to C++ class container to host callback procedure.

◆ ReadEncodedData()

UINT32 CPGFImage::ReadEncodedData ( int  level,
UINT8 *  target,
UINT32  targetLen 
) const

Reads the data of an encoded PGF level and copies it to a target buffer without decoding. Precondition: The PGF image has been opened with a call of Open(...). It might throw an IOException.

Parameters
levelThe image level
targetThe target buffer
targetLenThe length of the target buffer in bytes
Returns
The number of bytes copied to the target buffer

Definition at line 660 of file PGFimage.cpp.

660 {
661 ASSERT(level >= 0 && level < m_header.nLevels);
662 ASSERT(target);
663 ASSERT(targetLen > 0);
664 ASSERT(m_decoder);
665
666 // reset stream position
667 m_decoder->SetStreamPosToData();
668
669 // position stream
670 UINT64 offset = 0;
671
672 for (int i=m_header.nLevels - 1; i > level; i--) {
673 offset += m_levelLength[m_header.nLevels - 1 - i];
674 }
675 m_decoder->Skip(offset);
676
677 // compute number of bytes to read
678 UINT32 len = __min(targetLen, GetEncodedLevelLength(level));
679
680 // read data
681 len = m_decoder->ReadEncodedData(target, len);
682 ASSERT(len >= 0 && len <= targetLen);
683
684 return len;
685}
CDecoder::SetStreamPosToData
void SetStreamPosToData() THROW_
Reset stream position to beginning of data block.
Definition: Decoder.h:145
CDecoder::ReadEncodedData
UINT32 ReadEncodedData(UINT8 *target, UINT32 len) const THROW_
Definition: Decoder.cpp:232
CDecoder::Skip
void Skip(UINT64 offset) THROW_
Definition: Decoder.cpp:435
CPGFImage::GetEncodedLevelLength
UINT32 GetEncodedLevelLength(int level) const
Definition: PGFimage.h:370

◆ ReadEncodedHeader()

UINT32 CPGFImage::ReadEncodedHeader ( UINT8 *  target,
UINT32  targetLen 
) const

Reads the encoded PGF headers and copies it to a target buffer. Precondition: The PGF image has been opened with a call of Open(...). It might throw an IOException.

Parameters
targetThe target buffer
targetLenThe length of the target buffer in bytes
Returns
The number of bytes copied to the target buffer

Definition at line 626 of file PGFimage.cpp.

626 {
627 ASSERT(target);
628 ASSERT(targetLen > 0);
629 ASSERT(m_decoder);
630
631 // reset stream position
632 m_decoder->SetStreamPosToStart();
633
634 // compute number of bytes to read
635 UINT32 len = __min(targetLen, GetEncodedHeaderLength());
636
637 // read data
638 len = m_decoder->ReadEncodedData(target, len);
639 ASSERT(len >= 0 && len <= targetLen);
640
641 return len;
642}
CDecoder::SetStreamPosToStart
void SetStreamPosToStart() THROW_
Reset stream position to beginning of PGF pre-header.
Definition: Decoder.h:141
CPGFImage::GetEncodedHeaderLength
UINT32 GetEncodedHeaderLength() const
Definition: PGFimage.cpp:614

◆ ReadPreview()

void CPGFImage::ReadPreview ( )
inline

Read and decode smallest level of a PGF image at current stream position. For details, please refert to Read(...) Precondition: The PGF image has been opened with a call of Open(...). It might throw an IOException.

Definition at line 121 of file PGFimage.h.

121{ Read(Levels() - 1); }
CPGFImage::Levels
BYTE Levels() const
Definition: PGFimage.h:435

◆ Reconstruct()

void CPGFImage::Reconstruct ( int  level = 0)

After you've written a PGF image, you can call this method followed by GetBitmap/GetYUV to get a quick reconstruction (coded -> decoded image). It might throw an IOException.

Parameters
levelThe image level of the resulting image in the internal image buffer.

Definition at line 333 of file PGFimage.cpp.

333 {
334 if (m_header.nLevels == 0) {
335 // image didn't use wavelet transform
336 if (level == 0) {
337 for (int i=0; i < m_header.channels; i++) {
338 ASSERT(m_wtChannel[i]);
339 m_channel[i] = m_wtChannel[i]->GetSubband(0, LL)->GetBuffer();
340 }
341 }
342 } else {
343 int currentLevel = m_header.nLevels;
344
345 if (ROIisSupported()) {
346 // enable ROI reading
347 SetROI(PGFRect(0, 0, m_header.width, m_header.height));
348 }
349
350 while (currentLevel > level) {
351 for (int i=0; i < m_header.channels; i++) {
352 ASSERT(m_wtChannel[i]);
353 // dequantize subbands
354 if (currentLevel == m_header.nLevels) {
355 // last level also has LL band
356 m_wtChannel[i]->GetSubband(currentLevel, LL)->Dequantize(m_quant);
357 }
358 m_wtChannel[i]->GetSubband(currentLevel, HL)->Dequantize(m_quant);
359 m_wtChannel[i]->GetSubband(currentLevel, LH)->Dequantize(m_quant);
360 m_wtChannel[i]->GetSubband(currentLevel, HH)->Dequantize(m_quant);
361
362 // inverse transform from m_wtChannel to m_channel
363 OSError err = m_wtChannel[i]->InverseTransform(currentLevel, &m_width[i], &m_height[i], &m_channel[i]);
364 if (err != NoError) ReturnWithError(err);
365 ASSERT(m_channel[i]);
366 }
367
368 currentLevel--;
369 }
370 }
371}
CPGFImage::SetROI
void SetROI(PGFRect rect)
CSubband::GetBuffer
DataT * GetBuffer()
Definition: Subband.h:106
CSubband::Dequantize
void Dequantize(int quantParam)
Definition: Subband.cpp:154

◆ ResetStreamPos()

void CPGFImage::ResetStreamPos ( )

Reset stream position to start of PGF pre-header.

Definition at line 646 of file PGFimage.cpp.

646 {
647 ASSERT(m_decoder);
648 return m_decoder->SetStreamPosToStart();
649}

◆ RgbToYuv()

void CPGFImage::RgbToYuv ( int  pitch,
UINT8 *  rgbBuff,
BYTE  bpp,
int  channelMap[],
CallbackPtr  cb,
void *  data 
)
private

Definition at line 1332 of file PGFimage.cpp.

1332 {
1333 ASSERT(buff);
1334 int yPos = 0, cnt = 0;
1335 double percent = 0;
1336 const double dP = 1.0/m_header.height;
1337 int defMap[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; ASSERT(sizeof(defMap)/sizeof(defMap[0]) == MaxChannels);
1338
1339 if (channelMap == NULL) channelMap = defMap;
1340
1341 switch(m_header.mode) {
1342 case ImageModeBitmap:
1343 {
1344 ASSERT(m_header.channels == 1);
1345 ASSERT(m_header.bpp == 1);
1346 ASSERT(bpp == 1);
1347
1348 const UINT32 w = m_header.width;
1349 const UINT32 w2 = (m_header.width + 7)/8;
1350 DataT* y = m_channel[0]; ASSERT(y);
1351
1352 for (UINT32 h=0; h < m_header.height; h++) {
1353 if (cb) {
1354 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1355 percent += dP;
1356 }
1357
1358 for (UINT32 j=0; j < w2; j++) {
1359 y[yPos++] = buff[j] - YUVoffset8;
1360 }
1361 for (UINT32 j=w2; j < w; j++) {
1362 y[yPos++] = YUVoffset8;
1363 }
1364
1365 //UINT cnt = w;
1366 //for (UINT32 j=0; j < w2; j++) {
1367 // for (int k=7; k >= 0; k--) {
1368 // if (cnt) {
1369 // y[yPos++] = YUVoffset8 + (1 & (buff[j] >> k));
1370 // cnt--;
1371 // }
1372 // }
1373 //}
1374 buff += pitch;
1375 }
1376 }
1377 break;
1378 case ImageModeIndexedColor:
1379 case ImageModeGrayScale:
1380 case ImageModeHSLColor:
1381 case ImageModeHSBColor:
1382 case ImageModeLabColor:
1383 {
1384 ASSERT(m_header.channels >= 1);
1385 ASSERT(m_header.bpp == m_header.channels*8);
1386 ASSERT(bpp%8 == 0);
1387 const int channels = bpp/8; ASSERT(channels >= m_header.channels);
1388
1389 for (UINT32 h=0; h < m_header.height; h++) {
1390 if (cb) {
1391 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1392 percent += dP;
1393 }
1394
1395 cnt = 0;
1396 for (UINT32 w=0; w < m_header.width; w++) {
1397 for (int c=0; c < m_header.channels; c++) {
1398 m_channel[c][yPos] = buff[cnt + channelMap[c]] - YUVoffset8;
1399 }
1400 cnt += channels;
1401 yPos++;
1402 }
1403 buff += pitch;
1404 }
1405 }
1406 break;
1407 case ImageModeGray16:
1408 case ImageModeLab48:
1409 {
1410 ASSERT(m_header.channels >= 1);
1411 ASSERT(m_header.bpp == m_header.channels*16);
1412 ASSERT(bpp%16 == 0);
1413
1414 UINT16 *buff16 = (UINT16 *)buff;
1415 const int pitch16 = pitch/2;
1416 const int channels = bpp/16; ASSERT(channels >= m_header.channels);
1417 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
1418 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
1419
1420 for (UINT32 h=0; h < m_header.height; h++) {
1421 if (cb) {
1422 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1423 percent += dP;
1424 }
1425
1426 cnt = 0;
1427 for (UINT32 w=0; w < m_header.width; w++) {
1428 for (int c=0; c < m_header.channels; c++) {
1429 m_channel[c][yPos] = (buff16[cnt + channelMap[c]] >> shift) - yuvOffset16;
1430 }
1431 cnt += channels;
1432 yPos++;
1433 }
1434 buff16 += pitch16;
1435 }
1436 }
1437 break;
1438 case ImageModeRGBColor:
1439 {
1440 ASSERT(m_header.channels == 3);
1441 ASSERT(m_header.bpp == m_header.channels*8);
1442 ASSERT(bpp%8 == 0);
1443
1444 DataT* y = m_channel[0]; ASSERT(y);
1445 DataT* u = m_channel[1]; ASSERT(u);
1446 DataT* v = m_channel[2]; ASSERT(v);
1447 const int channels = bpp/8; ASSERT(channels >= m_header.channels);
1448 UINT8 b, g, r;
1449
1450 for (UINT32 h=0; h < m_header.height; h++) {
1451 if (cb) {
1452 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1453 percent += dP;
1454 }
1455
1456 cnt = 0;
1457 for (UINT32 w=0; w < m_header.width; w++) {
1458 b = buff[cnt + channelMap[0]];
1459 g = buff[cnt + channelMap[1]];
1460 r = buff[cnt + channelMap[2]];
1461 // Yuv
1462 y[yPos] = ((b + (g << 1) + r) >> 2) - YUVoffset8;
1463 u[yPos] = r - g;
1464 v[yPos] = b - g;
1465 yPos++;
1466 cnt += channels;
1467 }
1468 buff += pitch;
1469 }
1470 }
1471 break;
1472 case ImageModeRGB48:
1473 {
1474 ASSERT(m_header.channels == 3);
1475 ASSERT(m_header.bpp == m_header.channels*16);
1476 ASSERT(bpp%16 == 0);
1477
1478 UINT16 *buff16 = (UINT16 *)buff;
1479 const int pitch16 = pitch/2;
1480 const int channels = bpp/16; ASSERT(channels >= m_header.channels);
1481 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
1482 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
1483
1484 DataT* y = m_channel[0]; ASSERT(y);
1485 DataT* u = m_channel[1]; ASSERT(u);
1486 DataT* v = m_channel[2]; ASSERT(v);
1487 UINT16 b, g, r;
1488
1489 for (UINT32 h=0; h < m_header.height; h++) {
1490 if (cb) {
1491 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1492 percent += dP;
1493 }
1494
1495 cnt = 0;
1496 for (UINT32 w=0; w < m_header.width; w++) {
1497 b = buff16[cnt + channelMap[0]] >> shift;
1498 g = buff16[cnt + channelMap[1]] >> shift;
1499 r = buff16[cnt + channelMap[2]] >> shift;
1500 // Yuv
1501 y[yPos] = ((b + (g << 1) + r) >> 2) - yuvOffset16;
1502 u[yPos] = r - g;
1503 v[yPos] = b - g;
1504 yPos++;
1505 cnt += channels;
1506 }
1507 buff16 += pitch16;
1508 }
1509 }
1510 break;
1511 case ImageModeRGBA:
1512 case ImageModeCMYKColor:
1513 {
1514 ASSERT(m_header.channels == 4);
1515 ASSERT(m_header.bpp == m_header.channels*8);
1516 ASSERT(bpp%8 == 0);
1517 const int channels = bpp/8; ASSERT(channels >= m_header.channels);
1518
1519 DataT* y = m_channel[0]; ASSERT(y);
1520 DataT* u = m_channel[1]; ASSERT(u);
1521 DataT* v = m_channel[2]; ASSERT(v);
1522 DataT* a = m_channel[3]; ASSERT(a);
1523 UINT8 b, g, r;
1524
1525 for (UINT32 h=0; h < m_header.height; h++) {
1526 if (cb) {
1527 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1528 percent += dP;
1529 }
1530
1531 cnt = 0;
1532 for (UINT32 w=0; w < m_header.width; w++) {
1533 b = buff[cnt + channelMap[0]];
1534 g = buff[cnt + channelMap[1]];
1535 r = buff[cnt + channelMap[2]];
1536 // Yuv
1537 y[yPos] = ((b + (g << 1) + r) >> 2) - YUVoffset8;
1538 u[yPos] = r - g;
1539 v[yPos] = b - g;
1540 a[yPos++] = buff[cnt + channelMap[3]] - YUVoffset8;
1541 cnt += channels;
1542 }
1543 buff += pitch;
1544 }
1545 }
1546 break;
1547 case ImageModeCMYK64:
1548 {
1549 ASSERT(m_header.channels == 4);
1550 ASSERT(m_header.bpp == m_header.channels*16);
1551 ASSERT(bpp%16 == 0);
1552
1553 UINT16 *buff16 = (UINT16 *)buff;
1554 const int pitch16 = pitch/2;
1555 const int channels = bpp/16; ASSERT(channels >= m_header.channels);
1556 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
1557 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
1558
1559 DataT* y = m_channel[0]; ASSERT(y);
1560 DataT* u = m_channel[1]; ASSERT(u);
1561 DataT* v = m_channel[2]; ASSERT(v);
1562 DataT* a = m_channel[3]; ASSERT(a);
1563 UINT16 b, g, r;
1564
1565 for (UINT32 h=0; h < m_header.height; h++) {
1566 if (cb) {
1567 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1568 percent += dP;
1569 }
1570
1571 cnt = 0;
1572 for (UINT32 w=0; w < m_header.width; w++) {
1573 b = buff16[cnt + channelMap[0]] >> shift;
1574 g = buff16[cnt + channelMap[1]] >> shift;
1575 r = buff16[cnt + channelMap[2]] >> shift;
1576 // Yuv
1577 y[yPos] = ((b + (g << 1) + r) >> 2) - yuvOffset16;
1578 u[yPos] = r - g;
1579 v[yPos] = b - g;
1580 a[yPos++] = (buff16[cnt + channelMap[3]] >> shift) - yuvOffset16;
1581 cnt += channels;
1582 }
1583 buff16 += pitch16;
1584 }
1585 }
1586 break;
1587#ifdef __PGF32SUPPORT__
1588 case ImageModeGray32:
1589 {
1590 ASSERT(m_header.channels == 1);
1591 ASSERT(m_header.bpp == 32);
1592 ASSERT(bpp == 32);
1593 ASSERT(DataTSize == sizeof(UINT32));
1594
1595 DataT* y = m_channel[0]; ASSERT(y);
1596
1597 UINT32 *buff32 = (UINT32 *)buff;
1598 const int pitch32 = pitch/4;
1599 const int shift = 31 - UsedBitsPerChannel(); ASSERT(shift >= 0);
1600 const DataT yuvOffset31 = 1 << (UsedBitsPerChannel() - 1);
1601
1602 for (UINT32 h=0; h < m_header.height; h++) {
1603 if (cb) {
1604 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1605 percent += dP;
1606 }
1607
1608 for (UINT32 w=0; w < m_header.width; w++) {
1609 y[yPos++] = (buff32[w] >> shift) - yuvOffset31;
1610 }
1611 buff32 += pitch32;
1612 }
1613 }
1614 break;
1615#endif
1616 case ImageModeRGB12:
1617 {
1618 ASSERT(m_header.channels == 3);
1619 ASSERT(m_header.bpp == m_header.channels*4);
1620 ASSERT(bpp == m_header.channels*4);
1621
1622 DataT* y = m_channel[0]; ASSERT(y);
1623 DataT* u = m_channel[1]; ASSERT(u);
1624 DataT* v = m_channel[2]; ASSERT(v);
1625
1626 UINT8 rgb = 0, b, g, r;
1627
1628 for (UINT32 h=0; h < m_header.height; h++) {
1629 if (cb) {
1630 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1631 percent += dP;
1632 }
1633
1634 cnt = 0;
1635 for (UINT32 w=0; w < m_header.width; w++) {
1636 if (w%2 == 0) {
1637 // even pixel position
1638 rgb = buff[cnt];
1639 b = rgb & 0x0F;
1640 g = (rgb & 0xF0) >> 4;
1641 cnt++;
1642 rgb = buff[cnt];
1643 r = rgb & 0x0F;
1644 } else {
1645 // odd pixel position
1646 b = (rgb & 0xF0) >> 4;
1647 cnt++;
1648 rgb = buff[cnt];
1649 g = rgb & 0x0F;
1650 r = (rgb & 0xF0) >> 4;
1651 cnt++;
1652 }
1653
1654 // Yuv
1655 y[yPos] = ((b + (g << 1) + r) >> 2) - YUVoffset4;
1656 u[yPos] = r - g;
1657 v[yPos] = b - g;
1658 yPos++;
1659 }
1660 buff += pitch;
1661 }
1662 }
1663 break;
1664 case ImageModeRGB16:
1665 {
1666 ASSERT(m_header.channels == 3);
1667 ASSERT(m_header.bpp == 16);
1668 ASSERT(bpp == 16);
1669
1670 DataT* y = m_channel[0]; ASSERT(y);
1671 DataT* u = m_channel[1]; ASSERT(u);
1672 DataT* v = m_channel[2]; ASSERT(v);
1673
1674 UINT16 *buff16 = (UINT16 *)buff;
1675 UINT16 rgb, b, g, r;
1676 const int pitch16 = pitch/2;
1677
1678 for (UINT32 h=0; h < m_header.height; h++) {
1679 if (cb) {
1680 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1681 percent += dP;
1682 }
1683 for (UINT32 w=0; w < m_header.width; w++) {
1684 rgb = buff16[w];
1685 r = (rgb & 0xF800) >> 10; // highest 5 bits
1686 g = (rgb & 0x07E0) >> 5; // middle 6 bits
1687 b = (rgb & 0x001F) << 1; // lowest 5 bits
1688 // Yuv
1689 y[yPos] = ((b + (g << 1) + r) >> 2) - YUVoffset6;
1690 u[yPos] = r - g;
1691 v[yPos] = b - g;
1692 yPos++;
1693 }
1694
1695 buff16 += pitch16;
1696 }
1697 }
1698 break;
1699 default:
1700 ASSERT(false);
1701 }
1702}

◆ ROIisSupported()

bool CPGFImage::ROIisSupported ( ) const
inline

Return true if the pgf image supports Region Of Interest (ROI).

Returns
true if the pgf image supports ROI.

Definition at line 465 of file PGFimage.h.

465{ return (m_preHeader.version & PGFROI) == PGFROI; }
PGFROI
#define PGFROI
supports Regions Of Interest
Definition: PGFtypes.h:64

◆ SetChannel()

void CPGFImage::SetChannel ( DataT *  channel,
int  c = 0 
)
inline

Set internal PGF image buffer channel.

Parameters
channelA YUV data channel
cA channel index

Definition at line 276 of file PGFimage.h.

276{ ASSERT(c >= 0 && c < MaxChannels); m_channel[c] = channel; }

◆ SetColorTable()

void CPGFImage::SetColorTable ( UINT32  iFirstColor,
UINT32  nColors,
const RGBQUAD *  prgbColors 
)

Sets the red, green, blue (RGB) color values for a range of entries in the palette (clut). It might throw an IOException.

Parameters
iFirstColorThe color table index of the first entry to set.
nColorsThe number of color table entries to set.
prgbColorsA pointer to the array of RGBQUAD structures to set the color table entries.

Definition at line 1307 of file PGFimage.cpp.

1307 {
1308 if (iFirstColor + nColors > ColorTableLen) ReturnWithError(ColorTableError);
1309
1310 for (UINT32 i=iFirstColor, j=0; j < nColors; i++, j++) {
1311 m_postHeader.clut[i] = prgbColors[j];
1312 }
1313}

◆ SetHeader()

void CPGFImage::SetHeader ( const PGFHeader &  header,
BYTE  flags = 0,
UINT8 *  userData = 0,
UINT32  userDataLength = 0 
)

Set PGF header and user data. Precondition: The PGF image has been closed with Close(...) or never opened with Open(...). It might throw an IOException.

Parameters
headerA valid and already filled in PGF header structure
flagsA combination of additional version flags. In case you use level-wise encoding then set flag = PGFROI.
userDataA user-defined memory block containing any kind of cached metadata.
userDataLengthThe size of user-defined memory block in bytes

Definition at line 845 of file PGFimage.cpp.

845 {
846 ASSERT(!m_decoder); // current image must be closed
847 ASSERT(header.quality <= MaxQuality);
848
849 // init state
850#ifdef __PGFROISUPPORT__
851 m_streamReinitialized = false;
852#endif
853
854 // init preHeader
855 memcpy(m_preHeader.magic, PGFMagic, 3);
856 m_preHeader.version = PGFVersion | flags;
857 m_preHeader.hSize = HeaderSize;
858
859 // copy header
860 memcpy(&m_header, &header, HeaderSize);
861
862 // complete header
863 CompleteHeader();
864
865 // check and set number of levels
866 ComputeLevels();
867
868 // check for downsample
869 if (m_header.quality > DownsampleThreshold && (m_header.mode == ImageModeRGBColor ||
870 m_header.mode == ImageModeRGBA ||
871 m_header.mode == ImageModeRGB48 ||
872 m_header.mode == ImageModeCMYKColor ||
873 m_header.mode == ImageModeCMYK64 ||
874 m_header.mode == ImageModeLabColor ||
875 m_header.mode == ImageModeLab48)) {
876 m_downsample = true;
877 m_quant = m_header.quality - 1;
878 } else {
879 m_downsample = false;
880 m_quant = m_header.quality;
881 }
882
883 // update header size and copy user data
884 if (m_header.mode == ImageModeIndexedColor) {
885 // update header size
886 m_preHeader.hSize += ColorTableSize;
887 }
888 if (userDataLength && userData) {
889 m_postHeader.userData = new(std::nothrow) UINT8[userDataLength];
890 if (!m_postHeader.userData) ReturnWithError(InsufficientMemory);
891 m_postHeader.userDataLen = userDataLength;
892 memcpy(m_postHeader.userData, userData, userDataLength);
893 // update header size
894 m_preHeader.hSize += userDataLength;
895 }
896
897 // allocate channels
898 for (int i=0; i < m_header.channels; i++) {
899 // set current width and height
900 m_width[i] = m_header.width;
901 m_height[i] = m_header.height;
902
903 // allocate channels
904 ASSERT(!m_channel[i]);
905 m_channel[i] = new(std::nothrow) DataT[m_header.width*m_header.height];
906 if (!m_channel[i]) {
907 if (i) i--;
908 while(i) {
909 delete[] m_channel[i]; m_channel[i] = 0;
910 i--;
911 }
912 ReturnWithError(InsufficientMemory);
913 }
914 }
915}
HeaderSize
#define HeaderSize
Definition: PGFtypes.h:231
ColorTableSize
#define ColorTableSize
Definition: PGFtypes.h:232
MaxQuality
#define MaxQuality
maximum quality
Definition: PGFtypes.h:87
CPGFImage::ComputeLevels
void ComputeLevels()
Definition: PGFimage.cpp:805

◆ SetMaxValue()

void CPGFImage::SetMaxValue ( UINT32  maxValue)

Set maximum intensity value for image modes with more than eight bits per channel. Call this method after SetHeader, but before ImportBitmap.

Parameters
maxValueThe maximum intensity value.

Definition at line 691 of file PGFimage.cpp.

691 {
692 const BYTE bpc = m_header.bpp/m_header.channels;
693 BYTE pot = 0;
694
695 while(maxValue > 0) {
696 pot++;
697 maxValue >>= 1;
698 }
699 // store bits per channel
700 if (pot > bpc) pot = bpc;
701 if (pot > 31) pot = 31;
702 m_header.usedBitsPerChannel = pot;
703}

◆ SetProgressMode()

void CPGFImage::SetProgressMode ( ProgressMode  pm)
inline

Set progress mode used in Read and Write. Default mode is PM_Relative. This method must be called before Open() or SetHeader(). PM_Relative: 100% = level difference between current level and target level of Read/Write PM_Absolute: 100% = number of levels

Definition at line 300 of file PGFimage.h.

300{ m_progressMode = pm; }

◆ SetRefreshCallback()

void CPGFImage::SetRefreshCallback ( RefreshCB  callback,
void *  arg 
)
inline

Set refresh callback procedure and its parameter. The refresh callback is called during Read(...) after each level read.

Parameters
callbackA refresh callback procedure
argA parameter of the refresh callback procedure

Definition at line 307 of file PGFimage.h.

307{ m_cb = callback; m_cbArg = arg; }

◆ SetROI()

void CPGFImage::SetROI ( PGFRect  rect)
private

◆ UpdatePostHeaderSize()

UINT32 CPGFImage::UpdatePostHeaderSize ( )
private

Definition at line 1068 of file PGFimage.cpp.

1068 {
1069 ASSERT(m_encoder);
1070
1071 INT64 offset = m_encoder->ComputeOffset(); ASSERT(offset >= 0);
1072
1073 if (offset > 0) {
1074 // update post-header size and rewrite pre-header
1075 m_preHeader.hSize += (UINT32)offset;
1076 m_encoder->UpdatePostHeaderSize(m_preHeader);
1077 }
1078
1079 // write dummy levelLength into stream
1080 return m_encoder->WriteLevelLength(m_levelLength);
1081}
CEncoder::ComputeOffset
INT64 ComputeOffset() const
Definition: Encoder.h:184
CEncoder::WriteLevelLength
UINT32 WriteLevelLength(UINT32 *&levelLength) THROW_
Definition: Encoder.cpp:177
CEncoder::UpdatePostHeaderSize
void UpdatePostHeaderSize(PGFPreHeader preHeader) THROW_
Definition: Encoder.cpp:160

◆ UsedBitsPerChannel()

BYTE CPGFImage::UsedBitsPerChannel ( ) const

Returns number of used bits per input/output image channel. Precondition: header must be initialized.

Returns
number of used bits per input/output image channel.

Definition at line 709 of file PGFimage.cpp.

709 {
710 const BYTE bpc = m_header.bpp/m_header.channels;
711
712 if (bpc > 8) {
713 return m_header.usedBitsPerChannel;
714 } else {
715 return bpc;
716 }
717}

◆ Version()

BYTE CPGFImage::Version ( ) const
inline

Returns images' PGF version

Returns
PGF codec version of the image

Definition at line 476 of file PGFimage.h.

476{ return CurrentVersion(m_preHeader.version); }
CPGFImage::CurrentVersion
static BYTE CurrentVersion(BYTE version=PGFVersion)
Return version.
Definition: PGFimage.cpp:721

◆ Width()

UINT32 CPGFImage::Width ( int  level = 0) const
inline

Return image width of channel 0 at given level in pixels. The returned width is independent of any Read-operations and ROI.

Parameters
levelA level
Returns
Image level width in pixels

Definition at line 416 of file PGFimage.h.

416{ ASSERT(level >= 0); return LevelWidth(m_header.width, level); }

◆ Write() [1/2]

void CPGFImage::Write ( CPGFStream *  stream,
UINT32 *  nWrittenBytes = NULL,
CallbackPtr  cb = NULL,
void *  data = NULL 
)

Encode and write a entire PGF image (header and image) at current stream position. A PGF image is structered in levels, numbered between 0 and Levels() - 1. Each level can be seen as a single image, containing the same content as all other levels, but in a different size (width, height). The image size at level i is double the size (width, height) of the image at level i+1. The image at level 0 contains the original size. Precondition: the PGF image contains a valid header (see also SetHeader(...)). It might throw an IOException.

Parameters
streamA PGF stream
nWrittenBytes[in-out] The number of bytes written into stream are added to the input value.
cbA pointer to a callback procedure. The procedure is called after writing a single level. If cb returns true, then it stops proceeding.
dataData Pointer to C++ class container to host callback procedure.

Definition at line 1164 of file PGFimage.cpp.

1164 {
1165 ASSERT(stream);
1166 ASSERT(m_preHeader.hSize);
1167
1168 // create wavelet transform channels and encoder
1169 UINT32 nBytes = WriteHeader(stream);
1170
1171 // write image
1172 nBytes += WriteImage(stream, cb, data);
1173
1174 // return written bytes
1175 if (nWrittenBytes) *nWrittenBytes += nBytes;
1176}
CPGFImage::WriteImage
UINT32 WriteImage(CPGFStream *stream, CallbackPtr cb=NULL, void *data=NULL) THROW_
Definition: PGFimage.cpp:1093
CPGFImage::WriteHeader
UINT32 WriteHeader(CPGFStream *stream) THROW_
Definition: PGFimage.cpp:924

◆ Write() [2/2]

UINT32 CPGFImage::Write ( int  level,
CallbackPtr  cb = NULL,
void *  data = NULL 
)

Encode and write down to given level at current stream position. A PGF image is structered in levels, numbered between 0 and Levels() - 1. Each level can be seen as a single image, containing the same content as all other levels, but in a different size (width, height). The image size at level i is double the size (width, height) of the image at level i+1. The image at level 0 contains the original size. Preconditions: the PGF image contains a valid header (see also SetHeader(...)) and WriteHeader() has been called before. Levels() > 0. The ROI encoding scheme must be used (see also SetHeader(...)). It might throw an IOException.

Parameters
level[0, nLevels) The image level of the resulting image in the internal image buffer.
cbA pointer to a callback procedure. The procedure is called after writing a single level. If cb returns true, then it stops proceeding.
dataData Pointer to C++ class container to host callback procedure.
Returns
The number of bytes written into stream.

◆ WriteHeader()

UINT32 CPGFImage::WriteHeader ( CPGFStream *  stream)

Create wavelet transform channels and encoder. Write header at current stream position. Call this method before your first call of Write(int level) or WriteImage(), but after SetHeader(). This method is called inside of Write(stream, ...). It might throw an IOException.

Parameters
streamA PGF stream
Returns
The number of bytes written into stream.

Definition at line 924 of file PGFimage.cpp.

924 {
925 ASSERT(m_header.nLevels <= MaxLevel);
926 ASSERT(m_header.quality <= MaxQuality); // quality is already initialized
927
928 if (m_header.nLevels > 0) {
929 volatile OSError error = NoError; // volatile prevents optimizations
930 // create new wt channels
931#ifdef LIBPGF_USE_OPENMP
932 #pragma omp parallel for default(shared)
933#endif
934 for (int i=0; i < m_header.channels; i++) {
935 DataT *temp = NULL;
936 if (error == NoError) {
937 if (m_wtChannel[i]) {
938 ASSERT(m_channel[i]);
939 // copy m_channel to temp
940 int size = m_height[i]*m_width[i];
941 temp = new(std::nothrow) DataT[size];
942 if (temp) {
943 memcpy(temp, m_channel[i], size*DataTSize);
944 delete m_wtChannel[i]; // also deletes m_channel
945 m_channel[i] = NULL;
946 } else {
947 error = InsufficientMemory;
948 }
949 }
950 if (error == NoError) {
951 if (temp) {
952 ASSERT(!m_channel[i]);
953 m_channel[i] = temp;
954 }
955 m_wtChannel[i] = new CWaveletTransform(m_width[i], m_height[i], m_header.nLevels, m_channel[i]);
956 if (m_wtChannel[i]) {
957 #ifdef __PGFROISUPPORT__
958 m_wtChannel[i]->SetROI(PGFRect(0, 0, m_width[i], m_height[i]));
959 #endif
960
961 // wavelet subband decomposition
962 for (int l=0; error == NoError && l < m_header.nLevels; l++) {
963 OSError err = m_wtChannel[i]->ForwardTransform(l, m_quant);
964 if (err != NoError) error = err;
965 }
966 } else {
967 delete[] m_channel[i];
968 error = InsufficientMemory;
969 }
970 }
971 }
972 }
973 if (error != NoError) {
974 // free already allocated memory
975 for (int i=0; i < m_header.channels; i++) {
976 delete m_wtChannel[i];
977 }
978 ReturnWithError(error);
979 }
980
981 m_currentLevel = m_header.nLevels;
982
983 // create encoder and eventually write headers and levelLength
984 m_encoder = new CEncoder(stream, m_preHeader, m_header, m_postHeader, m_userDataPos, m_useOMPinEncoder);
985 if (m_favorSpeedOverSize) m_encoder->FavorSpeedOverSize();
986
987 #ifdef __PGFROISUPPORT__
988 if (ROIisSupported()) {
989 // new encoding scheme supporting ROI
990 m_encoder->SetROI();
991 }
992 #endif
993
994 } else {
995 // very small image: we don't use DWT and encoding
996
997 // create encoder and eventually write headers and levelLength
998 m_encoder = new CEncoder(stream, m_preHeader, m_header, m_postHeader, m_userDataPos, m_useOMPinEncoder);
999 }
1000
1001 INT64 nBytes = m_encoder->ComputeHeaderLength();
1002 return (nBytes > 0) ? (UINT32)nBytes : 0;
1003}
CEncoder
PGF encoder.
Definition: Encoder.h:46
CEncoder::ComputeHeaderLength
INT64 ComputeHeaderLength() const
Definition: Encoder.h:174
CEncoder::FavorSpeedOverSize
void FavorSpeedOverSize()
Encoder favors speed over compression size.
Definition: Encoder.h:121
CWaveletTransform::ForwardTransform
OSError ForwardTransform(int level, int quant)
Definition: WaveletTransform.cpp:88

◆ WriteImage()

UINT32 CPGFImage::WriteImage ( CPGFStream *  stream,
CallbackPtr  cb = NULL,
void *  data = NULL 
)

Encode and write the one and only image at current stream position. Call this method after WriteHeader(). In case you want to write uncached metadata, then do that after WriteHeader() and before WriteImage(). This method is called inside of Write(stream, ...). It might throw an IOException.

Parameters
streamA PGF stream
cbA pointer to a callback procedure. The procedure is called after writing a single level. If cb returns true, then it stops proceeding.
dataData Pointer to C++ class container to host callback procedure.
Returns
The number of bytes written into stream.

Definition at line 1093 of file PGFimage.cpp.

1093 {
1094 ASSERT(stream);
1095 ASSERT(m_preHeader.hSize);
1096
1097 int levels = m_header.nLevels;
1098 double percent = pow(0.25, levels);
1099
1100 // update post-header size, rewrite pre-header, and write dummy levelLength
1101 UINT32 nWrittenBytes = UpdatePostHeaderSize();
1102
1103 if (levels == 0) {
1104 // write channels
1105 for (int c=0; c < m_header.channels; c++) {
1106 const UINT32 size = m_width[c]*m_height[c];
1107
1108 // write channel data into stream
1109 for (UINT32 i=0; i < size; i++) {
1110 int count = DataTSize;
1111 stream->Write(&count, &m_channel[c][i]);
1112 }
1113 }
1114
1115 // now update progress
1116 if (cb) {
1117 if ((*cb)(1, true, data)) ReturnWithError(EscapePressed);
1118 }
1119
1120 } else {
1121 // encode quantized wavelet coefficients and write to PGF file
1122 // encode subbands, higher levels first
1123 // color channels are interleaved
1124
1125 // encode all levels
1126 for (m_currentLevel = levels; m_currentLevel > 0; ) {
1127 WriteLevel(); // decrements m_currentLevel
1128
1129 // now update progress
1130 if (cb) {
1131 percent *= 4;
1132 if ((*cb)(percent, true, data)) ReturnWithError(EscapePressed);
1133 }
1134 }
1135
1136 // flush encoder and write level lengths
1137 m_encoder->Flush();
1138 }
1139
1140 // update level lengths
1141 nWrittenBytes += m_encoder->UpdateLevelLength(); // return written image bytes
1142
1143 // delete encoder
1144 delete m_encoder; m_encoder = NULL;
1145
1146 ASSERT(!m_encoder);
1147
1148 return nWrittenBytes;
1149}
CEncoder::Flush
void Flush() THROW_
Definition: Encoder.cpp:310
CEncoder::UpdateLevelLength
UINT32 UpdateLevelLength() THROW_
Definition: Encoder.cpp:202
CPGFImage::UpdatePostHeaderSize
UINT32 UpdatePostHeaderSize() THROW_
Definition: PGFimage.cpp:1068
CPGFImage::WriteLevel
void WriteLevel() THROW_
Definition: PGFimage.cpp:1013
CPGFStream::Write
virtual void Write(int *count, void *buffer)=0

◆ WriteLevel()

void CPGFImage::WriteLevel ( )
private

Definition at line 1013 of file PGFimage.cpp.

1013 {
1014 ASSERT(m_encoder);
1015 ASSERT(m_currentLevel > 0);
1016 ASSERT(m_header.nLevels > 0);
1017
1018#ifdef __PGFROISUPPORT__
1019 if (ROIisSupported()) {
1020 const int lastChannel = m_header.channels - 1;
1021
1022 for (int i=0; i < m_header.channels; i++) {
1023 // get number of tiles and tile indices
1024 const UINT32 nTiles = m_wtChannel[i]->GetNofTiles(m_currentLevel);
1025 const UINT32 lastTile = nTiles - 1;
1026
1027 if (m_currentLevel == m_header.nLevels) {
1028 // last level also has LL band
1029 ASSERT(nTiles == 1);
1030 m_wtChannel[i]->GetSubband(m_currentLevel, LL)->ExtractTile(*m_encoder);
1031 m_encoder->EncodeTileBuffer();
1032 }
1033 for (UINT32 tileY=0; tileY < nTiles; tileY++) {
1034 for (UINT32 tileX=0; tileX < nTiles; tileX++) {
1035 m_wtChannel[i]->GetSubband(m_currentLevel, HL)->ExtractTile(*m_encoder, true, tileX, tileY);
1036 m_wtChannel[i]->GetSubband(m_currentLevel, LH)->ExtractTile(*m_encoder, true, tileX, tileY);
1037 m_wtChannel[i]->GetSubband(m_currentLevel, HH)->ExtractTile(*m_encoder, true, tileX, tileY);
1038 if (i == lastChannel && tileY == lastTile && tileX == lastTile) {
1039 // all necessary data are buffered. next call of EncodeBuffer will write the last piece of data of the current level.
1040 m_encoder->SetEncodedLevel(--m_currentLevel);
1041 }
1042 m_encoder->EncodeTileBuffer();
1043 }
1044 }
1045 }
1046 } else
1047#endif
1048 {
1049 for (int i=0; i < m_header.channels; i++) {
1050 ASSERT(m_wtChannel[i]);
1051 if (m_currentLevel == m_header.nLevels) {
1052 // last level also has LL band
1053 m_wtChannel[i]->GetSubband(m_currentLevel, LL)->ExtractTile(*m_encoder);
1054 }
1055 //encoder.EncodeInterleaved(m_wtChannel[i], m_currentLevel, m_quant); // until version 4
1056 m_wtChannel[i]->GetSubband(m_currentLevel, HL)->ExtractTile(*m_encoder); // since version 5
1057 m_wtChannel[i]->GetSubband(m_currentLevel, LH)->ExtractTile(*m_encoder); // since version 5
1058 m_wtChannel[i]->GetSubband(m_currentLevel, HH)->ExtractTile(*m_encoder);
1059 }
1060
1061 // all necessary data are buffered. next call of EncodeBuffer will write the last piece of data of the current level.
1062 m_encoder->SetEncodedLevel(--m_currentLevel);
1063 }
1064}
CEncoder::SetEncodedLevel
void SetEncodedLevel(int currentLevel)
Definition: Encoder.h:162
CSubband::ExtractTile
void ExtractTile(CEncoder &encoder, bool tile=false, UINT32 tileX=0, UINT32 tileY=0) THROW_
Definition: Subband.cpp:177

Member Data Documentation

◆ m_cb

RefreshCB CPGFImage::m_cb
private

pointer to refresh callback procedure

Definition at line 535 of file PGFimage.h.

◆ m_cbArg

void* CPGFImage::m_cbArg
private

refresh callback argument

Definition at line 536 of file PGFimage.h.

◆ m_channel

DataT* CPGFImage::m_channel[MaxChannels]
protected

untransformed channels in YUV format

Definition at line 512 of file PGFimage.h.

◆ m_currentLevel

int CPGFImage::m_currentLevel
protected

transform level of current image

Definition at line 522 of file PGFimage.h.

◆ m_decoder

CDecoder* CPGFImage::m_decoder
protected

PGF decoder.

Definition at line 513 of file PGFimage.h.

◆ m_downsample

bool CPGFImage::m_downsample
protected

chrominance channels are downsampled

Definition at line 524 of file PGFimage.h.

◆ m_encoder

CEncoder* CPGFImage::m_encoder
protected

PGF encoder.

Definition at line 514 of file PGFimage.h.

◆ m_favorSpeedOverSize

bool CPGFImage::m_favorSpeedOverSize
protected

favor encoding speed over compression ratio

Definition at line 525 of file PGFimage.h.

◆ m_header

PGFHeader CPGFImage::m_header
protected

PGF file header.

Definition at line 519 of file PGFimage.h.

◆ m_height

UINT32 CPGFImage::m_height[MaxChannels]
protected

height of each channel at current level

Definition at line 517 of file PGFimage.h.

◆ m_levelLength

UINT32* CPGFImage::m_levelLength
protected

length of each level in bytes; first level starts immediately after this array

Definition at line 515 of file PGFimage.h.

◆ m_percent

double CPGFImage::m_percent
private

progress [0..1]

Definition at line 537 of file PGFimage.h.

◆ m_postHeader

PGFPostHeader CPGFImage::m_postHeader
protected

PGF post-header.

Definition at line 520 of file PGFimage.h.

◆ m_preHeader

PGFPreHeader CPGFImage::m_preHeader
protected

PGF pre-header.

Definition at line 518 of file PGFimage.h.

◆ m_progressMode

ProgressMode CPGFImage::m_progressMode
private

progress mode used in Read and Write; PM_Relative is default mode

Definition at line 538 of file PGFimage.h.

◆ m_quant

BYTE CPGFImage::m_quant
protected

quantization parameter

Definition at line 523 of file PGFimage.h.

◆ m_roi

PGFRect CPGFImage::m_roi
protected

region of interest

Definition at line 531 of file PGFimage.h.

◆ m_skipUserData

bool CPGFImage::m_skipUserData
protected

skip user data (metadata) during open

Definition at line 528 of file PGFimage.h.

◆ m_streamReinitialized

bool CPGFImage::m_streamReinitialized
protected

stream has been reinitialized

Definition at line 530 of file PGFimage.h.

◆ m_useOMPinDecoder

bool CPGFImage::m_useOMPinDecoder
protected

use Open MP in decoder

Definition at line 527 of file PGFimage.h.

◆ m_useOMPinEncoder

bool CPGFImage::m_useOMPinEncoder
protected

use Open MP in encoder

Definition at line 526 of file PGFimage.h.

◆ m_userDataPos

UINT64 CPGFImage::m_userDataPos
protected

stream position of user data

Definition at line 521 of file PGFimage.h.

◆ m_width

UINT32 CPGFImage::m_width[MaxChannels]
protected

width of each channel at current level

Definition at line 516 of file PGFimage.h.

◆ m_wtChannel

CWaveletTransform* CPGFImage::m_wtChannel[MaxChannels]
protected

wavelet transformed color channels

Definition at line 511 of file PGFimage.h.

The documentation for this class was generated from the following files: