Rev 16911 |
Rev 19721 |
Go to most recent revision |
Blame |
Compare with Previous |
Last modification |
View Log
| RSS feed
/*
* The Progressive Graphics File; http://www.libpgf.org
*
* $Date: 2007-06-12 19:27:47 +0200 (Di, 12 Jun 2007) $
* $Revision: 307 $
*
* This file Copyright (C) 2006 xeraina GmbH, Switzerland
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE
* as published by the Free Software Foundation; either version 2.1
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
//////////////////////////////////////////////////////////////////////
/// @file PGFplatform.h
/// @brief PGF platform specific definitions
/// @author C. Stamm
#ifndef PGF_PGFPLATFORM_H
#define PGF_PGFPLATFORM_H
#include <cassert>
#include <cmath>
#include <cstdlib>
//-------------------------------------------------------------------------------
// Endianess detection taken from lcms2 header.
// This list can be endless, so only some checks are performed over here.
//-------------------------------------------------------------------------------
#if defined(_HOST_BIG_ENDIAN) || defined(__BIG_ENDIAN__) || defined(WORDS_BIGENDIAN)
#define PGF_USE_BIG_ENDIAN 1
#endif
#if defined(__sgi__) || defined(__sgi) || defined(__powerpc__) || defined(__sparc) || defined(__sparc__)
#define PGF_USE_BIG_ENDIAN 1
#endif
#if defined(__ppc__) || defined(__s390__) || defined(__s390x__)
#define PGF_USE_BIG_ENDIAN 1
#endif
#ifdef TARGET_CPU_PPC
#define PGF_USE_BIG_ENDIAN 1
#endif
//-------------------------------------------------------------------------------
// ROI support
//-------------------------------------------------------------------------------
#ifndef NPGFROI
#define __PGFROISUPPORT__ // without ROI support the program code gets simpler and smaller
#endif
//-------------------------------------------------------------------------------
// 32 bit per channel support
//-------------------------------------------------------------------------------
#ifndef NPGF32
#define __PGF32SUPPORT__ // without 32 bit the memory consumption during encoding and decoding is much lesser
#endif
//-------------------------------------------------------------------------------
// 32 Bit platform constants
//-------------------------------------------------------------------------------
#define WordWidth 32 // WordBytes*8
#define WordWidthLog 5 // ld of WordWidth
#define WordMask 0xFFFFFFE0 // least WordWidthLog bits are zero
#define WordBytes 4 // sizeof(UINT32)
#define WordBytesLog 2 // ld of WordBytes
//-------------------------------------------------------------------------------
// Macros
//-------------------------------------------------------------------------------
//#define DWWIDTH(bytes) ((((bytes) + WordBytes - 1) >> WordBytesLog) << WordBytesLog) // aligns scanline width in bytes to DWORD value
//#define DWWIDTHBITS(bits) ((((bits) + WordWidth - 1) >> WordWidthLog) << WordBytesLog) // aligns scanline width in bits to DWORD value
//#define DWWIDTHREST(bytes) ((WordBytes - (bytes)%WordBytes)%WordBytes) // DWWIDTHBITS(bytes*8) - bytes
//-------------------------------------------------------------------------------
// Min-Max macros
//-------------------------------------------------------------------------------
#ifndef __min
#define __min(x, y) ((x) <= (y) ? (x) : (y))
#define __max(x, y) ((x) >= (y) ? (x) : (y))
#endif // __min
//-------------------------------------------------------------------------------
// Defines -- Adobe image modes.
//-------------------------------------------------------------------------------
#define ImageModeBitmap 0
#define ImageModeGrayScale 1
#define ImageModeIndexedColor 2
#define ImageModeRGBColor 3
#define ImageModeCMYKColor 4
#define ImageModeHSLColor 5
#define ImageModeHSBColor 6
#define ImageModeMultichannel 7
#define ImageModeDuotone 8
#define ImageModeLabColor 9
#define ImageModeGray16 10
#define ImageModeRGB48 11
#define ImageModeLab48 12
#define ImageModeCMYK64 13
#define ImageModeDeepMultichannel 14
#define ImageModeDuotone16 15
// pgf extension
#define ImageModeRGBA 17
#define ImageModeGray31 18
#define ImageModeRGB12 19
#define ImageModeRGB16 20
#define ImageModeUnknown 255
//-------------------------------------------------------------------------------
// WINDOWS 32
//-------------------------------------------------------------------------------
#if defined(WIN32) || defined(WINCE)
#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
//-------------------------------------------------------------------------------
// MFC
//-------------------------------------------------------------------------------
#ifdef _MFC_VER
#include <afxwin.h> // MFC core and standard components
#include <afxext.h> // MFC extensions
#include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h> // MFC support for Windows Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT
#include <afx.h>
#else
#include <windows.h>
#include <ole2.h>
#endif // _MFC_VER
//-------------------------------------------------------------------------------
#define DllExport __declspec( dllexport )
//-------------------------------------------------------------------------------
// unsigned number type definitions
//-------------------------------------------------------------------------------
typedef unsigned char UINT8;
typedef unsigned char BYTE;
typedef unsigned short UINT16;
typedef unsigned short WORD;
typedef unsigned int UINT32;
typedef unsigned long DWORD;
typedef unsigned long ULONG;
typedef unsigned __int64 UINT64;
typedef unsigned __int64 ULONGLONG;
//-------------------------------------------------------------------------------
// signed number type definitions
//-------------------------------------------------------------------------------
typedef signed char INT8;
typedef signed short INT16;
typedef signed int INT32;
typedef signed int BOOL;
typedef signed long LONG;
typedef signed __int64 INT64;
typedef signed __int64 LONGLONG;
//-------------------------------------------------------------------------------
// other types
//-------------------------------------------------------------------------------
typedef int OSError;
typedef bool (__cdecl *CallbackPtr)(double percent, bool escapeAllowed, void *data);
//-------------------------------------------------------------------------------
// struct type definitions
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
// DEBUG macros
//-------------------------------------------------------------------------------
#ifndef ASSERT
#ifdef _DEBUG
#define ASSERT(x) assert(x)
#else
#if defined(__GNUC__)
#define ASSERT(ignore)((void) 0)
#elif _MSC_VER >= 1300
#define ASSERT __noop
#else
#define ASSERT ((void)0)
#endif
#endif //_DEBUG
#endif //ASSERT
//-------------------------------------------------------------------------------
// Exception handling macros
//-------------------------------------------------------------------------------
#ifdef NEXCEPTIONS
extern OSError _PGF_Error_;
extern OSError GetLastPGFError();
#define ReturnWithError(err) { _PGF_Error_ = err; return; }
#define ReturnWithError2(err, ret) { _PGF_Error_ = err; return ret; }
#else
#define ReturnWithError(err) throw IOException(err)
#define ReturnWithError2(err, ret) throw IOException(err)
#endif //NEXCEPTIONS
#if _MSC_VER >= 1300
//#define THROW_ throw(...)
#pragma warning( disable : 4290 )
#define THROW_ throw(IOException)
#else
#define THROW_
#endif
//-------------------------------------------------------------------------------
// constants
//-------------------------------------------------------------------------------
#define FSFromStart FILE_BEGIN // 0
#define FSFromCurrent FILE_CURRENT // 1
#define FSFromEnd FILE_END // 2
#define INVALID_SET_FILE_POINTER ((DWORD)-1)
//-------------------------------------------------------------------------------
// IO Error constants
//-------------------------------------------------------------------------------
#define NoError ERROR_SUCCESS // no error
#define AppError 0x20000000 // all application error messages must be larger than this value
#define InsufficientMemory 0x20000001 // memory allocation wasn't successfull
#define EndOfMemory 0x20000002 // like end-of-file (EOF) for memory stream
#define EscapePressed 0x20000003 // user break by ESC
#define WrongVersion 0x20000004 // wrong pgf version
#define FormatCannotRead 0x20000005 // wrong data file format
#define ImageTooSmall 0x20000006 // image is too small
#define ZlibError 0x20000007 // error in zlib functions
#define ColorTableError 0x20000008 // errors related to color table size
#define PNGError 0x20000009 // errors in png functions
#define MissingData 0x2000000A // expected data cannot be read
//-------------------------------------------------------------------------------
// methods
//-------------------------------------------------------------------------------
inline OSError FileRead(HANDLE hFile, int *count, void *buffPtr) {
if (ReadFile(hFile, buffPtr, *count, (ULONG *)count, NULL)) {
return NoError;
} else {
return GetLastError();
}
}
inline OSError FileWrite(HANDLE hFile, int *count, void *buffPtr) {
if (WriteFile(hFile, buffPtr, *count, (ULONG *)count, NULL)) {
return NoError;
} else {
return GetLastError();
}
}
inline OSError GetFPos(HANDLE hFile, UINT64 *pos) {
#ifdef WINCE
LARGE_INTEGER li;
li.QuadPart = 0;
li.LowPart = SetFilePointer (hFile, li.LowPart, &li.HighPart, FILE_CURRENT);
if (li.LowPart == INVALID_SET_FILE_POINTER) {
OSError err = GetLastError();
if (err != NoError) {
return err;
}
}
*pos = li.QuadPart;
return NoError;
#else
LARGE_INTEGER li;
li.QuadPart = 0;
if (SetFilePointerEx(hFile, li, (PLARGE_INTEGER)pos, FILE_CURRENT)) {
return NoError;
} else {
return GetLastError();
}
#endif
}
inline OSError SetFPos(HANDLE hFile, int posMode, INT64 posOff) {
#ifdef WINCE
LARGE_INTEGER li;
li.QuadPart = posOff;
if (SetFilePointer (hFile, li.LowPart, &li.HighPart, posMode) == INVALID_SET_FILE_POINTER) {
OSError err = GetLastError();
if (err != NoError) {
return err;
}
}
return NoError;
#else
LARGE_INTEGER li;
li.QuadPart = posOff;
if (SetFilePointerEx(hFile, li, NULL, posMode)) {
return NoError;
} else {
return GetLastError();
}
#endif
}
#endif //WIN32
//-------------------------------------------------------------------------------
// Apple OSX
//-------------------------------------------------------------------------------
#ifdef __APPLE__
#define __POSIX__
#endif // __APPLE__
//-------------------------------------------------------------------------------
// LINUX
//-------------------------------------------------------------------------------
#if defined(__linux__) || defined(__GLIBC__)
#define __POSIX__
#endif // __linux__ or __GLIBC__
//-------------------------------------------------------------------------------
// SOLARIS
//-------------------------------------------------------------------------------
#ifdef __sun
#define __POSIX__
#endif // __sun
//-------------------------------------------------------------------------------
// *BSD
//-------------------------------------------------------------------------------
#if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__)
#ifndef __POSIX__
#define __POSIX__
#endif
#ifndef off64_t
#define off64_t off_t
#endif
#ifndef lseek64
#define lseek64 lseek
#endif
#endif // __NetBSD__ or __OpenBSD__ or __FreeBSD__
//-------------------------------------------------------------------------------
// POSIX *NIXes
//-------------------------------------------------------------------------------
#ifdef __POSIX__
#include <unistd.h>
#include <errno.h>
#include <stdint.h> // for int64_t and uint64_t
#include <string.h> // memcpy()
//-------------------------------------------------------------------------------
// unsigned number type definitions
//-------------------------------------------------------------------------------
typedef unsigned char UINT8;
typedef unsigned char BYTE;
typedef unsigned short UINT16;
typedef unsigned short WORD;
typedef unsigned int UINT32;
typedef unsigned int DWORD;
typedef unsigned long ULONG;
typedef unsigned long long __Uint64;
typedef __Uint64 UINT64;
typedef __Uint64 ULONGLONG;
//-------------------------------------------------------------------------------
// signed number type definitions
//-------------------------------------------------------------------------------
typedef signed char INT8;
typedef signed short INT16;
typedef signed int INT32;
typedef signed int BOOL;
typedef signed long LONG;
typedef int64_t INT64;
typedef int64_t LONGLONG;
//-------------------------------------------------------------------------------
// other types
//-------------------------------------------------------------------------------
typedef int OSError;
typedef int HANDLE;
typedef unsigned long ULONG_PTR;
typedef void* PVOID;
typedef char* LPTSTR;
typedef bool (*CallbackPtr)(double percent, bool escapeAllowed, void *data);
//-------------------------------------------------------------------------------
// struct type definitions
//-------------------------------------------------------------------------------
typedef struct tagRGBTRIPLE {
BYTE rgbtBlue;
BYTE rgbtGreen;
BYTE rgbtRed;
} RGBTRIPLE;
typedef struct tagRGBQUAD {
BYTE rgbBlue;
BYTE rgbGreen;
BYTE rgbRed;
BYTE rgbReserved;
} RGBQUAD;
typedef union _LARGE_INTEGER {
struct {
DWORD LowPart;
LONG HighPart;
};
struct {
DWORD LowPart;
LONG HighPart;
} u;
LONGLONG QuadPart;
} LARGE_INTEGER, *PLARGE_INTEGER;
#endif // __POSIX__
#if defined(__POSIX__) || defined(WINCE)
// CMYK macros
#define GetKValue(cmyk) ((BYTE)(cmyk))
#define GetYValue(cmyk) ((BYTE)((cmyk)>> 8))
#define GetMValue(cmyk) ((BYTE)((cmyk)>>16))
#define GetCValue(cmyk) ((BYTE)((cmyk)>>24))
#define CMYK(c,m,y,k) ((COLORREF)((((BYTE)(k)|((WORD)((BYTE)(y))<<8))|(((DWORD)(BYTE)(m))<<16))|(((DWORD)(BYTE)(c))<<24)))
//-------------------------------------------------------------------------------
// methods
//-------------------------------------------------------------------------------
/* The MulDiv function multiplies two 32-bit values and then divides the 64-bit
* result by a third 32-bit value. The return value is rounded up or down to
* the nearest integer.
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winprog/winprog/muldiv.asp
* */
__inline int MulDiv(int nNumber, int nNumerator, int nDenominator) {
INT64 multRes = nNumber*nNumerator;
INT32 divRes = INT32(multRes/nDenominator);
return divRes;
}
#endif // __POSIX__ or WINCE
#ifdef __POSIX__
//-------------------------------------------------------------------------------
// DEBUG macros
//-------------------------------------------------------------------------------
#ifndef ASSERT
#ifdef _DEBUG
#define ASSERT(x) assert(x)
#else
#define ASSERT(x)
#endif //_DEBUG
#endif //ASSERT
//-------------------------------------------------------------------------------
// Exception handling macros
//-------------------------------------------------------------------------------
#ifdef NEXCEPTIONS
extern OSError _PGF_Error_;
extern OSError GetLastPGFError();
#define ReturnWithError(err) { _PGF_Error_ = err; return; }
#define ReturnWithError2(err, ret) { _PGF_Error_ = err; return ret; }
#else
#define ReturnWithError(err) throw IOException(err)
#define ReturnWithError2(err, ret) throw IOException(err)
#endif //NEXCEPTIONS
#define THROW_ throw(IOException)
#define CONST const
//-------------------------------------------------------------------------------
// constants
//-------------------------------------------------------------------------------
#define FSFromStart SEEK_SET
#define FSFromCurrent SEEK_CUR
#define FSFromEnd SEEK_END
//-------------------------------------------------------------------------------
// IO Error constants
//-------------------------------------------------------------------------------
#define NoError 0x0000
#define AppError 0x2000 // all application error messages must be larger than this value
#define InsufficientMemory 0x2001 // memory allocation wasn't successfull
#define EndOfMemory 0x2002 // like end-of-file (EOF) for memory stream
#define EscapePressed 0x2003 // user break by ESC
#define WrongVersion 0x2004 // wrong pgf version
#define FormatCannotRead 0x2005 // wrong data file format
#define ImageTooSmall 0x2006 // image is too small
#define ZlibError 0x2007 // error in zlib functions
#define ColorTableError 0x2008 // errors related to color table size
#define PNGError 0x2009 // errors in png functions
#define MissingData 0x200A // expected data cannot be read
//-------------------------------------------------------------------------------
// methods
//-------------------------------------------------------------------------------
__inline OSError FileRead(HANDLE hFile, int *count, void *buffPtr) {
*count = (int)read(hFile, buffPtr, *count);
if (*count != -1) {
return NoError;
} else {
return errno;
}
}
__inline OSError FileWrite(HANDLE hFile, int *count, void *buffPtr) {
*count = (int)write(hFile, buffPtr, (size_t)*count);
if (*count != -1) {
return NoError;
} else {
return errno;
}
}
__inline OSError GetFPos(HANDLE hFile, UINT64 *pos) {
#ifdef __APPLE__
off_t ret;
if ((ret = lseek(hFile, 0, SEEK_CUR)) == -1) {
return errno;
} else {
*pos = (UINT64)ret;
return NoError;
}
#else
off64_t ret;
if ((ret = lseek64(hFile, 0, SEEK_CUR)) == -1) {
return errno;
} else {
*pos = (UINT64)ret;
return NoError;
}
#endif
}
__inline OSError SetFPos(HANDLE hFile, int posMode, INT64 posOff) {
#ifdef __APPLE__
if ((lseek(hFile, (off_t)posOff, posMode)) == -1) {
return errno;
} else {
return NoError;
}
#else
if ((lseek64(hFile, (off64_t)posOff, posMode)) == -1) {
return errno;
} else {
return NoError;
}
#endif
}
#endif /* __POSIX__ */
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
// Big Endian
//-------------------------------------------------------------------------------
#ifdef PGF_USE_BIG_ENDIAN
#ifndef _lrotl
#define _lrotl(x,n) (((x) << ((UINT32)(n))) | ((x) >> (32 - (UINT32)(n))))
#endif
__inline UINT16 ByteSwap(UINT16 wX) {
return ((wX & 0xFF00) >> 8) | ((wX & 0x00FF) << 8);
}
__inline UINT32 ByteSwap(UINT32 dwX) {
#ifdef _X86_
_asm mov eax, dwX
_asm bswap eax
_asm mov dwX, eax
return dwX;
#else
return _lrotl(((dwX & 0xFF00FF00) >> 8) | ((dwX & 0x00FF00FF) << 8), 16);
#endif
}
#if defined WIN32
__inline UINT64 ByteSwap(UINT64 ui64) {
return _byteswap_uint64(ui64);
}
#endif
#define __VAL(x) ByteSwap(x)
#else //PGF_USE_BIG_ENDIAN
#define __VAL(x) (x)
#endif //PGF_USE_BIG_ENDIAN
// NOTE: Use LIBPGF_DISABLE_OPENMP to disable OpenMP support in whole libpgf
#ifndef LIBPGF_DISABLE_OPENMP
// OpenMP rules (inspired from libraw project)
#if defined (_OPENMP)
#if defined(WIN32)
# if defined (_MSC_VER) && (_MSC_VER >= 1500)
// VS2008 SP1 and VS2010+ : OpenMP works OK
# define LIBPGF_USE_OPENMP
#elif defined (__INTEL_COMPILER) && (__INTEL_COMPILER >=910)
// Have not tested on 9.x and 10.x, but Intel documentation claims OpenMP 2.5 support in 9.1
# define LIBPGF_USE_OPENMP
#else
# undef LIBPGF_USE_OPENMP
#endif
// Not Win32
# elif (defined(__APPLE__) || defined(__MACOSX__)) && defined(_REENTRANT)
# undef LIBPGF_USE_OPENMP
# else
# define LIBPGF_USE_OPENMP
# endif
#endif // defined (_OPENMP)
#endif // ifndef LIBPGF_DISABLE_OPENMP
#ifdef LIBPGF_USE_OPENMP
#include <omp.h>
#endif
#endif //PGF_PGFPLATFORM_H