开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
ximage.h
资源名称：Client_win_src.rar　[点击查看]
上传用户：gnaf34
上传日期：2022-04-22
资源大小：1657k
文件大小：15k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

ximage.h：源码内容
  1. /*
  2.  * File: ximage.h
  3.  * Purpose: General Purpose Image Class 
  4.  */
  5. /* === C R E D I T S  &  D I S C L A I M E R S ==============
  6.  * Permission is given by the author to freely redistribute and include
  7.  * this code in any program as long as this credit is given where due.
  8.  *
  9.  * CxImage (c)  07/Aug/2001 <ing.davide.pizzolato@libero.it>
  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.  * original CImage and CImageIterator implementation are:
  16.  * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
  17.  *
  18.  * COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
  19.  * OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
  20.  * THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
  21.  * OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
  22.  * CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
  23.  * THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
  24.  * SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
  25.  * PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  26.  * THIS DISCLAIMER.
  27.  *
  28.  * Use at your own risk!
  29.  * ==========================================================
  30.  */
  31. #if !defined(__MYFXIMAGE_H)
  32. #define __MYFXIMAGE_H
  34. #if _MSC_VER > 1000
  35. #pragma once
  36. #endif 
  38. /////////////////////////////////////////////////////////////////////////////
  39. // CxImage supported features
  40. #define CXIMAGE_SUPPORT_ALPHA          1
  41. #define CXIMAGE_SUPPORT_SELECTION      1
  42. #define CXIMAGE_SUPPORT_TRANSFORMATION 1
  43. #define CXIMAGE_SUPPORT_DSP            1
  45. #define CXIMAGE_SUPPORT_DECODE 1
  46. #define CXIMAGE_SUPPORT_ENCODE 1 //<vho><T.Peck>
  47. #define CXIMAGE_SUPPORT_WINDOWS 1
  48. #define CXIMAGE_SUPPORT_WINCE   0 //<T.Peck>
  50. /////////////////////////////////////////////////////////////////////////////
  51. // CxImage supported formats
  52. #define CXIMAGE_SUPPORT_BMP 1
  53. #define CXIMAGE_SUPPORT_GIF 1
  54. #define CXIMAGE_SUPPORT_JPG 1
  55. #define CXIMAGE_SUPPORT_PNG 1
  56. #define CXIMAGE_SUPPORT_MNG 0
  57. #define CXIMAGE_SUPPORT_ICO 1
  58. #define CXIMAGE_SUPPORT_TIF 1
  59. #define CXIMAGE_SUPPORT_TGA 1
  60. #define CXIMAGE_SUPPORT_PCX 1
  61. #define CXIMAGE_SUPPORT_WBMP 1
  62. #define CXIMAGE_SUPPORT_WMF 1
  63. #define CXIMAGE_SUPPORT_J2K 0 // Beta
  64. #define CXIMAGE_SUPPORT_JBG 0 // Patented! see ../jbig/patents.htm
  66. /////////////////////////////////////////////////////////////////////////////
  67. #include "xfile.h"
  68. #include "xiofile.h"
  69. #include "xmemfile.h"
  71. #include "ximadefs.h" //<vho> adjust some #define
  73. /////////////////////////////////////////////////////////////////////////////
  74. // CxImage formats enumerator
  75. enum ENUM_CXIMAGE_FORMATS{
  76. #if CXIMAGE_SUPPORT_BMP
  77. CXIMAGE_FORMAT_BMP,
  78. #endif
  79. #if CXIMAGE_SUPPORT_GIF
  80. CXIMAGE_FORMAT_GIF,
  81. #endif
  82. #if CXIMAGE_SUPPORT_JPG
  83. CXIMAGE_FORMAT_JPG,
  84. #endif
  85. #if CXIMAGE_SUPPORT_PNG
  86. CXIMAGE_FORMAT_PNG,
  87. #endif
  88. #if CXIMAGE_SUPPORT_MNG
  89. CXIMAGE_FORMAT_MNG,
  90. #endif
  91. #if CXIMAGE_SUPPORT_ICO
  92. CXIMAGE_FORMAT_ICO,
  93. #endif
  94. #if CXIMAGE_SUPPORT_TIF
  95. CXIMAGE_FORMAT_TIF,
  96. #endif
  97. #if CXIMAGE_SUPPORT_TGA
  98. CXIMAGE_FORMAT_TGA,
  99. #endif
  100. #if CXIMAGE_SUPPORT_PCX
  101. CXIMAGE_FORMAT_PCX,
  102. #endif
  103. #if CXIMAGE_SUPPORT_WBMP
  104. CXIMAGE_FORMAT_WBMP,
  105. #endif
  106. #if CXIMAGE_SUPPORT_WMF // <vho> - Windows Metafile
  107. CXIMAGE_FORMAT_WMF,
  108. #endif
  109. #if CXIMAGE_SUPPORT_J2K
  110. CXIMAGE_FORMAT_J2K,
  111. #endif
  112. #if CXIMAGE_SUPPORT_JBG
  113. CXIMAGE_FORMAT_JBG,
  114. #endif
  115. CMAX_IMAGE_FORMATS
  116. };
  118. // needed for png, gif, tga
  120. #define RGB2GRAY(r,g,b) ((b*11 + g*59 + r*30)/100) //color to grey mapping
  122. struct rgb_color { BYTE r,g,b; };
  124. /////////////////////////////////////////////////////////////////////////////
  125. // CxImage class
  126. /////////////////////////////////////////////////////////////////////////////
  127. class DLL_EXP CxImage
  128. {
  129. //extensible information collector
  130. typedef struct tagCxImageInfo {
  131. DWORD dwEffWidth; //DWORD aligned scan line width
  132. BYTE* pImage; //THE IMAGE BITS
  133. void* pGhost; //if this is a ghost, pGhost point to the body
  134. DWORD dwType; //original image format
  135. char szLastError[256]; //debugging
  136. long nProgress; //monitor
  137. long nEscape; //escape
  138. long nBkgndIndex; //used for GIF, PNG, MNG
  139. RGBQUAD nBkgndColor; //used for RGB transparency
  140. BYTE nQuality; //used for JPEG
  141. long nFrame; //used for TIF, GIF, MNG : actual frame
  142. long nNumFrames; //used for TIF, GIF, MNG : total number of frames
  143. DWORD dwFrameDelay; //used for GIF, MNG
  144. long xDPI; //horizontal resolution
  145. long yDPI; //vertical resolution
  146. RECT rSelectionBox; //bounding rectangle
  147. BYTE nAlphaMax; //max opacity (fade)
  148. BYTE bAlphaPaletteEnabled; //true if alpha values in the palette are enabled.
  149. BYTE bEnabled; //enables the painting functions
  150. long xOffset;
  151. long yOffset;
  152. } CXIMAGEINFO;
  154. public:
  155. //constructors
  156. CxImage(DWORD imagetype = 0);
  157. CxImage(DWORD dwWidth, DWORD dwHeight, long wBpp, long imagetype = 0);
  158. CxImage(const CxImage &src, bool copypixels = true, bool copyselection = true, bool copyalpha = true);
  159. CxImage(const char * filename, DWORD imagetype);
  160. CxImage(FILE * stream, DWORD imagetype);
  161. CxImage(CxFile * stream, DWORD imagetype);
  162. CxImage(BYTE * buffer, DWORD size, DWORD imagetype);
  163. virtual ~CxImage();
  164. CxImage& operator = (const CxImage&);
  166. //initializzation
  167. void Destroy();
  168. void* Create(DWORD dwWidth, DWORD dwHeight, long wBpp, long imagetype = 0);
  169. bool CreateFromHANDLE(HANDLE hMem); //Windows objects (clipboard)
  170. void Clear(BYTE bval=0);
  171. void Copy(const CxImage &src, bool copypixels = true, bool copyselection = true, bool copyalpha = true);
  172. HANDLE CopyToHandle();
  173. void Transfer(CxImage &from);
  175. //Attributes
  176. long GetSize();
  177. BYTE* GetBits();
  178. BYTE GetColorType();
  179. HANDLE GetDIB() const {return (HANDLE)pDib;}
  180. DWORD GetHeight() const {return head.biHeight;}
  181. DWORD GetWidth() const {return head.biWidth;}
  182. DWORD GetEffWidth() const {return info.dwEffWidth;}
  183. DWORD GetNumColors() const {return head.biClrUsed;}
  184. WORD GetBpp() const {return head.biBitCount;}
  185. DWORD GetType() const {return info.dwType;}
  186. char* GetLastError() {return info.szLastError;}
  187. const char* GetVersion();
  189. DWORD GetFrameDelay() const {return info.dwFrameDelay;}
  190. void SetFrameDelay(DWORD d) {info.dwFrameDelay=d;}
  192. void GetOffset(long *x,long *y) {*x=info.xOffset; *y=info.yOffset;}
  193. void SetOffset(long x,long y) {info.xOffset=x; info.yOffset=y;}
  195. BYTE GetJpegQuality() const {return info.nQuality;}
  196. void SetJpegQuality(BYTE q) {info.nQuality = q;}
  198. long GetXDPI() const {return info.xDPI;}
  199. long GetYDPI() const {return info.yDPI;}
  200. void SetXDPI(long dpi);
  201. void SetYDPI(long dpi);
  203. long GetProgress() const {return info.nProgress;}
  204. long GetEscape()     const {return info.nEscape;}
  205. void SetProgress(long p) {info.nProgress = p;}
  206. void SetEscape(long i)   {info.nEscape = i;}
  208. long GetTransIndex() const {return info.nBkgndIndex;}
  209. RGBQUAD GetTransColor();
  210. void SetTransIndex(long idx) {info.nBkgndIndex = idx;}
  211. void SetTransColor(RGBQUAD rgb) {info.nBkgndColor = rgb;}
  212. bool IsTransparent() const {return info.nBkgndIndex>=0;} // <vho>
  214. //palette operations
  215. bool IsGrayScale();
  216. bool IsIndexed() {return head.biClrUsed!=0;}
  217. DWORD GetPaletteSize();
  218. RGBQUAD* GetPalette() const;
  219. RGBQUAD GetPaletteColor(BYTE idx);
  220. bool GetRGB(int i, BYTE* r, BYTE* g, BYTE* b);
  221. BYTE GetNearestIndex(RGBQUAD c);
  222. void BlendPalette(COLORREF cr,long perc);
  223. void SetGrayPalette();
  224. void SetPalette(DWORD n, BYTE *r, BYTE *g, BYTE *b);
  225. void SetPalette(RGBQUAD* pPal,DWORD nColors=256);
  226. void SetPalette(rgb_color *rgb,DWORD nColors=256);
  227. void SetPaletteIndex(BYTE idx, BYTE r, BYTE g, BYTE b, BYTE alpha=0);
  228. void SetPaletteIndex(BYTE idx, RGBQUAD c);
  229. void SetPaletteIndex(BYTE idx, COLORREF cr);
  230. void SwapIndex(BYTE idx1, BYTE idx2);
  231. void SetStdPalette();
  233. //pixel operations
  234. bool IsInside(long x, long y);
  235. BYTE GetPixelIndex(long x,long y);
  236. RGBQUAD GetPixelColor(long x,long y);
  237. void SetPixelColor(long x,long y,RGBQUAD c);
  238. void SetPixelIndex(long x,long y,BYTE i);
  239. void SetPixelColor(long x,long y,COLORREF cr);
  241. //painting operations
  242. #if CXIMAGE_SUPPORT_WINCE
  243. long Blt(HDC pDC, long x=0, long y=0);
  244. #endif
  245. #if CXIMAGE_SUPPORT_WINDOWS
  246. HBITMAP MakeBitmap(HDC hdc = NULL);
  247. void CreateFromHBITMAP(HBITMAP hbmp); //Windows resource
  248. long Draw(HDC hdc, long x=0, long y=0, long cx = -1, long cy = -1, RECT* pClipRect = 0);
  249. long Draw(HDC hdc, const RECT& rect, RECT* pClipRect=NULL) { return Draw(hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, pClipRect); }
  250. long Stretch(HDC hdc, long xoffset, long yoffset, long xsize, long ysize);
  251. long Stretch(HDC hdc, const RECT& rect) { return Stretch(hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top); }
  252. long Tile(HDC hdc, RECT *rc);
  253. long Draw2(HDC hdc, long x=0, long y=0, long cx = -1, long cy = -1);
  254. long Draw2(HDC hdc, const RECT& rect) { return Draw2(hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top); }
  255. #endif //CXIMAGE_SUPPORT_WINDOWS
  257. // file operations
  258. #if CXIMAGE_SUPPORT_DECODE
  259. #ifdef WIN32
  260. bool Load(LPCWSTR filename, DWORD imagetype=0);
  261. bool LoadResource(HRSRC hRes, DWORD imagetype, HMODULE hModule=NULL);
  262. #endif
  263. bool Load(const char * filename, DWORD imagetype=0);
  264. bool Decode(FILE * hFile, DWORD imagetype);
  265. bool Decode(CxFile * hFile, DWORD imagetype);
  266. bool Decode(BYTE * buffer, DWORD size, DWORD imagetype);
  267. #endif //CXIMAGE_SUPPORT_DECODE
  269. #if CXIMAGE_SUPPORT_ENCODE
  270. #ifdef WIN32
  271. bool Save(LPCWSTR filename, DWORD imagetype=0);
  272. #endif
  273. bool Save(const char * filename, DWORD imagetype=0);
  274. bool Encode(FILE * hFile, DWORD imagetype);
  275. bool Encode(CxFile * hFile, DWORD imagetype);
  276. bool Encode(CxFile * hFile, CxImage ** pImages, int pagecount, DWORD imagetype);
  277. bool Encode(FILE *hFile, CxImage ** pImages, int pagecount, DWORD imagetype);
  278. bool Encode(BYTE * &buffer, long &size, DWORD imagetype);
  279. #endif //CXIMAGE_SUPPORT_ENCODE
  281. //misc.
  282. bool IsValid() const {return pDib!=0;}
  283. bool IsEnabled() const {return info.bEnabled!=0;}
  284. void Enable(bool enable=true){info.bEnabled=enable;}
  286. // frame operations
  287. long GetNumFrames() const {return info.nNumFrames;}
  288. long GetFrame() const {return info.nFrame;}
  289. void SetFrame(long nFrame) {info.nFrame=nFrame;}
  291. #if CXIMAGE_SUPPORT_BASICTRANSFORMATIONS
  292. bool GrayScale();
  293. bool Flip();
  294. bool Mirror();
  295. bool RotateLeft(CxImage* iDst = NULL);
  296. bool RotateRight(CxImage* iDst = NULL);
  297. #endif //CXIMAGE_SUPPORT_BASICTRANSFORMATIONS
  299. #if CXIMAGE_SUPPORT_TRANSFORMATION
  300. // image operations
  301. bool Negative();
  302. bool Rotate(float angle, CxImage* iDst = NULL);
  303. bool Rotate180(CxImage* iDst = NULL);
  304. bool Resample(long newx, long newy, int fast = 1);
  305. bool DecreaseBpp(DWORD nbit, bool errordiffusion, RGBQUAD* ppal = 0);
  306. bool IncreaseBpp(DWORD nbit);
  307. bool Dither(long method = 0);
  308. bool Crop(long left, long top, long right, long bottom, CxImage* iDst = NULL);
  309. bool Crop(const RECT& rect, CxImage* iDst = NULL) { return Crop(rect.left, rect.top, rect.right, rect.bottom, iDst); }
  310. #endif //CXIMAGE_SUPPORT_TRANSFORMATION
  312. #if CXIMAGE_SUPPORT_DSP
  313. bool Repair(float radius = 0.25f, long niterations = 1, long colorspace = 0);
  314. bool Combine(CxImage* r,CxImage* g,CxImage* b,CxImage* a, long colorspace = 0);
  315. bool FFT2(CxImage* srcReal, CxImage* srcImag, CxImage* dstReal, CxImage* dstImag, long direction = 1, bool bForceFFT = true, bool bMagnitude = true);
  316. long Histogram(long* red, long* green = 0, long* blue = 0, long* gray = 0, long colorspace = 0);
  317. bool Noise(long level);
  318. bool Median(long Ksize=3);
  319. bool Gamma(float gamma);
  320. bool ShiftRGB(long r, long g, long b);
  321. bool Threshold(BYTE level);
  322. bool Colorize(BYTE hue, BYTE sat);
  323. bool Light(long level, long contrast=100);
  324. float Mean();
  325. bool Filter(long* kernel, long Ksize, long Kfactor, long Koffset);
  326. bool Erode(long Ksize=2);
  327. bool Dilate(long Ksize=2);
  328. void HuePalette(float correction=1);
  329. enum ImageOpType { OpAdd, OpAnd, OpXor, OpOr, OpMask, OpSrcCopy, OpDstCopy, OpSub, OpSrcBlend };
  330. void Mix(CxImage & imgsrc2, ImageOpType op, long lXOffset = 0, long lYOffset = 0);
  331. protected:
  332. bool IsPowerof2(long x);
  333. bool FFT(int dir,int m,double *x,double *y);
  334. bool DFT(int dir,long m,double *x1,double *y1,double *x2,double *y2);
  335. bool RepairChannel(CxImage *ch, float radius);
  336. public:
  337. //color conversion utilities
  338. bool SplitRGB(CxImage* r,CxImage* g,CxImage* b);
  339. bool SplitYUV(CxImage* y,CxImage* u,CxImage* v);
  340. bool SplitHSL(CxImage* h,CxImage* s,CxImage* l);
  341. bool SplitYIQ(CxImage* y,CxImage* i,CxImage* q);
  342. bool SplitXYZ(CxImage* x,CxImage* y,CxImage* z);
  343. RGBQUAD HSLtoRGB(COLORREF cHSLColor);
  344. RGBQUAD RGBtoHSL(RGBQUAD lRGBColor);
  345. RGBQUAD HSLtoRGB(RGBQUAD lHSLColor);
  346. RGBQUAD YUVtoRGB(RGBQUAD lYUVColor);
  347. RGBQUAD RGBtoYUV(RGBQUAD lRGBColor);
  348. RGBQUAD YIQtoRGB(RGBQUAD lYIQColor);
  349. RGBQUAD RGBtoYIQ(RGBQUAD lRGBColor);
  350. RGBQUAD XYZtoRGB(RGBQUAD lXYZColor);
  351. RGBQUAD RGBtoXYZ(RGBQUAD lRGBColor);
  352. #endif //CXIMAGE_SUPPORT_DSP
  353. RGBQUAD RGBtoRGBQUAD(COLORREF cr);
  354. COLORREF RGBQUADtoRGB (RGBQUAD c);
  356. #if CXIMAGE_SUPPORT_SELECTION
  357. //selection
  358. void SelectionClear();
  359. void SelectionCreate();
  360. void SelectionDelete();
  361. void SelectionInvert();
  362. void SelectionAddRect(RECT r);
  363. void SelectionAddEllipse(RECT r);
  364. void SelectionAddPolygon(POINT *points, long npoints);
  365. bool SelectionCopy(CxImage &from);
  366. bool IsInsideSelection(long x, long y);
  367. bool HasSelection(){return pSelection!=0;}
  368. void GetSelectionBox(RECT& r){memcpy(&r,&info.rSelectionBox,sizeof(RECT));}
  369. #endif //CXIMAGE_SUPPORT_SELECTION
  371. #if CXIMAGE_SUPPORT_ALPHA
  372. //Alpha
  373. void AlphaClear();
  374. void AlphaCreate();
  375. void AlphaDelete();
  376. void AlphaInvert();
  377. bool AlphaMirror();
  378. bool AlphaFlip();
  379. bool AlphaCopy(CxImage &from);
  380. bool AlphaSplit(CxImage *dest);
  381. void AlphaStrip();
  382. void AlphaSet(BYTE level);
  383. void AlphaSet(long x,long y,BYTE level);
  384. BYTE AlphaGet(long x,long y);
  385. BYTE AlphaGetMax() const {return info.nAlphaMax;}
  386. void AlphaSetMax(BYTE nAlphaMax) {info.nAlphaMax=nAlphaMax;}
  387. bool HasAlpha(){return pAlpha!=0;}
  389. void AlphaPaletteClear();
  390. void AlphaPaletteEnable(bool enable=true){info.bAlphaPaletteEnabled=enable;}
  391. bool IsAlphaPaletteEnabled(){return info.bAlphaPaletteEnabled!=0;}
  392. bool HasAlphaPalette();
  393. #endif //CXIMAGE_SUPPORT_ALPHA
  395. protected:
  396. void Startup(DWORD imagetype = 0);
  397. void CopyInfo(const CxImage &src);
  398. void Ghost(CxImage *src);
  399. void RGBtoBGR(BYTE *buffer, int length);
  400. float HueToRGB(float n1,float n2, float hue);
  401. void Bitfield2RGB(BYTE *src, WORD redmask, WORD greenmask, WORD bluemask, BYTE bpp);
  402. static int CompareColors(const void *elem1, const void *elem2);
  404. void* pDib; //contains the header, the palette, the pixels
  405.     BITMAPINFOHEADER    head; //stadnard header
  406. CXIMAGEINFO info; //extended information
  407. BYTE* pSelection; //selected region
  408. BYTE* pAlpha; //alpha channel
  409. };
  410. ////////////////////////////////////////////////////////////////////////////
  411. #endif // !defined(__MYFXIMAGE_H)