jpegfile.h
上传用户:cjw5120
上传日期:2022-05-11
资源大小:5032k
文件大小:8k
源码类别:

网络截获/分析

开发平台:

Visual C++

  1. ////////////////////////////////////////////////////////////
  2. //
  3. // JpegFile - A C++ class to allow reading and writing of
  4. // RGB and Grayscale JPEG images. (actually, it reads all forms
  5. // that the JPEG lib will decode into RGB or grayscale) and
  6. // writes only RGB and Grayscale.
  7. //
  8. // It is based on a Win32 compilation of the IJG V.6a code.
  9. //
  10. // This will only work on 32-bit Windows systems. I have only 
  11. // tried this with Win 95, VC++ 4.1.
  12. //
  13. // This class Copyright 1997, Chris Losinger
  14. // This is free to use and modify provided my name is included.
  15. //
  16. // Comments:
  17. // Thanks to Robert Johnson for discovering a DWORD-alignment bug
  18. // Thanks to Lee Bode for catching a bug in CMfcappView::OnFileGetdimensionsjpg() 
  19. //
  20. ////////////////////////////////////////////////////////////
  21. //
  22. // General Usage:
  23. //
  24. // #include this file.
  25. // link with jpeglib2.lib
  26. //
  27. // All functions here are static. There is no need to have a JpegFile object.
  28. // There is actually nothing in a JpegFile object anyway. 
  29. //
  30. // So, you can do this :
  31. //
  32. // BOOL ok = JpegFile::vertFlipBuf(buf, widthbytes, height);
  33. //
  34. // instead of this :
  35. //
  36. // JpegFile jpgOb;
  37. // BOOL ok = jpgOb.vertFlipBuf(buf, widthbytes, height);
  38. //
  39. /////
  40. //
  41. // Linking usage :
  42. // It is sometimes necessary to set /NODEFAULTLIB:LIBC (or LIBCD) to use this
  43. // class. 
  44. //
  45. /////
  46. //
  47. // Error reporting:
  48. // The class generates message boxes in response to JPEG errors.
  49. //
  50. // The JpegFile.cpp fn my_error_exit defines the behavior for
  51. // fatal errors : show msg box, return to caller.
  52. //
  53. // Warnings are handled by jpeglib.lib - which generates msg boxes too.
  54. //
  55. ////////////////////////////////////////////////////////////////
  56. /*
  57. ////////////////////////////////////////////////////////////////
  58. // Reading Usage :
  59. UINT height;
  60. UINT width;
  61. BYTE *dataBuf;
  62.    //read the file
  63.    dataBuf=JpegFile::JpegFileToRGB(fileName,
  64. &width,
  65. &height);
  66. if (dataBuf==NULL) {
  67. return;
  68. }
  69. // RGB -> BGR
  70. JpegFile::BGRFromRGB(dataBuf, m_width, m_height);
  71. BYTE *buf;
  72. // create a DWORD aligned buffer from the JpegFile object
  73. buf = JpegFile::MakeDwordAlignedBuf(dataBuf,
  74. width,
  75. height,
  76. &m_widthDW);
  77. // flip that buffer
  78. JpegFile::VertFlipBuf(m_buf, m_widthDW, m_height);
  79. // you now have a buffer ready to be used as a DIB
  80. // be sure to delete [] dataBuf; // !!!!!!!!!!
  81. // delete [] buf;
  82. // Writing Usage
  83. // this assumes your data is stored as a 24-bit RGB DIB.
  84. // if you have a 1,4,8,15/16 or 32 bit DIB, you'll have to 
  85. // do some work to get it into a 24-bit RGB state.
  86. BYTE *tmp=NULL;
  87. // assume buf is a DWORD-aligned BGR buffer, vertically flipped
  88. // as if read from a BMP file.
  89. // un-DWORD-align
  90. tmp=JpegFile::RGBFromDWORDAligned(buf,
  91. widthPix,
  92. widthBytes,
  93. height);
  94. // vertical flip
  95. JpegFile::VertFlipBuf(tmp, widthPix * 3, height);
  96. // reverse BGR
  97. JpegFile::BGRFromRGB(tmp, widthPix, height);
  98. if (tmp==NULL) {
  99. AfxMessageBox("~DWORD Memory Error");
  100. return;
  101. }
  102. // write it
  103. BOOL ok=JpegFile::RGBToJpegFile(fileName, 
  104. tmp,
  105. width,
  106. height,
  107. TRUE, 
  108. 75);
  109. if (!ok) {
  110. AfxMessageBox("Write Error");
  111. }
  112. delete [] tmp;
  113. ////////////////////////////////////////////////////////////////
  114. */
  115. //
  116. // for DWORD aligning a buffer
  117. //
  118. #if !defined(AFX_JPEGFILE_H__7B4DD98B_945B_11D2_815A_444553540000__INCLUDED_)
  119. #define AFX_JPEGFILE_H__7B4DD98B_945B_11D2_815A_444553540000__INCLUDED_
  120. //#define HAVE_BOOLEAN
  121. #define WIDTHBYTES(bits)    (((bits) + 31) / 32 * 4)
  122. class JpegFile 
  123. {
  124. public:
  125. // int NextFrame(BYTE *lpSteam);
  126. // BYTE * m_lpBuffer;
  127. unsigned long m_lWidth;
  128. unsigned long m_lHeight;
  129. unsigned long  m_dwPoint;
  130. DWORD m_dwOutMaxSize;
  131.     BYTE * m_lpOutBuffer;
  132.     BYTE * m_lpPreData;
  133. DWORD m_dwScreenMaxSize;
  134.     BYTE * m_lpScreenBuffer;
  135. DWORD m_dwFrame;
  136.     bool m_bOpening;
  137. CFile m_rFile;
  138. //    MYMHEADER m_header;
  139. // MYMCELL m_cell;
  140. ////////////////////////////////////////////////////////////////
  141. // read a JPEG file to an RGB buffer - 3 bytes per pixel
  142. // returns a ptr to a buffer .
  143. // caller is responsible for cleanup!!!
  144. // BYTE *buf = JpegFile::JpegFileToRGB(....);
  145. // delete [] buf;
  146.  BYTE * JpegFileToRGB(BYTE *dataBuf, // path to image
  147.                        unsigned long size,
  148.    UINT *width, // image width in pixels
  149.    UINT *height); // image height
  150. ////////////////////////////////////////////////////////////////
  151. // write a JPEG file from a 3-component, 1-byte per component buffer
  152.  BOOL RGBToJpegFile( // path
  153. BYTE *dataBuf, // RGB buffer
  154. BYTE *outBuf,
  155. UINT width, // pixels
  156. UINT height, // rows
  157. BOOL color, // TRUE = RGB
  158. // FALSE = Grayscale
  159. int quality,
  160. unsigned long *size); // 0 - 100
  161. ////////////////////////////////////////////////////////////////
  162. // fetch width / height of an image
  163.  BOOL GetJPGDimensions(CString fileName, // path
  164. UINT *width, // pixels
  165. UINT *height);
  166. ////////////////////////////////////////////////////////////////
  167. // utility functions
  168. // to do things like DWORD-align, flip, convert to grayscale, etc.
  169. //
  170. ////////////////////////////////////////////////////////////////
  171. // allocates a DWORD-aligned buffer, copies data buffer
  172. // caller is responsible for delete []'ing the buffer
  173.  BYTE * MakeDwordAlignedBuf(BYTE *dataBuf, // input buf
  174.  UINT widthPix, // input pixels
  175.  UINT height, // lines
  176.  UINT *uiOutWidthBytes); // new width bytes
  177.      BYTE * JpegFile::MovetoBuf(BYTE *dataBuf,
  178.  CRect *prcRect, // pixels!!
  179.  UINT widthNew,
  180.  UINT heightNew); // bytes!!!
  181. ////////////////////////////////////////////////////////////////
  182. // if you have a DWORD aligned buffer, this will copy the
  183. // RGBs out of it into a new buffer. new width is widthPix * 3 bytes
  184. // caller is responsible for delete []'ing the buffer
  185.  BYTE *RGBFromDWORDAligned(BYTE *inBuf, // input buf
  186. UINT widthPix, // input size
  187. UINT widthBytes, // input size
  188. UINT height);
  189. ////////////////////////////////////////////////////////////////
  190. // vertically flip a buffer - for BMPs
  191. // in-place
  192. // note, this routine works on a buffer of width widthBytes: not a 
  193. // buffer of widthPixels.
  194.  BOOL VertFlipBuf(BYTE * inbuf, // input buf
  195.    UINT widthBytes, // input width bytes
  196.    UINT height); // height
  197. // NOTE :
  198. // the following routines do their magic on buffers with a whole number
  199. // of pixels per data row! these are assumed to be non DWORD-aligned buffers.
  200. ////////////////////////////////////////////////////////////////
  201. // convert RGB to grayscale using luminance calculation
  202. // in-place
  203.  BOOL MakeGrayScale(BYTE *buf, // input buf 
  204. UINT widthPix, // width in pixels
  205. UINT height,
  206. BOOL turn = false); // height
  207. ////////////////////////////////////////////////////////////////
  208. // swap Red and Blue bytes
  209. // in-place
  210.  BOOL BGRFromRGB(BYTE *buf, // input buf
  211. UINT widthPix, // width in pixels
  212. UINT height); // lines
  213.      BYTE *BMPtoFix(unsigned char * lpData, 
  214.             unsigned long *lWidth ,
  215. unsigned long *lHeight, 
  216. unsigned long *lHeadSize, 
  217. unsigned long *lSize);
  218.     void DeletePreData();
  219.     BYTE *FixtoBMP(unsigned char * lpInData, 
  220.   unsigned long lWidth ,
  221.   unsigned long lHeight, 
  222.   unsigned char * lpHeadData,
  223.   unsigned long lHeadSize, 
  224.   unsigned long w, 
  225.   unsigned long h) ;
  226.      BYTE * LoadBMP(LPSTR lpData,
  227.                 unsigned long *lWidth,
  228. unsigned long *lHeight);
  229. ////////////////////////////////////////////////////////////////
  230. // these do nothing
  231. JpegFile(); // creates an empty object
  232. ~JpegFile(); // destroys nothing
  233. };
  234. #endif