windows-server-2003/windows/advcore/gdiplus/engine/entry/compatibledib.cpp

/**************************************************************************\
* 
* Copyright (c) 2000  Microsoft Corporation
*
* Module Name:
*
*    Compatible DIBSections
*
* Abstract:
*
*    Create a DIB section with an optimal format w.r.t. the specified hdc.
*    If the hdc format is <8bpp, returns an 8bpp DIBSection.
*    If the hdc format is not recognized, returns a 32bpp DIBSection.
*
* Notes:
*
* History:
*
*  01/23/1996 gilmanw
*     Created it.
*  01/21/2000 agodfrey
*     Added it to GDI+ (from Gilman's 'fastdib.c'), and morphed it into 
*     'CreateSemiCompatibleDIB'.
*  08/10/2000 agodfrey
*     Hacked it further so that if we don't understand the format, we make
*     a 32bpp section. Bug #96879. 
*
\**************************************************************************/

#include "precomp.hpp"
#include "compatibleDIB.hpp"


const DWORD AlphaMaskFromPixelFormatIndex[PIXFMT_MAX] = {
    0x00000000, // PixelFormatUndefined
    0x00000000, // PixelFormat1bppIndexed
    0x00000000, // PixelFormat4bppIndexed
    0x00000000, // PixelFormat8bppIndexed
    0x00000000, // PixelFormat16bppGrayScale
    0x00000000, // PixelFormat16bppRGB555
    0x00000000, // PixelFormat16bppRGB565
    0x00008000, // PixelFormat16bppARGB1555
    0x00000000, // PixelFormat24bppRGB
    0x00000000, // PixelFormat32bppRGB
    0xff000000, // PixelFormat32bppARGB
    0xff000000, // PixelFormat32bppPARGB
    0x00000000, // PixelFormat48bppRGB
    0x00000000, // PixelFormat64bppARGB
    0x00000000, // PixelFormat64bppPARGB
    0x00000000  // PixelFormat24bppBGR
};

const DWORD RedMaskFromPixelFormatIndex[PIXFMT_MAX] = {
    0x00000000, // PixelFormatUndefined
    0x00000000, // PixelFormat1bppIndexed
    0x00000000, // PixelFormat4bppIndexed
    0x00000000, // PixelFormat8bppIndexed
    0x00000000, // PixelFormat16bppGrayScale
    0x00007c00, // PixelFormat16bppRGB555
    0x0000f800, // PixelFormat16bppRGB565
    0x00007c00, // PixelFormat16bppARGB1555
    0x00ff0000, // PixelFormat24bppRGB
    0x00ff0000, // PixelFormat32bppRGB
    0x00ff0000, // PixelFormat32bppARGB
    0x00ff0000, // PixelFormat32bppPARGB
    0x00000000, // PixelFormat48bppRGB
    0x00000000, // PixelFormat64bppARGB
    0x00000000, // PixelFormat64bppPARGB
    0x000000ff  // PixelFormat24bppBGR
};

const DWORD GreenMaskFromPixelFormatIndex[PIXFMT_MAX] = {
    0x00000000, // PixelFormatUndefined
    0x00000000, // PixelFormat1bppIndexed
    0x00000000, // PixelFormat4bppIndexed
    0x00000000, // PixelFormat8bppIndexed
    0x00000000, // PixelFormat16bppGrayScale
    0x000003e0, // PixelFormat16bppRGB555
    0x000007e0, // PixelFormat16bppRGB565
    0x000003e0, // PixelFormat16bppARGB1555
    0x0000ff00, // PixelFormat24bppRGB
    0x0000ff00, // PixelFormat32bppRGB
    0x0000ff00, // PixelFormat32bppARGB
    0x0000ff00, // PixelFormat32bppPARGB
    0x00000000, // PixelFormat48bppRGB
    0x00000000, // PixelFormat64bppARGB
    0x00000000, // PixelFormat64bppPARGB
    0x0000ff00  // PixelFormat24bppBGR
};

const DWORD BlueMaskFromPixelFormatIndex[PIXFMT_MAX] = {
    0x00000000, // PixelFormatUndefined
    0x00000000, // PixelFormat1bppIndexed
    0x00000000, // PixelFormat4bppIndexed
    0x00000000, // PixelFormat8bppIndexed
    0x00000000, // PixelFormat16bppGrayScale
    0x0000001f, // PixelFormat16bppRGB555
    0x0000001f, // PixelFormat16bppRGB565
    0x0000001f, // PixelFormat16bppARGB1555
    0x000000ff, // PixelFormat24bppRGB
    0x000000ff, // PixelFormat32bppRGB
    0x000000ff, // PixelFormat32bppARGB
    0x000000ff, // PixelFormat32bppPARGB
    0x00000000, // PixelFormat48bppRGB
    0x00000000, // PixelFormat64bppARGB
    0x00000000, // PixelFormat64bppPARGB
    0x00ff0000  // PixelFormat24bppBGR
};


/**************************************************************************\
* CreatePBMIFromPixelFormat
*
* Fills in the fields of a BITMAPINFO so that we can create a bitmap
* that matches the format of the display.
*
* This is done by analyzing the pixelFormat
*
* Arguments:
*    OUT pbmi : this must point to a valid BITMAPINFO structure
*               which has enough space for the palette (RGBQUAD array)
*               and MUST be zero initialized.
*    palette  : Input palette that will be copied into the BITMAPINFO
*               if it's a palettized mode.
*    pixelFormat : Input pixel format.
*  
*
* History:
*  06/07/1995 gilmanw
*     Created it.
*  01/21/2000 agodfrey
*     Munged it for GDI+'s needs.
*  08/11/2000 asecchia
*     Extracted the pixel format detection into a separate routine.
*     It now analyzes the pixelformat for all its data.
*
\**************************************************************************/

static VOID
CreatePBMIFromPixelFormat(
    OUT BITMAPINFO *pbmi,
    IN ColorPalette *palette, 
    IN PixelFormatID pixelFormat
    )
{
    // NOTE: Contents of pbmi should be zero initialized by the caller.
    
    ASSERT(pbmi != NULL);    
    if(pixelFormat == PixelFormatUndefined) { return; }
    
    // GDI can't handle the following formats: 
    
    ASSERT(
        pixelFormat != PixelFormatUndefined &&
        pixelFormat != PixelFormat16bppGrayScale &&
        pixelFormat != PixelFormat16bppARGB1555 &&
        pixelFormat != PixelFormat48bppRGB &&
        pixelFormat != PixelFormat64bppARGB &&
        pixelFormat != PixelFormat64bppPARGB
    );
 
    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    pbmi->bmiHeader.biWidth = 0;
    pbmi->bmiHeader.biHeight = 0;
    pbmi->bmiHeader.biPlanes = 1;    
    pbmi->bmiHeader.biBitCount = (WORD)GetPixelFormatSize(pixelFormat);
        
    pbmi->bmiHeader.biCompression = BI_RGB;
    
    if (IsIndexedPixelFormat(pixelFormat))
    {        
        // Fill the color table

        // If there's no palette, assume the caller is going to 
        // set it up.
                
        if(palette)
        {
            RGBQUAD *rgb = pbmi->bmiColors;
            UINT         i;
            
            for (i=0; i<palette->Count; i++, rgb++)
            {
               GpColor color(palette->Entries[i]);
            
               rgb->rgbRed    = color.GetRed();
               rgb->rgbGreen  = color.GetGreen();
               rgb->rgbBlue   = color.GetBlue();
            }
        }
    }
    else
    {
        INT pfSize = GetPixelFormatSize(pixelFormat);
        
        if( (pfSize==16) || (pfSize==32) )
        {
            // BI_BITFIELDS is only valid on 16- and 32-bpp formats.
            
            pbmi->bmiHeader.biCompression = BI_BITFIELDS;
        }
        
        // Get the masks from the 16bpp, 24bpp and 32bpp formats.
        DWORD* masks = reinterpret_cast<DWORD*>(&pbmi->bmiColors[0]);
        INT formatIndex = GetPixelFormatIndex(pixelFormat);
        
        masks[0] = RedMaskFromPixelFormatIndex[formatIndex];
        masks[1] = GreenMaskFromPixelFormatIndex[formatIndex];
        masks[2] = BlueMaskFromPixelFormatIndex[formatIndex];
    }
}

/**************************************************************************\
* CreateSemiCompatibleDIB
*
* Create a DIB section with an optimal format w.r.t. the specified hdc.
*
* If DC format <= 8bpp, creates an 8bpp section using the specified palette.
* If the palette handle is NULL, then the system palette is used.
*
* Otherwise, if the DC format is not natively supported, creates a 32bpp
* section.
*
* Note: The hdc must be a direct DC (not an info or memory DC).
*
* Arguments:
*
*   hdc                 - The reference hdc
*   ulWidth             - The width of the desired DIBSection
*   ulHeight            - The height of the desired DIBSection
*   palette             - The palette for <=8bpp modes
*   [OUT] ppvBits       - A pointer to the DIBSection's bits
*   [OUT] pixelFormat   - The pixel format of the returned DIBSection
*
* Returns:
*   Valid bitmap handle if successful, NULL if error.
*
* History:
*  01/23/1996 gilmanw
*     Created it.
*  01/21/2000 agodfrey
*     Munged it for GDI+'s needs.
*  08/11/2000 asecchia
*     Call more general pixel format determination code.
\**************************************************************************/

HBITMAP 
CreateSemiCompatibleDIB(
    HDC hdc,
    ULONG ulWidth, 
    ULONG ulHeight,
    ColorPalette *palette,
    PVOID *ppvBits,
    PixelFormatID *pixelFormat
    )
{
    HBITMAP hbmRet = (HBITMAP) NULL;
    BYTE aj[sizeof(BITMAPINFO) + (sizeof(RGBQUAD) * 255)];
    BITMAPINFO *pbmi = (BITMAPINFO *) aj;

    ASSERT(GetDCType(hdc) == OBJ_DC);
    ASSERT(pixelFormat && ppvBits);

    // Zero initialize the pbmi. This is a requirement for 
    // CreatePBMIFromPixelFormat()
    
    GpMemset(aj, 0, sizeof(aj));

    *pixelFormat = ExtractPixelFormatFromHDC(hdc);
    
    if(IsIndexedPixelFormat(*pixelFormat))
    {
        // For indexed modes, we only support 8bpp. Lower bit-depths
        // are supported via 8bpp mode, if at all.
        
        *pixelFormat = PixelFormat8bppIndexed;
    }

    // Not all printer HDC's have queriable palettes, the GpDevice()
    // constructor doesn't support it.  Fake 32bpp in this case.
    
    // Also, if the format is undefined, use 32bpp, and the caller will use
    // GDI to do the conversion.
    
    if (   (   (GetDeviceCaps(hdc, TECHNOLOGY) == DT_RASPRINTER)
            && (IsIndexedPixelFormat(*pixelFormat))
           )
        || (*pixelFormat == PixelFormatUndefined)
       )
    {
        *pixelFormat = PixelFormat32bppRGB;
    }
    
    CreatePBMIFromPixelFormat(pbmi, palette, *pixelFormat);
    
    // Change bitmap size to match specified dimensions.

    pbmi->bmiHeader.biWidth = ulWidth;
    pbmi->bmiHeader.biHeight = ulHeight;
    if (pbmi->bmiHeader.biCompression == BI_RGB)
    {
        pbmi->bmiHeader.biSizeImage = 0;
    }
    else
    {
        if ( pbmi->bmiHeader.biBitCount == 16 )
            pbmi->bmiHeader.biSizeImage = ulWidth * ulHeight * 2;
        else if ( pbmi->bmiHeader.biBitCount == 32 )
            pbmi->bmiHeader.biSizeImage = ulWidth * ulHeight * 4;
        else
            pbmi->bmiHeader.biSizeImage = 0;
    }
    pbmi->bmiHeader.biClrUsed = 0;
    pbmi->bmiHeader.biClrImportant = 0;

    // Create the DIB section.  Let Win32 allocate the memory and return
    // a pointer to the bitmap surface.

    hbmRet = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, ppvBits, NULL, 0);

    if ( !hbmRet )
    {
        ONCE(WARNING(("CreateSemiCompatibleDIB: CreateDIBSection failed")));
    }

    return hbmRet;
}

/**************************************************************************\
* ExtractPixelFormatFromHDC
* 
* Returns:
*   PixelFormatID if successful, PixelFormatUndefined if not.
*
* History:
*  08/11/2000 asecchia
*     Created it.
\**************************************************************************/

PixelFormatID
ExtractPixelFormatFromHDC(
    HDC hdc
    )
{
    HBITMAP hbm;
    BOOL    bRet = FALSE;
    PixelFormatID pixelFormat = PixelFormatUndefined;
    
    BYTE bmi_buf[sizeof(BITMAPINFO) + (sizeof(RGBQUAD) * 255)];
    BITMAPINFO *pbmi = (BITMAPINFO *) bmi_buf;
    
    GpMemset(bmi_buf, 0, sizeof(bmi_buf));
    
    // Create a dummy bitmap from which we can query color format info
    // about the device surface.

    if ( (hbm = CreateCompatibleBitmap(hdc, 1, 1)) != NULL )
    {
        pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

        // Call first time to fill in BITMAPINFO header.

        GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);

        // First handle the 'simple' case of indexed formats.
        
        if ( pbmi->bmiHeader.biBitCount <= 8 )
        {
            switch(pbmi->bmiHeader.biBitCount)
            {
            case 1: pixelFormat = PixelFormat1bppIndexed; break;
            case 4: pixelFormat = PixelFormat4bppIndexed; break;
            case 8: pixelFormat = PixelFormat8bppIndexed; break;
            
            // Fallthrough on default - the pixelFormat is already
            // initialized to PixelFormatUndefined.
            default: 
                WARNING((
                    "BitDepth %d from GetDIBits is not supported.", 
                    pbmi->bmiHeader.biBitCount
                ));                
            }
        }
        else
        {
            DWORD redMask = 0;
            DWORD greenMask = 0;
            DWORD blueMask = 0;
            
            if ( pbmi->bmiHeader.biCompression == BI_BITFIELDS )
            {
                // Call a second time to get the color masks.
                // It's a GetDIBits Win32 "feature".

                GetDIBits(
                    hdc, 
                    hbm, 
                    0, 
                    pbmi->bmiHeader.biHeight, 
                    NULL, 
                    pbmi,
                    DIB_RGB_COLORS
                );
                          
                DWORD* masks = reinterpret_cast<DWORD*>(&pbmi->bmiColors[0]);

                redMask = masks[0];
                greenMask = masks[1];
                blueMask = masks[2];          
            }
            else if (pbmi->bmiHeader.biCompression == BI_RGB)
            {
               redMask   = 0x00ff0000;
               greenMask = 0x0000ff00;
               blueMask  = 0x000000ff;
            }
            
            if ((redMask   == 0x00ff0000) &&
                (greenMask == 0x0000ff00) &&
                (blueMask  == 0x000000ff))
            {
                if (pbmi->bmiHeader.biBitCount == 24)
                {
                    pixelFormat = PixelFormat24bppRGB;
                }
                else if (pbmi->bmiHeader.biBitCount == 32)
                {
                    pixelFormat = PixelFormat32bppRGB;
                }
            }
            else if ((redMask   == 0x000000ff) &&
                     (greenMask == 0x0000ff00) &&
                     (blueMask  == 0x00ff0000) &&
                     (pbmi->bmiHeader.biBitCount == 24))
            {
                pixelFormat = PIXFMT_24BPP_BGR;
            }            
            else if ((redMask   == 0x00007c00) &&
                     (greenMask == 0x000003e0) &&
                     (blueMask  == 0x0000001f) &&
                     (pbmi->bmiHeader.biBitCount == 16))
            {
                pixelFormat = PixelFormat16bppRGB555;
            }
            else if ((redMask   == 0x0000f800) &&
                     (greenMask == 0x000007e0) &&
                     (blueMask  == 0x0000001f) &&
                     (pbmi->bmiHeader.biBitCount == 16))
            {
                pixelFormat = PixelFormat16bppRGB565;
            }
        }

        if (pixelFormat == PixelFormatUndefined)
        {
            ONCE(WARNING(("(once) ExtractPixelFormatFromHDC: Unrecognized pixel format")));
        }

        DeleteObject(hbm);
    }
    else
    {
        WARNING(("ExtractPixelFormatFromHDC: CreateCompatibleBitmap failed"));
    }

    return pixelFormat;
}