diff options
| author |  Chris Xiong <chirs241097@gmail.com>
| 2015-10-26 22:52:36 +0800 |
|---|---|---|
| committer | Chris Xiong <chirs241097@gmail.com>
| 2015-10-26 22:52:36 +0800 |
| commit | 3bd383baf6a17e734329e1fc677c7e86283db772 (patch) | |
| tree | 69a9148087577f797624ceb9c71323a2563d6bb4 /archive/hge/CxImage/ximaenc.cpp | |
| parent | 543e4f570be9b279ba558ca61cc02cda251af384 (diff) | |
| download | bullet-lab-remix-3bd383baf6a17e734329e1fc677c7e86283db772.tar.xz | |
Added support for relative line numbers.
Added instructions for, brk and cont. (They are still untested...)
Parser code cleanup. Removed garbage output to stderr.
Reorganize the repository structure.
Updated BLR2 code move it into archive.
Added BLR1 files.
Diffstat (limited to 'archive/hge/CxImage/ximaenc.cpp')
| -rw-r--r-- | archive/hge/CxImage/ximaenc.cpp | 1159 |
1 files changed, 1159 insertions, 0 deletions
diff --git a/archive/hge/CxImage/ximaenc.cpp b/archive/hge/CxImage/ximaenc.cpp new file mode 100644 index 0000000..6064e49 --- /dev/null +++ b/archive/hge/CxImage/ximaenc.cpp @@ -0,0 +1,1159 @@ +// xImaCodec.cpp : Encode Decode functions
+/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
+ * CxImage version 7.0.0 31/Dec/2010
+ */
+
+#include "ximage.h"
+
+#if CXIMAGE_SUPPORT_JPG
+#include "ximajpg.h"
+#endif
+
+#if CXIMAGE_SUPPORT_GIF
+#include "ximagif.h"
+#endif
+
+#if CXIMAGE_SUPPORT_PNG
+#include "ximapng.h"
+#endif
+
+#if CXIMAGE_SUPPORT_MNG
+#include "ximamng.h"
+#endif
+
+#if CXIMAGE_SUPPORT_BMP
+#include "ximabmp.h"
+#endif
+
+#if CXIMAGE_SUPPORT_ICO
+#include "ximaico.h"
+#endif
+
+#if CXIMAGE_SUPPORT_TIF
+#include "ximatif.h"
+#endif
+
+#if CXIMAGE_SUPPORT_TGA
+#include "ximatga.h"
+#endif
+
+#if CXIMAGE_SUPPORT_PCX
+#include "ximapcx.h"
+#endif
+
+#if CXIMAGE_SUPPORT_WBMP
+#include "ximawbmp.h"
+#endif
+
+#if CXIMAGE_SUPPORT_WMF
+#include "ximawmf.h" // <vho> - WMF/EMF support
+#endif
+
+#if CXIMAGE_SUPPORT_JBG
+#include "ximajbg.h"
+#endif
+
+#if CXIMAGE_SUPPORT_JASPER
+#include "ximajas.h"
+#endif
+
+#if CXIMAGE_SUPPORT_SKA
+#include "ximaska.h"
+#endif
+
+#if CXIMAGE_SUPPORT_RAW
+#include "ximaraw.h"
+#endif
+
+#if CXIMAGE_SUPPORT_PSD
+#include "ximapsd.h"
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+#if CXIMAGE_SUPPORT_ENCODE
+////////////////////////////////////////////////////////////////////////////////
+bool CxImage::EncodeSafeCheck(CxFile *hFile)
+{
+ if (hFile==NULL) {
+ strcpy(info.szLastError,CXIMAGE_ERR_NOFILE);
+ return true;
+ }
+
+ if (pDib==NULL){
+ strcpy(info.szLastError,CXIMAGE_ERR_NOIMAGE);
+ return true;
+ }
+ return false;
+}
+////////////////////////////////////////////////////////////////////////////////
+//#ifdef WIN32
+//bool CxImage::Save(LPCWSTR filename, uint32_t imagetype)
+//{
+// FILE* hFile; //file handle to write the image
+// if ((hFile=_wfopen(filename,L"wb"))==NULL) return false;
+// bool bOK = Encode(hFile,imagetype);
+// fclose(hFile);
+// return bOK;
+//}
+//#endif //WIN32
+////////////////////////////////////////////////////////////////////////////////
+// For UNICODE support: char -> TCHAR
+/**
+ * Saves to disk the image in a specific format.
+ * \param filename: file name
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ * \return true if everything is ok
+ */
+bool CxImage::Save(const TCHAR * filename, uint32_t imagetype)
+{
+ FILE* hFile; //file handle to write the image
+
+#ifdef WIN32
+ if ((hFile=_tfopen(filename,_T("wb")))==NULL) return false; // For UNICODE support
+#else
+ if ((hFile=fopen(filename,"wb"))==NULL) return false;
+#endif
+
+ bool bOK = Encode(hFile,imagetype);
+ fclose(hFile);
+ return bOK;
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Saves to disk the image in a specific format.
+ * \param hFile: file handle, open and enabled for writing.
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ * \return true if everything is ok
+ */
+bool CxImage::Encode(FILE *hFile, uint32_t imagetype)
+{
+ CxIOFile file(hFile);
+ return Encode(&file,imagetype);
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Saves to memory buffer the image in a specific format.
+ * \param buffer: output memory buffer pointer. Must be NULL,
+ * the function allocates and fill the memory,
+ * the application must free the buffer, see also FreeMemory().
+ * \param size: output memory buffer size.
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ * \return true if everything is ok
+ */
+bool CxImage::Encode(uint8_t * &buffer, int32_t &size, uint32_t imagetype)
+{
+ if (buffer!=NULL){
+ strcpy(info.szLastError,"the buffer must be empty");
+ return false;
+ }
+ CxMemFile file;
+ file.Open();
+ if(Encode(&file,imagetype)){
+ buffer=file.GetBuffer();
+ size=file.Size();
+ return true;
+ }
+ return false;
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Saves to disk the image in a specific format.
+ * \param hFile: file handle (CxMemFile or CxIOFile), with write access.
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ * \return true if everything is ok
+ * \sa ENUM_CXIMAGE_FORMATS
+ */
+bool CxImage::Encode(CxFile *hFile, uint32_t imagetype)
+{
+
+#if CXIMAGE_SUPPORT_BMP
+ if (CXIMAGE_FORMAT_BMP==imagetype){
+ CxImageBMP *newima = new CxImageBMP;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_ICO
+ if (CXIMAGE_FORMAT_ICO==imagetype){
+ CxImageICO *newima = new CxImageICO;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_TIF
+ if (CXIMAGE_FORMAT_TIF==imagetype){
+ CxImageTIF *newima = new CxImageTIF;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JPG
+ if (CXIMAGE_FORMAT_JPG==imagetype){
+ CxImageJPG *newima = new CxImageJPG;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_GIF
+ if (CXIMAGE_FORMAT_GIF==imagetype){
+ CxImageGIF *newima = new CxImageGIF;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_PNG
+ if (CXIMAGE_FORMAT_PNG==imagetype){
+ CxImagePNG *newima = new CxImagePNG;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_MNG
+ if (CXIMAGE_FORMAT_MNG==imagetype){
+ CxImageMNG *newima = new CxImageMNG;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_TGA
+ if (CXIMAGE_FORMAT_TGA==imagetype){
+ CxImageTGA *newima = new CxImageTGA;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_PCX
+ if (CXIMAGE_FORMAT_PCX==imagetype){
+ CxImagePCX *newima = new CxImagePCX;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_WBMP
+ if (CXIMAGE_FORMAT_WBMP==imagetype){
+ CxImageWBMP *newima = new CxImageWBMP;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS // <vho> - WMF/EMF support
+ if (CXIMAGE_FORMAT_WMF==imagetype){
+ CxImageWMF *newima = new CxImageWMF;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JBG
+ if (CXIMAGE_FORMAT_JBG==imagetype){
+ CxImageJBG *newima = new CxImageJBG;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JASPER
+ if (
+ #if CXIMAGE_SUPPORT_JP2
+ CXIMAGE_FORMAT_JP2==imagetype ||
+ #endif
+ #if CXIMAGE_SUPPORT_JPC
+ CXIMAGE_FORMAT_JPC==imagetype ||
+ #endif
+ #if CXIMAGE_SUPPORT_PGX
+ CXIMAGE_FORMAT_PGX==imagetype ||
+ #endif
+ #if CXIMAGE_SUPPORT_PNM
+ CXIMAGE_FORMAT_PNM==imagetype ||
+ #endif
+ #if CXIMAGE_SUPPORT_RAS
+ CXIMAGE_FORMAT_RAS==imagetype ||
+ #endif
+ false ){
+ CxImageJAS *newima = new CxImageJAS;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile,imagetype)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+
+#if CXIMAGE_SUPPORT_SKA
+ if (CXIMAGE_FORMAT_SKA==imagetype){
+ CxImageSKA *newima = new CxImageSKA;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+
+#if CXIMAGE_SUPPORT_RAW
+ if (CXIMAGE_FORMAT_RAW==imagetype){
+ CxImageRAW *newima = new CxImageRAW;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+
+#if CXIMAGE_SUPPORT_PSD
+ if (CXIMAGE_FORMAT_PSD==imagetype){
+ CxImagePSD *newima = new CxImagePSD;
+ if (!newima) return false;
+ newima->Ghost(this);
+ if (newima->Encode(hFile)){
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ delete newima;
+ return false;
+ }
+ }
+#endif
+
+ strcpy(info.szLastError,"Encode: Unknown format");
+ return false;
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Saves to disk or memory pagecount images, referenced by an array of CxImage pointers.
+ * \param hFile: file handle.
+ * \param pImages: array of CxImage pointers.
+ * \param pagecount: number of images.
+ * \param imagetype: can be CXIMAGE_FORMAT_TIF or CXIMAGE_FORMAT_GIF.
+ * \return true if everything is ok
+ */
+bool CxImage::Encode(FILE * hFile, CxImage ** pImages, int32_t pagecount, uint32_t imagetype)
+{
+ CxIOFile file(hFile);
+ return Encode(&file, pImages, pagecount,imagetype);
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Saves to disk or memory pagecount images, referenced by an array of CxImage pointers.
+ * \param hFile: file handle (CxMemFile or CxIOFile), with write access.
+ * \param pImages: array of CxImage pointers.
+ * \param pagecount: number of images.
+ * \param imagetype: can be CXIMAGE_FORMAT_TIF, CXIMAGE_FORMAT_GIF or CXIMAGE_FORMAT_ICO.
+ * \return true if everything is ok
+ */
+bool CxImage::Encode(CxFile * hFile, CxImage ** pImages, int32_t pagecount, uint32_t imagetype)
+{
+#if CXIMAGE_SUPPORT_TIF
+ if (imagetype==CXIMAGE_FORMAT_TIF){
+ CxImageTIF newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile,pImages,pagecount)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_GIF
+ if (imagetype==CXIMAGE_FORMAT_GIF){
+ CxImageGIF newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile,pImages,pagecount)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_ICO
+ if (imagetype==CXIMAGE_FORMAT_ICO){
+ CxImageICO newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile,pImages,pagecount)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+ strcpy(info.szLastError,"Multipage Encode, Unsupported operation for this format");
+ return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * exports the image into a RGBA buffer, Useful for OpenGL applications.
+ * \param buffer: output memory buffer pointer. Must be NULL,
+ * the function allocates and fill the memory,
+ * the application must free the buffer, see also FreeMemory().
+ * \param size: output memory buffer size.
+ * \param bFlipY: direction of Y axis. default = false.
+ * \return true if everything is ok
+ */
+bool CxImage::Encode2RGBA(uint8_t * &buffer, int32_t &size, bool bFlipY)
+{
+ if (buffer!=NULL){
+ strcpy(info.szLastError,"the buffer must be empty");
+ return false;
+ }
+ CxMemFile file;
+ file.Open();
+ if(Encode2RGBA(&file,bFlipY)){
+ buffer=file.GetBuffer();
+ size=file.Size();
+ return true;
+ }
+ return false;
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * exports the image into a RGBA buffer, Useful for OpenGL applications.
+ * \param hFile: file handle (CxMemFile or CxIOFile), with write access.
+ * \param bFlipY: direction of Y axis. default = false.
+ * \return true if everything is ok
+ */
+bool CxImage::Encode2RGBA(CxFile *hFile, bool bFlipY)
+{
+ if (EncodeSafeCheck(hFile)) return false;
+
+ for (int32_t y1 = 0; y1 < head.biHeight; y1++) {
+ int32_t y = bFlipY ? head.biHeight - 1 - y1 : y1;
+ for(int32_t x = 0; x < head.biWidth; x++) {
+ RGBQUAD color = BlindGetPixelColor(x,y);
+ hFile->PutC(color.rgbRed);
+ hFile->PutC(color.rgbGreen);
+ hFile->PutC(color.rgbBlue);
+ hFile->PutC(color.rgbReserved);
+ }
+ }
+ return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+#endif //CXIMAGE_SUPPORT_ENCODE
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+#if CXIMAGE_SUPPORT_DECODE
+////////////////////////////////////////////////////////////////////////////////
+// For UNICODE support: char -> TCHAR
+/**
+ * Reads from disk the image in a specific format.
+ * - If decoding fails using the specified image format,
+ * the function will try the automatic file format recognition.
+ *
+ * \param filename: file name
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ * \return true if everything is ok
+ */
+bool CxImage::Load(const TCHAR * filename, uint32_t imagetype)
+//bool CxImage::Load(const char * filename, uint32_t imagetype)
+{
+ /*FILE* hFile; //file handle to read the image
+ if ((hFile=fopen(filename,"rb"))==NULL) return false;
+ bool bOK = Decode(hFile,imagetype);
+ fclose(hFile);*/
+
+ /* automatic file type recognition */
+ bool bOK = false;
+ if ( GetTypeIndexFromId(imagetype) ){
+ FILE* hFile; //file handle to read the image
+
+#ifdef WIN32
+ if ((hFile=_tfopen(filename,_T("rb")))==NULL) return false; // For UNICODE support
+#else
+ if ((hFile=fopen(filename,"rb"))==NULL) return false;
+#endif
+
+ bOK = Decode(hFile,imagetype);
+ fclose(hFile);
+ if (bOK) return bOK;
+ }
+
+ char szError[256];
+ strcpy(szError,info.szLastError); //save the first error
+
+ // if failed, try automatic recognition of the file...
+ FILE* hFile;
+
+#ifdef WIN32
+ if ((hFile=_tfopen(filename,_T("rb")))==NULL) return false; // For UNICODE support
+#else
+ if ((hFile=fopen(filename,"rb"))==NULL) return false;
+#endif
+
+ bOK = Decode(hFile,CXIMAGE_FORMAT_UNKNOWN);
+ fclose(hFile);
+
+ if (!bOK && imagetype > 0) strcpy(info.szLastError,szError); //restore the first error
+
+ return bOK;
+}
+////////////////////////////////////////////////////////////////////////////////
+#ifdef WIN32
+//bool CxImage::Load(LPCWSTR filename, uint32_t imagetype)
+//{
+// /*FILE* hFile; //file handle to read the image
+// if ((hFile=_wfopen(filename, L"rb"))==NULL) return false;
+// bool bOK = Decode(hFile,imagetype);
+// fclose(hFile);*/
+//
+// /* automatic file type recognition */
+// bool bOK = false;
+// if ( GetTypeIndexFromId(imagetype) ){
+// FILE* hFile; //file handle to read the image
+// if ((hFile=_wfopen(filename,L"rb"))==NULL) return false;
+// bOK = Decode(hFile,imagetype);
+// fclose(hFile);
+// if (bOK) return bOK;
+// }
+//
+// char szError[256];
+// strcpy(szError,info.szLastError); //save the first error
+//
+// // if failed, try automatic recognition of the file...
+// FILE* hFile; //file handle to read the image
+// if ((hFile=_wfopen(filename,L"rb"))==NULL) return false;
+// bOK = Decode(hFile,CXIMAGE_FORMAT_UNKNOWN);
+// fclose(hFile);
+//
+// if (!bOK && imagetype > 0) strcpy(info.szLastError,szError); //restore the first error
+//
+// return bOK;
+//}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Loads an image from the application resources.
+ * \param hRes: the resource handle returned by FindResource().
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS.
+ * \param hModule: NULL for internal resource, or external application/DLL hinstance returned by LoadLibray.
+ * \return true if everything is ok
+ */
+bool CxImage::LoadResource(HRSRC hRes, uint32_t imagetype, HMODULE hModule)
+{
+ uint32_t rsize=SizeofResource(hModule,hRes);
+ HGLOBAL hMem=::LoadResource(hModule,hRes);
+ if (hMem){
+ char* lpVoid=(char*)LockResource(hMem);
+ if (lpVoid){
+ // FILE* fTmp=tmpfile(); doesn't work with network
+ /*char tmpPath[MAX_PATH] = {0};
+ char tmpFile[MAX_PATH] = {0};
+ GetTempPath(MAX_PATH,tmpPath);
+ GetTempFileName(tmpPath,"IMG",0,tmpFile);
+ FILE* fTmp=fopen(tmpFile,"w+b");
+ if (fTmp){
+ fwrite(lpVoid,rsize,1,fTmp);
+ fseek(fTmp,0,SEEK_SET);
+ bool bOK = Decode(fTmp,imagetype);
+ fclose(fTmp);
+ DeleteFile(tmpFile);
+ return bOK;
+ }*/
+
+ CxMemFile fTmp((uint8_t*)lpVoid,rsize);
+ return Decode(&fTmp,imagetype);
+ }
+ } else strcpy(info.szLastError,"Unable to load resource!");
+ return false;
+}
+#endif //WIN32
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Constructor from file name, see Load()
+ * \param filename: file name
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ */
+//
+// > filename: file name
+// > imagetype: specify the image format (CXIMAGE_FORMAT_BMP,...)
+// For UNICODE support: char -> TCHAR
+CxImage::CxImage(const TCHAR * filename, uint32_t imagetype)
+//CxImage::CxImage(const char * filename, uint32_t imagetype)
+{
+ Startup(imagetype);
+ Load(filename,imagetype);
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Constructor from file handle, see Decode()
+ * \param stream: file handle, with read access.
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ */
+CxImage::CxImage(FILE * stream, uint32_t imagetype)
+{
+ Startup(imagetype);
+ Decode(stream,imagetype);
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Constructor from CxFile object, see Decode()
+ * \param stream: file handle (CxMemFile or CxIOFile), with read access.
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ */
+CxImage::CxImage(CxFile * stream, uint32_t imagetype)
+{
+ Startup(imagetype);
+ Decode(stream,imagetype);
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Constructor from memory buffer, see Decode()
+ * \param buffer: memory buffer
+ * \param size: size of buffer
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ */
+CxImage::CxImage(uint8_t * buffer, uint32_t size, uint32_t imagetype)
+{
+ Startup(imagetype);
+ CxMemFile stream(buffer,size);
+ Decode(&stream,imagetype);
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Loads an image from memory buffer
+ * \param buffer: memory buffer
+ * \param size: size of buffer
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ * \return true if everything is ok
+ */
+bool CxImage::Decode(uint8_t * buffer, uint32_t size, uint32_t imagetype)
+{
+ CxMemFile file(buffer,size);
+ return Decode(&file,imagetype);
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Loads an image from file handle.
+ * \param hFile: file handle, with read access.
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ * \return true if everything is ok
+ */
+bool CxImage::Decode(FILE *hFile, uint32_t imagetype)
+{
+ CxIOFile file(hFile);
+ return Decode(&file,imagetype);
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Loads an image from CxFile object
+ * \param hFile: file handle (CxMemFile or CxIOFile), with read access.
+ * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
+ * \return true if everything is ok
+ * \sa ENUM_CXIMAGE_FORMATS
+ */
+bool CxImage::Decode(CxFile *hFile, uint32_t imagetype)
+{
+ if (hFile == NULL){
+ strcpy(info.szLastError,CXIMAGE_ERR_NOFILE);
+ return false;
+ }
+
+ uint32_t pos = hFile->Tell();
+
+#if CXIMAGE_SUPPORT_BMP
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_BMP==imagetype){
+ CxImageBMP *newima = new CxImageBMP;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JPG
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_JPG==imagetype){
+ CxImageJPG *newima = new CxImageJPG;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_ICO
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_ICO==imagetype){
+ CxImageICO *newima = new CxImageICO;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ info.nNumFrames = newima->info.nNumFrames;
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_GIF
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_GIF==imagetype){
+ CxImageGIF *newima = new CxImageGIF;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ info.nNumFrames = newima->info.nNumFrames;
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_PNG
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_PNG==imagetype){
+ CxImagePNG *newima = new CxImagePNG;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_TIF
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_TIF==imagetype){
+ CxImageTIF *newima = new CxImageTIF;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ info.nNumFrames = newima->info.nNumFrames;
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_MNG
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_MNG==imagetype){
+ CxImageMNG *newima = new CxImageMNG;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ info.nNumFrames = newima->info.nNumFrames;
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_TGA
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_TGA==imagetype){
+ CxImageTGA *newima = new CxImageTGA;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_PCX
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_PCX==imagetype){
+ CxImagePCX *newima = new CxImagePCX;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_WBMP
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_WBMP==imagetype){
+ CxImageWBMP *newima = new CxImageWBMP;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_WMF==imagetype){
+ CxImageWMF *newima = new CxImageWMF;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JBG
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_JBG==imagetype){
+ CxImageJBG *newima = new CxImageJBG;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JASPER
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype ||
+#if CXIMAGE_SUPPORT_JP2
+ CXIMAGE_FORMAT_JP2==imagetype ||
+#endif
+#if CXIMAGE_SUPPORT_JPC
+ CXIMAGE_FORMAT_JPC==imagetype ||
+#endif
+#if CXIMAGE_SUPPORT_PGX
+ CXIMAGE_FORMAT_PGX==imagetype ||
+#endif
+#if CXIMAGE_SUPPORT_PNM
+ CXIMAGE_FORMAT_PNM==imagetype ||
+#endif
+#if CXIMAGE_SUPPORT_RAS
+ CXIMAGE_FORMAT_RAS==imagetype ||
+#endif
+ false ){
+ CxImageJAS *newima = new CxImageJAS;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_SKA
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_SKA==imagetype){
+ CxImageSKA *newima = new CxImageSKA;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_RAW
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_RAW==imagetype){
+ CxImageRAW *newima = new CxImageRAW;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_PSD
+ if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_PSD==imagetype){
+ CxImagePSD *newima = new CxImagePSD;
+ if (!newima)
+ return false;
+ newima->CopyInfo(*this);
+ if (newima->Decode(hFile)) {
+ Transfer(*newima);
+ delete newima;
+ return true;
+ } else {
+ strcpy(info.szLastError,newima->GetLastError());
+ hFile->Seek(pos,SEEK_SET);
+ delete newima;
+ if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
+ return false;
+ }
+ }
+#endif
+
+ strcpy(info.szLastError,"Decode: Unknown or wrong format");
+ return false;
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Loads an image from CxFile object
+ * \param hFile: file handle (CxMemFile or CxIOFile), with read access.
+ * \param imagetype: file format, default = 0 (CXIMAGE_FORMAT_UNKNOWN)
+ * \return : if imagetype is not 0, the function returns true when imagetype
+ * matches the file image format. If imagetype is 0, the function returns true
+ * when the file image format is recognized as a supported format.
+ * If the returned value is true, use GetHeight(), GetWidth() or GetType()
+ * to retrieve the basic image information.
+ * \sa ENUM_CXIMAGE_FORMATS
+ */
+bool CxImage::CheckFormat(CxFile * hFile, uint32_t imagetype)
+{
+ SetType(CXIMAGE_FORMAT_UNKNOWN);
+ SetEscape(-1);
+
+ if (!Decode(hFile,imagetype))
+ return false;
+
+ if (GetType() == CXIMAGE_FORMAT_UNKNOWN ||
+ ((imagetype!=CXIMAGE_FORMAT_UNKNOWN)&&(GetType() != imagetype)))
+ return false;
+
+ return true;
+}
+////////////////////////////////////////////////////////////////////////////////
+bool CxImage::CheckFormat(uint8_t * buffer, uint32_t size, uint32_t imagetype)
+{
+ if (buffer==NULL || size==0){
+ strcpy(info.szLastError,"invalid or empty buffer");
+ return false;
+ }
+ CxMemFile file(buffer,size);
+ return CheckFormat(&file,imagetype);
+}
+////////////////////////////////////////////////////////////////////////////////
+#if CXIMAGE_SUPPORT_EXIF
+bool CxImage::GetExifThumbnail(const TCHAR *filename, const TCHAR *outname, int32_t type)
+{
+ switch (type){
+#if CXIMAGE_SUPPORT_RAW
+ case CXIMAGE_FORMAT_RAW:
+ {
+ CxImageRAW image;
+ return image.GetExifThumbnail(filename, outname, type);
+ }
+#endif //CXIMAGE_SUPPORT_RAW
+#if CXIMAGE_SUPPORT_JPG
+ case CXIMAGE_FORMAT_JPG:
+ {
+ CxImageJPG image;
+ return image.GetExifThumbnail(filename, outname, type);
+ }
+#endif //CXIMAGE_SUPPORT_JPG
+ default:
+ return false;
+ }
+}
+#endif //CXIMAGE_SUPPORT_EXIF
+
+////////////////////////////////////////////////////////////////////////////////
+#endif //CXIMAGE_SUPPORT_DECODE
+////////////////////////////////////////////////////////////////////////////////
|