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

网络截获/分析

开发平台:

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. #define WIDTHBYTES(bits)    (((bits) + 31) / 32 * 4)
  119. class JpegFile 
  120. {
  121. public:
  122. ////////////////////////////////////////////////////////////////
  123. // read a JPEG file to an RGB buffer - 3 bytes per pixel
  124. // returns a ptr to a buffer .
  125. // caller is responsible for cleanup!!!
  126. // BYTE *buf = JpegFile::JpegFileToRGB(....);
  127. // delete [] buf;
  128. static BYTE * JpegFileToRGB(CString fileName, // path to image
  129.    UINT *width, // image width in pixels
  130.    UINT *height); // image height
  131. ////////////////////////////////////////////////////////////////
  132. // write a JPEG file from a 3-component, 1-byte per component buffer
  133. static BOOL RGBToJpegFile(CString fileName, // path
  134. BYTE *dataBuf, // RGB buffer
  135. UINT width, // pixels
  136. UINT height, // rows
  137. BOOL color, // TRUE = RGB
  138. // FALSE = Grayscale
  139. int quality); // 0 - 100
  140. ////////////////////////////////////////////////////////////////
  141. // fetch width / height of an image
  142. static BOOL GetJPGDimensions(CString fileName, // path
  143. UINT *width, // pixels
  144. UINT *height);
  145. ////////////////////////////////////////////////////////////////
  146. // utility functions
  147. // to do things like DWORD-align, flip, convert to grayscale, etc.
  148. //
  149. ////////////////////////////////////////////////////////////////
  150. // allocates a DWORD-aligned buffer, copies data buffer
  151. // caller is responsible for delete []'ing the buffer
  152. static BYTE * MakeDwordAlignedBuf(BYTE *dataBuf, // input buf
  153.  UINT widthPix, // input pixels
  154.  UINT height, // lines
  155.  UINT *uiOutWidthBytes); // new width bytes
  156. ////////////////////////////////////////////////////////////////
  157. // if you have a DWORD aligned buffer, this will copy the
  158. // RGBs out of it into a new buffer. new width is widthPix * 3 bytes
  159. // caller is responsible for delete []'ing the buffer
  160. static BYTE *RGBFromDWORDAligned(BYTE *inBuf, // input buf
  161. UINT widthPix, // input size
  162. UINT widthBytes, // input size
  163. UINT height);
  164. ////////////////////////////////////////////////////////////////
  165. // vertically flip a buffer - for BMPs
  166. // in-place
  167. // note, this routine works on a buffer of width widthBytes: not a 
  168. // buffer of widthPixels.
  169. static BOOL VertFlipBuf(BYTE * inbuf, // input buf
  170.    UINT widthBytes, // input width bytes
  171.    UINT height); // height
  172. // NOTE :
  173. // the following routines do their magic on buffers with a whole number
  174. // of pixels per data row! these are assumed to be non DWORD-aligned buffers.
  175. ////////////////////////////////////////////////////////////////
  176. // convert RGB to grayscale using luminance calculation
  177. // in-place
  178. static BOOL MakeGrayScale(BYTE *buf, // input buf 
  179. UINT widthPix, // width in pixels
  180. UINT height); // height
  181. ////////////////////////////////////////////////////////////////
  182. // swap Red and Blue bytes
  183. // in-place
  184. static BOOL BGRFromRGB(BYTE *buf, // input buf
  185. UINT widthPix, // width in pixels
  186. UINT height); // lines
  187. ////////////////////////////////////////////////////////////////
  188. // these do nothing
  189. JpegFile(); // creates an empty object
  190. ~JpegFile(); // destroys nothing
  191. };