ComImage

//#include "StdAfx.h"
#include <Windows.h>
#include <stdlib.h>
#include <stdio.h>
#include "ComImage.h"
#include "ComFun.h"

HANDLE DDBToDIB(HBITMAP hBitmap, HPALETTE hPalette, BITMAPINFO * pOutDibInfo, int nBitpPix)
{
    BITMAP            BM;
    BITMAPINFOHEADER    BMinfoh;
    BITMAPINFO *        pBMinfo;
    HPALETTE        hPalOld = NULL;
    DWORD            dwLenDib, dwBmInfoLen;
    HANDLE            hDIB;
    HDC             hDC;
    int                nColors;
    BOOL            bRetVal;
    if(hBitmap == NULL)
    {
        ::SetLastError(ERROR_INVALID_HANDLE);
        return NULL;
    }
    if (hPalette==NULL)
        hPalette = (HPALETTE)::GetStockObject(DEFAULT_PALETTE);
    GetObject(hBitmap, sizeof(BITMAP), (LPVOID)&BM);
    BMinfoh.biSize            = sizeof(BITMAPINFOHEADER);
    BMinfoh.biWidth            = BM.bmWidth;
    BMinfoh.biHeight         = BM.bmHeight;
    BMinfoh.biPlanes         = 1;        //Must 1
    if(nBitpPix == 0)
        BMinfoh.biBitCount        = BM.bmPlanes * BM.bmBitsPixel;
    else
        BMinfoh.biBitCount        = BM.bmPlanes * nBitpPix;
    BMinfoh.biCompression    = BI_RGB;
    BMinfoh.biSizeImage        = 0;
    BMinfoh.biXPelsPerMeter    = 0;
    BMinfoh.biYPelsPerMeter    = 0;
    BMinfoh.biClrUsed        = 0;
    BMinfoh.biClrImportant    = 0;
    if(BMinfoh.biBitCount > 8)        nColors = 0;
    else                            nColors = 1 << BMinfoh.biBitCount;
    dwBmInfoLen  = BMinfoh.biSize + nColors * sizeof(RGBQUAD);
    hDC = GetDC(NULL);
    if(hPalette)
    {
        hPalOld = SelectPalette(hDC, hPalette, FALSE);
        RealizePalette(hDC);
    }

    pBMinfo = (BITMAPINFO *)GlobalAlloc(GMEM_FIXED, dwBmInfoLen);
    if(pBMinfo == NULL)
    {
        SelectPalette(hDC, hPalOld, FALSE);
        ReleaseDC(NULL, hDC);
        ::SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }
    memcpy(&pBMinfo->bmiHeader, &BMinfoh, sizeof(BITMAPINFOHEADER));
    GetDIBits(hDC, hBitmap, 0, BMinfoh.biHeight, NULL, pBMinfo, DIB_RGB_COLORS);
    if (pBMinfo->bmiHeader.biSizeImage == 0)
    {
        pBMinfo->bmiHeader.biSizeImage = ((((pBMinfo->bmiHeader.biWidth * pBMinfo->bmiHeader.biBitCount) + 31) & ~31) / 8) 
            * pBMinfo->bmiHeader.biHeight;
    }
    dwLenDib = dwBmInfoLen + pBMinfo->bmiHeader.biSizeImage;
    hDIB = GlobalAlloc(GMEM_FIXED, dwLenDib);
    if (hDIB == NULL)
    {
        GlobalFree(pBMinfo);
        if(hPalOld)    SelectPalette(hDC, hPalOld, FALSE);
        ReleaseDC(NULL, hDC);
        return NULL;
    }
    memcpy(hDIB, pBMinfo, sizeof(BITMAPINFOHEADER));
    bRetVal = GetDIBits(hDC, hBitmap, 0, BMinfoh.biHeight,
        (LPBYTE)hDIB + (BMinfoh.biSize + nColors * sizeof(RGBQUAD)),
        pBMinfo, DIB_RGB_COLORS);
    if( bRetVal == FALSE )
    {
        GlobalFree(hDIB);
        GlobalFree(pBMinfo);
        if(hPalOld)    SelectPalette(hDC, hPalOld, FALSE);
        ReleaseDC(NULL, hDC);
        return NULL;
    }
    if(pOutDibInfo != NULL)
        memcpy(pOutDibInfo, pBMinfo, dwBmInfoLen);
    GlobalFree(pBMinfo);
    if(hPalOld)    SelectPalette(hDC, hPalOld, FALSE);
    ReleaseDC(NULL, hDC);
    return hDIB;
}

BOOL SaveDIBToBMP(HANDLE hDib, CHAR * pFileName)
{
    BITMAPFILEHEADER    BmFileHead;
    BITMAPINFOHEADER *    pBmInfoHead;
    int                    nColors;
    HANDLE                hFile;
    DWORD                dwWrite;
    DWORD                dwDibSize;
    if (!hDib)
    {
        ::SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    hFile = CreateFileA(pFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        return FALSE;
    }
    pBmInfoHead = (BITMAPINFOHEADER *)hDib;
    if(pBmInfoHead->biBitCount > 8)        nColors = 0;
    else                                nColors = 1 << pBmInfoHead->biBitCount;
    dwDibSize = pBmInfoHead->biSize + nColors*sizeof(RGBQUAD) + pBmInfoHead->biSizeImage;
    BmFileHead.bfType        = ((WORD) ('M' << 8) | 'B');    //"BM"
    BmFileHead.bfSize        = dwDibSize + sizeof(BITMAPFILEHEADER);
    BmFileHead.bfReserved1    = 0;
    BmFileHead.bfReserved2    = 0;
    BmFileHead.bfOffBits    = (DWORD) (sizeof( BITMAPFILEHEADER ) + pBmInfoHead->biSize + nColors * sizeof(RGBQUAD));
    WriteFile(hFile, &BmFileHead, sizeof(BITMAPFILEHEADER), &dwWrite, NULL);
    WriteFile(hFile, hDib,        dwDibSize,                &dwWrite, NULL);
    CloseHandle(hFile);
    return TRUE;
}

BOOL SaveBitmapToFile(HBITMAP hBitmap, CHAR * pFileName)
{
    HANDLE        hDib = NULL;
    HPALETTE    hPalette = NULL;
    BOOL        bRetVal;
    hDib = DDBToDIB(hBitmap, hPalette);
    if(hDib == NULL)
    {
        return FALSE;
    }
    bRetVal = SaveDIBToBMP(hDib, pFileName);
    GlobalFree(hDib);
    return bRetVal;
}

HANDLE GetDIBFromWindow(HWND hWnd, RECT * pWndRect)
{
    HANDLE        hDib;
    HBITMAP        hBitmap, hOldBitmap;
    HDC            hWndDc, hMemDc;
    RECT        WndRect;
    int            nWidth, nHeigh;
    hWndDc = ::GetWindowDC(hWnd);
    hMemDc = ::CreateCompatibleDC(hWndDc); 
    if (pWndRect == NULL)
    {
        if(hWnd == HWND_DESKTOP)
        {
            nWidth    = GetSystemMetrics(SM_CXSCREEN);
            nHeigh    = GetSystemMetrics(SM_CYSCREEN);
        }
        else
        {
            ::GetWindowRect(hWnd, &WndRect);
            nWidth = WndRect.right - WndRect.left;
            nHeigh = WndRect.bottom - WndRect.top;
        }
    }
    else
    {
        nWidth = pWndRect->right - pWndRect->left;
        nHeigh = pWndRect->bottom - pWndRect->top;
    }

    hBitmap = ::CreateCompatibleBitmap(hWndDc, nWidth, nHeigh);
    hOldBitmap = (HBITMAP)::SelectObject(hMemDc, hBitmap);
    BitBlt(hMemDc, 0, 0, nWidth, nHeigh, hWndDc, 0, 0, SRCCOPY);
    hDib = DDBToDIB(hBitmap);
    ::SelectObject(hMemDc, hOldBitmap);
    ::DeleteObject(hBitmap);
    ::DeleteDC(hMemDc);
    ::ReleaseDC(hWnd, hWndDc);
    return hDib;
}

BOOL SaveWindowToBMP(CHAR * pBMPName, HWND hWnd, RECT * pWndRect)
{
    HANDLE    hDib;
    ::ShowWindow(hWnd, SW_SHOW);
    ::BringWindowToTop(hWnd);
    ::UpdateWindow(hWnd);
    hDib = GetDIBFromWindow(hWnd, pWndRect);
    SaveDIBToBMP(hDib, pBMPName);
    GlobalFree(hDib);
    return TRUE;
}

BOOL GetBitmapSize(HBITMAP hBitmap, DWORD * pdwBmInfoSize, DWORD * pdwDIBSize, int nBit)
{
    BITMAP                BM;
    int                    nRetVal, nColors, nBitpPix;
    if(hBitmap == NULL)
    {
        ::SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    nRetVal = GetObject(hBitmap, sizeof(BITMAP), (LPVOID)&BM);
    if(nRetVal != sizeof(BITMAP))
    {
        Msgerr("GetObject");
        return FALSE;
    }
    if(nBit != 0)    nBitpPix    = nBit;
    else            nBitpPix    = BM.bmBitsPixel;
    nColors = 1  <<  nBitpPix;
    if(nBitpPix <= 8)
        *pdwBmInfoSize = sizeof(BITMAPINFOHEADER) + nColors*sizeof(RGBQUAD);
    else    //无调色板
        *pdwBmInfoSize = sizeof(BITMAPINFOHEADER);
    *pdwDIBSize = *pdwBmInfoSize + ((BM.bmWidth * nBitpPix +31) / 32) * 4 * BM.bmHeight;
    return TRUE;
}

BOOL SaveHiconToICOFile(HICON hIcon, CHAR * pFileName, int nBit)
{
    ICONHEADER        IconHead;
    ICONDIRENTRY    IconDir;
    ICONINFO        IconInfo;
    HANDLE            hFile;
    VOID *            pColorDIB;
    VOID *            pMaskDIB;
    BITMAPINFO *    pColorInfo;
    BITMAPINFO *    phMaskInfo;
    DWORD    dwColorInfoSize, dwMaskInfoSize;
    DWORD    dwColorDIBSize,  dwMaskDIBSize;
    DWORD            dwWrite;
    BOOL            bRetVal;

    if(hIcon == NULL || pFileName == NULL)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    if(nBit != 0 && nBit != 1 && nBit != 4 && nBit != 5 && 
        nBit != 16 && nBit != 32)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    hFile = CreateFileA(pFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        return FALSE;
    }
    memset(&IconHead, 0, sizeof(IconHead));
    memset(&IconDir, 0, sizeof(IconDir));
    GetIconInfo(hIcon,  &IconInfo);

    GetBitmapSize(IconInfo.hbmColor, &dwColorInfoSize, &dwColorDIBSize, nBit);
    GetBitmapSize(IconInfo.hbmColor, &dwMaskInfoSize,  &dwMaskDIBSize,  1);
    pColorInfo    = (BITMAPINFO *)malloc(dwColorInfoSize);  
    phMaskInfo    = (BITMAPINFO *)malloc(dwMaskInfoSize); 
    if(pColorInfo == NULL || phMaskInfo == NULL)
    {
        ::SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }
    memset(pColorInfo, 0, dwColorInfoSize);
    memset(phMaskInfo, 0, dwMaskInfoSize);
    pColorDIB    = DDBToDIB(IconInfo.hbmColor, NULL, pColorInfo, 0);
    pMaskDIB    = DDBToDIB(IconInfo.hbmMask,  NULL, phMaskInfo, 1);    //单色蒙板

    IconHead.idReserved    = 0;
    IconHead.idType        = 1;
    IconHead.idCount    = 1;        //一个图标
    IconDir.bWidth        = (BYTE)pColorInfo->bmiHeader.biWidth;
    IconDir.bHeight        = (BYTE)pColorInfo->bmiHeader.biHeight;
    IconDir.bColorCount    = pColorInfo->bmiHeader.biPlanes  *  pColorInfo->bmiHeader.biBitCount;
    IconDir.dwBytesInRes    = dwColorDIBSize  +  dwMaskDIBSize - dwMaskInfoSize;
    IconDir.dwImageOffset    = sizeof(IconHead)  +  sizeof(IconDir);
    bRetVal &= WriteFile(hFile, &IconHead, sizeof(IconHead), &dwWrite, NULL);
    bRetVal &= WriteFile(hFile, &IconDir,  sizeof(IconDir),  &dwWrite, NULL);
    pColorInfo->bmiHeader.biHeight        *= 2;    //Color + Mask
    pColorInfo->bmiHeader.biSizeImage    += dwMaskDIBSize - dwMaskInfoSize;
    bRetVal &= WriteFile(hFile, pColorInfo, dwColorInfoSize, &dwWrite, NULL);
    bRetVal &= WriteFile(hFile, (BYTE *)pColorDIB + dwColorInfoSize, dwColorDIBSize - dwColorInfoSize, &dwWrite, NULL);
    bRetVal &= WriteFile(hFile, (BYTE *)pMaskDIB  + dwMaskInfoSize,  dwMaskDIBSize  - dwMaskInfoSize,  &dwWrite, NULL);
    
    // Ben: WriteFile() do the correct thing, but return 0, so:
    DWORD nErr;
    nErr = GetLastError();
    bRetVal = (0 == nErr) ? TRUE:FALSE;

    free(pColorInfo);
    free(phMaskInfo);
    GlobalFree(pColorDIB);    //for DDBToDIB
    GlobalFree(pMaskDIB);
    DeleteObject(IconInfo.hbmColor);
    DeleteObject(IconInfo.hbmMask);
    CloseHandle(hFile);
    return  bRetVal;
}

DWORD DibMaskFill(HANDLE hDib, HANDLE hMaskDib, COLORREF Color)
{
    BITMAPINFO *    pColorInfo;
    BITMAPINFO *    phMaskInfo;
    pColorInfo = (BITMAPINFO *)hDib;
    phMaskInfo = (BITMAPINFO *)hMaskDib;
    if(phMaskInfo->bmiHeader.biBitCount > 2)    //    蒙板 不是单色
    {
        return 0;
    }
    return 0;
}

HBITMAP GetHiconBitmap(HICON hIcon, COLORREF Color)
{
    ICONINFO    IconInfo;
    BITMAP        BM;
    HBITMAP        hBitmap, hBitmapOld1, hBitmapOld2;
    BOOL        bRetVal = TRUE;
    HDC        hmDC, hMemDc1, hMemDc2;
    hmDC    = GetDC(NULL);
    hMemDc1    = CreateCompatibleDC(hmDC);
    hMemDc2    = CreateCompatibleDC(hmDC);
    if(GetIconInfo(hIcon, &IconInfo) == FALSE)
    {
        Msgerr("GetIconInfo Error!");
        return NULL;
    }
    GetObject(IconInfo.hbmColor, sizeof(BITMAP), &BM);
    hBitmap = CreateBitmap(BM.bmWidth, BM.bmHeight, BM.bmPlanes, BM.bmBitsPixel, NULL);
    hBitmapOld1 = (HBITMAP)::SelectObject(hMemDc1, hBitmap);
    hBitmapOld2 = (HBITMAP)::SelectObject(hMemDc2, IconInfo.hbmColor);
    FloodFill(hMemDc1, 0, 0, Color);
    bRetVal = MaskBlt(hMemDc1, 0, 0, BM.bmWidth, BM.bmHeight, hMemDc2, 0, 0, IconInfo.hbmMask, 0, 0, 0xCCAA0000);
    if(bRetVal == FALSE)
    {
        Msgerr("MaskBlt Error");
        return NULL;
    }
    ::SelectObject(hMemDc1, hBitmapOld1);
    ::SelectObject(hMemDc2, hBitmapOld2);
    DeleteObject(IconInfo.hbmColor);
    DeleteObject(IconInfo.hbmMask);
    DeleteDC(hMemDc1);
    DeleteDC(hMemDc2);
    ::ReleaseDC(NULL, hmDC);
    return hBitmap;
}

#ifdef USEJPEGLIB

BOOL SaveBitmapToJPG(HBITMAP hBitMap, CHAR * pJPGName, int nQuality)
{
    HANDLE        hDib = NULL;
    HPALETTE    hPalette = NULL;
    BOOL        bRetVal;
    hDib = DDBToDIB(hBitMap, hPalette);
    if(hDib == NULL)
    {
        return FALSE;
    }
    bRetVal = JpegFromDib(hDib, nQuality, pJPGName);
    GlobalFree(hDib);
    return bRetVal;
}

RGBQUAD QuadFromWord(WORD b16)
{
    BYTE bytVals[] =
    {
        0,  16, 24, 32,  40, 48, 56, 64,
            72, 80, 88, 96, 104,112,120,128,
            136,144,152,160,168,176,184,192,
            200,208,216,224,232,240,248,255
    };
    WORD wR = b16;
    WORD wG = b16;
    WORD wB = b16;
    RGBQUAD rgb;
    wR <<= 1; wR >>= 11;
    wG <<= 6; wG >>= 11;
    wB <<= 11; wB >>= 11;
    rgb.rgbReserved = 0;
    rgb.rgbBlue     = bytVals[wB];
    rgb.rgbGreen    = bytVals[wG];
    rgb.rgbRed      = bytVals[wR];
    return rgb;
}

BOOL DibToSamps(HANDLE hDib, int nSampsPerRow, struct jpeg_compress_struct cinfo,
    JSAMPARRAY jsmpPixels)
{
    //Sanity...
    if (hDib == NULL || nSampsPerRow <= 0) 
    { 
        ::SetLastError(ERROR_INVALID_HANDLE);
        return FALSE; 
    } 
    int r=0, p=0, q=0, b=0, n=0, 
        nUnused=0, nBytesWide=0, nUsed=0, nLastBits=0, nLastNibs=0, nCTEntries=0,
        nRow=0, nByte=0, nPixel=0;
    BYTE bytCTEnt=0;
    LPBITMAPINFOHEADER pbBmHdr= (LPBITMAPINFOHEADER)hDib; //The bit count tells you the format of the bitmap: //Decide how many entries will be in the color table (if any) 
    switch (pbBmHdr->biBitCount)
    {
    case 1:
        nCTEntries = 2;   //Monochrome
        break;
    case 4:
        nCTEntries = 16;  //16-color
        break;
    case 8:
        nCTEntries = 256; //256-color
        break;
    case 16:
    case 24:
    case 32:
        nCTEntries = 0;   //No color table needed
        break;
    default:
        ::SetLastError(ERROR_INVALID_HANDLE);
        return FALSE; //Unsupported format
    }

    DWORD     dwCTab = (DWORD)pbBmHdr + pbBmHdr->biSize;
    LPRGBQUAD pCTab  = (LPRGBQUAD)(dwCTab);
    LPSTR     lpBits = (LPSTR)pbBmHdr +
        (WORD)pbBmHdr->biSize +    (WORD)(nCTEntries * sizeof(RGBQUAD));

    //Different formats for the image bits
    LPBYTE   lpPixels = (LPBYTE)  lpBits;
    RGBQUAD* pRgbQs   = (RGBQUAD*)lpBits;
    WORD*    wPixels  = (WORD*)   lpBits;

    //Set up the jsamps according to the bitmap's format.
    //Note that rows are processed bottom to top, because
    //that's how bitmaps are created.
    switch (pbBmHdr->biBitCount)
    {
    case 1:
        nUsed      = (pbBmHdr->biWidth + 7) / 8;
        nUnused    = (((nUsed + 3) / 4) * 4) - nUsed;
        nBytesWide = nUsed + nUnused;
        nLastBits  = 8 - ((nUsed * 8) - pbBmHdr->biWidth);

        for (r=0; r < pbBmHdr->biHeight; r++)
        {
            for (p=0, q=0; p < nUsed; p++) 
            { 
                nRow=(pbBmHdr->biHeight-r-1) * nBytesWide;
                nByte =  nRow + p;
                int nBUsed = (p < (nUsed >> 1) ) ? 8 : nLastBits;
                //                                        ^^        Not sure about this symbol Might be problem               
                for(b=0; b < nBUsed;b++) 
                { 
                    bytCTEnt = lpPixels[nByte] << b; 
                    bytCTEnt = bytCTEnt >> 7;

                    jsmpPixels[r][q+0] = pCTab[bytCTEnt].rgbRed;
                    jsmpPixels[r][q+1] = pCTab[bytCTEnt].rgbGreen;
                    jsmpPixels[r][q+2] = pCTab[bytCTEnt].rgbBlue;

                    q += 3;
                }
            }
        }
        break;

    case 4:
        nUsed      = (pbBmHdr->biWidth + 1) / 2;
        nUnused    = (((nUsed + 3) / 4) * 4) - nUsed;
        nBytesWide = nUsed + nUnused;
        nLastNibs  = 2 - ((nUsed * 2) - pbBmHdr->biWidth);

        for (r=0; r < pbBmHdr->biHeight;r++)
        {
            for (p=0,q=0; p < nUsed;p++) 
            { 
                nRow=(pbBmHdr->biHeight-r-1) * nBytesWide;
                nByte = nRow + p;

                int nNibbles = (p  >> (4- (n * 4)) );
                jsmpPixels[r][q+0] = pCTab[bytCTEnt].rgbRed;
                jsmpPixels[r][q+1] = pCTab[bytCTEnt].rgbGreen;
                jsmpPixels[r][q+2] = pCTab[bytCTEnt].rgbBlue;
                q += 3;
            }
        }
        break;

    default:
    case 8: //Each byte is a pointer to a pixel color
        nUnused = (((pbBmHdr->biWidth + 3) / 4) * 4) -
            pbBmHdr->biWidth;

        for (r=0;r < pbBmHdr->biHeight; r++)
        {
            for (p=0,q=0; p < pbBmHdr->biWidth; p++,q+=3)
            {
                nRow   = (pbBmHdr->biHeight-r-1) * (pbBmHdr->biWidth + nUnused);
                nPixel =  nRow + p;

                jsmpPixels[r][q+0] = pCTab[lpPixels[nPixel]].rgbRed;
                jsmpPixels[r][q+1] = pCTab[lpPixels[nPixel]].rgbGreen;
                jsmpPixels[r][q+2] = pCTab[lpPixels[nPixel]].rgbBlue;
            }
        }
        break;

    case 16: //Hi-color (16 bits per pixel)
        for (r=0;r < pbBmHdr->biHeight; r++)
        {
            for (p=0,q=0; p < pbBmHdr->biWidth; p++,q+=3)
            {
                nRow    = (pbBmHdr->biHeight-r-1) * pbBmHdr->biWidth;
                nPixel  = nRow + p;

                RGBQUAD quad = QuadFromWord(wPixels[nPixel]);

                jsmpPixels[r][q+0] = quad.rgbRed;
                jsmpPixels[r][q+1] = quad.rgbGreen;
                jsmpPixels[r][q+2] = quad.rgbBlue;
            }
        }
        break;

    case 24:
        nBytesWide =  (pbBmHdr->biWidth*3);
        nUnused    =  (((nBytesWide + 3) / 4) * 4) -
            nBytesWide;
        nBytesWide += nUnused;

        for (r=0; r < pbBmHdr->biHeight; r++)
        {
            for (p=0,q=0;p < (nBytesWide-nUnused); p+=3,q+=3)
            { 
                nRow = (pbBmHdr->biHeight-r-1) * nBytesWide;
                nPixel  = nRow + p;

                jsmpPixels[r][q+0] = lpPixels[nPixel+2]; //Red
                jsmpPixels[r][q+1] = lpPixels[nPixel+1]; //Green
                jsmpPixels[r][q+2] = lpPixels[nPixel+0]; //Blue
            }
        }
        break;

    case 32:
        for (r=0; r < pbBmHdr->biHeight; r++)
        {
            for (p=0,q=0; p < pbBmHdr->biWidth; p++,q+=3)
            {
                nRow    = (pbBmHdr->biHeight-r-1) *
                    pbBmHdr->biWidth;
                nPixel  = nRow + p;

                jsmpPixels[r][q+0] = pRgbQs[nPixel].rgbRed;
                jsmpPixels[r][q+1] = pRgbQs[nPixel].rgbGreen;
                jsmpPixels[r][q+2] = pRgbQs[nPixel].rgbBlue;
            }
        }
        break;
    }   //end switch
    return TRUE;
}

BOOL JpegFromDib(HANDLE hDib, int nQuality, CHAR * pJPGName)
{
    BOOL    bRetVal;
    int        nError;
    //Basic sanity checks...
    if (nQuality < 0 || nQuality > 100 || hDib   == NULL)
    {
        ::SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    byte *buf2 = 0;
    //Use libjpeg functions to write scanlines to disk in JPEG format
    jpeg_compress_struct * pcinfo = (jpeg_compress_struct *)malloc(sizeof(jpeg_compress_struct) * 4);
    memset(pcinfo, 0, sizeof(jpeg_compress_struct) * 4);    //WARNING    jpeg_start_compress OVER
    struct jpeg_error_mgr       jerr;

    FILE*      pOutFile;     //Target file 
    int        nSampsPerRow; //Physical row width in image buffer 
    JSAMPARRAY jsmpArray;    //Pixel RGB buffer for JPEG file
    pcinfo->err = jpeg_std_error(&jerr); //Use default error handling (ugly!)

    jpeg_create_compress(pcinfo);

    pOutFile = fopen(pJPGName, "wb");
    if (pOutFile == NULL)
    {
        nError = ::GetLastError();
        jpeg_destroy_compress(pcinfo);
        ::SetLastError(nError);
        free(pcinfo);
        return FALSE;
    }

    jpeg_stdio_dest(pcinfo, pOutFile);

    LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER)hDib;

    pcinfo->image_width      = lpbi->biWidth;  //Image width and height, in pixels 
    pcinfo->image_height     = lpbi->biHeight;
    pcinfo->input_components = 3;              //Color components per pixel
    //(RGB_PIXELSIZE - see jmorecfg.h)
    pcinfo->in_color_space   = JCS_RGB;          //Colorspace of input image

    jpeg_set_defaults(pcinfo);
    jpeg_set_quality(pcinfo, nQuality, TRUE);    //Limit to baseline-JPEG values
    jpeg_start_compress(pcinfo, TRUE);

    //JSAMPLEs per row in output buffer
    nSampsPerRow = pcinfo->image_width * pcinfo->input_components; 

    //Allocate array of pixel RGB values
    jsmpArray = (*pcinfo->mem->alloc_sarray)
        ((j_common_ptr) pcinfo,    JPOOL_IMAGE, nSampsPerRow, pcinfo->image_height);
    bRetVal = DibToSamps(hDib, nSampsPerRow, *pcinfo, jsmpArray);
    if(bRetVal == FALSE)
    {
        nError = ::GetLastError();
        jpeg_finish_compress(pcinfo); //Always finish
        fclose(pOutFile);
        jpeg_destroy_compress(pcinfo); //Free resources
        free(pcinfo);
        ::SetLastError(nError);
        return FALSE;
    }
    //Write the array of scan lines to the JPEG file
    jpeg_write_scanlines(pcinfo, jsmpArray, pcinfo->image_height);
    jpeg_finish_compress(pcinfo); //Always finish
    fclose(pOutFile);
    jpeg_destroy_compress(pcinfo); //Free resources
    free(pcinfo);
    return TRUE;
}

#endif

/*
//  Bmp转换为Ico格式,  nBit为色彩位数,  支持位数如下：
//  0,  1,  4,  8,  16,  24,  32
//-------------------------
void  Bmp2Ico(String  strBmpFileName,  int  nBit)
{
    int  nIconWidth    =  GetSystemMetrics(SM_CXICON);
    int  nIconHeight  =  GetSystemMetrics(SM_CYICON);;
    Graphics::TBitmap  *MyBmp  =  new  Graphics::TBitmap();
    MyBmp->LoadFromFile(strBmpFileName);
    Graphics::TBitmap  *AndMask  =  new  Graphics::TBitmap();
    AndMask->Width    =  nIconWidth;
    AndMask->Height  =  nIconHeight;
    AndMask->Canvas->Brush->Color  =  clBlack;
    AndMask->Canvas->Rectangle(0,  0,  nIconWidth,  nIconHeight);
    Graphics::TBitmap  *XorMask  =  new  Graphics::TBitmap();
    XorMask->Width    =  nIconWidth;
    XorMask->Height  =  nIconHeight;
    StretchBlt(XorMask->Canvas->Handle,  0,  0,  nIconWidth,  nIconHeight,
        MyBmp->Canvas->Handle,  0,  0,  MyBmp->Width,  MyBmp->Height,  SRCCOPY);
    TIcon  *pIcon  =  new  TIcon();
    TIconInfo  IconInfo;
    IconInfo.fIcon  =  true;
    IconInfo.xHotspot  =  0;
    IconInfo.yHotspot  =  0;
    IconInfo.hbmMask    =  AndMask->Handle;
    IconInfo.hbmColor  =  XorMask->Handle;
    pIcon->Handle  =  CreateIconIndirect(&IconInfo);
    delete  AndMask;
    delete  XorMask;
    delete  MyBmp;
    String  strIcoFileName  =  ChangeFileExt(strBmpFileName,  ".ico");
    SaveIcon(pIcon->Handle,  strIcoFileName.c_str(),  nBit);
    delete  pIcon;
}
*/