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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图片显示 > 查看源码
IMAGEOBJECT.CPP
资源名称：vc图像处理比较全面的程序.rar　[点击查看]
上传用户：alisonmail
上传日期：2013-02-28
资源大小：500k
文件大小：49k
源码类别：

图片显示

开发平台：

Visual C++

IMAGEOBJECT.CPP：源码内容
  1. // ImageObject.cpp
  3. #include "stdafx.h"
  4. #include "ImageObject.h"
  6. char *CImageObject::szExtensions[] = { ".BMP", ".GIF", ".PCX", ".TGA", ".JPG", ".TIF", "" };
  8. CImageObject::CImageObject()
  9. {
  11. InitVars();
  13. }
  15. CImageObject::CImageObject( const char *pszFilename, CDC *pDC, int nX, int nY )
  16. {
  18. InitVars();
  19. Load( pszFilename, pDC, nX, nY );
  21. }
  23. CImageObject::~CImageObject()
  24. {
  26. if( m_hDib ) ::GlobalFree( m_hDib );
  27. if( m_pszFilename != NULL ) delete [] m_pszFilename;
  29. }
  31. void CImageObject::InitVars( BOOL bFlag )
  32. {
  34. m_nWidth = m_nHeight = m_nBits = m_nColors = m_nImageType = 0;
  35. m_nX = m_nY = 0;
  36. m_nLastError = 0;
  37. m_hDib = NULL;
  38. m_nPaletteCreationType = FIXED_PALETTE;
  39. if( !bFlag ){
  40. m_pszFilename = NULL;
  41. m_pLogPal = NULL;
  42. }
  43. m_nQuality = 50;
  45. }
  47. BOOL CImageObject::Load( const char *pszFilename, CDC *pDC, int nX, int nY )
  48. {
  50. m_nImageType = FileType( pszFilename );
  51. if( m_nImageType == 0 ){
  52. m_nLastError = IMAGELIB_UNSUPPORTED_FILETYPE;
  53. return( FALSE );
  54. }
  56. KillImage();
  58. m_pszFilename = new char [strlen(pszFilename)+1];
  59. if( m_pszFilename != NULL ) strcpy( m_pszFilename, pszFilename );
  61. switch( m_nImageType ){
  62. case IMAGETYPE_BMP:
  63. m_hDib = ::LoadBMP( pszFilename );
  64. if( m_hDib == NULL ){
  65. m_nLastError = ::GetLastPicLibError();
  66. return( FALSE );
  67. }
  68. break;
  69. case IMAGETYPE_GIF:
  70. m_hDib = ::LoadGIF( pszFilename );
  71. if( m_hDib == NULL ){
  72. m_nLastError = ::GetLastPicLibError();
  73. return( FALSE );
  74. }
  75. break;
  76. case IMAGETYPE_JPG:
  77. m_hDib = ::LoadJPG( pszFilename );
  78. if( m_hDib == NULL ){
  79. m_nLastError = ::GetLastPicLibError();
  80. return( FALSE );
  81. }
  82. break;
  83. case IMAGETYPE_PCX:
  84. m_hDib = ::LoadPCX( pszFilename );
  85. if( m_hDib == NULL ){
  86. m_nLastError = ::GetLastPicLibError();
  87. return( FALSE );
  88. }
  89. break;
  90. case IMAGETYPE_TGA:
  91. m_hDib = ::LoadTGA( pszFilename );
  92. if( m_hDib == NULL ){
  93. m_nLastError = ::GetLastPicLibError();
  94. return( FALSE );
  95. }
  96. break;
  97. case IMAGETYPE_TIF:
  98. m_hDib = ::LoadTIF( pszFilename );
  99. if( m_hDib == NULL ){
  100. m_nLastError = ::GetLastPicLibError();
  101. return( FALSE );
  102. }
  103. break;
  104. }
  106. ProcessImageHeader();
  107. ProcessPalette();
  109. if( pDC != NULL ) Draw( pDC, nX, nY );
  111. return( TRUE );
  113. }
  115. BOOL CImageObject::GetImageInfo( const char *pszFilename, int *pnWidth,
  116. int *pnHeight, int *pnPlanes, int *pnBitsPerPixel, int *pnNumColors )
  117. {
  118. int nImageType;
  120. nImageType = FileType( pszFilename );
  121. if( nImageType == 0 ){
  122. m_nLastError = IMAGELIB_UNSUPPORTED_FILETYPE;
  123. return( FALSE );
  124. }
  126. switch( nImageType ){
  127. case IMAGETYPE_BMP:
  128. return( ::GetBMPInfo( pszFilename, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) );
  129. case IMAGETYPE_GIF:
  130. return( ::GetGIFInfo( pszFilename, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) );
  131. case IMAGETYPE_JPG:
  132. return( ::GetJPGInfo( pszFilename, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) );
  133. case IMAGETYPE_PCX:
  134. return( ::GetPCXInfo( pszFilename, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) );
  135. case IMAGETYPE_TGA:
  136. return( ::GetTGAInfo( pszFilename, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) );
  137. case IMAGETYPE_TIF:
  138. return( ::GetTIFInfo( pszFilename, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) );
  139. }
  141. return( FALSE );
  143. }
  145. int CImageObject::GetLastError( void )
  146. {
  148. return( m_nLastError );
  150. }
  152. BOOL CImageObject::Save( const char *pszFilename, int nType )
  153. {
  155. if( nType == -1 ) nType = ExtensionIndex( pszFilename );
  157. if( nType < IMAGETYPE_FIRSTTYPE || nType > IMAGETYPE_LASTTYPE ) return( FALSE );
  158. m_nImageType = nType;
  159. delete [] m_pszFilename;
  160. m_pszFilename = new char [strlen(pszFilename)+1];
  161. if( m_pszFilename != NULL ) strcpy( m_pszFilename, pszFilename );
  163. switch( m_nImageType ){
  164. case IMAGETYPE_BMP:
  165. return( ::SaveBMP( pszFilename, m_hDib ) );
  166. break;
  167. case IMAGETYPE_GIF:
  168. return( ::SaveGIF( pszFilename, m_hDib ) );
  169. break;
  170. case IMAGETYPE_JPG:
  171. return( ::SaveJPG( pszFilename, m_hDib, m_nQuality ) );
  172. break;
  173. case IMAGETYPE_PCX:
  174. return( ::SavePCX( pszFilename, m_hDib ) );
  175. break;
  176. case IMAGETYPE_TGA:
  177. return( ::SaveTGA( pszFilename, m_hDib ) );
  178. break;
  179. case IMAGETYPE_TIF:
  180. return( ::SaveTIF( pszFilename, m_hDib ) );
  181. break;
  182. }
  184. return( TRUE );
  186. }
  188. int CImageObject::ExtensionIndex( const char *pszFilename )
  189. {
  190. int Index = 0;
  191. char *pszExtension;
  193. pszExtension = (char *) &pszFilename[strlen(pszFilename)-4];
  195. while( szExtensions[Index][0] ){
  196. if( !stricmp( pszExtension, szExtensions[Index] ) ) return( Index + 1 );
  197. Index++;
  198. }
  200. return( -1 );
  202. }
  204. int CImageObject::GetWidth( void )
  205. {
  207. return( m_nWidth );
  209. }
  211. int CImageObject::GetHeight( void )
  212. {
  214. return( m_nHeight );
  216. }
  218. int CImageObject::GetNumBits( void )
  219. {
  221. return( m_nBits );
  223. }
  225. int CImageObject::GetNumColors( void )
  226. {
  228. return( m_nColors );
  230. }
  232. BOOL CImageObject::GetPaletteData( RGBQUAD *pRGBPalette )
  233. {
  235. m_nLastError = IMAGELIB_HDIB_NULL;
  236. if( m_hDib == NULL ) return( FALSE );
  238. char *pTemp;
  239. pTemp = (char *) ::GlobalLock( m_hDib );
  240. m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  241. if( pTemp == NULL ) return( FALSE );
  243. memcpy( pRGBPalette, &pTemp[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)], m_nPaletteBytes );
  245. m_nLastError = IMAGELIB_SUCCESS;
  246. ::GlobalUnlock( m_hDib );
  248. return( TRUE );
  250. }
  252. RGBQUAD *CImageObject::GetPaletteData( void )
  253. {
  254. m_nLastError = IMAGELIB_HDIB_NULL;
  255. if( m_hDib == NULL ) return( NULL );
  257. m_nLastError = IMAGELIB_NO_PALETTE_FOR_HIGH_COLOR;
  258. if( m_nColors <= 0 || m_nColors > 256 ) return( NULL );
  260. RGBQUAD *pRGBPalette;
  261. pRGBPalette = new RGBQUAD [m_nColors];
  262. if( pRGBPalette == NULL ){
  263. m_nLastError = IMAGELIB_MEMORY_ALLOCATION_ERROR;
  264. return( NULL );
  265. }
  267. char *pTemp;
  268. pTemp = (char *) ::GlobalLock( m_hDib );
  269. m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  270. if( pTemp == NULL ){
  271. delete [] pRGBPalette;
  272. return( NULL );
  273. }
  275. memcpy( pRGBPalette, &pTemp[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)], m_nColors * sizeof( RGBQUAD ) );
  277. m_nLastError = IMAGELIB_SUCCESS;
  278. ::GlobalUnlock( m_hDib );
  280. return( pRGBPalette );
  282. }
  284. int CImageObject::GetImageType( const char *pFilename )
  285. {
  287. return( ::FileType( pFilename ) );
  289. }
  291. int CImageObject::GetImageType( void )
  292. {
  294. return( m_nImageType );
  296. }
  298. BOOL CImageObject::Draw( CDC *pDC, int nX, int nY )
  299. {
  300. if( nX != -1 ) m_nX = nX;
  301. if( nY != -1 ) m_nY = nY;
  303. m_nLastError = IMAGELIB_HDIB_NULL;
  304. if( m_hDib == NULL ) return( FALSE );
  306. char *pTemp;
  307. pTemp = (char *) ::GlobalLock( m_hDib );
  308. m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  309. if( pTemp == NULL ) return( NULL );
  310. BITMAPINFOHEADER *pBIH;
  311. pBIH = (BITMAPINFOHEADER *) &pTemp[sizeof(BITMAPFILEHEADER)];
  313. int nRet = ::StretchDIBits( pDC->m_hDC, m_nX, m_nY, m_nWidth, m_nHeight, 0, 0, m_nWidth, m_nHeight, (const void FAR *) &pTemp[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+m_nPaletteBytes], (BITMAPINFO *) pBIH, DIB_RGB_COLORS, SRCCOPY );
  315. ::GlobalUnlock( m_hDib );
  316. m_nLastError = IMAGELIB_STRETCHDIBITS_ERROR;
  317. if( nRet != m_nHeight ) return( FALSE );
  318. m_nLastError = IMAGELIB_SUCCESS;
  320. return( TRUE );
  322. }
  324. LOGPALETTE *CImageObject::CreateLogPalette( RGBQUAD *pPalette, int nNumColors )
  325. {
  326. LOGPALETTE *pLogPal;
  327. int i;
  329. if( pPalette == NULL ) return( NULL );
  331. pLogPal = (LOGPALETTE *) new char [sizeof(LOGPALETTE)+nNumColors*sizeof(PALETTEENTRY)];
  332. if( pLogPal == NULL ) return( NULL );
  334. pLogPal->palVersion = 0x300;
  335. pLogPal->palNumEntries = (unsigned short) nNumColors;
  336. for( i=0; i<nNumColors; i++ ){
  337. pLogPal->palPalEntry[i].peRed = pPalette[i].rgbRed;
  338. pLogPal->palPalEntry[i].peGreen = pPalette[i].rgbGreen;
  339. pLogPal->palPalEntry[i].peBlue = pPalette[i].rgbBlue;
  340. pLogPal->palPalEntry[i].peFlags = 0;
  341. }
  343. return( pLogPal );
  345. }
  347. void CImageObject::ProcessImageHeader( void )
  348. {
  350. m_nLastError = IMAGELIB_HDIB_NULL;
  351. if( m_hDib == NULL ) return;
  353. char *pTemp;
  354. BITMAPINFOHEADER *pBIH;
  355. pTemp = (char *) ::GlobalLock( m_hDib );
  356. m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  357. if( pTemp == NULL ) return;
  359. pBIH = (BITMAPINFOHEADER *) &pTemp[sizeof(BITMAPFILEHEADER)];
  360. m_nWidth = pBIH->biWidth;
  361. m_nHeight = pBIH->biHeight;
  362. m_nPlanes = pBIH->biPlanes;
  363. m_nBits = pBIH->biBitCount;
  364. m_nColors = 1 << m_nBits;
  365. if( m_nPlanes > 1 ) m_nColors <<= ( m_nPlanes - 1 );
  366. if( m_nBits >= 16 ) m_nColors = 0;
  368. ::GlobalUnlock( m_hDib );
  370. m_nLastError = IMAGELIB_SUCCESS;
  372. }
  374. void CImageObject::ProcessPalette( void )
  375. {
  377. m_nLastError = IMAGELIB_HDIB_NULL;
  378. if( m_hDib == NULL ) return;
  380. CWindowDC WindowDC( NULL );
  381. m_nScreenPlanes = WindowDC.GetDeviceCaps( PLANES );
  382. m_nScreenBits = WindowDC.GetDeviceCaps( BITSPIXEL );
  384. m_nPaletteBytes = 0;
  385. m_Palette.DeleteObject();
  387. if( m_nBits <= 8 ) m_nPaletteBytes = m_nColors * sizeof( RGBQUAD );
  388. if( m_nScreenBits >= 16 ) return;
  390. char *pTemp;
  391. pTemp = (char *) ::GlobalLock( m_hDib );
  392. m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  393. if( pTemp == NULL ) return;
  395. if( m_nBits <= 8 ){
  396. RGBQUAD *pRGBPalette;
  397. pRGBPalette = (RGBQUAD *) &pTemp[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  398. LOGPALETTE *pPalette;
  399. pPalette = CreateLogPalette( pRGBPalette, m_nColors );
  400. if( pPalette == NULL ){
  401. m_nLastError = IMAGELIB_LOGICAL_PALETTE_CREATION_ERROR;
  402. goto ProcessPaletteExit;
  403. }
  404. m_Palette.CreatePalette( pPalette );
  405. delete [] pPalette;
  406. }
  408. m_nLastError = IMAGELIB_SUCCESS;
  410. ProcessPaletteExit:
  411. ::GlobalUnlock( m_hDib );
  413. }
  415. void CImageObject::KillImage( void )
  416. {
  418. if( m_hDib ) ::GlobalFree( m_hDib );
  419. m_hDib = NULL;
  421. if( m_pLogPal != NULL ) delete [] m_pLogPal;
  422. m_pLogPal = NULL;
  424. if( m_pszFilename != NULL ) delete [] m_pszFilename;
  425. m_pszFilename = NULL;
  427. m_Palette.DeleteObject();
  429. }
  431. BOOL CImageObject::SetPalette( CDC *pDC )
  432. {
  434. m_nLastError = IMAGELIB_HDIB_NULL;
  435. if( m_hDib == NULL ) return( FALSE );
  437. pDC->SelectPalette( &m_Palette, FALSE );
  438. pDC->RealizePalette();
  440. m_nLastError = IMAGELIB_SUCCESS;
  442. return( TRUE );
  444. }
  446. BOOL CImageObject::IsLoaded( void )
  447. {
  449. return( m_hDib != NULL );
  451. }
  453. void *CImageObject::GetDIBPointer( int *nWidthBytes, int nNewBits, int *nNewWidthBytes, int nNewWidth )
  454. {
  456. m_nLastError = IMAGELIB_HDIB_NULL;
  457. if( m_hDib == NULL ) return( NULL );
  459. void *pTemp;
  460. pTemp = ::GlobalLock( m_hDib );
  461. m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  462. if( pTemp == NULL ) return( NULL );
  464. if( nWidthBytes != NULL ) *nWidthBytes = WidthBytes( m_nBits, m_nWidth );
  466. if( nNewWidthBytes != NULL ){
  467. if( nNewWidth == -1 ) nNewWidth = m_nWidth;
  468. *nNewWidthBytes = WidthBytes( nNewBits, nNewWidth );
  469. }
  471. return( pTemp );
  473. }
  475. int CImageObject::WidthBytes( int nBits, int nWidth )
  476. {
  477. int nWidthBytes;
  479. nWidthBytes = nWidth;
  480. if( nBits == 1 ) nWidthBytes = ( nWidth + 7 ) / 8;
  481. else if( nBits == 4 ) nWidthBytes = ( nWidth + 1 ) / 2;
  482. else if( nBits == 16 ) nWidthBytes = nWidth * 2;
  483. else if( nBits == 24 ) nWidthBytes = nWidth * 3;
  484. else if( nBits == 32 ) nWidthBytes = nWidth * 4;
  485. while( ( nWidthBytes & 3 ) != 0 ) nWidthBytes++;
  487. return( nWidthBytes );
  489. }
  491. BOOL CImageObject::Crop( int nX1, int nY1, int nX2, int nY2 )
  492. {
  494. NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2 );
  496. if( nX2 - nX1 + 1 == m_nWidth && nY2 - nY1 + 1 == m_nHeight ) return( TRUE );
  498. unsigned char *pOldBuffer, *pNewBuffer;
  499. HGLOBAL hNewMemory;
  500. DWORD dwNewMemorySize;
  501. BITMAPFILEHEADER *pOldBFH, *pNewBFH;
  502. BITMAPINFOHEADER *pOldBIH, *pNewBIH;
  503. RGBQUAD *pOldPalette, *pNewPalette;
  504. unsigned char *pOldBits, *pNewBits, *pOldTemp, *pNewTemp;
  505. int nOldWidthBytes, nNewWidthBytes;
  506. int nNumColors, y, nPixelBytes;
  508. pOldBuffer = (unsigned char *) GetDIBPointer( &nOldWidthBytes, m_nBits, &nNewWidthBytes, nX2 - nX1 + 1 );
  509. if( pOldBuffer == NULL ) return( FALSE );
  511. pOldBFH = (BITMAPFILEHEADER *) pOldBuffer;
  512. pOldBIH = (BITMAPINFOHEADER *) &pOldBuffer[sizeof(BITMAPFILEHEADER)];
  513. nNumColors = m_nColors;
  514. pOldPalette = (RGBQUAD *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  515. pOldBits = (unsigned char *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  517. dwNewMemorySize = (DWORD) nNumColors * sizeof( RGBQUAD ) + sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNewWidthBytes * ( nY2 - nY1 + 1 );
  518. m_nLastError = IMAGELIB_MEMORY_ALLOCATION_ERROR;
  519. hNewMemory = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwNewMemorySize );
  520. if( hNewMemory == NULL ){
  521. ::GlobalUnlock( m_hDib );
  522. return( FALSE );
  523. }
  525. m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  526. pNewBuffer = (unsigned char *) ::GlobalLock( hNewMemory );
  527. if( pNewBuffer == NULL ){
  528. ::GlobalFree( hNewMemory );
  529. ::GlobalUnlock( m_hDib );
  530. return( FALSE );
  531. }
  533. pNewBFH = (BITMAPFILEHEADER *) pNewBuffer;
  534. pNewBIH = (BITMAPINFOHEADER *) &pNewBuffer[sizeof(BITMAPFILEHEADER)];
  535. pNewPalette = (RGBQUAD *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  536. pNewBits = (unsigned char *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  538. *pNewBFH = *pOldBFH;
  539. *pNewBIH = *pOldBIH;
  540. pNewBIH->biSizeImage = 0;
  541. pNewBIH->biWidth = nX2 - nX1 + 1;
  542. pNewBIH->biHeight = nY2 - nY1 + 1;
  543. if( nNumColors != 0 ) memcpy( pNewPalette, pOldPalette, nNumColors * sizeof( RGBQUAD ) );
  545. nPixelBytes = 1;
  546. if( pOldBIH->biBitCount == 16 ) nPixelBytes = 2;
  547. else if( pOldBIH->biBitCount == 24 ) nPixelBytes = 3;
  548. else if( pOldBIH->biBitCount == 32 ) nPixelBytes = 4;
  550. for( y=0; y<pNewBIH->biHeight; y++ ){
  551. pOldTemp = pOldBits;
  552. pOldTemp += ( ( pOldBIH->biHeight - 1 - ( y + nY1 ) ) * nOldWidthBytes );
  553. pOldTemp += ( nPixelBytes * nX1 );
  554. pNewTemp = pNewBits;
  555. pNewTemp += ( ( pNewBIH->biHeight - 1 - y ) * nNewWidthBytes );
  556. memcpy( pNewTemp, pOldTemp, nNewWidthBytes );
  557. pNewBIH->biSizeImage += nNewWidthBytes;
  558. }
  560. m_nWidth = pNewBIH->biWidth;
  561. m_nHeight = pNewBIH->biHeight;
  562. ::GlobalUnlock( m_hDib );
  563. ::GlobalUnlock( hNewMemory );
  564. ::GlobalFree( m_hDib );
  565. m_hDib = hNewMemory;
  567. m_nLastError = IMAGELIB_SUCCESS;
  569. return( TRUE );
  571. }
  573. void CImageObject::NormalizeCoordinates( int *nX1, int *nY1, int *nX2, int *nY2, BOOL *bCompleteImage, BOOL *bLessThanHalf )
  574. {
  576. if( *nX1 == -1 ) *nX1 = 0;
  577. if( *nY1 == -1 ) *nY1 = 0;
  578. if( *nX2 == -1 ) *nX2 = m_nWidth - 1;
  579. if( *nY2 == -1 ) *nY2 = m_nHeight - 1;
  581. if( *nX1 > *nX2 ){
  582. int nTemp;
  583. nTemp = *nX1;
  584. *nX1 = *nX2;
  585. *nX2 = nTemp;
  586. }
  588. if( *nY1 > *nY2 ){
  589. int nTemp;
  590. nTemp = *nY1;
  591. *nY1 = *nY2;
  592. *nY2 = nTemp;
  593. }
  595. if( *nX1 < 0 ) *nX1 = 0;
  596. if( *nX2 > m_nWidth - 1 ) *nX2 = m_nWidth - 1;
  598. if( *nX2 < 0 ) *nX2 = 0;
  599. if( *nX2 > m_nWidth - 1 ) *nX2 = m_nWidth - 1;
  601. if( *nY1 < 0 ) *nY1 = 0;
  602. if( *nY1 > m_nHeight - 1 ) *nY1 = m_nHeight - 1;
  604. if( *nY2 < 0 ) *nY2 = 0;
  605. if( *nY2 > m_nHeight - 1 ) *nY2 = m_nHeight - 1;
  607. if( bCompleteImage != NULL ) *bCompleteImage = TRUE;
  608. if( bLessThanHalf != NULL ) *bLessThanHalf = FALSE;
  609. if( *nX1 > 0 || *nY1 > 0 || *nX2 < m_nWidth - 1 || *nY2 < m_nHeight - 1 ){
  610. if( bCompleteImage != NULL ) *bCompleteImage = FALSE;
  611. DWORD dwTotalPixels, dwThesePixels;
  612. dwTotalPixels = (DWORD) m_nWidth * m_nHeight;
  613. dwThesePixels = (DWORD) ( (*nX2) - (*nX1) + 1 ) * (DWORD) ( (*nY2) - (*nY1) + 1 );
  614. if( bLessThanHalf != NULL && dwThesePixels <= dwTotalPixels / 2 ) *bLessThanHalf = TRUE;
  615. }
  617. }
  619. BOOL CImageObject::Stretch( int nNewWidth, int nNewHeight )
  620. {
  622. if( nNewWidth == m_nWidth && nNewHeight == m_nHeight ) return( TRUE );
  624. unsigned char *pOldBuffer, *pNewBuffer, *pOldTemp, *pNewTemp;
  625. HGLOBAL hNewMemory;
  626. DWORD dwNewMemorySize;
  627. BITMAPFILEHEADER *pOldBFH, *pNewBFH;
  628. BITMAPINFOHEADER *pOldBIH, *pNewBIH;
  629. RGBQUAD *pOldPalette, *pNewPalette;
  630. unsigned char *pOldBits, *pNewBits;
  631. int nOldWidthBytes, nNewWidthBytes;
  632. int nNumColors;
  633. int x, y, xx, yy;
  634. unsigned char Data;
  636. pOldBuffer = (unsigned char *) GetDIBPointer( &nOldWidthBytes, m_nBits, &nNewWidthBytes, nNewWidth );
  637. if( pOldBuffer == NULL ) return( FALSE );
  639. pOldBFH = (BITMAPFILEHEADER *) pOldBuffer;
  640. pOldBIH = (BITMAPINFOHEADER *) &pOldBuffer[sizeof(BITMAPFILEHEADER)];
  641. nNumColors = m_nColors;
  642. pOldPalette = (RGBQUAD *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  643. pOldBits = (unsigned char *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  645. dwNewMemorySize = (DWORD) nNumColors * sizeof( RGBQUAD ) + sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNewWidthBytes * nNewHeight;
  646. m_nLastError = IMAGELIB_MEMORY_ALLOCATION_ERROR;
  647. hNewMemory = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwNewMemorySize );
  648. if( hNewMemory == NULL ){
  649. ::GlobalUnlock( m_hDib );
  650. return( FALSE );
  651. }
  653. m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  654. pNewBuffer = (unsigned char *) ::GlobalLock( hNewMemory );
  655. if( pNewBuffer == NULL ){
  656. ::GlobalFree( hNewMemory );
  657. ::GlobalUnlock( m_hDib );
  658. return( FALSE );
  659. }
  661. pNewBFH = (BITMAPFILEHEADER *) pNewBuffer;
  662. pNewBIH = (BITMAPINFOHEADER *) &pNewBuffer[sizeof(BITMAPFILEHEADER)];
  663. pNewPalette = (RGBQUAD *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  664. pNewBits = (unsigned char *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  666. *pNewBFH = *pOldBFH;
  667. *pNewBIH = *pOldBIH;
  668. pNewBIH->biSizeImage = nNewWidthBytes * nNewHeight;
  669. pNewBIH->biWidth = nNewWidth;
  670. pNewBIH->biHeight = nNewHeight;
  671. if( nNumColors != 0 ) memcpy( pNewPalette, pOldPalette, nNumColors * sizeof( RGBQUAD ) );
  673. m_nWidth = nNewWidth;
  674. m_nHeight = nNewHeight;
  676. switch( m_nBits ){
  677. case 1:
  678. for( y=0; y<nNewHeight; y++ ){
  679. yy = ( pOldBIH->biHeight * y ) / nNewHeight;
  680. pOldTemp = pOldBits;
  681. pOldTemp += ( ( pOldBIH->biHeight - 1 - yy ) * nOldWidthBytes );
  682. pNewTemp = pNewBits;
  683. pNewTemp += ( ( nNewHeight - 1 - y ) * nNewWidthBytes );
  684. for( x=0; x<nNewWidth; x++ ){
  685. xx = ( pOldBIH->biWidth * x ) / nNewWidth;
  686. Data = pOldTemp[xx/8];
  687. Data >>= ( 7 - ( xx & 7 ) );
  688. Data &= 0x01;
  689. Data <<= ( 7 - ( x & 7 ) );
  690. pNewTemp[x/8] |= Data;
  691. }
  692. }
  693. break;
  694. case 4:
  695. for( y=0; y<nNewHeight; y++ ){
  696. yy = ( pOldBIH->biHeight * y ) / nNewHeight;
  697. pOldTemp = pOldBits;
  698. pOldTemp += ( ( pOldBIH->biHeight - 1 - yy ) * nOldWidthBytes );
  699. pNewTemp = pNewBits;
  700. pNewTemp += ( ( nNewHeight - 1 - y ) * nNewWidthBytes );
  701. for( x=0; x<nNewWidth; x++ ){
  702. xx = ( pOldBIH->biWidth * x ) / nNewWidth;
  703. Data = pOldTemp[xx/2];
  704. if( !( xx & 1 ) ) Data >>= 4;
  705. else Data &= 0x0f;
  706. if( !( x & 1 ) ) Data <<= 4;
  707. pNewTemp[x/2] |= Data;
  708. }
  709. }
  710. break;
  711. case 8:
  712. for( y=0; y<nNewHeight; y++ ){
  713. yy = ( pOldBIH->biHeight * y ) / nNewHeight;
  714. pOldTemp = pOldBits;
  715. pOldTemp += ( ( pOldBIH->biHeight - 1 - yy ) * nOldWidthBytes );
  716. pNewTemp = pNewBits;
  717. pNewTemp += ( ( nNewHeight - 1 - y ) * nNewWidthBytes );
  718. for( x=0; x<nNewWidth; x++ ){
  719. xx = ( pOldBIH->biWidth * x ) / nNewWidth;
  720. pNewTemp[x] = pOldTemp[xx];
  721. }
  722. }
  723. break;
  724. case 16:
  725. for( y=0; y<nNewHeight; y++ ){
  726. yy = ( pOldBIH->biHeight * y ) / nNewHeight;
  727. pOldTemp = pOldBits;
  728. pOldTemp += ( ( pOldBIH->biHeight - 1 - yy ) * nOldWidthBytes );
  729. pNewTemp = pNewBits;
  730. pNewTemp += ( ( nNewHeight - 1 - y ) * nNewWidthBytes );
  731. for( x=0; x<nNewWidth; x++ ){
  732. xx = ( pOldBIH->biWidth * x ) / nNewWidth;
  733. pNewTemp[x*2] = pOldTemp[xx*2];
  734. pNewTemp[x*2+1] = pOldTemp[xx*2+1];
  735. }
  736. }
  737. break;
  738. case 24:
  739. for( y=0; y<nNewHeight; y++ ){
  740. yy = ( pOldBIH->biHeight * y ) / nNewHeight;
  741. pOldTemp = pOldBits;
  742. pOldTemp += ( ( pOldBIH->biHeight - 1 - yy ) * nOldWidthBytes );
  743. pNewTemp = pNewBits;
  744. pNewTemp += ( ( nNewHeight - 1 - y ) * nNewWidthBytes );
  745. for( x=0; x<nNewWidth; x++ ){
  746. xx = ( pOldBIH->biWidth * x ) / nNewWidth;
  747. pNewTemp[x*3] = pOldTemp[xx*3];
  748. pNewTemp[x*3+1] = pOldTemp[xx*3+1];
  749. pNewTemp[x*3+2] = pOldTemp[xx*3+2];
  750. }
  751. }
  752. break;
  753. case 32:
  754. for( y=0; y<nNewHeight; y++ ){
  755. yy = ( pOldBIH->biHeight * y ) / nNewHeight;
  756. pOldTemp = pOldBits;
  757. pOldTemp += ( ( pOldBIH->biHeight - 1 - yy ) * nOldWidthBytes );
  758. pNewTemp = pNewBits;
  759. pNewTemp += ( ( nNewHeight - 1 - y ) * nNewWidthBytes );
  760. for( x=0; x<nNewWidth; x++ ){
  761. xx = ( pOldBIH->biWidth * x ) / nNewWidth;
  762. pNewTemp[x*4] = pOldTemp[xx*4];
  763. pNewTemp[x*4+1] = pOldTemp[xx*4+1];
  764. pNewTemp[x*4+2] = pOldTemp[xx*4+2];
  765. pNewTemp[x*4+3] = pOldTemp[xx*4+3];
  766. }
  767. }
  768. break;
  769. }
  771. ::GlobalUnlock( m_hDib );
  772. ::GlobalUnlock( hNewMemory );
  773. ::GlobalFree( m_hDib );
  774. m_hDib = hNewMemory;
  776. m_nLastError = IMAGELIB_SUCCESS;
  778. return( TRUE );
  780. }
  782. void CImageObject::operator= (const CImageObject &ImageObject)
  783. {
  785. KillImage();
  787. m_nWidth = ImageObject.m_nWidth;
  788. m_nHeight = ImageObject.m_nHeight;
  789. m_nPlanes = ImageObject.m_nPlanes;
  790. m_nBits = ImageObject.m_nBits;
  791. m_nColors = ImageObject.m_nColors;
  792. m_nImageType = ImageObject.m_nImageType;
  793. m_nX = ImageObject.m_nX;
  794. m_nY = ImageObject.m_nY;
  795. m_nLastError = ImageObject.m_nLastError;
  796. m_nScreenPlanes = ImageObject.m_nScreenPlanes;
  797. m_nScreenBits = ImageObject.m_nScreenBits;
  798. m_nPaletteBytes = ImageObject.m_nPaletteBytes;
  799. m_nQuality = ImageObject.m_nQuality;
  800. m_nPaletteCreationType = ImageObject.m_nPaletteCreationType;
  802. int nNumColors = m_nColors;
  803. int nWidthBytes = WidthBytes( m_nBits, m_nWidth );
  805. if( ImageObject.m_hDib != NULL ){
  807. DWORD dwSize = ::GlobalSize( ImageObject.m_hDib );
  809. char *pData = (char *) ::GlobalLock( ImageObject.m_hDib );
  810. if( pData != NULL ){
  812. HGLOBAL hGlobal = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwSize );
  813. if( hGlobal != NULL ){
  815. char *pDestData = (char *) ::GlobalLock( hGlobal );
  816. if( pDestData != NULL ){
  818. memcpy( pDestData, pData, dwSize );
  820. if( nNumColors != 0 ) CreatePaletteFromDIB( (RGBQUAD *) &pData[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)], nNumColors );
  822. else if( ImageObject.m_pLogPal != NULL ){
  823. m_pLogPal = (LOGPALETTE *) new char [sizeof(LOGPALETTE)+ImageObject.m_pLogPal->palNumEntries*sizeof(PALETTEENTRY)];
  824. if( m_pLogPal != NULL ){
  825. for( int i=0; i<ImageObject.m_pLogPal->palNumEntries; i++ ) m_pLogPal[i] = ImageObject.m_pLogPal[i];
  826. m_Palette.CreatePalette( m_pLogPal );
  827. }
  828. }
  830. ::GlobalUnlock( hGlobal );
  831. m_hDib = hGlobal;
  832. }
  833. else ::GlobalFree( hGlobal );
  834. }
  835. ::GlobalUnlock( ImageObject.m_hDib );
  836. }
  837. }
  839. if( ImageObject.m_pszFilename != NULL ){
  840. m_pszFilename = new char [strlen(ImageObject.m_pszFilename)+1];
  841. strcpy( m_pszFilename, ImageObject.m_pszFilename );
  842. }
  844. }
  846. void CImageObject::CreatePaletteFromDIB( RGBQUAD *pRGBPalette, int nNumColors )
  847. {
  849. if( pRGBPalette != NULL ){
  850. LOGPALETTE *pPalette;
  851. pPalette = CreateLogPalette( pRGBPalette, nNumColors );
  852. if( pPalette != NULL ){
  853. m_Palette.CreatePalette( pPalette );
  854. delete [] pPalette;
  855. }
  856. else m_nLastError = IMAGELIB_LOGICAL_PALETTE_CREATION_ERROR;
  857. }
  859. }
  861. int CImageObject::GetNearestIndex( unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue, RGBQUAD *pRGBPalette, int nNumColors )
  862. {
  863. int i, Index = 0;
  864. DWORD NewDiff, Diff = 100000L;
  865. DWORD Red, Green, Blue;
  867. for( i=0; i<nNumColors; i++ ){
  868. if( ucRed > pRGBPalette[i].rgbRed ) Red = (DWORD) ( pRGBPalette[i].rgbRed - ucRed );
  869. else Red = (DWORD) ( ucRed - pRGBPalette[i].rgbRed );
  870. if( ucGreen > pRGBPalette[i].rgbGreen ) Green = (DWORD) ( pRGBPalette[i].rgbGreen - ucGreen );
  871. else Green = (DWORD) ( ucGreen - pRGBPalette[i].rgbGreen );
  872. if( ucBlue > pRGBPalette[i].rgbBlue ) Blue = (DWORD) ( pRGBPalette[i].rgbBlue - ucBlue );
  873. else Blue = (DWORD) ( ucBlue - pRGBPalette[i].rgbBlue );
  874. NewDiff = ( Red * Red ) + ( Green * Green ) + ( Blue * Blue );
  875. if( NewDiff < Diff ){
  876. if( NewDiff <= 1 ) return( i );
  877. Diff = NewDiff;
  878. Index = i;
  879. }
  880. }
  882. return( Index );
  884. }
  886. BOOL CImageObject::Rotate( int nDegrees )
  887. {
  889. m_nLastError = IMAGELIB_HDIB_NULL;
  890. if( m_hDib == NULL ) return( FALSE );
  892. m_nLastError = IMAGELIB_ROTATE_ERROR;
  893. switch( nDegrees ){
  894. case 90:
  895. if( !RotateIt( nDegrees ) ) return( FALSE );
  896. break;
  897. case 180:
  898. if( !Invert() ) return( FALSE );
  899. if( !Reverse() ) return( FALSE );
  900. break;
  901. case 270:
  902. if( !RotateIt( nDegrees ) ) return( FALSE );
  903. break;
  904. default:
  905. m_nLastError = IMAGELIB_ROTATION_VALUE_ERROR;
  906. return( FALSE );
  907. }
  909. m_nLastError = IMAGELIB_SUCCESS;
  911. return( TRUE );
  913. }
  915. BOOL CImageObject::RotateIt( int nDegrees )
  916. {
  918. int nNewWidth, nNewHeight;
  919. nNewWidth = m_nHeight;
  920. nNewHeight = m_nWidth;
  922. unsigned char *pOldBuffer, *pNewBuffer;
  923. HGLOBAL hNewMemory;
  924. DWORD dwNewMemorySize;
  925. BITMAPFILEHEADER *pOldBFH, *pNewBFH;
  926. BITMAPINFOHEADER *pOldBIH, *pNewBIH;
  927. RGBQUAD *pOldPalette, *pNewPalette;
  928. unsigned char *pOldBits, *pNewBits;
  929. int nOldWidthBytes, nNewWidthBytes;
  930. int nNumColors;
  932. pOldBuffer = (unsigned char *) GetDIBPointer( &nOldWidthBytes, m_nBits, &nNewWidthBytes, nNewWidth );
  933. if( pOldBuffer == NULL ) return( FALSE );
  935. pOldBFH = (BITMAPFILEHEADER *) pOldBuffer;
  936. pOldBIH = (BITMAPINFOHEADER *) &pOldBuffer[sizeof(BITMAPFILEHEADER)];
  937. nNumColors = m_nColors;
  938. pOldPalette = (RGBQUAD *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  939. pOldBits = (unsigned char *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  941. dwNewMemorySize = (DWORD) nNumColors * sizeof( RGBQUAD ) + sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNewWidthBytes * nNewHeight;
  942. m_nLastError = IMAGELIB_MEMORY_ALLOCATION_ERROR;
  943. hNewMemory = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwNewMemorySize );
  944. if( hNewMemory == NULL ){
  945. ::GlobalUnlock( m_hDib );
  946. return( FALSE );
  947. }
  949. m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  950. pNewBuffer = (unsigned char *) ::GlobalLock( hNewMemory );
  951. if( pNewBuffer == NULL ){
  952. ::GlobalFree( hNewMemory );
  953. ::GlobalUnlock( m_hDib );
  954. return( FALSE );
  955. }
  957. pNewBFH = (BITMAPFILEHEADER *) pNewBuffer;
  958. pNewBIH = (BITMAPINFOHEADER *) &pNewBuffer[sizeof(BITMAPFILEHEADER)];
  959. pNewPalette = (RGBQUAD *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  960. pNewBits = (unsigned char *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  962. *pNewBFH = *pOldBFH;
  963. *pNewBIH = *pOldBIH;
  964. pNewBIH->biSizeImage = nNewWidthBytes * nNewHeight;
  965. pNewBIH->biWidth = nNewWidth;
  966. pNewBIH->biHeight = nNewHeight;
  967. if( nNumColors != 0 ) memcpy( pNewPalette, pOldPalette, nNumColors * sizeof( RGBQUAD ) );
  969. m_nWidth = nNewWidth;
  970. m_nHeight = nNewHeight;
  972. if( nDegrees == 90 ) Rotate90( pNewBits, pOldBits );
  973. else Rotate270( pNewBits, pOldBits );
  975. ::GlobalUnlock( m_hDib );
  976. ::GlobalUnlock( hNewMemory );
  977. ::GlobalFree( m_hDib );
  978. m_hDib = hNewMemory;
  980. m_nLastError = IMAGELIB_SUCCESS;
  982. return( TRUE );
  984. }
  986. void CImageObject::Rotate90( unsigned char *pNewBits, unsigned char *pOldBits )
  987. {
  989. int nOldWidth, nOldHeight, nOldWidthBytes, nNewWidthBytes;
  990. nOldWidth = m_nHeight;
  991. nOldHeight = m_nWidth;
  993. unsigned char *pTemp;
  994. unsigned char Data, Data1, Data2, Data3, Data4, Mask, Shift;
  995. int x, y;
  997. switch( m_nBits ){
  998. case 1:
  999. nOldWidthBytes = ( nOldWidth + 7 ) / 8;
  1000. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1001. nNewWidthBytes = ( m_nWidth + 7 ) / 8;
  1002. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1003. for( y=0; y<m_nHeight; y++ ){
  1004. pTemp = pNewBits;
  1005. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1006. for( x=0; x<m_nWidth; x++ ){
  1007. Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+(y/8)];
  1008. Data >>= ( 7 - ( y & 7 ) );
  1009. Data &= 0x01;
  1010. Shift = ( 7 - ( ( m_nWidth - 1 - x ) & 7 ) );
  1011. Mask = 1 << Shift;
  1012. Data <<= Shift;
  1013. pTemp[(m_nWidth-1-x)/8] &= ( Mask ^ 0xff );
  1014. pTemp[(m_nWidth-1-x)/8] |= Data;
  1015. }
  1016. }
  1017. break;
  1018. case 4:
  1019. nOldWidthBytes = ( nOldWidth + 1 ) / 2;
  1020. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1021. nNewWidthBytes = ( m_nWidth + 1 ) / 2;
  1022. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1023. for( y=0; y<m_nHeight; y++ ){
  1024. pTemp = pNewBits;
  1025. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1026. for( x=0; x<m_nWidth; x++ ){
  1027. Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+(y/2)];
  1028. if( !( y & 1 ) ) Data >>= 4;
  1029. else Data &= 0x0f;
  1030. if( ( x & 1 ) ){
  1031. Data <<= 4;
  1032. pTemp[(m_nWidth-1-x)/2] &= 0x0f;
  1033. pTemp[(m_nWidth-1-x)/2] |= Data;
  1034. }
  1035. else{
  1036. pTemp[(m_nWidth-1-x)/2] &= 0xf0;
  1037. pTemp[(m_nWidth-1-x)/2] |= Data;
  1038. }
  1039. }
  1040. }
  1041. break;
  1042. case 8:
  1043. nOldWidthBytes = nOldWidth;
  1044. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1045. nNewWidthBytes = m_nWidth;
  1046. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1047. for( y=0; y<m_nHeight; y++ ){
  1048. pTemp = pNewBits;
  1049. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1050. for( x=0; x<m_nWidth; x++ ){
  1051. Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y];
  1052. pTemp[m_nWidth-1-x] = Data;
  1053. }
  1054. }
  1055. break;
  1056. case 16:
  1057. nOldWidthBytes = nOldWidth * 2;
  1058. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1059. nNewWidthBytes = m_nWidth * 2;
  1060. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1061. for( y=0; y<m_nHeight; y++ ){
  1062. pTemp = pNewBits;
  1063. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1064. for( x=0; x<m_nWidth; x++ ){
  1065. Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*2];
  1066. Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*2+1];
  1067. pTemp[(m_nWidth-1-x)*2] = Data1;
  1068. pTemp[(m_nWidth-1-x)*2+1] = Data2;
  1069. }
  1070. }
  1071. break;
  1072. case 24:
  1073. nOldWidthBytes = nOldWidth * 3;
  1074. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1075. nNewWidthBytes = m_nWidth * 3;
  1076. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1077. for( y=0; y<m_nHeight; y++ ){
  1078. pTemp = pNewBits;
  1079. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1080. for( x=0; x<m_nWidth; x++ ){
  1081. Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*3];
  1082. Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*3+1];
  1083. Data3 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*3+2];
  1084. pTemp[(m_nWidth-1-x)*3] = Data1;
  1085. pTemp[(m_nWidth-1-x)*3+1] = Data2;
  1086. pTemp[(m_nWidth-1-x)*3+2] = Data3;
  1087. }
  1088. }
  1089. break;
  1090. case 32:
  1091. nOldWidthBytes = nOldWidth * 4;
  1092. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1093. nNewWidthBytes = m_nWidth * 4;
  1094. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1095. for( y=0; y<m_nHeight; y++ ){
  1096. pTemp = pNewBits;
  1097. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1098. for( x=0; x<m_nWidth; x++ ){
  1099. Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*4];
  1100. Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*4+1];
  1101. Data3 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*4+2];
  1102. Data4 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*4+3];
  1103. pTemp[(m_nWidth-1-x)*4] = Data1;
  1104. pTemp[(m_nWidth-1-x)*4+1] = Data2;
  1105. pTemp[(m_nWidth-1-x)*4+2] = Data3;
  1106. pTemp[(m_nWidth-1-x)*4+3] = Data4;
  1107. }
  1108. }
  1109. break;
  1110. }
  1112. }
  1114. void CImageObject::Rotate270( unsigned char *pNewBits, unsigned char *pOldBits )
  1115. {
  1117. int nOldWidth, nOldHeight, nOldWidthBytes, nNewWidthBytes;
  1118. nOldWidth = m_nHeight;
  1119. nOldHeight = m_nWidth;
  1121. unsigned char *pTemp;
  1122. unsigned char Data, Data1, Data2, Data3, Data4, Mask, Shift;
  1123. int x, y, yy;
  1125. switch( m_nBits ){
  1126. case 1:
  1127. nOldWidthBytes = ( nOldWidth + 7 ) / 8;
  1128. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1129. nNewWidthBytes = ( m_nWidth + 7 ) / 8;
  1130. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1131. for( y=0; y<m_nHeight; y++ ){
  1132. yy = m_nHeight - 1 - y;
  1133. pTemp = pNewBits;
  1134. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1135. for( x=0; x<m_nWidth; x++ ){
  1136. Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+(yy/8)];
  1137. Data >>= ( 7 - ( yy & 7 ) );
  1138. Data &= 0x01;
  1139. Shift = ( 7 - ( x & 7 ) );
  1140. Mask = 1 << Shift;
  1141. Data <<= Shift;
  1142. pTemp[x/8] &= ( Mask ^ 0xff );
  1143. pTemp[x/8] |= Data;
  1144. }
  1145. }
  1146. break;
  1147. case 4:
  1148. nOldWidthBytes = ( nOldWidth + 1 ) / 2;
  1149. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1150. nNewWidthBytes = ( m_nWidth + 1 ) / 2;
  1151. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1152. for( y=0; y<m_nHeight; y++ ){
  1153. yy = m_nHeight - 1 - y;
  1154. pTemp = pNewBits;
  1155. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1156. for( x=0; x<m_nWidth; x++ ){
  1157. Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+(yy/2)];
  1158. if( !( yy & 1 ) ) Data >>= 4;
  1159. else Data &= 0x0f;
  1160. if( !( x & 1 ) ){
  1161. Data <<= 4;
  1162. pTemp[x/2] &= 0x0f;
  1163. pTemp[x/2] |= Data;
  1164. }
  1165. else{
  1166. pTemp[x/2] &= 0xf0;
  1167. pTemp[x/2] |= Data;
  1168. }
  1169. }
  1170. }
  1171. break;
  1172. case 8:
  1173. nOldWidthBytes = nOldWidth;
  1174. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1175. nNewWidthBytes = m_nWidth;
  1176. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1177. for( y=0; y<m_nHeight; y++ ){
  1178. yy = m_nHeight - 1 - y;
  1179. pTemp = pNewBits;
  1180. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1181. for( x=0; x<m_nWidth; x++ ){
  1182. Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy];
  1183. pTemp[x] = Data;
  1184. }
  1185. }
  1186. break;
  1187. case 16:
  1188. nOldWidthBytes = nOldWidth * 2;
  1189. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1190. nNewWidthBytes = m_nWidth * 2;
  1191. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1192. for( y=0; y<m_nHeight; y++ ){
  1193. yy = m_nHeight - 1 - y;
  1194. pTemp = pNewBits;
  1195. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1196. for( x=0; x<m_nWidth; x++ ){
  1197. Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*2];
  1198. Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*2+1];
  1199. pTemp[x*2] = Data1;
  1200. pTemp[x*2+1] = Data2;
  1201. }
  1202. }
  1203. break;
  1204. case 24:
  1205. nOldWidthBytes = nOldWidth * 3;
  1206. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1207. nNewWidthBytes = m_nWidth * 3;
  1208. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1209. for( y=0; y<m_nHeight; y++ ){
  1210. yy = m_nHeight - 1 - y;
  1211. pTemp = pNewBits;
  1212. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1213. for( x=0; x<m_nWidth; x++ ){
  1214. Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*3];
  1215. Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*3+1];
  1216. Data3 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*3+2];
  1217. pTemp[x*3] = Data1;
  1218. pTemp[x*3+1] = Data2;
  1219. pTemp[x*3+2] = Data3;
  1220. }
  1221. }
  1222. break;
  1223. case 32:
  1224. nOldWidthBytes = nOldWidth * 4;
  1225. while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
  1226. nNewWidthBytes = m_nWidth * 4;
  1227. while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
  1228. for( y=0; y<m_nHeight; y++ ){
  1229. yy = m_nHeight - 1 - y;
  1230. pTemp = pNewBits;
  1231. pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
  1232. for( x=0; x<m_nWidth; x++ ){
  1233. Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*4];
  1234. Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*4+1];
  1235. Data3 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*4+2];
  1236. Data4 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*4+3];
  1237. pTemp[x*4] = Data1;
  1238. pTemp[x*4+1] = Data2;
  1239. pTemp[x*4+2] = Data3;
  1240. pTemp[x*4+3] = Data4;
  1241. }
  1242. }
  1243. break;
  1244. }
  1246. }
  1248. BOOL CImageObject::Invert( void )
  1249. {
  1251. unsigned char *pBuffer, *pTemp1, *pTemp2;
  1252. BITMAPINFOHEADER *pBIH;
  1253. RGBQUAD *pPalette;
  1254. unsigned char *pBits;
  1255. int nWidthBytes;
  1256. int nNumColors;
  1257. int y, yy;
  1258. unsigned char *pTemp;
  1260. pBuffer = (unsigned char *) GetDIBPointer( &nWidthBytes );
  1261. if( pBuffer == NULL ) return( FALSE );
  1263. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  1264. nNumColors = m_nColors;
  1265. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  1266. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  1268. pTemp = new unsigned char [nWidthBytes];
  1269. if( pTemp != NULL ){
  1270. yy = pBIH->biHeight;
  1271. if( !( yy & 1 ) ) yy /= 2;
  1272. else yy = ( yy / 2 ) + 1;
  1273. for( y=0; y<yy; y++ ){
  1274. pTemp1 = pBits;
  1275. pTemp1 += ( ( pBIH->biHeight - 1 - y ) * nWidthBytes );
  1276. pTemp2 = pBits;
  1277. pTemp2 += y * nWidthBytes;
  1278. memcpy( pTemp, pTemp1, nWidthBytes );
  1279. memcpy( pTemp1, pTemp2, nWidthBytes );
  1280. memcpy( pTemp2, pTemp, nWidthBytes );
  1281. }
  1282. delete [] pTemp;
  1283. }
  1285. ::GlobalUnlock( m_hDib );
  1287. m_nLastError = IMAGELIB_SUCCESS;
  1289. return( TRUE );
  1291. }
  1293. BOOL CImageObject::Reverse( void )
  1294. {
  1296. unsigned char *pBuffer, *pTemp;
  1297. BITMAPINFOHEADER *pBIH;
  1298. RGBQUAD *pPalette;
  1299. unsigned char *pBits;
  1300. int nWidthBytes;
  1301. int nNumColors;
  1302. int y, x, xx, xt, nWidth;
  1303. unsigned char Data, Tmp, Data1, Tmp1;
  1305. pBuffer = (unsigned char *) GetDIBPointer( &nWidthBytes );
  1306. if( pBuffer == NULL ) return( FALSE );
  1308. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  1309. nNumColors = m_nColors;
  1310. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  1311. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  1313. xx = pBIH->biWidth;
  1314. if( !( xx & 1 ) ) xx /= 2;
  1315. else xx = ( xx / 2 ) + 1;
  1316. nWidth = pBIH->biWidth;
  1317. if( m_nBits == 4 ){
  1318. xx = pBIH->biWidth;
  1319. xx = ( xx + 3 ) / 4;
  1320. nWidth = ( pBIH->biWidth + 1 ) / 2;
  1321. }
  1322. else if( m_nBits == 1 ){
  1323. xx = pBIH->biWidth;
  1324. xx = ( xx + 15 ) / 16;
  1325. nWidth = ( pBIH->biWidth + 7 ) / 8;
  1326. }
  1328. for( y=0; y<pBIH->biHeight; y++ ){
  1329. pTemp = pBits;
  1330. pTemp += y * nWidthBytes;
  1331. switch( m_nBits ){
  1332. case 1:
  1333. for( x=0; x<xx; x++ ){
  1334. xt = nWidth - 1 - x;
  1335. Data = pTemp[x];
  1336. Data1 = Data << 7;
  1337. Data1 |= ( ( Data & 0x02 ) << 5 );
  1338. Data1 |= ( ( Data & 0x04 ) << 3 );
  1339. Data1 |= ( ( Data & 0x08 ) << 1 );
  1340. Data1 |= ( ( Data & 0x10 ) >> 1 );
  1341. Data1 |= ( ( Data & 0x20 ) >> 3 );
  1342. Data1 |= ( ( Data & 0x40 ) >> 5 );
  1343. Data1 |= ( ( Data & 0x80 ) >> 7 );
  1345. Tmp = pTemp[xt];
  1346. Tmp1 = Tmp << 7;
  1347. Tmp1 |= ( ( Tmp & 0x02 ) << 5 );
  1348. Tmp1 |= ( ( Tmp & 0x04 ) << 3 );
  1349. Tmp1 |= ( ( Tmp & 0x08 ) << 1 );
  1350. Tmp1 |= ( ( Tmp & 0x10 ) >> 1 );
  1351. Tmp1 |= ( ( Tmp & 0x20 ) >> 3 );
  1352. Tmp1 |= ( ( Tmp & 0x40 ) >> 5 );
  1353. Tmp1 |= ( ( Tmp & 0x80 ) >> 7 );
  1355. pTemp[x] = Tmp1;
  1356. pTemp[xt] = Data1;
  1357. }
  1358. break;
  1359. case 4:
  1360. for( x=0; x<xx; x++ ){
  1361. xt = nWidth - 1 - x;
  1362. Data = pTemp[x];
  1363. Tmp = pTemp[xt];
  1364. Data = ( Data << 4 ) | ( Data >> 4 );
  1365. Tmp = ( Tmp << 4 ) | ( Tmp >> 4 );
  1366. pTemp[x] = Tmp;
  1367. pTemp[xt] = Data;
  1368. }
  1369. break;
  1370. case 8:
  1371. for( x=0; x<xx; x++ ){
  1372. xt = nWidth - 1 - x;
  1373. Data = pTemp[x];
  1374. pTemp[x] = pTemp[xt];
  1375. pTemp[xt] = Data;
  1376. }
  1377. break;
  1378. case 16:
  1379. for( x=0; x<xx; x++ ){
  1380. xt = nWidth - 1 - x;
  1381. Data = pTemp[x*2];
  1382. pTemp[x*2] = pTemp[xt*2];
  1383. pTemp[xt*2] = Data;
  1384. Data = pTemp[x*2+1];
  1385. pTemp[x*2+1] = pTemp[xt*2+1];
  1386. pTemp[xt*2+1] = Data;
  1387. }
  1388. break;
  1389. case 24:
  1390. for( x=0; x<xx; x++ ){
  1391. xt = nWidth - 1 - x;
  1392. Data = pTemp[x*3];
  1393. pTemp[x*3] = pTemp[xt*3];
  1394. pTemp[xt*3] = Data;
  1395. Data = pTemp[x*3+1];
  1396. pTemp[x*3+1] = pTemp[xt*3+1];
  1397. pTemp[xt*3+1] = Data;
  1398. Data = pTemp[x*3+2];
  1399. pTemp[x*3+2] = pTemp[xt*3+2];
  1400. pTemp[xt*3+2] = Data;
  1401. }
  1402. break;
  1403. case 32:
  1404. for( x=0; x<xx; x++ ){
  1405. xt = nWidth - 1 - x;
  1406. Data = pTemp[x*4];
  1407. pTemp[x*4] = pTemp[xt*4];
  1408. pTemp[xt*4] = Data;
  1409. Data = pTemp[x*4+1];
  1410. pTemp[x*4+1] = pTemp[xt*4+1];
  1411. pTemp[xt*4+1] = Data;
  1412. Data = pTemp[x*4+2];
  1413. pTemp[x*4+2] = pTemp[xt*4+2];
  1414. pTemp[xt*4+2] = Data;
  1415. Data = pTemp[x*4+3];
  1416. pTemp[x*4+3] = pTemp[xt*4+3];
  1417. pTemp[xt*4+3] = Data;
  1418. }
  1419. break;
  1420. }
  1421. }
  1423. ::GlobalUnlock( m_hDib );
  1425. m_nLastError = IMAGELIB_SUCCESS;
  1427. return( TRUE );
  1429. }
  1431. BOOL CImageObject::ChangeFormat( int nNewBitsPerPixel )
  1432. {
  1434. m_nLastError = IMAGELIB_SUCCESS;
  1435. if( nNewBitsPerPixel == m_nBits ) return( TRUE );
  1437. int nOldWidthBytes, nNewWidthBytes;
  1438. char *pBuffer = (char *) GetDIBPointer( &nOldWidthBytes, nNewBitsPerPixel, &nNewWidthBytes );
  1439. if( pBuffer == NULL ) return( FALSE );
  1441. BITMAPINFOHEADER *pOldBIH, *pNewBIH;
  1442. BITMAPFILEHEADER *pOldBFH, *pNewBFH;
  1443. RGBQUAD *pOldRGBPalette, *pNewRGBPalette;
  1444. unsigned char *pOldBits, *pNewBits;
  1445. int nNumColors, nNumNewColors;
  1447. pOldBFH = (BITMAPFILEHEADER *) pBuffer;
  1448. pOldBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  1449. pOldRGBPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  1450. nNumColors = m_nColors;
  1451. nNumNewColors = 1 << nNewBitsPerPixel;
  1452. if( nNewBitsPerPixel > 8 ) nNumNewColors = 0;
  1453. pOldBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  1455. if( m_nBits >= 16 && nNewBitsPerPixel < 16 ){
  1456. if( m_pLogPal != NULL ) delete [] m_pLogPal;
  1457. m_pLogPal = CreatePaletteFromBitmap( nNumNewColors, pOldBits, m_nBits, m_nWidth, m_nHeight );
  1458. }
  1460. HGLOBAL hGlobal;
  1461. DWORD dwSize;
  1462. dwSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNumNewColors * sizeof( RGBQUAD ) + m_nHeight * nNewWidthBytes;
  1463. hGlobal = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwSize );
  1464. if( hGlobal == NULL ){
  1465. ::GlobalUnlock( m_hDib );
  1466. return( FALSE );
  1467. }
  1469. pBuffer = (char *) ::GlobalLock( hGlobal );
  1470. if( pBuffer == NULL ){
  1471. ::GlobalFree( hGlobal );
  1472. ::GlobalUnlock( m_hDib );
  1473. return( FALSE );
  1474. }
  1476. pNewBFH = (BITMAPFILEHEADER *) pBuffer;
  1477. pNewBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  1478. pNewRGBPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  1479. *pNewBFH = *pOldBFH;
  1480. *pNewBIH = *pOldBIH;
  1481. int i, j = nNumNewColors;
  1483. if( m_nBits < 16 && nNewBitsPerPixel < 16 ){
  1484. for( i=0; i<j; i++ ) pNewRGBPalette[i] = pOldRGBPalette[i];
  1485. }
  1486. else if( m_nBits >= 16 ){
  1487.   for( i=0; i<j; i++ ){
  1488. pNewRGBPalette[i].rgbRed = m_pLogPal->palPalEntry[i].peRed;
  1489. pNewRGBPalette[i].rgbGreen = m_pLogPal->palPalEntry[i].peGreen;
  1490. pNewRGBPalette[i].rgbBlue = m_pLogPal->palPalEntry[i].peBlue;
  1491. }
  1492. }
  1493. pNewBIH->biBitCount = nNewBitsPerPixel;
  1494. pNewBIH->biSizeImage = nNewWidthBytes * m_nHeight;
  1495. pNewBIH->biClrUsed = nNumNewColors;
  1496. pNewBFH->bfSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNumNewColors * sizeof( RGBQUAD ) + pNewBIH->biSizeImage;
  1497. pNewBFH->bfOffBits = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNumNewColors * sizeof( RGBQUAD );
  1498. pNewBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumNewColors*sizeof(RGBQUAD)];
  1499. m_nPaletteBytes = nNumNewColors * sizeof( RGBQUAD );
  1501. for( int y=0; y<m_nHeight; y++ ){
  1502. unsigned char ucRed, ucGreen, ucBlue;
  1503. unsigned char *pSrc, *pDest;
  1504. pSrc = pOldBits;
  1505. pSrc += ( nOldWidthBytes * y );
  1506. pDest = pNewBits;
  1507. pDest += ( nNewWidthBytes * y );
  1508. for( int x=0; x<m_nWidth; x++ ){
  1509. switch( m_nBits ){
  1510. case 1:
  1511. if( pSrc[x/8] & ( 0x80 >> ( x & 7 ) ) )
  1512. ucRed = ucGreen = ucBlue = 0xff;
  1513. else
  1514. ucRed = ucGreen = ucBlue = 0x00;
  1515. break;
  1516. case 4:
  1517. if( !( x & 1 ) ){
  1518. ucRed = pOldRGBPalette[pSrc[x/2]>>4].rgbRed;
  1519. ucGreen = pOldRGBPalette[pSrc[x/2]>>4].rgbGreen;
  1520. ucBlue = pOldRGBPalette[pSrc[x/2]>>4].rgbBlue;
  1521. }
  1522. else{
  1523. ucRed = pOldRGBPalette[pSrc[x/2]&15].rgbRed;
  1524. ucGreen = pOldRGBPalette[pSrc[x/2]&15].rgbGreen;
  1525. ucBlue = pOldRGBPalette[pSrc[x/2]&15].rgbBlue;
  1526. }
  1527. break;
  1528. case 8:
  1529. ucRed = pOldRGBPalette[pSrc[x]].rgbRed;
  1530. ucGreen = pOldRGBPalette[pSrc[x]].rgbGreen;
  1531. ucBlue = pOldRGBPalette[pSrc[x]].rgbBlue;
  1532. break;
  1533. case 16:
  1534. GETRGB555( ucRed, ucGreen, ucBlue, &pSrc[x*2] );
  1535. break;
  1536. case 24:
  1537. ucRed = pSrc[x*3+2];
  1538. ucGreen = pSrc[x*3+1];
  1539. ucBlue = pSrc[x*3];
  1540. break;
  1541. case 32:
  1542. GETRGB888( ucRed, ucGreen, ucBlue, &pSrc[x*4] );
  1543. break;
  1544. }
  1546. switch( nNewBitsPerPixel ){
  1547. case 1:
  1548. if( !( x & 7 ) ) pDest[x/8] = 0;
  1549. pDest[x/8] |= (unsigned char) GetNearestIndex( ucRed, ucGreen, ucBlue, pNewRGBPalette, nNumNewColors ) << ( x & 7 );
  1550. break;
  1551. case 4:
  1552. if( !( x & 1 ) )
  1553. pDest[x/2] = (unsigned char) GetNearestIndex( ucRed, ucGreen, ucBlue, pNewRGBPalette, nNumNewColors ) << 4;
  1554. else
  1555. pDest[x/2] |= (unsigned char) GetNearestIndex( ucRed, ucGreen, ucBlue, pNewRGBPalette, nNumNewColors );
  1556. break;
  1557. case 8:
  1558. pDest[x] = (unsigned char) GetNearestIndex( ucRed, ucGreen, ucBlue, pNewRGBPalette, nNumNewColors );
  1559. break;
  1560. case 16:
  1561. PUTRGB555( ucRed, ucGreen, ucBlue, &pDest[x*2] );
  1562. break;
  1563. case 24:
  1564. pDest[x*3+2] = ucRed;
  1565. pDest[x*3+1] = ucGreen;
  1566. pDest[x*3] = ucBlue;
  1567. break;
  1568. case 32:
  1569. PUTRGB888( ucRed, ucGreen, ucBlue, &pDest[x*4] );
  1570. break;
  1571. }
  1572. }
  1573. }
  1575. ::GlobalUnlock( m_hDib );
  1576. ::GlobalFree( m_hDib );
  1577. ::GlobalUnlock( hGlobal );
  1578. m_hDib = hGlobal;
  1580. ProcessImageHeader();
  1582. return( TRUE );
  1584. }
  1586. LOGPALETTE *CImageObject::CreatePaletteFromBitmap( int nNumColors, unsigned char *pBits, int nBits, int nWidth, int nHeight )
  1587. {
  1589. RGBQUAD *pRGBPalette;
  1590. if( nBits != 8 && m_nPaletteCreationType == POPULARITY_PALETTE ) pRGBPalette = MakePopularityPalette( nNumColors, pBits, nBits, nWidth, nHeight );
  1591. else if( nBits != 8 && m_nPaletteCreationType == MEDIAN_CUT_PALETTE ) pRGBPalette = MakeMedianCutPalette( nNumColors, pBits, nBits, nWidth, nHeight );
  1592. else if( m_nPaletteCreationType == FIXED_PALETTE ) pRGBPalette = MakeFixedPalette( nNumColors );
  1593. if( pRGBPalette == NULL ) return( NULL );
  1595. LOGPALETTE *pLogPal = CreateLogPalette( pRGBPalette, nNumColors );
  1597. delete [] pRGBPalette;
  1599. return( pLogPal );
  1601. }
  1603. void CImageObject::SetPaletteCreationType( int nType )
  1604. {
  1606. m_nPaletteCreationType = nType;
  1608. }
  1610. int CImageObject::GetPaletteCreationType( void )
  1611. {
  1613. return( m_nPaletteCreationType );
  1615. }
  1617. RGBQUAD *CImageObject::MakePopularityPalette( int nNumColors, unsigned char *pBits, int nBits, int nWidth, int nHeight )
  1618. {
  1619. RGBQUAD *pRGBQuad = new RGBQUAD[nNumColors];
  1620. if( pRGBQuad == NULL ) return( MakeFixedPalette( nNumColors ) );
  1621. memset( pRGBQuad, 0, nNumColors * sizeof( RGBQUAD ) );
  1623. BYTE ColMap[256][3];
  1624. if( !Popularity( pBits, nBits, nWidth, nHeight, ColMap ) ){
  1625. delete [] pRGBQuad;
  1626. return( MakeFixedPalette( nNumColors ) );
  1627. }
  1629. for( int i=0; i<nNumColors; i++ ){
  1630. pRGBQuad[i].rgbRed = ColMap[i][0];
  1631. pRGBQuad[i].rgbGreen = ColMap[i][1];
  1632. pRGBQuad[i].rgbBlue = ColMap[i][2];
  1633. }
  1635. return( pRGBQuad );
  1637. }
  1639. RGBQUAD *CImageObject::MakeMedianCutPalette( int nNumColors, unsigned char *pBits, int nBits, int nWidth, int nHeight )
  1640. {
  1641. RGBQUAD *pRGBQuad = new RGBQUAD[nNumColors];
  1642. if( pRGBQuad == NULL ) return( MakeFixedPalette( nNumColors ) );
  1643. memset( pRGBQuad, 0, nNumColors * sizeof( RGBQUAD ) );
  1645. BYTE ColMap[256][3];
  1646. WORD *Hist = new WORD[32768];
  1647. if( Hist == NULL ){
  1648. delete [] pRGBQuad;
  1649. return( MakeFixedPalette( nNumColors ) );
  1650. }
  1651. memset( Hist, 0, 32768 * sizeof( WORD ) );
  1653. int nWidthBytes = WidthBytes( nBits, nWidth );
  1655. for( int y=0; y<nHeight; y++ ){
  1656. unsigned char *pData = pBits;
  1657. unsigned char ucRed, ucGreen, ucBlue;
  1658. WORD color;
  1659. pData += ( y * nWidthBytes );
  1660. for( int x=0; x<nWidth; x++ ){
  1661. switch( nBits ){
  1662. case 16:
  1663. GETRGB555( ucRed, ucGreen, ucBlue, &pData[x*2] );
  1664. break;
  1665. case 24:
  1666. ucRed = pData[x*3+2];
  1667. ucGreen = pData[x*3+1];
  1668. ucBlue = pData[x*3];
  1669. break;
  1670. case 32:
  1671. GETRGB888( ucRed, ucGreen, ucBlue, &pData[x*4] );
  1672. break;
  1673. }
  1674. color = _RGB( ucRed, ucGreen, ucBlue );
  1675. if( Hist[color] < 65535 ) Hist[color]++;
  1676. }
  1677. }
  1679. MedianCut( Hist, ColMap, (int) 256 );
  1680. for( int i=0; i<nNumColors; i++ ){
  1681. pRGBQuad[i].rgbRed = ColMap[i][0];
  1682. pRGBQuad[i].rgbGreen = ColMap[i][1];
  1683. pRGBQuad[i].rgbBlue = ColMap[i][2];
  1684. }
  1685. delete [] Hist;
  1687. return( pRGBQuad );
  1689. }
  1691. RGBQUAD *CImageObject::MakeFixedPalette( int nNumColors )
  1692. {
  1693. RGBQUAD *pRGBQuad = new RGBQUAD[nNumColors];
  1694. if( pRGBQuad == NULL ) return( NULL );
  1696. static int colors[] = {
  1697. 255, 255, 255,
  1698. 0, 0, 0,
  1699. 255, 0, 0,
  1700. 0, 0, 255,
  1701. 0, 255, 0,
  1702. 150, 150, 150,
  1703. 255, 255, 0,
  1704. 0, 150, 150,
  1705. 150, 0, 150,
  1706. 150, 150, 0,
  1707. 0, 255, 255,
  1708. 255, 0, 255,
  1709. 255, 120, 120,
  1710. 120, 255, 120,
  1711. 120, 120, 255,
  1712. 90, 90, 90 };
  1714. int nSteps = ( ( nNumColors + 15 ) / 16 );
  1716. for( int i=0; i<nSteps; i++ ){
  1717. for( int j=0; j<16; j++ ){
  1718. if( i * 16 + j < nNumColors ){
  1719. int r, g, b;
  1720. r = colors[j*3];
  1721. g = colors[j*3+1];
  1722. b = colors[j*3+2];
  1723. r = ( ( nSteps - i ) * r ) / nSteps;
  1724. g = ( ( nSteps - i ) * g ) / nSteps;
  1725. b = ( ( nSteps - i ) * b ) / nSteps;
  1726. pRGBQuad[i*16+j].rgbRed = (unsigned char) r;
  1727. pRGBQuad[i*16+j].rgbGreen = (unsigned char) g;
  1728. pRGBQuad[i*16+j].rgbBlue = (unsigned char) b;
  1729. }
  1730. }
  1731. }
  1733. return( pRGBQuad );
  1735. }
  1737. int CImageObject::GetPaletteBytes( void )
  1738. {
  1740. return( m_nPaletteBytes );
  1742. }
  1744. HGLOBAL CImageObject::GetDib( void )
  1745. {
  1747. return( m_hDib );
  1749. }
  1751. CPalette *CImageObject::GetPalette( void )
  1752. {
  1754. return( &m_Palette );
  1756. }
  1758. LOGPALETTE *CImageObject::GetLogPal( void )
  1759. {
  1761. return( m_pLogPal );
  1763. }