dibapi.cpp

用内存设备上下文实现图像选中区域 的判断

        }
    }
	*/

    // Clean up and delete the DCs
    SelectObject( hSourceDC, hOldSourceBitmap );
    SelectObject( hSourceDC, hOldTargetBitmap );
    DeleteDC( hSourceDC );
    DeleteDC( hTargetDC );
    ReleaseDC( NULL, hDC );

    // Flush the GDI batch, so we can play with the bits
    GdiFlush();

    // Allocate enough memory for the new CF_DIB, and copy bits
    //lpResult = malloc( dwTargetHeaderSize + dwTargetBitsSize );
    hDib=(HDIB)GlobalAlloc(GHND,dwTargetHeaderSize+dwTargetBitsSize);
	lpResult=(LPBYTE)GlobalLock(hDib);
	memcpy( lpResult, lpbmi, dwTargetHeaderSize );
    memcpy( FindDIBBits( (LPSTR)lpResult ), lpTargetBits, dwTargetBitsSize );

    // final cleanup
    DeleteObject( hTargetBitmap );
    DeleteObject( hSourceBitmap );
    free( lpbmi );
	GlobalUnlock(hDib);

    return hDib;
}

BOOL CopyColorTable( LPBITMAPINFO lpTarget, LPBITMAPINFO lpSource,HPALETTE hPalScr)
{
    // What we do depends on the target's color depth
    switch( lpTarget->bmiHeader.biBitCount )
    {
        // 8bpp - need 256 entry color table
        case 8:
			if(hPalScr)
			{//Palette is provided,use it
				PALETTEENTRY pe[256];
				UINT i;
				GetPaletteEntries(hPalScr,0,256,pe);
				for(i=0;i<256;i++)
				{
					lpTarget->bmiColors[i].rgbRed=pe[i].peRed;
					lpTarget->bmiColors[i].rgbGreen=pe[i].peGreen;
					lpTarget->bmiColors[i].rgbBlue=pe[i].peBlue;
					lpTarget->bmiColors[i].rgbReserved=0;
				}
				//return TRUE;
			}
			else{
				//for else

            if( lpSource->bmiHeader.biBitCount == 8 )
            { // Source is 8bpp too, copy color table
                memcpy( lpTarget->bmiColors, lpSource->bmiColors, 256*sizeof(RGBQUAD) );
                //return TRUE;
            }
            else
            { // Source is != 8bpp, use halftone palette                
                HPALETTE        hPal;
                HDC            	hDC = GetDC( NULL );
                PALETTEENTRY    pe[256];
                UINT            i;

                //if don't want lose color infomation do
				//hPal=CreateOctreePalette((LPBYTE)lpSource,236,8);
				
				//if(!hPal)
					hPal = CreateHalftonePalette( hDC );
                ReleaseDC( NULL, hDC );
                GetPaletteEntries( hPal, 0, 256, pe );
                DeleteObject( hPal );
                for(i=0;i<256;i++)
                {
                    lpTarget->bmiColors[i].rgbRed = pe[i].peRed;
                    lpTarget->bmiColors[i].rgbGreen = pe[i].peGreen;
                    lpTarget->bmiColors[i].rgbBlue = pe[i].peBlue;
                    lpTarget->bmiColors[i].rgbReserved = pe[i].peFlags;
                }
                //return TRUE;
            }
			}//end of else
        break; // end 8bpp

        // 4bpp - need 16 entry color table
        case 4:
			if(hPalScr)
			{//Palette is provided,use it
				PALETTEENTRY pe[16];
				UINT i;
				GetPaletteEntries(hPalScr,0,16,pe);
				for(i=0;i<16;i++)
				{
					lpTarget->bmiColors[i].rgbRed=pe[i].peRed;
					lpTarget->bmiColors[i].rgbGreen=pe[i].peGreen;
					lpTarget->bmiColors[i].rgbBlue=pe[i].peBlue;
					lpTarget->bmiColors[i].rgbReserved=0;
				}
				//return TRUE;
			}
			else{
				//for else
            if( lpSource->bmiHeader.biBitCount == 4 )
            { // Source is 4bpp too, copy color table
                memcpy( lpTarget->bmiColors, lpSource->bmiColors, 16*sizeof(RGBQUAD) );
                //return TRUE;
            }
            else
            { // Source is != 4bpp, use system palette
                HPALETTE        hPal;
                PALETTEENTRY    pe[256];
                UINT            i;

                hPal = (HPALETTE)GetStockObject( DEFAULT_PALETTE );
                GetPaletteEntries( hPal, 0, 16, pe );
                for(i=0;i<16;i++)
                {
                    lpTarget->bmiColors[i].rgbRed = pe[i].peRed;
                    lpTarget->bmiColors[i].rgbGreen = pe[i].peGreen;
                    lpTarget->bmiColors[i].rgbBlue = pe[i].peBlue;
                    lpTarget->bmiColors[i].rgbReserved = pe[i].peFlags;
                }
                //return TRUE;
            }
			}//end of else
        break; // end 4bpp

        // 1bpp - need 2 entry mono color table
        case 1:
            lpTarget->bmiColors[0].rgbRed = 0;
            lpTarget->bmiColors[0].rgbGreen = 0;
            lpTarget->bmiColors[0].rgbBlue = 0;
            lpTarget->bmiColors[0].rgbReserved = 0;
            lpTarget->bmiColors[1].rgbRed = 255;
            lpTarget->bmiColors[1].rgbGreen = 255;
            lpTarget->bmiColors[1].rgbBlue = 255;
            lpTarget->bmiColors[1].rgbReserved = 0;
			//return TRUE;
        break; // end 1bpp

        // no color table for the > 8bpp modes
        case 32:
        case 24:
        case 16:
        default:
            //return TRUE;
        break;
    }
    return TRUE;
}

HDIB      WINAPI  ColorQuantizeDIB(HDIB hDIB,UINT nColorBits,UINT nMaxColors)
{
	HPALETTE hPal=NULL;
	//BeginWaitCursor();

	LPBYTE lpDIB=(LPBYTE)GlobalLock(hDIB);
	
	//if don't want lose color information do
	//hPal=CreateOctreePalette(lpDIB,nMaxColors,nColorBits);
    
	GlobalUnlock(hDIB);
	HDIB hNewDIB =::ConvertDIBFormat(lpDIB,nColorBits,hPal);

	//EndWaitCursor();

	return hNewDIB;
}

//////////////////////////////////////////////////////////////////////////
//  Function:  SaveDIBToFile
//  Description:
//
//  Parameters:    @@@
//
//  Returns:    BOOL
//
//  Comments:
//////////////////////////////////////////////////////////////////////////

BOOL WINAPI SaveDIBToFile(HDIB hdib, LPCTSTR lpszFileName)
{   
    HANDLE              hFile;
    //HANDLE              hDIBTransformed = NULL;
	BITMAPFILEHEADER    bmfHdr;
    LPBITMAPINFOHEADER   lpBI;
	DWORD               dwDIBSize,dwWritten;


    // Validate Parameters.
    if ( !hdib)
    {
        return FALSE;
    }

    // Open file handle.
    hFile = CreateFile(lpszFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
                       FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN, NULL);
    if (INVALID_HANDLE_VALUE == hFile)
		return FALSE;

	lpBI=(LPBITMAPINFOHEADER)GlobalLock(hdib);
	if(!lpBI)
	{
		CloseHandle(hFile);
		return FALSE;
	}

	if(lpBI->biSize!=sizeof(BITMAPINFOHEADER))
	{
		GlobalUnlock(hdib);
		CloseHandle(hFile);
		return FALSE;
	}

	bmfHdr.bfType=0x4D42;
	dwDIBSize=*(LPDWORD)lpBI+DIBNumColors((LPSTR)lpBI)*sizeof(RGBQUAD);

	DWORD dwBmBitsSize;
	dwBmBitsSize=WIDTHBYTES((lpBI->biWidth)*((DWORD)lpBI->biBitCount))
		*lpBI->biHeight;

	dwDIBSize+=dwBmBitsSize;

	lpBI->biSizeImage=dwBmBitsSize;

	bmfHdr.bfSize=dwDIBSize+sizeof(BITMAPFILEHEADER);
	bmfHdr.bfReserved1=0;
	bmfHdr.bfReserved2=0;

	bmfHdr.bfOffBits=(DWORD)sizeof(BITMAPFILEHEADER)+lpBI->biSize
		+DIBNumColors((LPSTR)lpBI)*sizeof(RGBQUAD);

	WriteFile(hFile,(LPBYTE)&bmfHdr,sizeof(BITMAPFILEHEADER),
		&dwWritten,NULL);
	if(dwWritten==0)
	{
		GlobalUnlock(hdib);
		CloseHandle(hFile);
		return FALSE;
	}
	WriteFile(hFile,(LPBYTE)lpBI,dwDIBSize,	&dwWritten,NULL);	
	GlobalUnlock(hdib);
	CloseHandle(hFile);
	if(dwWritten==0)
		return FALSE;
	else
		return TRUE;    
}

HBITMAP   WINAPI  DIBToDIBSection(LPBYTE lpDIB)
{
	LPBYTE lpSourceBits;
	HDC    hDC=NULL,hSourceDC;
	HBITMAP hSourceBitmap,hOldSourceBitmap;
	DWORD  dwSourceBitsSize;

	LPBITMAPINFO lpSrcDIB=(LPBITMAPINFO)lpDIB;
	if(!lpSrcDIB)
		return NULL;
	hDC=GetDC(NULL);
	hSourceBitmap=CreateDIBSection(hDC,lpSrcDIB,DIB_RGB_COLORS,
		(VOID**)&lpSourceBits,NULL,0);
	hSourceDC=CreateCompatibleDC(hDC);

	dwSourceBitsSize=lpSrcDIB->bmiHeader.biHeight
		*BytesPerLine((LPBYTE)&(lpSrcDIB->bmiHeader));
	memcpy(lpSourceBits,FindDIBBits((LPSTR)lpSrcDIB),dwSourceBitsSize);

	hOldSourceBitmap=(HBITMAP)SelectObject(hSourceDC,hSourceBitmap);

	if(lpSrcDIB->bmiHeader.biBitCount<=8)
		SetDIBColorTable(hSourceDC,0,1<<lpSrcDIB->bmiHeader.biBitCount,
		lpSrcDIB->bmiColors);
	SelectObject(hSourceDC,hOldSourceBitmap);
	DeleteDC(hSourceDC);
	ReleaseDC(NULL,hDC);

	GdiFlush();
	return hSourceBitmap;
}

HDIB      WINAPI  DIBSectionToDIB(HBITMAP hBitmap)
{
	HDC hDC=NULL,hSourceDC;
	HBITMAP hOldSourceBitmap;
	HDIB  hNewDIB;
	LPBITMAPINFO lpbmi=NULL;
	DWORD dwSize;
	DIBSECTION ds;
	DWORD  dwColorNum;

	GetObject(hBitmap,sizeof(DIBSECTION),&ds);
	dwColorNum=ds.dsBmih.biClrUsed;
	if(dwColorNum==0&&ds.dsBmih.biBitCount<=8)
		dwColorNum=1<<ds.dsBmih.biBitCount;

	dwSize=sizeof(BITMAPINFOHEADER)+dwColorNum*sizeof(RGBQUAD)
		+ds.dsBmih.biSizeImage;
	hNewDIB=(HDIB)GlobalAlloc(GHND,dwSize);
	if(!hNewDIB)
		return  NULL;
	lpbmi=(LPBITMAPINFO)GlobalLock(hNewDIB);
	if(!lpbmi)
		return NULL;
	lpbmi->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
	lpbmi->bmiHeader.biWidth=ds.dsBm.bmWidth;
	lpbmi->bmiHeader.biHeight=ds.dsBm.bmHeight;
	lpbmi->bmiHeader.biPlanes=1;
	lpbmi->bmiHeader.biBitCount=ds.dsBmih.biBitCount;
	lpbmi->bmiHeader.biCompression=ds.dsBmih.biCompression;
	lpbmi->bmiHeader.biSizeImage=ds.dsBmih.biSizeImage;
	lpbmi->bmiHeader.biXPelsPerMeter=ds.dsBmih.biXPelsPerMeter;
	lpbmi->bmiHeader.biYPelsPerMeter=ds.dsBmih.biYPelsPerMeter;
	lpbmi->bmiHeader.biClrUsed=ds.dsBmih.biClrUsed;
	lpbmi->bmiHeader.biClrImportant=ds.dsBmih.biClrImportant;

	hDC=GetDC(NULL);
	if(!GetDIBits(hDC,hBitmap,0L,(DWORD)ds.dsBm.bmHeight,
		(LPBYTE)lpbmi+(WORD)lpbmi->bmiHeader.biSize
		+(dwColorNum*sizeof(RGBQUAD)),
		(LPBITMAPINFO)lpbmi,(DWORD)DIB_RGB_COLORS))
	{
		GlobalUnlock(hNewDIB);
		ReleaseDC(NULL,hDC);
		return NULL;
	}

	hSourceDC=CreateCompatibleDC(hDC);
	hOldSourceBitmap=(HBITMAP)SelectObject(hSourceDC,hBitmap);

	if(lpbmi->bmiHeader.biBitCount<=8)
		GetDIBColorTable(hSourceDC,0,1<<lpbmi->bmiHeader.biBitCount,
		lpbmi->bmiColors);
	SelectObject(hSourceDC,hOldSourceBitmap);
	DeleteDC(hSourceDC);
	ReleaseDC(NULL,hDC);
	GlobalUnlock(hNewDIB);

	return hNewDIB;
}