-// xImaCodec.cpp : Encode Decode functions\r
-/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it\r
- * CxImage version 6.0.0 02/Feb/2008\r
- */\r
-\r
-#include "ximage.h"\r
-\r
-#if CXIMAGE_SUPPORT_JPG\r
-#include "ximajpg.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_GIF\r
-#include "ximagif.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_PNG\r
-#include "ximapng.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_MNG\r
-#include "ximamng.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_BMP\r
-#include "ximabmp.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_ICO\r
-#include "ximaico.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_TIF\r
-#include "ximatif.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_TGA\r
-#include "ximatga.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_PCX\r
-#include "ximapcx.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_WBMP\r
-#include "ximawbmp.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_WMF\r
-#include "ximawmf.h" // <vho> - WMF/EMF support\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_JBG\r
-#include "ximajbg.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_JASPER\r
-#include "ximajas.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_SKA\r
-#include "ximaska.h"\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_RAW\r
-#include "ximaraw.h"\r
-#endif\r
-\r
-////////////////////////////////////////////////////////////////////////////////\r
-#if CXIMAGE_SUPPORT_ENCODE\r
-////////////////////////////////////////////////////////////////////////////////\r
-bool CxImage::EncodeSafeCheck(CxFile *hFile)\r
-{\r
- if (hFile==NULL) {\r
- strcpy(info.szLastError,CXIMAGE_ERR_NOFILE);\r
- return true;\r
- }\r
-\r
- if (pDib==NULL){\r
- strcpy(info.szLastError,CXIMAGE_ERR_NOIMAGE);\r
- return true;\r
- }\r
- return false;\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-//#ifdef WIN32\r
-//bool CxImage::Save(LPCWSTR filename, DWORD imagetype)\r
-//{\r
-// FILE* hFile; //file handle to write the image\r
-// if ((hFile=_wfopen(filename,L"wb"))==NULL) return false;\r
-// bool bOK = Encode(hFile,imagetype);\r
-// fclose(hFile);\r
-// return bOK;\r
-//}\r
-//#endif //WIN32\r
-////////////////////////////////////////////////////////////////////////////////\r
-// For UNICODE support: char -> TCHAR\r
-/**\r
- * Saves to disk the image in a specific format.\r
- * \param filename: file name\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- * \return true if everything is ok\r
- */\r
-bool CxImage::Save(const TCHAR * filename, DWORD imagetype)\r
-{\r
- FILE* hFile; //file handle to write the image\r
-\r
-#ifdef WIN32\r
- if ((hFile=_tfopen(filename,_T("wb")))==NULL) return false; // For UNICODE support\r
-#else\r
- if ((hFile=fopen(filename,"wb"))==NULL) return false;\r
-#endif\r
-\r
- bool bOK = Encode(hFile,imagetype);\r
- fclose(hFile);\r
- return bOK;\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Saves to disk the image in a specific format.\r
- * \param hFile: file handle, open and enabled for writing.\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- * \return true if everything is ok\r
- */\r
-bool CxImage::Encode(FILE *hFile, DWORD imagetype)\r
-{\r
- CxIOFile file(hFile);\r
- return Encode(&file,imagetype);\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Saves to memory buffer the image in a specific format.\r
- * \param buffer: output memory buffer pointer. Must be NULL,\r
- * the function allocates and fill the memory,\r
- * the application must free the buffer, see also FreeMemory().\r
- * \param size: output memory buffer size.\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- * \return true if everything is ok\r
- */\r
-bool CxImage::Encode(BYTE * &buffer, long &size, DWORD imagetype)\r
-{\r
- if (buffer!=NULL){\r
- strcpy(info.szLastError,"the buffer must be empty");\r
- return false;\r
- }\r
- CxMemFile file;\r
- file.Open();\r
- if(Encode(&file,imagetype)){\r
- buffer=file.GetBuffer();\r
- size=file.Size();\r
- return true;\r
- }\r
- return false;\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Saves to disk the image in a specific format.\r
- * \param hFile: file handle (CxMemFile or CxIOFile), with write access.\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- * \return true if everything is ok\r
- * \sa ENUM_CXIMAGE_FORMATS\r
- */\r
-bool CxImage::Encode(CxFile *hFile, DWORD imagetype)\r
-{\r
-\r
-#if CXIMAGE_SUPPORT_BMP\r
-\r
- if (imagetype==CXIMAGE_FORMAT_BMP){\r
- CxImageBMP newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_ICO\r
- if (imagetype==CXIMAGE_FORMAT_ICO){\r
- CxImageICO newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_TIF\r
- if (imagetype==CXIMAGE_FORMAT_TIF){\r
- CxImageTIF newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_JPG\r
- if (imagetype==CXIMAGE_FORMAT_JPG){\r
- CxImageJPG newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_GIF\r
- if (imagetype==CXIMAGE_FORMAT_GIF){\r
- CxImageGIF newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_PNG\r
- if (imagetype==CXIMAGE_FORMAT_PNG){\r
- CxImagePNG newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_MNG\r
- if (imagetype==CXIMAGE_FORMAT_MNG){\r
- CxImageMNG newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_TGA\r
- if (imagetype==CXIMAGE_FORMAT_TGA){\r
- CxImageTGA newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_PCX\r
- if (imagetype==CXIMAGE_FORMAT_PCX){\r
- CxImagePCX newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_WBMP\r
- if (imagetype==CXIMAGE_FORMAT_WBMP){\r
- CxImageWBMP newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS // <vho> - WMF/EMF support\r
- if (imagetype==CXIMAGE_FORMAT_WMF){\r
- CxImageWMF newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_JBG\r
- if (imagetype==CXIMAGE_FORMAT_JBG){\r
- CxImageJBG newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_JASPER\r
- if (\r
- #if CXIMAGE_SUPPORT_JP2\r
- imagetype==CXIMAGE_FORMAT_JP2 || \r
- #endif\r
- #if CXIMAGE_SUPPORT_JPC\r
- imagetype==CXIMAGE_FORMAT_JPC || \r
- #endif\r
- #if CXIMAGE_SUPPORT_PGX\r
- imagetype==CXIMAGE_FORMAT_PGX || \r
- #endif\r
- #if CXIMAGE_SUPPORT_PNM\r
- imagetype==CXIMAGE_FORMAT_PNM || \r
- #endif\r
- #if CXIMAGE_SUPPORT_RAS\r
- imagetype==CXIMAGE_FORMAT_RAS || \r
- #endif\r
- false ){\r
- CxImageJAS newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile,imagetype)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_SKA\r
- if (imagetype==CXIMAGE_FORMAT_SKA){\r
- CxImageSKA newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_RAW\r
- if (imagetype==CXIMAGE_FORMAT_RAW){\r
- CxImageRAW newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-\r
- strcpy(info.szLastError,"Encode: Unknown format");\r
- return false;\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Saves to disk or memory pagecount images, referenced by an array of CxImage pointers.\r
- * \param hFile: file handle.\r
- * \param pImages: array of CxImage pointers.\r
- * \param pagecount: number of images.\r
- * \param imagetype: can be CXIMAGE_FORMAT_TIF or CXIMAGE_FORMAT_GIF.\r
- * \return true if everything is ok\r
- */\r
-bool CxImage::Encode(FILE * hFile, CxImage ** pImages, int pagecount, DWORD imagetype)\r
-{\r
- CxIOFile file(hFile);\r
- return Encode(&file, pImages, pagecount,imagetype);\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Saves to disk or memory pagecount images, referenced by an array of CxImage pointers.\r
- * \param hFile: file handle (CxMemFile or CxIOFile), with write access.\r
- * \param pImages: array of CxImage pointers.\r
- * \param pagecount: number of images.\r
- * \param imagetype: can be CXIMAGE_FORMAT_TIF, CXIMAGE_FORMAT_GIF or CXIMAGE_FORMAT_ICO.\r
- * \return true if everything is ok\r
- */\r
-bool CxImage::Encode(CxFile * hFile, CxImage ** pImages, int pagecount, DWORD imagetype)\r
-{\r
-#if CXIMAGE_SUPPORT_TIF\r
- if (imagetype==CXIMAGE_FORMAT_TIF){\r
- CxImageTIF newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile,pImages,pagecount)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_GIF\r
- if (imagetype==CXIMAGE_FORMAT_GIF){\r
- CxImageGIF newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile,pImages,pagecount)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_ICO\r
- if (imagetype==CXIMAGE_FORMAT_ICO){\r
- CxImageICO newima;\r
- newima.Ghost(this);\r
- if (newima.Encode(hFile,pImages,pagecount)){\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
- strcpy(info.szLastError,"Multipage Encode, Unsupported operation for this format");\r
- return false;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * exports the image into a RGBA buffer, Useful for OpenGL applications.\r
- * \param buffer: output memory buffer pointer. Must be NULL,\r
- * the function allocates and fill the memory,\r
- * the application must free the buffer, see also FreeMemory().\r
- * \param size: output memory buffer size.\r
- * \param bFlipY: direction of Y axis. default = false.\r
- * \return true if everything is ok\r
- */\r
-bool CxImage::Encode2RGBA(BYTE * &buffer, long &size, bool bFlipY)\r
-{\r
- if (buffer!=NULL){\r
- strcpy(info.szLastError,"the buffer must be empty");\r
- return false;\r
- }\r
- CxMemFile file;\r
- file.Open();\r
- if(Encode2RGBA(&file,bFlipY)){\r
- buffer=file.GetBuffer();\r
- size=file.Size();\r
- return true;\r
- }\r
- return false;\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * exports the image into a RGBA buffer, Useful for OpenGL applications.\r
- * \param hFile: file handle (CxMemFile or CxIOFile), with write access.\r
- * \param bFlipY: direction of Y axis. default = false.\r
- * \return true if everything is ok\r
- */\r
-bool CxImage::Encode2RGBA(CxFile *hFile, bool bFlipY)\r
-{\r
- if (EncodeSafeCheck(hFile)) return false;\r
-\r
- for (long y1 = 0; y1 < head.biHeight; y1++) {\r
- long y = bFlipY ? head.biHeight - 1 - y1 : y1;\r
- for(long x = 0; x < head.biWidth; x++) {\r
- RGBQUAD color = BlindGetPixelColor(x,y);\r
- hFile->PutC(color.rgbRed);\r
- hFile->PutC(color.rgbGreen);\r
- hFile->PutC(color.rgbBlue);\r
- hFile->PutC(color.rgbReserved);\r
- }\r
- }\r
- return true;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////////////\r
-#endif //CXIMAGE_SUPPORT_ENCODE\r
-////////////////////////////////////////////////////////////////////////////////\r
-\r
-////////////////////////////////////////////////////////////////////////////////\r
-#if CXIMAGE_SUPPORT_DECODE\r
-////////////////////////////////////////////////////////////////////////////////\r
-// For UNICODE support: char -> TCHAR\r
-/**\r
- * Reads from disk the image in a specific format.\r
- * - If decoding fails using the specified image format,\r
- * the function will try the automatic file format recognition.\r
- *\r
- * \param filename: file name\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- * \return true if everything is ok\r
- */\r
-bool CxImage::Load(const TCHAR * filename, DWORD imagetype)\r
-//bool CxImage::Load(const char * filename, DWORD imagetype)\r
-{\r
- /*FILE* hFile; //file handle to read the image\r
- if ((hFile=fopen(filename,"rb"))==NULL) return false;\r
- bool bOK = Decode(hFile,imagetype);\r
- fclose(hFile);*/\r
-\r
- /* automatic file type recognition */\r
- bool bOK = false;\r
- if ( GetTypeIndexFromId(imagetype) ){\r
- FILE* hFile; //file handle to read the image\r
-\r
-#ifdef WIN32\r
- if ((hFile=_tfopen(filename,_T("rb")))==NULL) return false; // For UNICODE support\r
-#else\r
- if ((hFile=fopen(filename,"rb"))==NULL) return false;\r
-#endif\r
-\r
- bOK = Decode(hFile,imagetype);\r
- fclose(hFile);\r
- if (bOK) return bOK;\r
- }\r
-\r
- char szError[256];\r
- strcpy(szError,info.szLastError); //save the first error\r
-\r
- // if failed, try automatic recognition of the file...\r
- FILE* hFile;\r
-\r
-#ifdef WIN32\r
- if ((hFile=_tfopen(filename,_T("rb")))==NULL) return false; // For UNICODE support\r
-#else\r
- if ((hFile=fopen(filename,"rb"))==NULL) return false;\r
-#endif\r
-\r
- bOK = Decode(hFile,CXIMAGE_FORMAT_UNKNOWN);\r
- fclose(hFile);\r
-\r
- if (!bOK && imagetype > 0) strcpy(info.szLastError,szError); //restore the first error\r
-\r
- return bOK;\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-#ifdef WIN32\r
-//bool CxImage::Load(LPCWSTR filename, DWORD imagetype)\r
-//{\r
-// /*FILE* hFile; //file handle to read the image\r
-// if ((hFile=_wfopen(filename, L"rb"))==NULL) return false;\r
-// bool bOK = Decode(hFile,imagetype);\r
-// fclose(hFile);*/\r
-//\r
-// /* automatic file type recognition */\r
-// bool bOK = false;\r
-// if ( GetTypeIndexFromId(imagetype) ){\r
-// FILE* hFile; //file handle to read the image\r
-// if ((hFile=_wfopen(filename,L"rb"))==NULL) return false;\r
-// bOK = Decode(hFile,imagetype);\r
-// fclose(hFile);\r
-// if (bOK) return bOK;\r
-// }\r
-//\r
-// char szError[256];\r
-// strcpy(szError,info.szLastError); //save the first error\r
-//\r
-// // if failed, try automatic recognition of the file...\r
-// FILE* hFile; //file handle to read the image\r
-// if ((hFile=_wfopen(filename,L"rb"))==NULL) return false;\r
-// bOK = Decode(hFile,CXIMAGE_FORMAT_UNKNOWN);\r
-// fclose(hFile);\r
-//\r
-// if (!bOK && imagetype > 0) strcpy(info.szLastError,szError); //restore the first error\r
-//\r
-// return bOK;\r
-//}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Loads an image from the application resources.\r
- * \param hRes: the resource handle returned by FindResource().\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS.\r
- * \param hModule: NULL for internal resource, or external application/DLL hinstance returned by LoadLibray.\r
- * \return true if everything is ok\r
- */\r
-bool CxImage::LoadResource(HRSRC hRes, DWORD imagetype, HMODULE hModule)\r
-{\r
- DWORD rsize=SizeofResource(hModule,hRes);\r
- HGLOBAL hMem=::LoadResource(hModule,hRes);\r
- if (hMem){\r
- char* lpVoid=(char*)LockResource(hMem);\r
- if (lpVoid){\r
- // FILE* fTmp=tmpfile(); doesn't work with network\r
- /*char tmpPath[MAX_PATH] = {0};\r
- char tmpFile[MAX_PATH] = {0};\r
- GetTempPath(MAX_PATH,tmpPath);\r
- GetTempFileName(tmpPath,"IMG",0,tmpFile);\r
- FILE* fTmp=fopen(tmpFile,"w+b");\r
- if (fTmp){\r
- fwrite(lpVoid,rsize,1,fTmp);\r
- fseek(fTmp,0,SEEK_SET);\r
- bool bOK = Decode(fTmp,imagetype);\r
- fclose(fTmp);\r
- DeleteFile(tmpFile);\r
- return bOK;\r
- }*/\r
-\r
- CxMemFile fTmp((BYTE*)lpVoid,rsize);\r
- return Decode(&fTmp,imagetype);\r
- }\r
- } else strcpy(info.szLastError,"Unable to load resource!");\r
- return false;\r
-}\r
-#endif //WIN32\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Constructor from file name, see Load()\r
- * \param filename: file name\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- */\r
-// \r
-// > filename: file name\r
-// > imagetype: specify the image format (CXIMAGE_FORMAT_BMP,...)\r
-// For UNICODE support: char -> TCHAR\r
-CxImage::CxImage(const TCHAR * filename, DWORD imagetype)\r
-//CxImage::CxImage(const char * filename, DWORD imagetype)\r
-{\r
- Startup(imagetype);\r
- Load(filename,imagetype);\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Constructor from file handle, see Decode()\r
- * \param stream: file handle, with read access.\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- */\r
-CxImage::CxImage(FILE * stream, DWORD imagetype)\r
-{\r
- Startup(imagetype);\r
- Decode(stream,imagetype);\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Constructor from CxFile object, see Decode()\r
- * \param stream: file handle (CxMemFile or CxIOFile), with read access.\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- */\r
-CxImage::CxImage(CxFile * stream, DWORD imagetype)\r
-{\r
- Startup(imagetype);\r
- Decode(stream,imagetype);\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Constructor from memory buffer, see Decode()\r
- * \param buffer: memory buffer\r
- * \param size: size of buffer\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- */\r
-CxImage::CxImage(BYTE * buffer, DWORD size, DWORD imagetype)\r
-{\r
- Startup(imagetype);\r
- CxMemFile stream(buffer,size);\r
- Decode(&stream,imagetype);\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Loads an image from memory buffer\r
- * \param buffer: memory buffer\r
- * \param size: size of buffer\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- * \return true if everything is ok\r
- */\r
-bool CxImage::Decode(BYTE * buffer, DWORD size, DWORD imagetype)\r
-{\r
- CxMemFile file(buffer,size);\r
- return Decode(&file,imagetype);\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Loads an image from file handle.\r
- * \param hFile: file handle, with read access.\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- * \return true if everything is ok\r
- */\r
-bool CxImage::Decode(FILE *hFile, DWORD imagetype)\r
-{\r
- CxIOFile file(hFile);\r
- return Decode(&file,imagetype);\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Loads an image from CxFile object\r
- * \param hFile: file handle (CxMemFile or CxIOFile), with read access.\r
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS\r
- * \return true if everything is ok\r
- * \sa ENUM_CXIMAGE_FORMATS\r
- */\r
-bool CxImage::Decode(CxFile *hFile, DWORD imagetype)\r
-{\r
- if (hFile == NULL){\r
- strcpy(info.szLastError,CXIMAGE_ERR_NOFILE);\r
- return false;\r
- }\r
-\r
- if (imagetype==CXIMAGE_FORMAT_UNKNOWN){\r
- DWORD pos = hFile->Tell();\r
-#if CXIMAGE_SUPPORT_BMP\r
- { CxImageBMP newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_JPG\r
- { CxImageJPG newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_ICO\r
- { CxImageICO newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_GIF\r
- { CxImageGIF newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_PNG\r
- { CxImagePNG newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_TIF\r
- { CxImageTIF newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_MNG\r
- { CxImageMNG newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_TGA\r
- { CxImageTGA newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_PCX\r
- { CxImagePCX newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_WBMP\r
- { CxImageWBMP newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS\r
- { CxImageWMF newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_JBG\r
- { CxImageJBG newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_JASPER\r
- { CxImageJAS newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_SKA\r
- { CxImageSKA newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
-#if CXIMAGE_SUPPORT_RAW\r
- { CxImageRAW newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }\r
-#endif\r
- }\r
-\r
-#if CXIMAGE_SUPPORT_BMP\r
- if (imagetype==CXIMAGE_FORMAT_BMP){\r
- CxImageBMP newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_JPG\r
- if (imagetype==CXIMAGE_FORMAT_JPG){\r
- CxImageJPG newima;\r
- newima.CopyInfo(*this); // <ignacio>\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_ICO\r
- if (imagetype==CXIMAGE_FORMAT_ICO){\r
- CxImageICO newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- info.nNumFrames = newima.info.nNumFrames;\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_GIF\r
- if (imagetype==CXIMAGE_FORMAT_GIF){\r
- CxImageGIF newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- info.nNumFrames = newima.info.nNumFrames;\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_PNG\r
- if (imagetype==CXIMAGE_FORMAT_PNG){\r
- CxImagePNG newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_TIF\r
- if (imagetype==CXIMAGE_FORMAT_TIF){\r
- CxImageTIF newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- info.nNumFrames = newima.info.nNumFrames;\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_MNG\r
- if (imagetype==CXIMAGE_FORMAT_MNG){\r
- CxImageMNG newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- info.nNumFrames = newima.info.nNumFrames;\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_TGA\r
- if (imagetype==CXIMAGE_FORMAT_TGA){\r
- CxImageTGA newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_PCX\r
- if (imagetype==CXIMAGE_FORMAT_PCX){\r
- CxImagePCX newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_WBMP\r
- if (imagetype==CXIMAGE_FORMAT_WBMP){\r
- CxImageWBMP newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS // vho - WMF support\r
- if (imagetype == CXIMAGE_FORMAT_WMF){\r
- CxImageWMF newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_JBG\r
- if (imagetype==CXIMAGE_FORMAT_JBG){\r
- CxImageJBG newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_JASPER\r
- if (\r
- #if CXIMAGE_SUPPORT_JP2\r
- imagetype==CXIMAGE_FORMAT_JP2 || \r
- #endif\r
- #if CXIMAGE_SUPPORT_JPC\r
- imagetype==CXIMAGE_FORMAT_JPC || \r
- #endif\r
- #if CXIMAGE_SUPPORT_PGX\r
- imagetype==CXIMAGE_FORMAT_PGX || \r
- #endif\r
- #if CXIMAGE_SUPPORT_PNM\r
- imagetype==CXIMAGE_FORMAT_PNM || \r
- #endif\r
- #if CXIMAGE_SUPPORT_RAS\r
- imagetype==CXIMAGE_FORMAT_RAS || \r
- #endif\r
- false ){\r
- CxImageJAS newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile,imagetype)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-#if CXIMAGE_SUPPORT_SKA\r
- if (imagetype==CXIMAGE_FORMAT_SKA){\r
- CxImageSKA newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-\r
-#if CXIMAGE_SUPPORT_RAW\r
- if (imagetype==CXIMAGE_FORMAT_RAW){\r
- CxImageRAW newima;\r
- newima.CopyInfo(*this);\r
- if (newima.Decode(hFile)){\r
- Transfer(newima);\r
- return true;\r
- } else {\r
- strcpy(info.szLastError,newima.GetLastError());\r
- return false;\r
- }\r
- }\r
-#endif\r
-\r
- strcpy(info.szLastError,"Decode: Unknown or wrong format");\r
- return false;\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-/**\r
- * Loads an image from CxFile object\r
- * \param hFile: file handle (CxMemFile or CxIOFile), with read access.\r
- * \param imagetype: file format, default = 0 (CXIMAGE_FORMAT_UNKNOWN)\r
- * \return : if imagetype is not 0, the function returns true when imagetype\r
- * matches the file image format. If imagetype is 0, the function returns true\r
- * when the file image format is recognized as a supported format.\r
- * If the returned value is true, use GetHeight(), GetWidth() or GetType()\r
- * to retrieve the basic image information.\r
- * \sa ENUM_CXIMAGE_FORMATS\r
- */\r
-bool CxImage::CheckFormat(CxFile * hFile, DWORD imagetype)\r
-{\r
- SetType(CXIMAGE_FORMAT_UNKNOWN);\r
- SetEscape(-1);\r
-\r
- if (!Decode(hFile,imagetype))\r
- return false;\r
-\r
- if (GetType() == CXIMAGE_FORMAT_UNKNOWN || GetType() != imagetype)\r
- return false;\r
-\r
- return true;\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-bool CxImage::CheckFormat(BYTE * buffer, DWORD size, DWORD imagetype)\r
-{\r
- if (buffer==NULL || size==NULL){\r
- strcpy(info.szLastError,"invalid or empty buffer");\r
- return false;\r
- }\r
- CxMemFile file(buffer,size);\r
- return CheckFormat(&file,imagetype);\r
-}\r
-////////////////////////////////////////////////////////////////////////////////\r
-#endif //CXIMAGE_SUPPORT_DECODE\r
-////////////////////////////////////////////////////////////////////////////////\r
+// xImaCodec.cpp : Encode Decode functions
+/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
+ * CxImage version 6.0.0 02/Feb/2008
+ */
+
+#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_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, DWORD 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, DWORD 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, DWORD 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(BYTE * &buffer, long &size, DWORD 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, DWORD imagetype)
+{
+
+#if CXIMAGE_SUPPORT_BMP
+
+ if (imagetype==CXIMAGE_FORMAT_BMP){
+ CxImageBMP newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ 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)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_TIF
+ if (imagetype==CXIMAGE_FORMAT_TIF){
+ CxImageTIF newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JPG
+ if (imagetype==CXIMAGE_FORMAT_JPG){
+ CxImageJPG newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ 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)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_PNG
+ if (imagetype==CXIMAGE_FORMAT_PNG){
+ CxImagePNG newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_MNG
+ if (imagetype==CXIMAGE_FORMAT_MNG){
+ CxImageMNG newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_TGA
+ if (imagetype==CXIMAGE_FORMAT_TGA){
+ CxImageTGA newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_PCX
+ if (imagetype==CXIMAGE_FORMAT_PCX){
+ CxImagePCX newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_WBMP
+ if (imagetype==CXIMAGE_FORMAT_WBMP){
+ CxImageWBMP newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS // <vho> - WMF/EMF support
+ if (imagetype==CXIMAGE_FORMAT_WMF){
+ CxImageWMF newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JBG
+ if (imagetype==CXIMAGE_FORMAT_JBG){
+ CxImageJBG newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JASPER
+ if (
+ #if CXIMAGE_SUPPORT_JP2
+ imagetype==CXIMAGE_FORMAT_JP2 ||
+ #endif
+ #if CXIMAGE_SUPPORT_JPC
+ imagetype==CXIMAGE_FORMAT_JPC ||
+ #endif
+ #if CXIMAGE_SUPPORT_PGX
+ imagetype==CXIMAGE_FORMAT_PGX ||
+ #endif
+ #if CXIMAGE_SUPPORT_PNM
+ imagetype==CXIMAGE_FORMAT_PNM ||
+ #endif
+ #if CXIMAGE_SUPPORT_RAS
+ imagetype==CXIMAGE_FORMAT_RAS ||
+ #endif
+ false ){
+ CxImageJAS newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile,imagetype)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+
+#if CXIMAGE_SUPPORT_SKA
+ if (imagetype==CXIMAGE_FORMAT_SKA){
+ CxImageSKA newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+
+#if CXIMAGE_SUPPORT_RAW
+ if (imagetype==CXIMAGE_FORMAT_RAW){
+ CxImageRAW newima;
+ newima.Ghost(this);
+ if (newima.Encode(hFile)){
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ 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, int pagecount, DWORD 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, int pagecount, DWORD 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(BYTE * &buffer, long &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 (long y1 = 0; y1 < head.biHeight; y1++) {
+ long y = bFlipY ? head.biHeight - 1 - y1 : y1;
+ for(long 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, DWORD imagetype)
+//bool CxImage::Load(const char * filename, DWORD 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, DWORD 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, DWORD imagetype, HMODULE hModule)
+{
+ DWORD 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((BYTE*)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, DWORD imagetype)
+//CxImage::CxImage(const char * filename, DWORD 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, DWORD 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, DWORD 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(BYTE * buffer, DWORD size, DWORD 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(BYTE * buffer, DWORD size, DWORD 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, DWORD 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, DWORD imagetype)
+{
+ if (hFile == NULL){
+ strcpy(info.szLastError,CXIMAGE_ERR_NOFILE);
+ return false;
+ }
+
+ if (imagetype==CXIMAGE_FORMAT_UNKNOWN){
+ DWORD pos = hFile->Tell();
+#if CXIMAGE_SUPPORT_BMP
+ { CxImageBMP newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_JPG
+ { CxImageJPG newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_ICO
+ { CxImageICO newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_GIF
+ { CxImageGIF newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_PNG
+ { CxImagePNG newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_TIF
+ { CxImageTIF newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_MNG
+ { CxImageMNG newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_TGA
+ { CxImageTGA newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_PCX
+ { CxImagePCX newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_WBMP
+ { CxImageWBMP newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS
+ { CxImageWMF newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_JBG
+ { CxImageJBG newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_JASPER
+ { CxImageJAS newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_SKA
+ { CxImageSKA newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+#if CXIMAGE_SUPPORT_RAW
+ { CxImageRAW newima; newima.CopyInfo(*this); if (newima.Decode(hFile)) { Transfer(newima); return true; } else hFile->Seek(pos,SEEK_SET); }
+#endif
+ }
+
+#if CXIMAGE_SUPPORT_BMP
+ if (imagetype==CXIMAGE_FORMAT_BMP){
+ CxImageBMP newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JPG
+ if (imagetype==CXIMAGE_FORMAT_JPG){
+ CxImageJPG newima;
+ newima.CopyInfo(*this); // <ignacio>
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_ICO
+ if (imagetype==CXIMAGE_FORMAT_ICO){
+ CxImageICO newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ info.nNumFrames = newima.info.nNumFrames;
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_GIF
+ if (imagetype==CXIMAGE_FORMAT_GIF){
+ CxImageGIF newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ info.nNumFrames = newima.info.nNumFrames;
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_PNG
+ if (imagetype==CXIMAGE_FORMAT_PNG){
+ CxImagePNG newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_TIF
+ if (imagetype==CXIMAGE_FORMAT_TIF){
+ CxImageTIF newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ info.nNumFrames = newima.info.nNumFrames;
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_MNG
+ if (imagetype==CXIMAGE_FORMAT_MNG){
+ CxImageMNG newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ info.nNumFrames = newima.info.nNumFrames;
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_TGA
+ if (imagetype==CXIMAGE_FORMAT_TGA){
+ CxImageTGA newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_PCX
+ if (imagetype==CXIMAGE_FORMAT_PCX){
+ CxImagePCX newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_WBMP
+ if (imagetype==CXIMAGE_FORMAT_WBMP){
+ CxImageWBMP newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS // vho - WMF support
+ if (imagetype == CXIMAGE_FORMAT_WMF){
+ CxImageWMF newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JBG
+ if (imagetype==CXIMAGE_FORMAT_JBG){
+ CxImageJBG newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_JASPER
+ if (
+ #if CXIMAGE_SUPPORT_JP2
+ imagetype==CXIMAGE_FORMAT_JP2 ||
+ #endif
+ #if CXIMAGE_SUPPORT_JPC
+ imagetype==CXIMAGE_FORMAT_JPC ||
+ #endif
+ #if CXIMAGE_SUPPORT_PGX
+ imagetype==CXIMAGE_FORMAT_PGX ||
+ #endif
+ #if CXIMAGE_SUPPORT_PNM
+ imagetype==CXIMAGE_FORMAT_PNM ||
+ #endif
+ #if CXIMAGE_SUPPORT_RAS
+ imagetype==CXIMAGE_FORMAT_RAS ||
+ #endif
+ false ){
+ CxImageJAS newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile,imagetype)){
+ Transfer(newima);
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+#if CXIMAGE_SUPPORT_SKA
+ if (imagetype==CXIMAGE_FORMAT_SKA){
+ CxImageSKA newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ return false;
+ }
+ }
+#endif
+
+#if CXIMAGE_SUPPORT_RAW
+ if (imagetype==CXIMAGE_FORMAT_RAW){
+ CxImageRAW newima;
+ newima.CopyInfo(*this);
+ if (newima.Decode(hFile)){
+ Transfer(newima);
+ return true;
+ } else {
+ strcpy(info.szLastError,newima.GetLastError());
+ 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, DWORD imagetype)
+{
+ SetType(CXIMAGE_FORMAT_UNKNOWN);
+ SetEscape(-1);
+
+ if (!Decode(hFile,imagetype))
+ return false;
+
+ if (GetType() == CXIMAGE_FORMAT_UNKNOWN || GetType() != imagetype)
+ return false;
+
+ return true;
+}
+////////////////////////////////////////////////////////////////////////////////
+bool CxImage::CheckFormat(BYTE * buffer, DWORD size, DWORD imagetype)
+{
+ if (buffer==NULL || size==NULL){
+ strcpy(info.szLastError,"invalid or empty buffer");
+ return false;
+ }
+ CxMemFile file(buffer,size);
+ return CheckFormat(&file,imagetype);
+}
+////////////////////////////////////////////////////////////////////////////////
+#endif //CXIMAGE_SUPPORT_DECODE
+////////////////////////////////////////////////////////////////////////////////
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff