ximajpg.h
上传用户:gnaf34
上传日期:2022-04-22
资源大小:1657k
文件大小:8k
源码类别:

IP电话/视频会议

开发平台:

Visual C++

  1. /*
  2.  * File: ximajpg.h
  3.  * Purpose: JPG Image Class Loader and Writer
  4.  */
  5. /* === C R E D I T S  &  D I S C L A I M E R S ==============
  6.  * CxImageJPG (c) 07/Aug/2001 <ing.davide.pizzolato@libero.it>
  7.  * Permission is given by the author to freely redistribute and include
  8.  * this code in any program as long as this credit is given where due.
  9.  *
  10.  * CxImage version 5.00 23/Aug/2002
  11.  * See the file history.htm for the complete bugfix and news report.
  12.  *
  13.  * Special thanks to Troels Knakkergaard for new features, enhancements and bugfixes
  14.  *
  15.  * Special thanks to Chris Shearer Cooper for CxFileJpg tips & code
  16.  *
  17.  * original CImageJPG  and CImageIterator implementation are:
  18.  * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
  19.  *
  20.  * This software is based in part on the work of the Independent JPEG Group.
  21.  * Copyright (C) 1991-1998, Thomas G. Lane.
  22.  *
  23.  * COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
  24.  * OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
  25.  * THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
  26.  * OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
  27.  * CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
  28.  * THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
  29.  * SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
  30.  * PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  31.  * THIS DISCLAIMER.
  32.  *
  33.  * Use at your own risk!
  34.  * ==========================================================
  35.  */
  36. #if !defined(__ximaJPEG_h)
  37. #define __ixmaJPEG_h
  38. #include "ximage.h"
  39. #if CXIMAGE_SUPPORT_JPG
  40. #define CXIMAGEJPG_SUPPORT_EXIF 0
  41. extern "C" {
  42.  #include "../jpeg/jpeglib.h"
  43.  #include "../jpeg/jerror.h"
  44. };
  45. class CxImageJPG: public CxImage
  46. {
  47. public:
  48. CxImageJPG(): CxImage(CXIMAGE_FORMAT_JPG) {}
  49. // bool Load(const char * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_JPG);}
  50. // bool Save(const char * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_JPG);}
  51. bool Decode(CxFile * hFile);
  52. bool Encode(CxFile * hFile);
  53. bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
  54. bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
  55. ////////////////////////////////////////////////////////////////////////////////////////
  56. //////////////////////        E X I F             //////////////////////////////////////
  57. ////////////////////////////////////////////////////////////////////////////////////////
  58. #if CXIMAGEJPG_SUPPORT_EXIF
  59. #define MAX_COMMENT 1000
  60. typedef struct tag_ExifInfo {
  61.     char  CameraMake   [32];
  62.     char  CameraModel  [40];
  63.     char  DateTime     [20];
  64.     int   Height, Width;
  65.     int   IsColor;
  66.     int   FlashUsed;
  67.     float FocalLength;
  68.     float ExposureTime;
  69.     float ApertureFNumber;
  70.     float Distance;
  71.     float CCDWidth;
  72.     float ExposureBias;
  73.     int   Whitebalance;
  74.     int   MeteringMode;
  75.     int   ExposureProgram;
  76.     int   ISOequivalent;
  77.     int   CompressionLevel;
  78.     char  Comments[MAX_COMMENT];
  79.     unsigned char * ThumbnailPointer;  /* Pointer at the thumbnail */
  80.     unsigned ThumbnailSize;     /* Size of thumbnail. */
  81. } EXIFINFO;
  82. class CxExifInfo
  83. {
  84. typedef struct tag_ExifTable{
  85.     unsigned short Tag;
  86.     char * Desc;
  87. } EXIFTABLE;
  88. public:
  89. EXIFINFO* m_exifinfo;
  90. char m_szLastError[256];
  91. CxExifInfo(EXIFINFO* info);
  92. bool DecodeInfo(struct jpeg_decompress_struct cinfo);
  93. protected:
  94. bool exif_process(unsigned char * CharBuf, unsigned int length, EXIFINFO* pInfo);
  95. int Get16u(void * Short);
  96. int Get32s(void * Long);
  97. unsigned long Get32u(void * Long);
  98. bool ProcessExifDir(unsigned char * DirStart, unsigned char * OffsetBase, unsigned ExifLength,
  99.                            EXIFINFO * const pInfo, unsigned char ** const LastExifRefdP);
  100. double ConvertAnyFormat(void * ValuePtr, int Format);
  101. bool is_exif(struct jpeg_marker_struct const marker);
  102. double FocalplaneXRes;
  103. double FocalplaneUnits;
  104. int ExifImageWidth;
  105. int MotorolaOrder;
  106. };
  107. EXIFINFO m_exifinfo;
  108. #endif //CXIMAGEJPG_SUPPORT_EXIF
  109. ////////////////////////////////////////////////////////////////////////////////////////
  110. //////////////////////        C x F i l e J p g         ////////////////////////////////
  111. ////////////////////////////////////////////////////////////////////////////////////////
  112. // thanks to Chris Shearer Cooper <cscooper@frii.com>
  113. class CxFileJpg : public jpeg_destination_mgr, public jpeg_source_mgr
  114. {
  115. public:
  116. enum { eBufSize = 4096 };
  117. CxFileJpg(CxFile* pFile)
  118. {
  119.         m_pFile = pFile;
  120. init_destination = InitDestination;
  121. empty_output_buffer = EmptyOutputBuffer;
  122. term_destination = TermDestination;
  123. init_source = InitSource;
  124. fill_input_buffer = FillInputBuffer;
  125. skip_input_data = SkipInputData;
  126. resync_to_restart = jpeg_resync_to_restart; // use default method
  127. term_source = TermSource;
  128. next_input_byte = NULL; //* => next byte to read from buffer 
  129. bytes_in_buffer = 0; //* # of bytes remaining in buffer 
  130. m_pBuffer = new unsigned char[eBufSize];
  131. }
  132. ~CxFileJpg()
  133. {
  134. delete [] m_pBuffer;
  135. }
  136. static void InitDestination(j_compress_ptr cinfo)
  137. {
  138. CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;
  139. pDest->next_output_byte = pDest->m_pBuffer;
  140. pDest->free_in_buffer = eBufSize;
  141. }
  142. static boolean EmptyOutputBuffer(j_compress_ptr cinfo)
  143. {
  144. CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;
  145. if (pDest->m_pFile->Write(pDest->m_pBuffer,1,eBufSize)!=(size_t)eBufSize)
  146. ERREXIT(cinfo, JERR_FILE_WRITE);
  147. pDest->next_output_byte = pDest->m_pBuffer;
  148. pDest->free_in_buffer = eBufSize;
  149. return TRUE;
  150. }
  151. static void TermDestination(j_compress_ptr cinfo)
  152. {
  153. CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;
  154. size_t datacount = eBufSize - pDest->free_in_buffer;
  155. /* Write any data remaining in the buffer */
  156. if (datacount > 0) {
  157. if (!pDest->m_pFile->Write(pDest->m_pBuffer,1,datacount))
  158. ERREXIT(cinfo, JERR_FILE_WRITE);
  159. }
  160. pDest->m_pFile->Flush();
  161. /* Make sure we wrote the output file OK */
  162. if (pDest->m_pFile->Error()) ERREXIT(cinfo, JERR_FILE_WRITE);
  163. return;
  164. }
  165. static void InitSource(j_decompress_ptr cinfo)
  166. {
  167. CxFileJpg* pSource = (CxFileJpg*)cinfo->src;
  168. pSource->m_bStartOfFile = TRUE;
  169. }
  170. static boolean FillInputBuffer(j_decompress_ptr cinfo)
  171. {
  172. size_t nbytes;
  173. CxFileJpg* pSource = (CxFileJpg*)cinfo->src;
  174. nbytes = pSource->m_pFile->Read(pSource->m_pBuffer,1,eBufSize);
  175. if (nbytes <= 0){
  176. if (pSource->m_bStartOfFile) //* Treat empty input file as fatal error 
  177. ERREXIT(cinfo, JERR_INPUT_EMPTY);
  178. WARNMS(cinfo, JWRN_JPEG_EOF);
  179. // Insert a fake EOI marker 
  180. pSource->m_pBuffer[0] = (JOCTET) 0xFF;
  181. pSource->m_pBuffer[1] = (JOCTET) JPEG_EOI;
  182. nbytes = 2;
  183. }
  184. pSource->next_input_byte = pSource->m_pBuffer;
  185. pSource->bytes_in_buffer = nbytes;
  186. pSource->m_bStartOfFile = FALSE;
  187. return TRUE;
  188. }
  189. static void SkipInputData(j_decompress_ptr cinfo, long num_bytes)
  190. {
  191. CxFileJpg* pSource = (CxFileJpg*)cinfo->src;
  192. if (num_bytes > 0){
  193. while (num_bytes > (long)pSource->bytes_in_buffer){
  194. num_bytes -= (long)pSource->bytes_in_buffer;
  195. FillInputBuffer(cinfo);
  196. // note we assume that fill_input_buffer will never return FALSE,
  197. // so suspension need not be handled.
  198. }
  199. pSource->next_input_byte += (size_t) num_bytes;
  200. pSource->bytes_in_buffer -= (size_t) num_bytes;
  201. }
  202. }
  203. static void TermSource(j_decompress_ptr cinfo)
  204. {
  205. return;
  206. }
  207. protected:
  208.     CxFile  *m_pFile;
  209. unsigned char *m_pBuffer;
  210. bool m_bStartOfFile;
  211. };
  212. };
  213. #endif
  214. #endif