ximajpg.h
上传用户:pass2008
上传日期:2021-07-05
资源大小:3299k
文件大小:9k
源码类别:

Internet/IE编程

开发平台:

Visual C++

  1. /*
  2.  * File: ximajpg.h
  3.  * Purpose: JPG Image Class Loader and Writer
  4.  */
  5. /* ==========================================================
  6.  * CxImageJPG (c) 07/Aug/2001 Davide Pizzolato - www.xdp.it
  7.  * For conditions of distribution and use, see copyright notice in ximage.h
  8.  *
  9.  * Special thanks to Troels Knakkergaard for new features, enhancements and bugfixes
  10.  *
  11.  * Special thanks to Chris Shearer Cooper for CxFileJpg tips & code
  12.  *
  13.  * EXIF support based on jhead-1.8 by Matthias Wandel <mwandel(at)rim(dot)net>
  14.  *
  15.  * original CImageJPG  and CImageIterator implementation are:
  16.  * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra(at)servidor(dot)unam(dot)mx>
  17.  *
  18.  * This software is based in part on the work of the Independent JPEG Group.
  19.  * Copyright (C) 1991-1998, Thomas G. Lane.
  20.  * ==========================================================
  21.  */
  22. #if !defined(__ximaJPEG_h)
  23. #define __ximaJPEG_h
  24. #include "ximage.h"
  25. #if CXIMAGE_SUPPORT_JPG
  26. #define CXIMAGEJPG_SUPPORT_EXIF 1
  27. extern "C" {
  28.  #include "../jpeg/jpeglib.h"
  29.  #include "../jpeg/jerror.h"
  30. }
  31. class DLL_EXP CxImageJPG: public CxImage
  32. {
  33. public:
  34. CxImageJPG();
  35. ~CxImageJPG();
  36. // bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_JPG);}
  37. // bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_JPG);}
  38. bool Decode(CxFile * hFile);
  39. bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
  40. #if CXIMAGE_SUPPORT_ENCODE
  41. bool Encode(CxFile * hFile);
  42. bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
  43. #endif // CXIMAGE_SUPPORT_ENCODE
  44. /*
  45.  * EXIF support based on jhead-1.8 by Matthias Wandel <mwandel(at)rim(dot)net>
  46.  */
  47. #if CXIMAGEJPG_SUPPORT_EXIF
  48. #define MAX_COMMENT 1000
  49. #define MAX_SECTIONS 20
  50. typedef struct tag_ExifInfo {
  51. char  Version      [5];
  52.     char  CameraMake   [32];
  53.     char  CameraModel  [40];
  54.     char  DateTime     [20];
  55.     int   Height, Width;
  56.     int   Orientation;
  57.     int   IsColor;
  58.     int   Process;
  59.     int   FlashUsed;
  60.     float FocalLength;
  61.     float ExposureTime;
  62.     float ApertureFNumber;
  63.     float Distance;
  64.     float CCDWidth;
  65.     float ExposureBias;
  66.     int   Whitebalance;
  67.     int   MeteringMode;
  68.     int   ExposureProgram;
  69.     int   ISOequivalent;
  70.     int   CompressionLevel;
  71. float FocalplaneXRes;
  72. float FocalplaneYRes;
  73. float FocalplaneUnits;
  74. float Xresolution;
  75. float Yresolution;
  76. float ResolutionUnit;
  77. float Brightness;
  78.     char  Comments[MAX_COMMENT];
  79.     unsigned char * ThumbnailPointer;  /* Pointer at the thumbnail */
  80.     unsigned ThumbnailSize;     /* Size of thumbnail. */
  81. bool  IsExif;
  82. } EXIFINFO;
  83. //--------------------------------------------------------------------------
  84. // JPEG markers consist of one or more 0xFF bytes, followed by a marker
  85. // code byte (which is not an FF).  Here are the marker codes of interest
  86. // in this program.  (See jdmarker.c for a more complete list.)
  87. //--------------------------------------------------------------------------
  88. #define M_SOF0  0xC0            // Start Of Frame N
  89. #define M_SOF1  0xC1            // N indicates which compression process
  90. #define M_SOF2  0xC2            // Only SOF0-SOF2 are now in common use
  91. #define M_SOF3  0xC3
  92. #define M_SOF5  0xC5            // NB: codes C4 and CC are NOT SOF markers
  93. #define M_SOF6  0xC6
  94. #define M_SOF7  0xC7
  95. #define M_SOF9  0xC9
  96. #define M_SOF10 0xCA
  97. #define M_SOF11 0xCB
  98. #define M_SOF13 0xCD
  99. #define M_SOF14 0xCE
  100. #define M_SOF15 0xCF
  101. #define M_SOI   0xD8            // Start Of Image (beginning of datastream)
  102. #define M_EOI   0xD9            // End Of Image (end of datastream)
  103. #define M_SOS   0xDA            // Start Of Scan (begins compressed data)
  104. #define M_JFIF  0xE0            // Jfif marker
  105. #define M_EXIF  0xE1            // Exif marker
  106. #define M_COM   0xFE            // COMment 
  107. #define PSEUDO_IMAGE_MARKER 0x123; // Extra value.
  108. #define EXIF_READ_EXIF  0x01
  109. #define EXIF_READ_IMAGE 0x02
  110. #define EXIF_READ_ALL   0x03
  111. class DLL_EXP CxExifInfo
  112. {
  113. typedef struct tag_Section_t{
  114.     BYTE*    Data;
  115.     int      Type;
  116.     unsigned Size;
  117. } Section_t;
  118. public:
  119. EXIFINFO* m_exifinfo;
  120. char m_szLastError[256];
  121. CxExifInfo(EXIFINFO* info = NULL);
  122. ~CxExifInfo();
  123. bool DecodeExif(CxFile * hFile, int nReadMode = EXIF_READ_EXIF);
  124. bool EncodeExif(CxFile * hFile);
  125. void DiscardAllButExif();
  126. protected:
  127. bool process_EXIF(unsigned char * CharBuf, unsigned int length);
  128. void process_COM (const BYTE * Data, int length);
  129. void process_SOFn (const BYTE * Data, int marker);
  130. int Get16u(void * Short);
  131. int Get16m(void * Short);
  132. long Get32s(void * Long);
  133. unsigned long Get32u(void * Long);
  134. double ConvertAnyFormat(void * ValuePtr, int Format);
  135. void* FindSection(int SectionType);
  136. bool ProcessExifDir(unsigned char * DirStart, unsigned char * OffsetBase, unsigned ExifLength,
  137.                            EXIFINFO * const pInfo, unsigned char ** const LastExifRefdP, int NestingLevel=0);
  138. int ExifImageWidth;
  139. int MotorolaOrder;
  140. Section_t Sections[MAX_SECTIONS];
  141. int SectionsRead;
  142. bool freeinfo;
  143. };
  144. CxExifInfo* m_exif;
  145. EXIFINFO m_exifinfo;
  146. bool DecodeExif(CxFile * hFile);
  147. bool DecodeExif(FILE * hFile) { CxIOFile file(hFile); return DecodeExif(&file); }
  148. #endif //CXIMAGEJPG_SUPPORT_EXIF
  149. ////////////////////////////////////////////////////////////////////////////////////////
  150. //////////////////////        C x F i l e J p g         ////////////////////////////////
  151. ////////////////////////////////////////////////////////////////////////////////////////
  152. // thanks to Chris Shearer Cooper <cscooper(at)frii(dot)com>
  153. class CxFileJpg : public jpeg_destination_mgr, public jpeg_source_mgr
  154. {
  155. public:
  156. enum { eBufSize = 4096 };
  157. CxFileJpg(CxFile* pFile)
  158. {
  159.         m_pFile = pFile;
  160. init_destination = InitDestination;
  161. empty_output_buffer = EmptyOutputBuffer;
  162. term_destination = TermDestination;
  163. init_source = InitSource;
  164. fill_input_buffer = FillInputBuffer;
  165. skip_input_data = SkipInputData;
  166. resync_to_restart = jpeg_resync_to_restart; // use default method
  167. term_source = TermSource;
  168. next_input_byte = NULL; //* => next byte to read from buffer 
  169. bytes_in_buffer = 0; //* # of bytes remaining in buffer 
  170. m_pBuffer = new unsigned char[eBufSize];
  171. }
  172. ~CxFileJpg()
  173. {
  174. delete [] m_pBuffer;
  175. }
  176. static void InitDestination(j_compress_ptr cinfo)
  177. {
  178. CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;
  179. pDest->next_output_byte = pDest->m_pBuffer;
  180. pDest->free_in_buffer = eBufSize;
  181. }
  182. static boolean EmptyOutputBuffer(j_compress_ptr cinfo)
  183. {
  184. CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;
  185. if (pDest->m_pFile->Write(pDest->m_pBuffer,1,eBufSize)!=(size_t)eBufSize)
  186. ERREXIT(cinfo, JERR_FILE_WRITE);
  187. pDest->next_output_byte = pDest->m_pBuffer;
  188. pDest->free_in_buffer = eBufSize;
  189. return TRUE;
  190. }
  191. static void TermDestination(j_compress_ptr cinfo)
  192. {
  193. CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;
  194. size_t datacount = eBufSize - pDest->free_in_buffer;
  195. /* Write any data remaining in the buffer */
  196. if (datacount > 0) {
  197. if (!pDest->m_pFile->Write(pDest->m_pBuffer,1,datacount))
  198. ERREXIT(cinfo, JERR_FILE_WRITE);
  199. }
  200. pDest->m_pFile->Flush();
  201. /* Make sure we wrote the output file OK */
  202. if (pDest->m_pFile->Error()) ERREXIT(cinfo, JERR_FILE_WRITE);
  203. return;
  204. }
  205. static void InitSource(j_decompress_ptr cinfo)
  206. {
  207. CxFileJpg* pSource = (CxFileJpg*)cinfo->src;
  208. pSource->m_bStartOfFile = TRUE;
  209. }
  210. static boolean FillInputBuffer(j_decompress_ptr cinfo)
  211. {
  212. size_t nbytes;
  213. CxFileJpg* pSource = (CxFileJpg*)cinfo->src;
  214. nbytes = pSource->m_pFile->Read(pSource->m_pBuffer,1,eBufSize);
  215. if (nbytes <= 0){
  216. if (pSource->m_bStartOfFile) //* Treat empty input file as fatal error 
  217. ERREXIT(cinfo, JERR_INPUT_EMPTY);
  218. WARNMS(cinfo, JWRN_JPEG_EOF);
  219. // Insert a fake EOI marker 
  220. pSource->m_pBuffer[0] = (JOCTET) 0xFF;
  221. pSource->m_pBuffer[1] = (JOCTET) JPEG_EOI;
  222. nbytes = 2;
  223. }
  224. pSource->next_input_byte = pSource->m_pBuffer;
  225. pSource->bytes_in_buffer = nbytes;
  226. pSource->m_bStartOfFile = FALSE;
  227. return TRUE;
  228. }
  229. static void SkipInputData(j_decompress_ptr cinfo, long num_bytes)
  230. {
  231. CxFileJpg* pSource = (CxFileJpg*)cinfo->src;
  232. if (num_bytes > 0){
  233. while (num_bytes > (long)pSource->bytes_in_buffer){
  234. num_bytes -= (long)pSource->bytes_in_buffer;
  235. FillInputBuffer(cinfo);
  236. // note we assume that fill_input_buffer will never return FALSE,
  237. // so suspension need not be handled.
  238. }
  239. pSource->next_input_byte += (size_t) num_bytes;
  240. pSource->bytes_in_buffer -= (size_t) num_bytes;
  241. }
  242. }
  243. static void TermSource(j_decompress_ptr /*cinfo*/)
  244. {
  245. return;
  246. }
  247. protected:
  248.     CxFile  *m_pFile;
  249. unsigned char *m_pBuffer;
  250. bool m_bStartOfFile;
  251. };
  252. public:
  253. enum CODEC_OPTION
  254. {
  255. ENCODE_BASELINE = 0x1,
  256. ENCODE_ARITHMETIC = 0x2,
  257. ENCODE_GRAYSCALE = 0x4,
  258. ENCODE_OPTIMIZE = 0x8,
  259. ENCODE_PROGRESSIVE = 0x10,
  260. ENCODE_LOSSLESS = 0x20,
  261. ENCODE_SMOOTHING = 0x40,
  262. DECODE_GRAYSCALE = 0x80,
  263. DECODE_QUANTIZE = 0x100,
  264. DECODE_DITHER = 0x200,
  265. DECODE_ONEPASS = 0x400,
  266. DECODE_NOSMOOTH = 0x800,
  267. ENCODE_SUBSAMPLE_422 = 0x1000,
  268. ENCODE_SUBSAMPLE_444 = 0x2000
  269. }; 
  270. int m_nPredictor;
  271. int m_nPointTransform;
  272. int m_nSmoothing;
  273. int m_nQuantize;
  274. J_DITHER_MODE m_nDither;
  275. };
  276. #endif
  277. #endif