dib.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include <math.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "wincrypt.h"
#include "mmsystem.h"
#include "wine/test.h"

Include dependency graph for dib.c:

Go to the source code of this file.

Functions
static BOOL	rop_uses_src (DWORD rop)
static DWORD	get_stride (const BITMAPINFO *bmi)
static DWORD	get_dib_size (const BITMAPINFO *bmi)
static void	reset_bits (HDC hdc, const BITMAPINFO *bmi, BYTE *bits)
static char *	hash_dib (HDC hdc, const BITMAPINFO *bmi, const void *bits)
static void	reset_bounds (HDC hdc)
static void	compare_bounds (HDC hdc, const char *info)
static void	compare_hash_broken_todo (HDC hdc, const BITMAPINFO *bmi, BYTE *bits, const char *info, int num_broken, BOOL todo)
static void	compare_hash (HDC hdc, const BITMAPINFO *bmi, BYTE *bits, const char *info)
static HPALETTE	create_default_palette (int bpp)
static void	solid_patblt (HDC hdc, int x, int y, int width, int height, COLORREF color)
static void	draw_graphics (HDC hdc, const BITMAPINFO *bmi, BYTE *bits)
static void	get_range (BYTE alpha, DWORD text_comp, BYTE *min_comp, BYTE *max_comp)
static BYTE	aa_comp (BYTE dst, BYTE text, BYTE alpha)
static COLORREF	aa_colorref (COLORREF dst, COLORREF text, BYTE glyph)
static void	draw_text_2 (HDC hdc, const BITMAPINFO *bmi, BYTE *bits, BOOL aa)
static void	draw_text (HDC hdc, const BITMAPINFO *bmi, BYTE *bits)
static void	test_simple_graphics (void)
	START_TEST (dib)

Variables
static HCRYPTPROV	crypt_prov
static const DWORD	rop3 [256]
static const char *	sha1_graphics_a8r8g8b8 []
static const char *	sha1_graphics_a8r8g8b8_bitfields []
static const char *	sha1_graphics_a8b8g8r8 []
static const char *	sha1_graphics_r10g10b10 []
static const char *	sha1_graphics_r6g6b6 []
static const char *	sha1_graphics_24 []
static const char *	sha1_graphics_r5g5b5 []
static const char *	sha1_graphics_r4g4b4 []
static const char *	sha1_graphics_8_color []
static const char *	sha1_graphics_8_grayscale []
static const char *	sha1_graphics_8 []
static const char *	sha1_graphics_4 []
static const char *	sha1_graphics_4_grayscale []
static const char *	sha1_graphics_1 []
static const char *	sha1_graphics_1_ddb []
static const char *	sha1_graphics_1_ddb_inverted []
static const RECT	graphics_bounds []
static const char **	current_sha1
static const RECT *	current_bounds
static const char *	dst_format
static const RECT	bias_check []
static const RECT	hline_clips []
static const RECT	vline_clips []
static const RECT	line_clips []
static const RECT	wide_lines []
static const POINT	poly_lines []
static const POINT	polypoly_lines []
static const DWORD	polypoly_counts []
static const RECT	patblt_clips []
static const RECT	rectangles []
static const BITMAPINFOHEADER	dib_brush_header_8888 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 32, BI_RGB, 0, 0, 0, 0, 0}
static const BITMAPINFOHEADER	dib_brush_header_24 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 24, BI_RGB, 0, 0, 0, 0, 0}
static const BITMAPINFOHEADER	dib_brush_header_555 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 16, BI_RGB, 0, 0, 0, 0, 0}
static const BITMAPINFOHEADER	dib_brush_header_8 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 8, BI_RGB, 0, 0, 0, 0, 0}
static const BITMAPINFOHEADER	dib_brush_header_4 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 4, BI_RGB, 0, 0, 0, 0, 0}
static const BITMAPINFOHEADER	dib_brush_header_1 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 1, BI_RGB, 0, 0, 0, 0, 0}
static const BYTE	rle8_data [20]
static const DWORD	four_by_four_data [16]
static const DWORD	ddb_brush_bits [8]
static const RGBQUAD	default_palette_1 [2]
static const RGBQUAD	default_palette_4 [16]
static const RGBQUAD	default_palette_8 [256]
static const BYTE	ramp [17]
static const BYTE	masks [8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01}

Function Documentation

aa_colorref()

static COLORREF aa_colorref ( COLORREF  dst, COLORREF  text, BYTE  glyph  )

inlinestatic

Definition at line 2998 of file dib.c.

{
    COLORREF ret;
 
    ret = RGB( aa_comp( GetRValue(dst), GetRValue(text), glyph ),
               aa_comp( GetGValue(dst), GetGValue(text), glyph ),
               aa_comp( GetBValue(dst), GetBValue(text), glyph ) );
    return ret;
}

Referenced by draw_text_2().

aa_comp()

static BYTE aa_comp ( BYTE  dst, BYTE  text, BYTE  alpha  )

inlinestatic

Definition at line 2972 of file dib.c.

{
    BYTE min_comp, max_comp;
 
    if (alpha == 16)  return text;
    if (alpha <= 1)   return dst;
    if (text == dst)  return dst;
 
    get_range( alpha, text, &min_comp, &max_comp );
 
    if (dst > text)
    {
        DWORD diff = dst - text;
        DWORD range = max_comp - text;
        dst = text + (diff * range ) / (0xff - text);
        return dst;
    }
    else
    {
        DWORD diff = text - dst;
        DWORD range = text - min_comp ;
        dst = text - (diff * range) / text;
        return dst;
    }
}

Referenced by aa_colorref().

compare_bounds()

static void compare_bounds ( HDC  hdc, const char *  info  )

static

Definition at line 1411 of file dib.c.

{
    RECT rect;
 
    GetBoundsRect( hdc, &rect, DCB_RESET );
 
    if (current_bounds->left == -1 &&
        current_bounds->top == -1 &&
        current_bounds->right == -1 &&
        current_bounds->bottom == -1)
    {
        ok( 0, "missing bounds, got %s,\n", wine_dbgstr_rect( &rect ));
        return;
    }
 
    ok( EqualRect( current_bounds, &rect ), "%s: %s: expected bounds %s got %s\n", dst_format, info,
        wine_dbgstr_rect( current_bounds ), wine_dbgstr_rect( &rect ));
    current_bounds++;
}

Referenced by compare_hash_broken_todo().

compare_hash()

static void compare_hash ( HDC  hdc, const BITMAPINFO *  bmi, BYTE *  bits, const char *  info  )

static

Definition at line 1472 of file dib.c.

{
    compare_hash_broken_todo(hdc, bmi, bits, info, 0, FALSE);
}

Referenced by draw_graphics().

compare_hash_broken_todo()

static void compare_hash_broken_todo ( HDC  hdc, const BITMAPINFO *  bmi, BYTE *  bits, const char *  info, int  num_broken, BOOL  todo  )

static

Definition at line 1431 of file dib.c.

{
    char *hash = hash_dib(hdc, bmi, bits);
    BOOL ok_cond;
    int i;
 
    /* reset the bits for the next test */
    reset_bits( hdc, bmi, bits );
 
    if(!hash)
    {
        skip("SHA1 hashing unavailable on this platform\n");
        return;
    }
 
    for(i = 0; i <= num_broken; i++)
    {
        if(current_sha1[i] == NULL)
        {
            ok(current_sha1[i] != NULL, "missing hash, got \"%s\",\n", hash);
            free(hash);
            return;
        }
    }
 
    ok_cond = !strcmp(hash, *current_sha1);
 
    for(i = 1; i <= num_broken; i++)
        ok_cond = ok_cond || broken( !strcmp(hash, current_sha1[i]) );
 
    todo_wine_if(todo)
        ok( ok_cond, "%s: %s: expected hash %s got %s\n",
            dst_format, info, *current_sha1, hash );
 
    current_sha1 += num_broken + 1;
 
    free( hash );
 
    compare_bounds( hdc, info );
}

Referenced by compare_hash(), and draw_graphics().

create_default_palette()

static HPALETTE create_default_palette ( int  bpp )

static

Definition at line 1705 of file dib.c.

{
    char pal_buffer[sizeof(LOGPALETTE) + 255 * sizeof(PALETTEENTRY)];
    LOGPALETTE *pal = (LOGPALETTE *)pal_buffer;
    PALETTEENTRY *entries = pal->palPalEntry;
    int i;
 
    pal->palVersion = 0x300;
    pal->palNumEntries = 1 << bpp;
    switch (bpp)
    {
    case 1:
        for (i = 0; i < 2; i++)
        {
            entries[i].peRed   = default_palette_1[i].rgbRed;
            entries[i].peGreen = default_palette_1[i].rgbGreen;
            entries[i].peBlue  = default_palette_1[i].rgbBlue;
            entries[i].peFlags = 0;
        }
        break;
    case 4:
        for (i = 0; i < 16; i++)
        {
            entries[i].peRed   = default_palette_4[i].rgbRed;
            entries[i].peGreen = default_palette_4[i].rgbGreen;
            entries[i].peBlue  = default_palette_4[i].rgbBlue;
            entries[i].peFlags = 0;
        }
        break;
    case 8:
        for (i = 0; i < 256; i++)
        {
            entries[i].peRed   = default_palette_8[i].rgbRed;
            entries[i].peGreen = default_palette_8[i].rgbGreen;
            entries[i].peBlue  = default_palette_8[i].rgbBlue;
            entries[i].peFlags = 0;
        }
        break;
    }
    return CreatePalette( pal );
}

Referenced by test_simple_graphics().

draw_graphics()

static void draw_graphics ( HDC  hdc, const BITMAPINFO *  bmi, BYTE *  bits  )

static

Definition at line 1755 of file dib.c.

{
    char pal_buffer[sizeof(LOGPALETTE) + 255 * sizeof(PALETTEENTRY)];
    LOGPALETTE *pal = (LOGPALETTE *)pal_buffer;
    PALETTEENTRY *entries = pal->palPalEntry;
    HPEN solid_pen, dashed_pen, wide_pen, orig_pen;
    LOGBRUSH log_brush;
    HBRUSH solid_brush, dib_brush, hatch_brush, orig_brush;
    HBITMAP bmp;
    INT i, j, x, y, hatch_style;
    HDC src_dc;
    HRGN hrgn, hrgn2;
    BYTE dib_src_buf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
    BYTE dib_brush_buf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD) + 16 * 16 * sizeof(DWORD)]; /* Enough for 16 x 16 at 32 bpp */
    BITMAPINFO *src_bi = (BITMAPINFO*)dib_src_buf;
    BITMAPINFO *brush_bi = (BITMAPINFO*)dib_brush_buf;
    RGBQUAD *brush_colors = brush_bi->bmiColors;
    BYTE *brush_bits, *src_bits;
    BOOL is_ddb = !bits;
    BOOL ret, dib_is_1bpp = (bmi->bmiHeader.biBitCount == 1);
    BOOL dib_is_8bpp_gray = (bmi->bmiHeader.biBitCount == 8 && bmi->bmiColors[1].rgbRed == 1);
    BLENDFUNCTION blend;
    COLORREF old_text, old_bkgnd;
    HPALETTE hpal, old_hpal;
 
    blend.BlendOp = AC_SRC_OVER;
    blend.BlendFlags = 0;
 
    reset_bounds( hdc );
    reset_bits( hdc, bmi, bits );
    compare_hash(hdc, bmi, bits, "empty");
 
    src_dc = CreateCompatibleDC( 0 );
    solid_pen = CreatePen(PS_SOLID, 1, RGB(0, 0, 0xff));
    orig_pen = SelectObject(hdc, solid_pen);
    SetBrushOrgEx(hdc, 0, 0, NULL);
 
    /* horizontal and vertical lines */
    for(i = 1; i <= 16; i++)
    {
        SetROP2(hdc, i);
        MoveToEx(hdc, 10, i * 3, NULL);
        LineTo(hdc, 100, i * 3); /* l -> r */
        MoveToEx(hdc, 100, 50 + i * 3, NULL);
        LineTo(hdc, 10, 50 + i * 3); /* r -> l */
        MoveToEx(hdc, 120 + i * 3, 10, NULL);
        LineTo(hdc, 120 + i * 3, 100); /* t -> b */
        MoveToEx(hdc, 170 + i * 3, 100, NULL);
        LineTo(hdc, 170 + i * 3, 10); /* b -> t */
    }
    compare_hash(hdc, bmi, bits, "h and v solid lines");
 
    /* diagonal lines */
    SetROP2(hdc, R2_COPYPEN);
    for(i = 0; i < 16; i++)
    {
        double s = sin(M_PI * i / 8.0);
        double c = cos(M_PI * i / 8.0);
 
        MoveToEx(hdc, 200.5 + 10 * c, 200.5 + 10 * s, NULL);
        LineTo(hdc, 200.5 + 100 * c, 200.5 + 100 * s);
    }
    compare_hash(hdc, bmi, bits, "diagonal solid lines");
 
    for(i = 0; i < ARRAY_SIZE(bias_check); i++)
    {
        MoveToEx(hdc, bias_check[i].left, bias_check[i].top, NULL);
        LineTo(hdc, bias_check[i].right, bias_check[i].bottom);
    }
    compare_hash(hdc, bmi, bits, "more diagonal solid lines");
 
    /* solid brush PatBlt */
    solid_brush = CreateSolidBrush(RGB(0x33, 0xaa, 0xff));
    orig_brush = SelectObject(hdc, solid_brush);
 
    for(i = 0, y = 10; i < 256; i++)
    {
        ret = PatBlt(hdc, 10, y, 100, 10, rop3[i]);
 
        if(rop_uses_src(rop3[i]))
            ok(ret == FALSE || broken(is_ddb), "got TRUE for %lx\n", rop3[i]);
        else
        {
            ok(ret, "got FALSE for %lx\n", rop3[i]);
            y += 20;
        }
 
    }
    compare_hash_broken_todo(hdc, bmi, bits, "solid patblt", is_ddb, is_ddb);
 
    /* clipped lines */
    hrgn = CreateRectRgn(10, 10, 200, 20);
    hrgn2 = CreateRectRgn(100, 100, 200, 200);
    CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
    SetRectRgn(hrgn2, 290, 100, 300, 200);
    CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
    ExtSelectClipRgn(hdc, hrgn, RGN_COPY);
    DeleteObject(hrgn2);
 
    for(i = 0; i < ARRAY_SIZE(hline_clips); i++)
    {
        MoveToEx(hdc, hline_clips[i].left, hline_clips[i].top, NULL);
        LineTo(hdc, hline_clips[i].right, hline_clips[i].bottom);
    }
    compare_hash(hdc, bmi, bits, "clipped solid hlines");
 
    for(i = 0; i < ARRAY_SIZE(vline_clips); i++)
    {
        MoveToEx(hdc, vline_clips[i].left, vline_clips[i].top, NULL);
        LineTo(hdc, vline_clips[i].right, vline_clips[i].bottom);
    }
    compare_hash(hdc, bmi, bits, "clipped solid vlines");
 
    for(i = 0; i < ARRAY_SIZE(line_clips); i++)
    {
        MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
        LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
    }
    compare_hash(hdc, bmi, bits, "clipped solid diagonal lines");
 
    /* clipped PatBlt */
    for(i = 0; i < ARRAY_SIZE(patblt_clips); i++)
    {
        PatBlt(hdc, patblt_clips[i].left, patblt_clips[i].top,
               patblt_clips[i].right - patblt_clips[i].left,
               patblt_clips[i].bottom - patblt_clips[i].top, PATCOPY);
    }
    compare_hash_broken_todo(hdc, bmi, bits, "clipped patblt", is_ddb, is_ddb);
 
    /* clipped dashed lines */
    dashed_pen = CreatePen(PS_DASH, 1, RGB(0xff, 0, 0));
    SelectObject(hdc, dashed_pen);
    SetBkMode(hdc, TRANSPARENT);
    SetBkColor(hdc, RGB(0, 0xff, 0));
 
    for(i = 0; i < ARRAY_SIZE(hline_clips); i++)
    {
        MoveToEx(hdc, hline_clips[i].left, hline_clips[i].top, NULL);
        LineTo(hdc, hline_clips[i].right, hline_clips[i].bottom);
    }
    compare_hash(hdc, bmi, bits, "clipped dashed hlines");
 
    for(i = 0; i < ARRAY_SIZE(hline_clips); i++)
    {
        MoveToEx(hdc, hline_clips[i].right - 1, hline_clips[i].bottom, NULL);
        LineTo(hdc, hline_clips[i].left - 1, hline_clips[i].top);
    }
    compare_hash(hdc, bmi, bits, "clipped dashed hlines r -> l");
 
    for(i = 0; i < ARRAY_SIZE(vline_clips); i++)
    {
        MoveToEx(hdc, vline_clips[i].left, vline_clips[i].top, NULL);
        LineTo(hdc, vline_clips[i].right, vline_clips[i].bottom);
    }
    compare_hash(hdc, bmi, bits, "clipped dashed vlines");
 
    for(i = 0; i < ARRAY_SIZE(vline_clips); i++)
    {
        MoveToEx(hdc, vline_clips[i].right, vline_clips[i].bottom - 1, NULL);
        LineTo(hdc, vline_clips[i].left, vline_clips[i].top - 1);
    }
    compare_hash(hdc, bmi, bits, "clipped dashed vlines b -> t");
 
    for(i = 0; i < ARRAY_SIZE(line_clips); i++)
    {
        MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
        LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
    }
    compare_hash(hdc, bmi, bits, "clipped dashed diagonal lines");
 
    SetBkMode(hdc, OPAQUE);
 
    for(i = 0; i < ARRAY_SIZE(line_clips); i++)
    {
        MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
        LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
    }
    compare_hash(hdc, bmi, bits, "clipped opaque dashed diagonal lines");
 
    ExtSelectClipRgn(hdc, NULL, RGN_COPY);
 
    /* 8888 DIB pattern brush */
 
    brush_bi->bmiHeader = dib_brush_header_8888;
    brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
    memset(brush_bits, 0, 16 * 16 * sizeof(DWORD));
    brush_bits[2] = 0xff;
    brush_bits[6] = 0xff;
    brush_bits[14] = 0xff;
    brush_bits[65] = 0xff;
    brush_bits[69] = 0xff;
    brush_bits[72] = 0xff;
 
    dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 
    SelectObject(hdc, dib_brush);
    SetBrushOrgEx(hdc, 1, 1, NULL);
 
    for(i = 0, y = 10; i < 256; i++)
    {
        if(!rop_uses_src(rop3[i]))
        {
            ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
            ok(ret, "got FALSE for %lx\n", rop3[i]);
            y += 25;
        }
    }
    compare_hash(hdc, bmi, bits, "top-down 8888 dib brush patblt");
 
    SelectObject(hdc, orig_brush);
    DeleteObject(dib_brush);
 
    /* 8888 bottom-up DIB pattern brush */
 
    brush_bi->bmiHeader.biHeight = -brush_bi->bmiHeader.biHeight;
 
    dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 
    SelectObject(hdc, dib_brush);
 
    /* This used to set the x origin to 100 as well, but
       there's a Windows bug for 24 bpp where the brush's x offset
       is incorrectly calculated for rops that involve both D and P */
    SetBrushOrgEx(hdc, 4, 100, NULL);
 
    for(i = 0, y = 10; i < 256; i++)
    {
        if(!rop_uses_src(rop3[i]))
        {
            ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
            ok(ret, "got FALSE for %lx\n", rop3[i]);
            y += 25;
        }
    }
    compare_hash(hdc, bmi, bits, "bottom-up 8888 dib brush patblt");
 
    SelectObject(hdc, orig_brush);
    DeleteObject(dib_brush);
 
    /* 24 bpp dib pattern brush */
 
    brush_bi->bmiHeader = dib_brush_header_24;
    brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
    memset(brush_bits, 0, 16 * 16 * 3);
    brush_bits[0] = brush_bits[3] = brush_bits[6] = brush_bits[8] = 0xff;
    brush_bits[49] = brush_bits[52] = 0xff;
 
    dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 
    SelectObject(hdc, dib_brush);
    SetBrushOrgEx(hdc, 1, 1, NULL);
 
    for(i = 0, y = 10; i < 256; i++)
    {
        if(!rop_uses_src(rop3[i]))
        {
            ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
            ok(ret, "got FALSE for %lx\n", rop3[i]);
            y += 25;
        }
    }
    compare_hash(hdc, bmi, bits, "top-down 24 bpp brush patblt");
 
    SelectObject(hdc, orig_brush);
    DeleteObject(dib_brush);
 
    /* 555 dib pattern brush */
 
    brush_bi->bmiHeader = dib_brush_header_555;
    brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
    memset(brush_bits, 0, 16 * 16 * sizeof(WORD));
    brush_bits[0] = brush_bits[1] = 0xff;
    brush_bits[32] = brush_bits[34] = 0x7c;
 
    dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 
    SelectObject(hdc, dib_brush);
    SetBrushOrgEx(hdc, 1, 1, NULL);
 
    for(i = 0, y = 10; i < 256; i++)
    {
        if(!rop_uses_src(rop3[i]))
        {
            ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
            ok(ret, "got FALSE for %lx\n", rop3[i]);
            y += 25;
        }
    }
    compare_hash_broken_todo(hdc, bmi, bits, "top-down 555 dib brush patblt", 0, dib_is_1bpp);
 
    SelectObject(hdc, orig_brush);
    DeleteObject(dib_brush);
 
    SetBrushOrgEx(hdc, 0, 0, NULL);
 
    /* 8 bpp dib pattern brush */
 
    brush_bi->bmiHeader = dib_brush_header_8;
    brush_bi->bmiHeader.biClrUsed = 3;
    memset(brush_colors, 0, brush_bi->bmiHeader.biClrUsed * sizeof(RGBQUAD));
    brush_colors[0].rgbRed = 0xff;
    brush_colors[1].rgbRed = 0xff;
    brush_colors[1].rgbGreen = 0xff;
    brush_colors[1].rgbBlue = 0xff;
 
    brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER) + brush_bi->bmiHeader.biClrUsed * sizeof(RGBQUAD);
    memset(brush_bits, 0, 16 * 16 * sizeof(BYTE));
    brush_bits[0] = brush_bits[1] = 1;
    brush_bits[16] = brush_bits[17] = 2;
    brush_bits[32] = brush_bits[33] = 6;
 
    dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 
    SelectObject(hdc, dib_brush);
    SetBrushOrgEx(hdc, 1, 1, NULL);
 
    for(i = 0, y = 10; i < 256; i++)
    {
        if(!rop_uses_src(rop3[i]))
        {
            ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
            ok(ret, "got FALSE for %lx\n", rop3[i]);
            y += 25;
        }
    }
    compare_hash_broken_todo(hdc, bmi, bits, "top-down 8 bpp dib brush patblt", 0, dib_is_1bpp);
 
    SelectObject(hdc, orig_brush);
    DeleteObject(dib_brush);
 
    /* 4 bpp dib pattern brush */
 
    brush_bi->bmiHeader = dib_brush_header_4;
    dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 
    SelectObject(hdc, dib_brush);
    SetBrushOrgEx(hdc, 1, 1, NULL);
 
    for(i = 0, y = 10; i < 256; i++)
    {
        if(!rop_uses_src(rop3[i]))
        {
            ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
            ok(ret, "got FALSE for %lx\n", rop3[i]);
            y += 25;
        }
    }
    compare_hash_broken_todo(hdc, bmi, bits, "top-down 4 bpp dib brush patblt", 0, dib_is_1bpp);
 
    SelectObject(hdc, orig_brush);
    DeleteObject(dib_brush);
 
    /* 1 bpp dib pattern brush */
 
    brush_bi->bmiHeader = dib_brush_header_1;
    brush_bi->bmiHeader.biClrUsed = 2;
    memset(brush_bits, 0, 16 * 4);
    brush_bits[0] = 0xf0;
    brush_bits[4] = 0xf0;
    brush_bits[8] = 0xf0;
 
    dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
    SelectObject(hdc, dib_brush);
    for(i = 0, y = 10; i < 256; i++)
    {
        if(!rop_uses_src(rop3[i]))
        {
            ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
            ok(ret, "got FALSE for %lx\n", rop3[i]);
            y += 25;
        }
    }
 
    compare_hash_broken_todo(hdc, bmi, bits, "top-down 1 bpp dib brush patblt", 0, dib_is_1bpp);
 
    SelectObject(hdc, orig_brush);
    DeleteObject(dib_brush);
 
    /* 1 bpp ddb pattern brush */
 
    old_text = GetTextColor( hdc );
    old_bkgnd = GetBkColor( hdc );
    bmp = CreateBitmap( 16, 16, 1, 1, ddb_brush_bits );
    dib_brush = CreatePatternBrush( bmp );
    SelectObject(hdc, dib_brush);
    for(i = 0, y = 10; i < 256; i++)
    {
        SetTextColor(hdc, RGB( i, 2*i, 255 - i ) );
        SetBkColor(hdc, RGB( 255 - i, i / 3, i ) );
        if(!rop_uses_src(rop3[i]))
        {
            ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
            ok(ret, "got FALSE for %lx\n", rop3[i]);
            y += 25;
        }
    }
 
    compare_hash_broken_todo(hdc, bmi, bits, "1 bpp ddb brush patblt", 0, dib_is_1bpp);
 
    DeleteObject(bmp);
    SelectObject(hdc, orig_brush);
    DeleteObject( dib_brush );
    SetBrushOrgEx(hdc, 0, 0, NULL);
    SetTextColor(hdc, old_text);
    SetBkColor(hdc, old_bkgnd);
 
    /* Rectangle */
 
    SelectObject(hdc, solid_pen);
    SelectObject(hdc, solid_brush);
 
    for(i = 0; i < ARRAY_SIZE(rectangles); i++)
    {
        Rectangle(hdc, rectangles[i].left, rectangles[i].top, rectangles[i].right, rectangles[i].bottom);
    }
 
    SelectObject(hdc, dashed_pen);
    for(i = 0; i < ARRAY_SIZE(rectangles); i++)
    {
        Rectangle(hdc, rectangles[i].left, rectangles[i].top + 150, rectangles[i].right, rectangles[i].bottom + 150);
    }
 
    compare_hash_broken_todo(hdc, bmi, bits, "rectangles", is_ddb, is_ddb);
    SelectObject(hdc, solid_pen);
 
    /* PaintRgn */
 
    PaintRgn(hdc, hrgn);
    compare_hash_broken_todo(hdc, bmi, bits, "PaintRgn", is_ddb, is_ddb);
 
    /* RTL rectangles */
 
    SetLayout(hdc, LAYOUT_RTL);
    PaintRgn(hdc, hrgn);
    PatBlt(hdc, 10, 250, 10, 10, PATCOPY);
    Rectangle(hdc, 100, 250, 110, 260);
    compare_hash_broken_todo(hdc, bmi, bits, "rtl", is_ddb, is_ddb);
    SetLayout(hdc, LAYOUT_LTR);
    DeleteObject( hrgn );
 
    for(i = 0, y = 10; i < 256; i++)
    {
        if(!rop_uses_src(rop3[i]))
        {
            for(hatch_style = HS_HORIZONTAL; hatch_style <= HS_DIAGCROSS; hatch_style++)
            {
                hatch_brush = CreateHatchBrush(hatch_style, RGB(0xff, 0, 0));
                SelectObject(hdc, hatch_brush);
                ret = PatBlt(hdc, 10 + i + 30 * hatch_style, y, 20, 20, rop3[i]);
                ok(ret, "got FALSE for %lx\n", rop3[i]);
                SelectObject(hdc, orig_brush);
                DeleteObject(hatch_brush);
            }
            y += 25;
        }
    }
 
    compare_hash(hdc, bmi, bits, "hatch brushes");
 
    /* overlapping blits */
 
    orig_brush = SelectObject(hdc, solid_brush);
 
    Rectangle(hdc, 10, 10, 100, 100);
    Rectangle(hdc, 20, 15, 30, 40);
    Rectangle(hdc, 15, 15, 20, 20);
    Rectangle(hdc, 15, 20, 50, 45);
    BitBlt( hdc, 20, 20, 100, 100, hdc, 10, 10, SRCCOPY );
    compare_hash_broken_todo(hdc, bmi, bits, "overlapping BitBlt SRCCOPY +x, +y", is_ddb, is_ddb);
 
    Rectangle(hdc, 10, 10, 100, 100);
    Rectangle(hdc, 20, 15, 30, 40);
    Rectangle(hdc, 15, 15, 20, 20);
    Rectangle(hdc, 15, 20, 50, 45);
    BitBlt( hdc, 10, 10, 100, 100, hdc, 20, 20, SRCCOPY );
    compare_hash_broken_todo(hdc, bmi, bits, "overlapping BitBlt SRCCOPY -x, -y", dib_is_1bpp + is_ddb, is_ddb);
 
    Rectangle(hdc, 10, 10, 100, 100);
    Rectangle(hdc, 20, 15, 30, 40);
    Rectangle(hdc, 15, 15, 20, 20);
    Rectangle(hdc, 15, 20, 50, 45);
    BitBlt( hdc, 20, 10, 100, 100, hdc, 10, 20, SRCCOPY );
    compare_hash_broken_todo(hdc, bmi, bits, "overlapping BitBlt SRCCOPY +x, -y", is_ddb, is_ddb);
 
    Rectangle(hdc, 10, 10, 100, 100);
    Rectangle(hdc, 20, 15, 30, 40);
    Rectangle(hdc, 15, 15, 20, 20);
    Rectangle(hdc, 15, 20, 50, 45);
    BitBlt( hdc, 10, 20, 100, 100, hdc, 20, 10, SRCCOPY );
    compare_hash_broken_todo(hdc, bmi, bits, "overlapping BitBlt SRCCOPY -x, +y", dib_is_1bpp + is_ddb, is_ddb);
 
    Rectangle(hdc, 10, 10, 100, 100);
    Rectangle(hdc, 20, 15, 30, 40);
    Rectangle(hdc, 15, 15, 20, 20);
    Rectangle(hdc, 15, 20, 50, 45);
    BitBlt( hdc, 20, 20, 100, 100, hdc, 10, 10, PATPAINT );
    compare_hash_broken_todo(hdc, bmi, bits, "overlapping BitBlt PATPAINT +x, +y", is_ddb, is_ddb);
 
    Rectangle(hdc, 10, 10, 100, 100);
    Rectangle(hdc, 20, 15, 30, 40);
    Rectangle(hdc, 15, 15, 20, 20);
    Rectangle(hdc, 15, 20, 50, 45);
    BitBlt( hdc, 10, 10, 100, 100, hdc, 20, 20, PATPAINT );
    compare_hash_broken_todo(hdc, bmi, bits, "overlapping BitBlt PATPAINT -x, -y", is_ddb, is_ddb);
 
    Rectangle(hdc, 10, 10, 100, 100);
    Rectangle(hdc, 20, 15, 30, 40);
    Rectangle(hdc, 15, 15, 20, 20);
    Rectangle(hdc, 15, 20, 50, 45);
    BitBlt( hdc, 20, 10, 100, 100, hdc, 10, 20, PATPAINT );
    if (bmi->bmiHeader.biBitCount >= 24)  /* Windows gets this one wrong */
        compare_hash_broken_todo(hdc, bmi, bits, "overlapping BitBlt PATPAINT +x, -y", 1, FALSE);
    else
        compare_hash_broken_todo(hdc, bmi, bits, "overlapping BitBlt PATPAINT +x, -y", is_ddb, is_ddb);
 
    Rectangle(hdc, 10, 10, 100, 100);
    Rectangle(hdc, 20, 15, 30, 40);
    Rectangle(hdc, 15, 15, 20, 20);
    Rectangle(hdc, 15, 20, 50, 45);
    BitBlt( hdc, 10, 20, 100, 100, hdc, 20, 10, PATPAINT );
    compare_hash_broken_todo(hdc, bmi, bits, "overlapping BitBlt PATPAINT -x, +y", is_ddb, is_ddb);
 
    /* blitting with 32-bpp BI_RGB source */
 
    memset( dib_src_buf, 0, sizeof(dib_src_buf) );
    src_bi->bmiHeader.biSize = sizeof(bmi->bmiHeader);
    src_bi->bmiHeader.biHeight = 256;
    src_bi->bmiHeader.biWidth = 256;
    src_bi->bmiHeader.biBitCount = 32;
    src_bi->bmiHeader.biPlanes = 1;
    src_bi->bmiHeader.biCompression = BI_RGB;
    bmp = CreateDIBSection(0, src_bi, DIB_RGB_COLORS, (void**)&src_bits, NULL, 0);
    SelectObject( src_dc, bmp );
    for (y = 0; y < 256; y++)
        for (x = 0; x < 256; x++)
        {
            BYTE a = (x + y) * 2;
            BYTE r = (BYTE)(y + 2 * x) * a / 255;
            BYTE g = (BYTE)(x + y / 3) * a / 255;
            BYTE b = (BYTE)(x / 3 + 2 * y) * a / 255;
            ((DWORD *)src_bits)[y * 256 + x] = (a << 24) | RGB( r, g, b );
        }
 
    BitBlt( hdc, 100, 100, 256, 256, src_dc, 0, 0, SRCCOPY );
 
    /* Interesting cases for 1-bpp dst */
    BitBlt( hdc, 1, 4, 2, 2, src_dc, 0, 0, SRCCOPY );
    BitBlt( hdc, 1, 8, 16, 2, src_dc, 0, 0, SRCCOPY );
    BitBlt( hdc, 1, 12, 15, 2, src_dc, 0, 0, SRCCOPY );
    BitBlt( hdc, 0, 16, 8, 2, src_dc, 0, 0, SRCCOPY );
    BitBlt( hdc, 0, 20, 9, 2, src_dc, 0, 0, SRCCOPY );
    BitBlt( hdc, 7, 24, 1, 2, src_dc, 0, 0, SRCCOPY );
    BitBlt( hdc, 7, 28, 2, 2, src_dc, 0, 0, SRCCOPY );
    BitBlt( hdc, 7, 32, 9, 2, src_dc, 0, 0, SRCCOPY );
    BitBlt( hdc, 7, 36, 10, 2, src_dc, 0, 0, SRCCOPY );
    compare_hash(hdc, bmi, bits, "BitBlt src 32-bpp SRCCOPY" );
 
    blend.SourceConstantAlpha = 0xd0;
    blend.AlphaFormat = 0;
    GdiAlphaBlend( hdc, 100, 100, 256, 256, src_dc, 0, 0, 256, 256, blend );
    compare_hash_broken_todo(hdc, bmi, bits, "AlphaBlend src 32-bpp no alpha", 0, dib_is_1bpp );
 
    blend.SourceConstantAlpha = 0xb0;
    blend.AlphaFormat = AC_SRC_ALPHA;
    GdiAlphaBlend( hdc, 50, 50, 256, 256, src_dc, 0, 0, 256, 256, blend );
    compare_hash_broken_todo(hdc, bmi, bits, "AlphaBlend src 32-bpp alpha", 0, dib_is_1bpp );
 
    /* blitting with 32-bpp r10g10b10 source */
 
    src_bi->bmiHeader.biBitCount = 32;
    src_bi->bmiHeader.biCompression = BI_BITFIELDS;
    ((DWORD *)src_bi->bmiColors)[0] = 0x3ff00000;
    ((DWORD *)src_bi->bmiColors)[1] = 0x000ffc00;
    ((DWORD *)src_bi->bmiColors)[2] = 0x000003ff;
    bmp = CreateDIBSection(0, src_bi, DIB_RGB_COLORS, (void**)&src_bits, NULL, 0);
    SelectObject( src_dc, bmp );
    for (y = 0; y < 256; y++)
        for (x = 0; x < 256; x++)
        {
            WORD r = (7 * x + 3 * y) % 1024;
            WORD g = (11 * x + y / 3) % 1024;
            WORD b = (x / 3 + 9 * y) % 1024;
            ((DWORD *)src_bits)[y * 256 + x] = r << 20 | g << 10 | b;
        }
 
    BitBlt( hdc, 100, 100, 256, 256, src_dc, 0, 0, SRCCOPY );
    compare_hash(hdc, bmi, bits, "BitBlt src 32-bpp r10g10b10 SRCCOPY" );
 
    /* blitting with 32-bpp b6g6r6 source */
 
    src_bi->bmiHeader.biBitCount = 32;
    src_bi->bmiHeader.biCompression = BI_BITFIELDS;
    ((DWORD *)src_bi->bmiColors)[0] = 0x00003f;
    ((DWORD *)src_bi->bmiColors)[1] = 0x000fc0;
    ((DWORD *)src_bi->bmiColors)[2] = 0x03f000;
    bmp = CreateDIBSection(0, src_bi, DIB_RGB_COLORS, (void**)&src_bits, NULL, 0);
    SelectObject( src_dc, bmp );
    for (y = 0; y < 256; y++)
        for (x = 0; x < 256; x++)
        {
            BYTE r = (y + 2 * x) % 64;
            BYTE g = (x + y / 3) % 64;
            BYTE b = (x / 3 + 2 * y) % 64;
            ((DWORD *)src_bits)[y * 256 + x] = r | g << 6 | b << 12;
        }
 
    BitBlt( hdc, 100, 100, 256, 256, src_dc, 0, 0, SRCCOPY );
    compare_hash(hdc, bmi, bits, "BitBlt src 32-bpp b6g6r6 SRCCOPY" );
 
    /* blitting with 24-bpp source */
 
    src_bi->bmiHeader.biBitCount = 24;
    src_bi->bmiHeader.biCompression = BI_RGB;
    bmp = CreateDIBSection(0, src_bi, DIB_RGB_COLORS, (void**)&src_bits, NULL, 0);
    DeleteObject( SelectObject( src_dc, bmp ) );
    for (y = 0; y < 256; y++)
        for (x = 0; x < 256; x++)
        {
            src_bits[(y * 256 + x) * 3 + 0] = x + 3 * y;
            src_bits[(y * 256 + x) * 3 + 1] = 2 * x + 7 * y;
            src_bits[(y * 256 + x) * 3 + 2] = 5 * x + 12 * y;
        }
 
    BitBlt( hdc, 100, 100, 256, 256, src_dc, 0, 0, SRCCOPY );
    compare_hash(hdc, bmi, bits, "BitBlt src 24-bpp SRCCOPY" );
 
    blend.SourceConstantAlpha = 0xe0;
    blend.AlphaFormat = 0;
    GdiAlphaBlend( hdc, 100, 100, 256, 256, src_dc, 0, 0, 256, 256, blend );
    compare_hash_broken_todo(hdc, bmi, bits, "AlphaBlend src 24-bpp", 0, dib_is_1bpp );
 
    /* blitting with 16-bpp BI_RGB source */
 
    src_bi->bmiHeader.biBitCount = 16;
    src_bi->bmiHeader.biCompression = BI_RGB;
    bmp = CreateDIBSection(0, src_bi, DIB_RGB_COLORS, (void**)&src_bits, NULL, 0);
    DeleteObject( SelectObject( src_dc, bmp ) );
    for (y = 0; y < 256; y++)
        for (x = 0; x < 256; x++)
            ((WORD *)src_bits)[y * 256 + x] = x | x << 4 | x << 8 | y << 3 | y << 7;
 
    BitBlt( hdc, 100, 100, 256, 256, src_dc, 0, 0, SRCCOPY );
    compare_hash(hdc, bmi, bits, "BitBlt src 16-bpp SRCCOPY" );
 
    /* blitting with 16-bpp b4g4r4 source */
 
    src_bi->bmiHeader.biBitCount = 16;
    src_bi->bmiHeader.biCompression = BI_BITFIELDS;
    ((DWORD *)src_bi->bmiColors)[0] = 0x00000f;
    ((DWORD *)src_bi->bmiColors)[1] = 0x0000f0;
    ((DWORD *)src_bi->bmiColors)[2] = 0x000f00;
    bmp = CreateDIBSection(0, src_bi, DIB_RGB_COLORS, (void**)&src_bits, NULL, 0);
    DeleteObject( SelectObject( src_dc, bmp ) );
    for (y = 0; y < 256; y++)
        for (x = 0; x < 256; x++)
            ((WORD *)src_bits)[y * 256 + x] = x | x << 4 | x << 8 | y << 3 | y << 7;
 
    BitBlt( hdc, 100, 100, 256, 256, src_dc, 0, 0, SRCCOPY );
    compare_hash(hdc, bmi, bits, "BitBlt src 16-bpp b4g4r4 SRCCOPY" );
 
    /* blitting with 8-bpp source */
 
    src_bi->bmiHeader.biBitCount = 8;
    src_bi->bmiHeader.biCompression = BI_RGB;
    src_bi->bmiHeader.biClrUsed = 160;
    for (i = 0; i < 256; i++) ((DWORD *)src_bi->bmiColors)[i] = i | (i * 3) << 8 | (i / 2) << 16;
    bmp = CreateDIBSection(0, src_bi, DIB_RGB_COLORS, (void**)&src_bits, NULL, 0);
    DeleteObject( SelectObject( src_dc, bmp ) );
    for (y = 0; y < 256; y++)
        for (x = 0; x < 256; x++)
            src_bits[y * 256 + x] = 3 * x + 5 * y;
 
    BitBlt( hdc, 100, 100, 256, 256, src_dc, 0, 0, SRCCOPY );
    compare_hash(hdc, bmi, bits, "BitBlt src 8-bpp SRCCOPY" );
 
    blend.SourceConstantAlpha = 0xd0;
    blend.AlphaFormat = 0;
    GdiAlphaBlend( hdc, 100, 100, 256, 256, src_dc, 0, 0, 256, 256, blend );
    compare_hash_broken_todo(hdc, bmi, bits, "AlphaBlend src 8-bpp", 0, dib_is_1bpp );
 
    /* blitting with 4-bpp source */
 
    src_bi->bmiHeader.biBitCount = 4;
    src_bi->bmiHeader.biClrUsed = 12;
    for (i = 0; i < 16; i++) ((DWORD *)src_bi->bmiColors)[i] = i | (i * 5) << 8 | (i * 19) << 16;
    bmp = CreateDIBSection(0, src_bi, DIB_RGB_COLORS, (void**)&src_bits, NULL, 0);
    DeleteObject( SelectObject( src_dc, bmp ) );
    for (y = 0; y < 256; y++)
        for (x = 0; x < 256; x += 2)
            src_bits[(y * 256 + x) / 2] = 7 * x + 3 * y;
 
    BitBlt( hdc, 100, 100, 256, 256, src_dc, 0, 0, SRCCOPY );
    compare_hash(hdc, bmi, bits, "BitBlt src 4-bpp SRCCOPY" );
 
    /* blitting with 1-bpp source */
 
    src_bi->bmiHeader.biBitCount = 1;
    src_bi->bmiHeader.biClrUsed = 0;
    for (i = 0; i < 2; i++) ((DWORD *)src_bi->bmiColors)[i] = (i + 37) | (i * 91) << 8 | (i * 53) << 16;
    bmp = CreateDIBSection(0, src_bi, DIB_RGB_COLORS, (void**)&src_bits, NULL, 0);
    DeleteObject( SelectObject( src_dc, bmp ) );
    for (y = 0; y < 256; y++)
        for (x = 0; x < 256; x += 8)
            src_bits[(y * 256 + x) / 8] = 7 * x + 3 * y;
 
    BitBlt( hdc, 100, 100, 256, 256, src_dc, 0, 0, SRCCOPY );
    /* Some interesting src co-ords */
    BitBlt( hdc, 10, 10, 3, 10, src_dc, 0, 0, SRCCOPY );
    BitBlt( hdc, 20, 10, 3, 10, src_dc, 2, 0, SRCCOPY );
    BitBlt( hdc, 30, 10, 3, 10, src_dc, 5, 0, SRCCOPY );
    BitBlt( hdc, 40, 10, 3, 10, src_dc, 6, 0, SRCCOPY );
    BitBlt( hdc, 50, 10, 20, 10, src_dc, 6, 0, SRCCOPY );
    compare_hash(hdc, bmi, bits, "BitBlt src 1-bpp SRCCOPY" );
 
    blend.SourceConstantAlpha = 0x90;
    blend.AlphaFormat = 0;
    GdiAlphaBlend( hdc, 100, 100, 256, 256, src_dc, 0, 0, 256, 256, blend );
    compare_hash_broken_todo(hdc, bmi, bits, "AlphaBlend src 1-bpp", 0, is_ddb );
 
    /* blitting with 1-bpp ddb source */
 
    bmp = CreateBitmap( 16, 16, 1, 1, ddb_brush_bits );
    DeleteObject( SelectObject( src_dc, bmp ) );
 
    old_text = GetTextColor( hdc );
    old_bkgnd = GetBkColor( hdc );
    for (i = 0; i < 256; i += 13)
    {
        SetTextColor(hdc, RGB( i, 2*i, 255 - i ) );
        SetBkColor(hdc, RGB( 255 - i, i / 3, i ) );
        BitBlt( hdc, i, 0, 13, 13, src_dc, 0, 0, SRCCOPY );
    }
    for (i = 0; i < 256; i += 13)
    {
        SetTextColor(hdc, PALETTEINDEX( i ));
        SetBkColor(hdc, PALETTEINDEX( i + 3 ));
        BitBlt( hdc, i, 13, 13, 13, src_dc, 0, 0, SRCCOPY );
    }
    for (i = 0; i < 256; i += 13)
    {
        SetTextColor(hdc, DIBINDEX( i ));
        SetBkColor(hdc, DIBINDEX( i + 3 ));
        BitBlt( hdc, i, 26, 13, 13, src_dc, 0, 0, SRCCOPY );
    }
    SetTextColor( hdc, old_text );
    SetBkColor( hdc, old_bkgnd );
    compare_hash(hdc, bmi, bits, "BitBlt src 1-bpp ddb SRCCOPY" );
 
    DeleteObject( bmp );
 
    /* blitting to 1-bpp ddb dest */
 
    bmp = CreateBitmap( 16, 16, 1, 1, ddb_brush_bits );
    DeleteObject( SelectObject( src_dc, bmp ) );
 
    for (y = 0; y < 16; y++)
        for (x = 0; x < 16; x++)
            SetPixel( hdc, x, y, RGB( 16 * x, 16 * y, 8 * (x + y)) );
    PatBlt( hdc, 15, 15, 1, 1, WHITENESS );
    /* source colors are ignored */
    SetTextColor( src_dc, 0xbeef );
    SetBkColor( src_dc, RGB( 16 * 2, 16 * 3, 8 * (2 + 3) ));
    /* destination text color is also ignored */
    SetTextColor( hdc, 0xbedead );
 
    if (bits)
    {
        i = 16;
        SetBkColor( hdc, 0xffffff );
        BitBlt( src_dc, 0, 0, 16, 16, hdc, 0, 0, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        StretchDIBits( src_dc, 0, 0, 16, 16, 0,
                       bmi->bmiHeader.biHeight - 16, 16, 16, bits, bmi, DIB_RGB_COLORS, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        SetBkColor( hdc, 0 );
        BitBlt( src_dc, 0, 0, 16, 16, hdc, 0, 0, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        StretchDIBits( src_dc, 0, 0, 16, 16, 0,
                       bmi->bmiHeader.biHeight - 16, 16, 16, bits, bmi, DIB_RGB_COLORS, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        SetBkColor( hdc, RGB( 16 * 2, 16 * 3, 8 * (2 + 3) ));
        BitBlt( src_dc, 0, 0, 16, 16, hdc, 0, 0, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        StretchDIBits( src_dc, 0, 0, 16, 16, 0,
                       bmi->bmiHeader.biHeight - 16, 16, 16, bits, bmi, DIB_RGB_COLORS, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        SetBkColor( hdc, RGB( 16 * 13, 16 * 14, 8 * (13 + 14) ));
        BitBlt( src_dc, 0, 0, 16, 16, hdc, 0, 0, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        StretchDIBits( src_dc, 0, 0, 16, 16, 0,
                       bmi->bmiHeader.biHeight - 16, 16, 16, bits, bmi, DIB_RGB_COLORS, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        SetBkColor( hdc, PALETTEINDEX( 1 ));
        BitBlt( src_dc, 0, 0, 16, 16, hdc, 0, 0, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        StretchDIBits( src_dc, 0, 0, 16, 16, 0,
                       bmi->bmiHeader.biHeight - 16, 16, 16, bits, bmi, DIB_RGB_COLORS, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        SetBkColor( hdc, DIBINDEX( 2 ));
        BitBlt( src_dc, 0, 0, 16, 16, hdc, 0, 0, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        StretchDIBits( src_dc, 0, 0, 16, 16, 0,
                       bmi->bmiHeader.biHeight - 16, 16, 16, bits, bmi, DIB_RGB_COLORS, SRCCOPY );
        GetBitmapBits( bmp, 32, bits + get_stride(bmi) * i++ );
        SetTextColor( hdc, old_text );
        SetBkColor( hdc, old_bkgnd );
    }
    compare_hash(hdc, bmi, bits, "BitBlt dst 1-bpp ddb");
 
    DeleteDC( src_dc );
    DeleteObject( bmp );
 
    /* RLE StretchDIBits */
    src_bi->bmiHeader.biSize        = sizeof(src_bi->bmiHeader);
    src_bi->bmiHeader.biWidth       = 8;
    src_bi->bmiHeader.biHeight      = 8;
    src_bi->bmiHeader.biPlanes      = 1;
    src_bi->bmiHeader.biBitCount    = 8;
    src_bi->bmiHeader.biCompression = BI_RLE8;
    src_bi->bmiHeader.biClrUsed     = 0;
    src_bi->bmiHeader.biSizeImage   = sizeof(rle8_data);
 
    for (i = 0; i < 256; i++)
    {
        src_bi->bmiColors[i].rgbRed      = i;
        src_bi->bmiColors[i].rgbGreen    = i;
        src_bi->bmiColors[i].rgbBlue     = i;
        src_bi->bmiColors[i].rgbReserved = 0;
    }
 
    StretchDIBits( hdc,  10, 10, 7, 7, 0, 0, 7, 7, rle8_data, src_bi, DIB_RGB_COLORS, SRCCOPY );
    StretchDIBits( hdc, 100, 10, 7, 7, 0, 0, 7, 7, rle8_data, src_bi, DIB_RGB_COLORS, SRCAND );
    StretchDIBits( hdc, 200, 10, 7, 7, 0, 1, 7, 7, rle8_data, src_bi, DIB_RGB_COLORS, SRCCOPY );
    StretchDIBits( hdc, 300, 10, 7, 7, 1, 0, 7, 7, rle8_data, src_bi, DIB_RGB_COLORS, SRCCOPY );
    StretchDIBits( hdc, 400, 10, 16, 16, 0, 0, 8, 8, rle8_data, src_bi, DIB_RGB_COLORS, SRCCOPY );
    compare_hash_broken_todo(hdc,  bmi, bits, "rle stretchdibits", 0, dib_is_1bpp );
 
    /* 32 bpp StretchDIBits */
 
    src_bi->bmiHeader.biWidth       = 4;
    src_bi->bmiHeader.biHeight      = 4;
    src_bi->bmiHeader.biPlanes      = 1;
    src_bi->bmiHeader.biBitCount    = 32;
    src_bi->bmiHeader.biCompression = BI_RGB;
    src_bi->bmiHeader.biClrUsed     = 0;
    src_bi->bmiHeader.biSizeImage   = 0;
 
    ret = StretchDIBits( hdc,  10, 10, 4, 4, 0, 0, 4, 4, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCCOPY );
    ok(ret == 4, "got %d\n", ret);
    ret = StretchDIBits( hdc,  20, 10, 4, 4, 0, 0, 4, 4, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCAND );
    ok(ret == 4, "got %d\n", ret);
    ret = StretchDIBits( hdc,  30, 10, 3, 3, 1, 1, 3, 3, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCCOPY );
    ok(ret == 4, "got %d\n", ret);
    ret = StretchDIBits( hdc,  40, 10, 3, 3, 1, 1, 3, 3, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCAND );
    ok(ret == 4, "got %d\n", ret);
    ret = StretchDIBits( hdc,  50, 10, -2, -2, 2, 3, -2, -2, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCCOPY );
    ok(ret == 4, "got %d\n", ret);
    ret = StretchDIBits( hdc,  60, 10, -2, -2, 2, 3, -2, -2, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCAND );
    ok(ret == 4, "got %d\n", ret);
 
    src_bi->bmiHeader.biHeight = -4;
 
    ret = StretchDIBits( hdc,  10, 100, 4, 4, 0, 0, 4, 4, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCCOPY );
    ok(ret == 4, "got %d\n", ret);
    ret = StretchDIBits( hdc,  20, 100, 4, 4, 0, 0, 4, 4, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCAND );
    ok(ret == -4, "got %d\n", ret);
    ret = StretchDIBits( hdc,  30, 100, 3, 3, 1, 1, 3, 3, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCCOPY );
    ok(ret == 4, "got %d\n", ret);
    ret = StretchDIBits( hdc,  40, 100, 3, 3, 1, 1, 3, 3, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCAND );
    ok(ret == -4, "got %d\n", ret);
    ret = StretchDIBits( hdc,  50, 100, -2, -2, 2, 3, -2, -2, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCCOPY );
    ok(ret == 4, "got %d\n", ret);
    ret = StretchDIBits( hdc,  60, 100, -2, -2, 2, 3, -2, -2, four_by_four_data, src_bi, DIB_RGB_COLORS, SRCAND );
    ok(ret == -4, "got %d\n", ret);
 
    compare_hash_broken_todo(hdc,  bmi, bits, "stretchdibits", dib_is_8bpp_gray ? 1 : 0, dib_is_8bpp_gray );
 
    /* Solid colors */
 
    for (i = 0; i < 16; i++)
    {
        for (j = 0; j < 16; j++)
        {
            solid_patblt( hdc, 16 * j, 16 * i, 16, 16, RGB( i*16+j, i*16+j, i*16+j ));
            solid_patblt( hdc, 16 * j, 256 + 16 * i, 16, 16, RGB( 3*(i*16+j), i*16+j, i*16+j ));
            solid_patblt( hdc, 256 + 16 * j, 16 * i, 16, 16, RGB( i*16+j, 3*(i*16+j), i*16+j ));
            solid_patblt( hdc, 256 + 16 * j, 256 + 16 * i, 16, 16, RGB( i*16+j, i*16+j, 3*(i*16+j) ));
        }
    }
    compare_hash_broken_todo(hdc, bmi, bits, "color fills", is_ddb, is_ddb);
 
    for (i = 0; i < 256; i++)
    {
        solid_patblt( hdc, i * 2, 10, 1, 1, DIBINDEX(i) );
        solid_patblt( hdc, i * 2, 20, 1, 1, PALETTEINDEX(i) );
        solid_patblt( hdc, i * 2, 30, 1, 1, RGB( (i & 0x07) << 5, (i & 0x38) << 2, i & 0xc0 ) );
        solid_patblt( hdc, i * 2, 40, 1, 1, PALETTERGB( (i & 0x07) << 5, (i & 0x38) << 2, i & 0xc0 ) );
        for (j = 0; j < 256; j++) solid_patblt( hdc, i * 2, 50 + j, 1, 1, (j << 24) | i );
    }
 
    /* A few extra colors that are interesting in the 1bpp case */
 
    /* bk color */
    solid_patblt( hdc, 0, 50, 1, 1, RGB( 0, 0xff, 0 ) );
    solid_patblt( hdc, 2, 50, 1, 1, PALETTERGB( 0, 0xff, 0 ) );
 
    /* color 0 */
    solid_patblt( hdc, 4, 50, 1, 1, RGB( 0, 0x1, 0xff ) );
    solid_patblt( hdc, 6, 50, 1, 1, PALETTERGB( 0, 0x1, 0xff ) );
 
    /* color 1 */
    solid_patblt( hdc,  8, 50, 1, 1, RGB( 0xff, 0, 0 ) );
    solid_patblt( hdc, 10, 50, 1, 1, PALETTERGB( 0xff, 0, 0 ) );
 
    compare_hash_broken_todo(hdc, bmi, bits, "Colors", is_ddb, is_ddb);
 
    for (i = 0; i < 256; i++)
    {
        COLORREF s, g;
 
        for (j = 0; j < 16; j++)
        {
            SetROP2( hdc, (j + R2_COPYPEN - 1) % 16 + 1 ); /* Start with R2_COPYPEN */
 
            s = SetPixel( hdc, i * 2, j, DIBINDEX(i) );
            g = GetPixel( hdc, i * 2, 0 ); /* retrieve value set with R2_COPYPEN */
            ok( s == g, "got %08lx and %08lx\n", s, g );
 
            s = SetPixel( hdc, i * 2, 20 + j, PALETTEINDEX(i) );
            g = GetPixel( hdc, i * 2, 20 + 0 ); /* retrieve value set with R2_COPYPEN */
            ok( s == g, "got %08lx and %08lx\n", s, g );
 
            s = SetPixel( hdc, i * 2, 40 + j, RGB( (i & 0x07) << 5, (i & 0x38) << 2, i & 0xc0 ) );
            g = GetPixel( hdc, i * 2, 40 + 0 ); /* retrieve value set with R2_COPYPEN */
            ok( s == g, "got %08lx and %08lx\n", s, g );
 
            s = SetPixel( hdc, i * 2, 60 + j, PALETTERGB( (i & 0x07) << 5, (i & 0x38) << 2, i & 0xc0 ) );
            g = GetPixel( hdc, i * 2, 60 + 0 ); /* retrieve value set with R2_COPYPEN */
            ok( s == g, "got %08lx and %08lx\n", s, g );
        }
 
        SetROP2( hdc, R2_COPYPEN );
 
        for (j = 0; j < 256; j++)
        {
            s = SetPixel( hdc, i * 2, 80 + j, (j << 24) | RGB( (i & 0x07) << 5, (i & 0x38) << 2, i & 0xc0 ));
            g = GetPixel( hdc, i * 2, 80 + j );
            ok( s == g, "got %08lx and %08lx\n", s, g );
 
            s = SetPixel( hdc, i * 2 + 1, 80 + j, (j << 24) | i );
            g = GetPixel( hdc, i * 2 + 1, 80 + j );
            ok( s == g, "got %08lx and %08lx\n", s, g );
        }
    }
 
    compare_hash(hdc, bmi, bits, "SetPixel");
 
    /* gradients */
 
    {
        TRIVERTEX vrect[] =
        {
            {   1,   1, 0xff00, 0x8000, 0x0000, 0x8000 },
            { 200, 200, 0x0000, 0x0000, 0xff00, 0xff00 },
            { 180, 180, 0x1234, 0x5678, 0x9abc, 0xdef0 },
            { 300, 300, 0xff00, 0xff00, 0xff00, 0x0000 }
        };
        GRADIENT_RECT rect[] = { { 0, 1 }, { 2, 3 }, { 2, 1 } };
 
        TRIVERTEX vtri[] =
        {
            { 250,   0, 0xff00, 0x0000, 0xff00, 0xff00 },
            { 500, 500, 0x0000, 0xff00, 0x0000, 0xff00 },
            {   0, 500, 0x0000, 0x0000, 0xff00, 0xff00 },
 
            {  10,   0, 0x8000, 0x0000, 0x8000, 0x8000 },
            {   0,  20, 0xff00, 0xff00, 0xff00, 0x0000 },
            {   5,  30, 0x4000, 0xc000, 0x7000, 0x9000 },
 
            {  30,   0, 0x9000, 0x8800, 0xcc00, 0xff00 },
            {   5,  12, 0x9900, 0xaa00, 0xbb00, 0xcc00 },
            {   0,  30, 0x5000, 0xd000, 0x9000, 0xbb00 },
 
            {  35,   3, 0xaa00, 0x6500, 0x4300, 0x2100 },
            {  50,   6, 0x9800, 0x9800, 0x9800, 0x2000 },
            {  60,  10, 0x0100, 0x0200, 0x0300, 0x3000 },
 
            {  60,   2, 0x0700, 0x0800, 0x0900, 0xff00 },
            {  73,  10, 0x9900, 0x8800, 0x7700, 0xff00 },
            {  66,  23, 0x1100, 0x2200, 0x3300, 0xff00 },
 
            {  80,   1, 0xa000, 0x6000, 0x4000, 0x2000 },
            {  76,   9, 0x7000, 0x5000, 0x3000, 0x1000 },
            {  85,  23, 0x3300, 0x3300, 0x3300, 0x3300 },
 
            {  90,   4, 0x4400, 0x5500, 0x6600, 0x9900 },
            {  95,  12, 0x4500, 0x5600, 0x6700, 0x9900 },
            {  85,  14, 0x4600, 0x5700, 0x6800, 0x9900 },
        };
        GRADIENT_TRIANGLE tri[] =
        {
            { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 }, { 9, 10, 11 }, { 12, 13, 14 }, { 15, 16, 17 }, { 18, 19, 20 },
            { 2, 1, 0 }, { 3, 5, 4 }, { 7, 6, 8 }, { 10, 11, 9 }, { 14, 13, 12 }, { 17, 15, 16 }, { 19, 20, 18 }
        };
 
        GdiGradientFill( hdc, vrect, 4, rect, 2, GRADIENT_FILL_RECT_H );
        for (i = 0; i < 4; i++) vrect[i].y += 250;
        GdiGradientFill( hdc, vrect, 4, rect, 2, GRADIENT_FILL_RECT_V );
        /* Wine's 8-bit dithering isn't identical to Windows */
        compare_hash_broken_todo(hdc,  bmi, bits, "GdiGradientFill", 0, (bmi->bmiHeader.biBitCount <= 8) );
 
        GdiGradientFill( hdc, vtri, 7*3, tri, 7, GRADIENT_FILL_TRIANGLE );
        for (i = 0; i < 7*3; i++) vtri[i].y += 100;
        GdiGradientFill( hdc, vtri, 7*3, tri + 7, 7, GRADIENT_FILL_TRIANGLE );
        /* Wine's 8-bit dithering isn't identical to Windows */
        compare_hash_broken_todo(hdc,  bmi, bits, "GdiGradientFill", 0, (bmi->bmiHeader.biBitCount <= 8) );
    }
 
    /* wide pen */
 
    wide_pen = CreatePen( PS_SOLID, 7, RGB( 0xff, 0, 0 ) );
    SelectObject( hdc, wide_pen );
 
    for (i = 0; i < ARRAY_SIZE(wide_lines); i++)
    {
        MoveToEx( hdc, wide_lines[i].left, wide_lines[i].top, NULL );
        LineTo( hdc, wide_lines[i].right, wide_lines[i].bottom );
    }
 
    compare_hash( hdc, bmi, bits, "wide pen" );
 
    SelectObject( hdc, orig_pen );
    DeleteObject( wide_pen );
 
    log_brush.lbStyle = BS_SOLID;
    log_brush.lbColor = RGB(0xff, 0, 0);
    log_brush.lbHatch = 0;
 
    wide_pen = ExtCreatePen( PS_GEOMETRIC | PS_ENDCAP_FLAT | PS_JOIN_MITER | PS_SOLID,
                             9, &log_brush, 0, NULL );
    SelectObject( hdc, wide_pen );
    SetBrushOrgEx( hdc, 3, 3, NULL );
    Polyline( hdc, poly_lines, ARRAY_SIZE( poly_lines ));
    compare_hash_broken_todo( hdc, bmi, bits, "wide pen - flat caps, mitred", is_ddb, is_ddb );
    SetBrushOrgEx( hdc, 0, 0, NULL );
 
    SelectObject( hdc, orig_pen );
    DeleteObject( wide_pen );
 
    wide_pen = ExtCreatePen( PS_GEOMETRIC | PS_ENDCAP_SQUARE | PS_JOIN_BEVEL | PS_SOLID,
                             16, &log_brush, 0, NULL );
    SelectObject( hdc, wide_pen );
 
    Polyline( hdc, poly_lines, ARRAY_SIZE( poly_lines ));
    compare_hash_broken_todo( hdc, bmi, bits, "wide pen - square caps, bevelled", is_ddb, is_ddb );
 
    SelectObject( hdc, orig_pen );
    DeleteObject( wide_pen );
 
    wide_pen = ExtCreatePen( PS_GEOMETRIC | PS_ENDCAP_FLAT | PS_JOIN_MITER | PS_SOLID,
                             9, &log_brush, 0, NULL );
    SelectObject( hdc, wide_pen );
 
    PolyPolyline( hdc, polypoly_lines, polypoly_counts, ARRAY_SIZE( polypoly_counts ));
    compare_hash_broken_todo( hdc, bmi, bits, "wide pen - empty segments", is_ddb, is_ddb );
 
    SelectObject( hdc, orig_pen );
    DeleteObject( wide_pen );
 
    /* brushed wide pen */
 
    old_text = GetTextColor( hdc );
    old_bkgnd = GetBkColor( hdc );
    bmp = CreateBitmap( 16, 16, 1, 1, ddb_brush_bits );
    log_brush.lbStyle = BS_PATTERN;
    log_brush.lbColor = 0;
    log_brush.lbHatch = (ULONG_PTR)bmp;
    wide_pen = ExtCreatePen( PS_GEOMETRIC | PS_ENDCAP_FLAT | PS_JOIN_BEVEL | PS_SOLID,
                             12, &log_brush, 0, NULL );
    ok( wide_pen != 0, "failed to create pen\n" );
    SelectObject( hdc, wide_pen );
    Polyline( hdc, poly_lines, ARRAY_SIZE( poly_lines ));
 
    for (i = 1; i < 20; i++)
    {
        wide_pen = ExtCreatePen( PS_GEOMETRIC | PS_ENDCAP_FLAT | PS_JOIN_BEVEL | PS_SOLID,
                                 i, &log_brush, 0, NULL );
        ok( wide_pen != 0, "failed to create pen\n" );
        DeleteObject( SelectObject( hdc, wide_pen ));
        SetTextColor(hdc, RGB( 2*i, i, 255 - i ) );
        SetBkColor(hdc, RGB( 255 - i, i, i / 3 ) );
        MoveToEx( hdc, 10 * i, 10, NULL );
        LineTo( hdc, 10 * i, 200 + i );
        LineTo( hdc, 20 * i, 200 + i );
    }
    compare_hash_broken_todo(hdc,  bmi, bits, "wide brushed pen", 0, dib_is_1bpp );
 
    for (i = 1; i < 20; i++)
    {
        wide_pen = ExtCreatePen( PS_GEOMETRIC | PS_ENDCAP_FLAT | PS_JOIN_BEVEL | (i % 5),
                                 i, &log_brush, 0, NULL );
        DeleteObject( SelectObject( hdc, wide_pen ));
        SetTextColor(hdc, RGB( 2*i, i, 255 - i ) );
        SetBkColor(hdc, RGB( i, 255 - i, i / 3 ) );
        MoveToEx( hdc, 10 * i, 10, NULL );
        LineTo( hdc, 10 * i, 200 + i );
        LineTo( hdc, 20 * i, 200 + i );
    }
    compare_hash_broken_todo(hdc,  bmi, bits, "dashed wide brushed pen", 0, dib_is_1bpp );
 
    DeleteObject(bmp);
    SetTextColor(hdc, old_text);
    SetBkColor(hdc, old_bkgnd);
    SelectObject( hdc, orig_pen );
 
    /* PALETTEINDEX */
 
    solid_brush = CreateSolidBrush( PALETTEINDEX(3) );
    solid_pen = CreatePen( PS_DASH, 1, PALETTEINDEX(5) );
    SetTextColor( hdc, PALETTEINDEX(38) );
    SetBkColor( hdc, PALETTEINDEX(9) );
    SelectObject( hdc, solid_brush );
    SelectObject( hdc, solid_pen );
 
    pal->palVersion = 0x300;
    pal->palNumEntries = 40;
    for (i = 0; i < 80; i++)
    {
        entries[i].peRed   = i * 3;
        entries[i].peGreen = i * 7;
        entries[i].peBlue  = 128 - i;
        entries[i].peFlags = 0;
    }
    hpal = CreatePalette( pal );
    old_hpal = SelectPalette( hdc, hpal, FALSE );
 
    solid_patblt( hdc, 20, 10, 10, 10, PALETTEINDEX(15) );
    Rectangle( hdc, 0, 0, 10, 10 );
    SetPaletteEntries( hpal, 0, 40, entries + 40 );
    Rectangle( hdc, 10, 0, 10, 10 );
    SelectObject( hdc, orig_brush );
    DeleteObject( solid_brush );
 
    solid_brush = CreateHatchBrush( HS_CROSS, PALETTEINDEX(7) );
    DeleteObject( SelectObject( hdc, solid_brush ));
    PatBlt( hdc, 20, 0, 10, 10, PATCOPY );
    SetPaletteEntries( hpal, 0, 40, entries );
    PatBlt( hdc, 30, 0, 10, 10, PATCOPY );
    SelectObject( hdc, orig_brush );
    DeleteObject( solid_brush );
 
    bmp = CreateBitmap( 16, 16, 1, 1, ddb_brush_bits );
    dib_brush = CreatePatternBrush( bmp );
    SelectObject( hdc, dib_brush );
    PatBlt( hdc, 40, 0, 10, 10, PATCOPY );
    SetPaletteEntries( hpal, 0, 40, entries + 40 );
    PatBlt( hdc, 50, 0, 10, 10, PATCOPY );
    DeleteObject( bmp );
    SelectObject( hdc, orig_brush );
    DeleteObject( dib_brush );
 
    SelectPalette( hdc, old_hpal, FALSE );
    DeleteObject( hpal );
 
    compare_hash_broken_todo(hdc, bmi, bits, "PALETTEINDEX", is_ddb, dib_is_1bpp );
 
    /* ExtFloodFill */
 
    solid_patblt( hdc,   0,   0, 512, 512, RGB( 0, 0, 0xff ) );
    solid_patblt( hdc,  10,  10, 200, 200, RGB( 0, 0xff, 0 ) );
    solid_patblt( hdc,  10,  50,  50,  50, RGB( 0, 0, 0xff ) );
    solid_patblt( hdc, 100, 160,  50,  50, RGB( 0, 0, 0xff ) );
    solid_patblt( hdc,  90, 160,  70,  10, RGB( 0, 0, 0xff ) );
 
    /* add a vertical 'bar' to show that the clip rgn stops the flooding */
    hrgn = CreateRectRgn( 180, 10, 190, 210 );
    ExtSelectClipRgn( hdc, hrgn, RGN_DIFF );
    DeleteObject( hrgn );
 
    solid_brush = CreateSolidBrush( RGB( 0xff, 0, 0 ) );
    SelectObject( hdc, solid_brush );
 
    ret = ExtFloodFill( hdc, 100, 100, RGB( 0, 0xff, 0 ), FLOODFILLSURFACE );
    if (is_ddb)
        todo_wine ok (!ret || broken(ret), "got ret %d\n", ret);
    else
        ok (ret, "got ret %d\n", ret);
    compare_hash_broken_todo( hdc, bmi, bits, "flood fill", is_ddb, is_ddb );
 
    ExtSelectClipRgn( hdc, NULL, RGN_COPY );
 
    ret = ExtFloodFill( hdc, -1, -1, RGB( 0, 0xff, 0 ), FLOODFILLSURFACE );
    ok (!ret, "got ret %d\n", ret);
 
    SelectObject(hdc, orig_brush);
    SelectObject(hdc, orig_pen);
    DeleteObject(solid_brush);
    DeleteObject(wide_pen);
    DeleteObject(dashed_pen);
    DeleteObject(solid_pen);
}

Referenced by test_simple_graphics().

draw_text()

static void draw_text ( HDC  hdc, const BITMAPINFO *  bmi, BYTE *  bits  )

static

Definition at line 3139 of file dib.c.

{
    draw_text_2( hdc, bmi, bits, FALSE );
 
    /* Rounding errors make these cases hard to test */
    if ((bmi->bmiHeader.biCompression == BI_BITFIELDS && ((DWORD*)bmi->bmiColors)[0] == 0x3f000) ||
        (bmi->bmiHeader.biBitCount == 16))
        return;
 
    draw_text_2( hdc, bmi, bits, TRUE );
}

Referenced by test_simple_graphics().

draw_text_2()

static void draw_text_2 ( HDC  hdc, const BITMAPINFO *  bmi, BYTE *  bits, BOOL  aa  )

static

Definition at line 3010 of file dib.c.

{
    DWORD dib_size = get_dib_size(bmi), ret;
    LOGFONTA lf;
    HFONT font;
    GLYPHMETRICS gm;
    BYTE g_buf[10000];
    int i, stride, x, y;
    static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
    char *eto_hash = NULL, *diy_hash = NULL;
    static const char str[] = "Hello Wine";
    POINT origin, g_org;
    static const BYTE vals[4] = { 0x00, 0x00, 0x00, 0x00 };
    COLORREF bk_color, text_color;
    TEXTMETRICA tm;
    RECT rect;
 
    for(i = 0; i < dib_size; i++)
        bits[i] = vals[i % 4];
 
    memset( &lf, 0, sizeof(lf) );
    strcpy( lf.lfFaceName, "Tahoma" );
    lf.lfHeight = 24;
    lf.lfQuality = aa ? ANTIALIASED_QUALITY : NONANTIALIASED_QUALITY;
 
    font = CreateFontIndirectA( &lf );
    font = SelectObject( hdc, font );
 
    GetTextMetricsA( hdc, &tm );
    if (!(tm.tmPitchAndFamily & TMPF_VECTOR))
    {
        skip( "skipping as a bitmap font has been selected for Tahoma.\n" );
        DeleteObject( SelectObject( hdc, font ) );
        return;
    }
 
    SetTextColor( hdc, RGB(0xff, 0x00, 0x00) );
    SetTextAlign( hdc, TA_BASELINE );
    SetBkMode( hdc, TRANSPARENT );
    origin.x = 10;
    origin.y = 100;
 
    ExtTextOutA( hdc, origin.x, origin.y, 0, NULL, str, strlen(str), NULL );
    eto_hash = hash_dib( hdc, bmi, bits );
 
    for(i = 0; i < dib_size; i++)
        bits[i] = vals[i % 4];
 
    if (bmi->bmiHeader.biBitCount <= 8) aa = FALSE;
 
    text_color = GetTextColor( hdc );
    for (i = 0; i < strlen(str); i++)
    {
        DWORD ggo_flags = aa ? GGO_GRAY4_BITMAP : GGO_BITMAP;
 
        ret = GetGlyphOutlineA( hdc, str[i], ggo_flags, &gm, 0, NULL, &identity );
 
        if (ret == GDI_ERROR) continue;
 
        if (ret) GetGlyphOutlineA( hdc, str[i], ggo_flags, &gm, sizeof(g_buf), g_buf, &identity );
 
        g_org.x = origin.x + gm.gmptGlyphOrigin.x;
        g_org.y = origin.y - gm.gmptGlyphOrigin.y;
 
        origin.x += gm.gmCellIncX;
        origin.y += gm.gmCellIncY;
 
        if (!ret) continue;
 
        if (aa)
        {
            stride = (gm.gmBlackBoxX + 3) & ~3;
 
            for (y = 0; y < gm.gmBlackBoxY; y++)
            {
                BYTE *g_ptr = g_buf + y * stride;
                COLORREF val;
 
                for (x = 0; x < gm.gmBlackBoxX; x++)
                {
                    if (g_ptr[x] <= 1) continue;
                    if (g_ptr[x] >= 16) val = text_color;
                    else
                    {
                        val = GetPixel( hdc, g_org.x + x, g_org.y + y );
                        val = aa_colorref( val, text_color, g_ptr[x] );
                    }
                    SetPixel( hdc, g_org.x + x, g_org.y + y, val );
                }
            }
        }
        else
        {
            stride = ((gm.gmBlackBoxX + 31) >> 3) & ~3;
 
            for (y = 0; y < gm.gmBlackBoxY; y++)
            {
                BYTE *g_ptr = g_buf + y * stride;
                for (x = 0; x < gm.gmBlackBoxX; x++)
                {
                    if (g_ptr[x / 8] & masks[x % 8])
                        SetPixel( hdc, g_org.x + x, g_org.y + y, text_color );
                }
            }
        }
    }
 
    diy_hash = hash_dib( hdc, bmi, bits );
    ok( !strcmp( eto_hash, diy_hash ), "hash mismatch - aa %d\n", aa );
 
    bk_color = GetBkColor( hdc );
    SetBkColor( hdc, RGB(128,64,32) );
 
    SetRect( &rect, 0, 0, bmi->bmiHeader.biWidth, bmi->bmiHeader.biHeight );
    ret = ExtTextOutA( hdc, 10, 100, ETO_OPAQUE, &rect, str, -1, NULL );
    ok( !ret, "ExtTextOutA succeeded\n" );
 
    diy_hash = hash_dib( hdc, bmi, bits );
    ok( !strcmp( eto_hash, diy_hash ), "hash mismatch - aa %d\n", aa );
 
    SetBkColor( hdc, bk_color );
 
    free( diy_hash );
    free( eto_hash );
 
    font = SelectObject( hdc, font );
    DeleteObject( font );
}

Referenced by draw_text().

get_dib_size()

static DWORD get_dib_size ( const BITMAPINFO *  bmi )

inlinestatic

Definition at line 1346 of file dib.c.

{
    return get_stride(bmi) * abs(bmi->bmiHeader.biHeight);
}

Referenced by draw_text_2(), hash_dib(), and reset_bits().

get_range()

static void get_range ( BYTE  alpha, DWORD  text_comp, BYTE *  min_comp, BYTE *  max_comp  )

inlinestatic

Definition at line 2966 of file dib.c.

{
    *min_comp = (ramp[alpha] * text_comp) / 0xff;
    *max_comp = ramp[16 - alpha] + ((0xff - ramp[16 - alpha]) * text_comp) / 0xff;
}

Referenced by aa_comp().

get_stride()

static DWORD get_stride ( const BITMAPINFO *  bmi )

inlinestatic

Definition at line 1341 of file dib.c.

{
    return ((bmi->bmiHeader.biBitCount * bmi->bmiHeader.biWidth + 31) >> 3) & ~3;
}

Referenced by draw_graphics(), and get_dib_size().

hash_dib()

static char * hash_dib ( HDC  hdc, const BITMAPINFO *  bmi, const void *  bits  )

static

Definition at line 1364 of file dib.c.

{
    DWORD dib_size = get_dib_size(bmi);
    HCRYPTHASH hash;
    char *buf;
    BYTE hash_buf[20];
    DWORD hash_size = sizeof(hash_buf);
    int i;
    static const char *hex = "0123456789abcdef";
 
    if(!crypt_prov) return NULL;
 
    if(!CryptCreateHash(crypt_prov, CALG_SHA1, 0, 0, &hash)) return NULL;
 
    if (!bits)
    {
        void *ddb_bits = malloc(dib_size);
        GetBitmapBits(GetCurrentObject(hdc, OBJ_BITMAP), dib_size, ddb_bits);
        CryptHashData(hash, ddb_bits, dib_size, 0);
        free(ddb_bits);
    }
    else CryptHashData(hash, bits, dib_size, 0);
 
    CryptGetHashParam(hash, HP_HASHVAL, NULL, &hash_size, 0);
    if(hash_size != sizeof(hash_buf)) return NULL;
 
    CryptGetHashParam(hash, HP_HASHVAL, hash_buf, &hash_size, 0);
    CryptDestroyHash(hash);
 
    buf = malloc(hash_size * 2 + 1);
 
    for(i = 0; i < hash_size; i++)
    {
        buf[i * 2] = hex[hash_buf[i] >> 4];
        buf[i * 2 + 1] = hex[hash_buf[i] & 0xf];
    }
    buf[i * 2] = '\0';
 
    return buf;
}

Referenced by compare_hash_broken_todo(), and draw_text_2().

reset_bits()

static void reset_bits ( HDC  hdc, const BITMAPINFO *  bmi, BYTE *  bits  )

static

Definition at line 1351 of file dib.c.

{
    DWORD size = get_dib_size( bmi );
    if (bits) memset( bits, 0xcc, size );
    else
    {
        void *ddb_bits = malloc( size );
        memset( ddb_bits, 0xcc, size );
        SetBitmapBits( GetCurrentObject(hdc, OBJ_BITMAP), size, ddb_bits );
        free( ddb_bits );
    }
}

Referenced by compare_hash_broken_todo(), and draw_graphics().

reset_bounds()

static void reset_bounds ( HDC  hdc )

static

Definition at line 1405 of file dib.c.

{
    current_bounds = graphics_bounds;
    SetBoundsRect( hdc, NULL, DCB_RESET | DCB_ENABLE );
}

Referenced by draw_graphics().

rop_uses_src()

static BOOL rop_uses_src ( DWORD  rop )

inlinestatic

Definition at line 72 of file dib.c.

{
    return (((rop & 0xcc0000) >> 2) != (rop & 0x330000));
}

Referenced by draw_graphics().

solid_patblt()

static void solid_patblt ( HDC  hdc, int  x, int  y, int  width, int  height, COLORREF  color  )

inlinestatic

Definition at line 1747 of file dib.c.

{
    HBRUSH brush = CreateSolidBrush( color );
    brush = SelectObject( hdc, brush );
    PatBlt( hdc, x, y, width, height, PATCOPY );
    DeleteObject( SelectObject( hdc, brush ) );
}

Referenced by draw_graphics().

START_TEST()

START_TEST

(

dib

)

Definition at line 3532 of file dib.c.

{
    CryptAcquireContextW(&crypt_prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
 
    test_simple_graphics();
 
    CryptReleaseContext(crypt_prov, 0);
}

test_simple_graphics()

static void test_simple_graphics ( void  )

static

Definition at line 3151 of file dib.c.

{
    char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
    BITMAPINFO *bmi = (BITMAPINFO *)bmibuf;
    RGBQUAD *colors = bmi->bmiColors;
    DWORD *bit_fields = (DWORD*)(bmibuf + sizeof(BITMAPINFOHEADER));
    HDC mem_dc;
    BYTE *bits;
    HBITMAP dib, orig_bm;
    DIBSECTION ds;
    HPALETTE default_palette, old_hpal;
    int i;
 
    mem_dc = CreateCompatibleDC(NULL);
 
    /* a8r8g8b8 */
    trace("8888\n");
    memset(bmi, 0, sizeof(bmibuf));
    bmi->bmiHeader.biSize = sizeof(bmi->bmiHeader);
    bmi->bmiHeader.biHeight = 512;
    bmi->bmiHeader.biWidth = 512;
    bmi->bmiHeader.biBitCount = 32;
    bmi->bmiHeader.biPlanes = 1;
    bmi->bmiHeader.biCompression = BI_RGB;
 
    dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
    ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
    ok(ds.dsBitfields[0] == 0, "got %08lx\n", ds.dsBitfields[0]);
    ok(ds.dsBitfields[1] == 0, "got %08lx\n", ds.dsBitfields[1]);
    ok(ds.dsBitfields[2] == 0, "got %08lx\n", ds.dsBitfields[2]);
    ok(ds.dsBmih.biCompression == BI_RGB, "got %lx\n", ds.dsBmih.biCompression);
 
    orig_bm = SelectObject(mem_dc, dib);
 
    default_palette = create_default_palette( 8 );
    old_hpal = SelectPalette( mem_dc, default_palette, FALSE );
 
    dst_format = "8888";
    current_sha1 = sha1_graphics_a8r8g8b8;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* a8r8g8b8 - bitfields.  Should be the same as the regular 32 bit case.*/
    trace("8888 - bitfields\n");
    bmi->bmiHeader.biBitCount = 32;
    bmi->bmiHeader.biCompression = BI_BITFIELDS;
    bit_fields[0] = 0xff0000;
    bit_fields[1] = 0x00ff00;
    bit_fields[2] = 0x0000ff;
 
    dib = CreateDIBSection(mem_dc, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
    ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
    ok(ds.dsBitfields[0] == 0xff0000, "got %08lx\n", ds.dsBitfields[0]);
    ok(ds.dsBitfields[1] == 0x00ff00, "got %08lx\n", ds.dsBitfields[1]);
    ok(ds.dsBitfields[2] == 0x0000ff, "got %08lx\n", ds.dsBitfields[2]);
    ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %lx\n", ds.dsBmih.biCompression);
 
    orig_bm = SelectObject(mem_dc, dib);
    SelectPalette( mem_dc, default_palette, FALSE );
 
    dst_format = "8888 - bitfields";
    current_sha1 = sha1_graphics_a8r8g8b8_bitfields;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* a8b8g8r8. */
    trace("a8b8g8r8\n");
    bmi->bmiHeader.biBitCount = 32;
    bmi->bmiHeader.biCompression = BI_BITFIELDS;
    bit_fields[0] = 0x0000ff;
    bit_fields[1] = 0x00ff00;
    bit_fields[2] = 0xff0000;
 
    dib = CreateDIBSection(mem_dc, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
    ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
    ok(ds.dsBitfields[0] == 0x0000ff, "got %08lx\n", ds.dsBitfields[0]);
    ok(ds.dsBitfields[1] == 0x00ff00, "got %08lx\n", ds.dsBitfields[1]);
    ok(ds.dsBitfields[2] == 0xff0000, "got %08lx\n", ds.dsBitfields[2]);
    ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %lx\n", ds.dsBmih.biCompression);
 
    orig_bm = SelectObject(mem_dc, dib);
 
    dst_format = "a8b8g8r8";
    current_sha1 = sha1_graphics_a8b8g8r8;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* r10g10b10. */
    trace("r10g10b10\n");
    bmi->bmiHeader.biBitCount = 32;
    bmi->bmiHeader.biCompression = BI_BITFIELDS;
    bit_fields[0] = 0x3ff00000;
    bit_fields[1] = 0x000ffc00;
    bit_fields[2] = 0x000003ff;
 
    dib = CreateDIBSection(mem_dc, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
    ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
    ok(ds.dsBitfields[0] == 0x3ff00000, "got %08lx\n", ds.dsBitfields[0]);
    ok(ds.dsBitfields[1] == 0x000ffc00, "got %08lx\n", ds.dsBitfields[1]);
    ok(ds.dsBitfields[2] == 0x000003ff, "got %08lx\n", ds.dsBitfields[2]);
    ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %lx\n", ds.dsBmih.biCompression);
 
    orig_bm = SelectObject(mem_dc, dib);
 
    dst_format = "r10g10b10";
    current_sha1 = sha1_graphics_r10g10b10;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* r6g6b6. */
    trace("r6g6b6\n");
    bmi->bmiHeader.biBitCount = 32;
    bmi->bmiHeader.biCompression = BI_BITFIELDS;
    bit_fields[0] = 0x0003f000;
    bit_fields[1] = 0x00000fc0;
    bit_fields[2] = 0x0000003f;
 
    dib = CreateDIBSection(mem_dc, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
    ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
    ok(ds.dsBitfields[0] == 0x0003f000, "got %08lx\n", ds.dsBitfields[0]);
    ok(ds.dsBitfields[1] == 0x00000fc0, "got %08lx\n", ds.dsBitfields[1]);
    ok(ds.dsBitfields[2] == 0x0000003f, "got %08lx\n", ds.dsBitfields[2]);
    ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %lx\n", ds.dsBmih.biCompression);
 
    orig_bm = SelectObject(mem_dc, dib);
 
    dst_format = "r6g6b6";
    current_sha1 = sha1_graphics_r6g6b6;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* 24 */
    trace("24\n");
    bmi->bmiHeader.biBitCount = 24;
    bmi->bmiHeader.biCompression = BI_RGB;
 
    dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
    orig_bm = SelectObject(mem_dc, dib);
 
    dst_format = "24";
    current_sha1 = sha1_graphics_24;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* r5g5b5 */
    trace("555\n");
    bmi->bmiHeader.biBitCount = 16;
    bmi->bmiHeader.biCompression = BI_RGB;
 
    dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
    ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
    ok(ds.dsBitfields[0] == 0x7c00, "got %08lx\n", ds.dsBitfields[0]);
    ok(ds.dsBitfields[1] == 0x03e0, "got %08lx\n", ds.dsBitfields[1]);
    ok(ds.dsBitfields[2] == 0x001f, "got %08lx\n", ds.dsBitfields[2]);
    ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %lx\n", ds.dsBmih.biCompression);
 
    orig_bm = SelectObject(mem_dc, dib);
 
    dst_format = "r5g5b5";
    current_sha1 = sha1_graphics_r5g5b5;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* r4g4b4 */
    trace("444\n");
    bmi->bmiHeader.biBitCount = 16;
    bmi->bmiHeader.biCompression = BI_BITFIELDS;
    bit_fields[0] = 0x0f00;
    bit_fields[1] = 0x00f0;
    bit_fields[2] = 0x000f;
    dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
    ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
    ok(ds.dsBitfields[0] == 0x0f00, "got %08lx\n", ds.dsBitfields[0]);
    ok(ds.dsBitfields[1] == 0x00f0, "got %08lx\n", ds.dsBitfields[1]);
    ok(ds.dsBitfields[2] == 0x000f, "got %08lx\n", ds.dsBitfields[2]);
    ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %lx\n", ds.dsBmih.biCompression);
 
    orig_bm = SelectObject(mem_dc, dib);
 
    dst_format = "r4g4b4";
    current_sha1 = sha1_graphics_r4g4b4;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* 8 color */
    trace("8 color\n");
    bmi->bmiHeader.biBitCount = 8;
    bmi->bmiHeader.biCompression = BI_RGB;
    bmi->bmiHeader.biClrUsed = 236;
    for (i = 0; i < 236; i++)
    {
        colors[i].rgbRed   = (i & 0x07) << 5;
        colors[i].rgbGreen = (i & 0x38) << 2;
        colors[i].rgbBlue  =  i & 0xc0;
    }
    dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
 
    orig_bm = SelectObject(mem_dc, dib);
 
    dst_format = "8 color";
    current_sha1 = sha1_graphics_8_color;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* 8 grayscale */
    trace("8 grayscale\n");
    bmi->bmiHeader.biBitCount = 8;
    bmi->bmiHeader.biCompression = BI_RGB;
    bmi->bmiHeader.biClrUsed = 256;
    for (i = 0; i < 256; i++) colors[i].rgbRed = colors[i].rgbGreen = colors[i].rgbBlue = i;
 
    dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
 
    orig_bm = SelectObject(mem_dc, dib);
 
    dst_format = "8 grayscale";
    current_sha1 = sha1_graphics_8_grayscale;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* 8 */
    trace("8\n");
    bmi->bmiHeader.biBitCount = 8;
    bmi->bmiHeader.biCompression = BI_RGB;
    bmi->bmiHeader.biClrUsed = 5;
    colors[0].rgbRed = 0xff;
    colors[0].rgbGreen = 0xff;
    colors[0].rgbBlue = 0xff;
    colors[1].rgbRed = 0;
    colors[1].rgbGreen = 0;
    colors[1].rgbBlue = 0;
    colors[2].rgbRed = 0xff;
    colors[2].rgbGreen = 0;
    colors[2].rgbBlue = 0;
    colors[3].rgbRed = 0;
    colors[3].rgbGreen = 0xff;
    colors[3].rgbBlue = 0;
    colors[4].rgbRed = 0;
    colors[4].rgbGreen = 0;
    colors[4].rgbBlue = 0xff;
 
    dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
 
    orig_bm = SelectObject(mem_dc, dib);
 
    dst_format = "8";
    current_sha1 = sha1_graphics_8;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* 4 */
    trace("4\n");
    bmi->bmiHeader.biBitCount = 4;
 
    dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
 
    orig_bm = SelectObject(mem_dc, dib);
    DeleteObject( SelectPalette( mem_dc, create_default_palette(4), FALSE ));
 
    dst_format = "4";
    current_sha1 = sha1_graphics_4;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* 4 grayscale */
    trace("4 grayscale\n");
    bmi->bmiHeader.biClrUsed = 16;
    for (i = 0; i < 16; i++) colors[i].rgbRed = colors[i].rgbGreen = colors[i].rgbBlue = i * 17;
 
    dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
 
    orig_bm = SelectObject(mem_dc, dib);
 
    dst_format = "4 grayscale";
    current_sha1 = sha1_graphics_4_grayscale;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* 1 */
    trace("1\n");
    bmi->bmiHeader.biBitCount = 1;
    bmi->bmiHeader.biClrUsed = 2;
 
    colors[0].rgbRed = 0x00;
    colors[0].rgbGreen = 0x01;
    colors[0].rgbBlue = 0xff;
    colors[1].rgbRed = 0xff;
    colors[1].rgbGreen = 0x00;
    colors[1].rgbBlue = 0x00;
 
    dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(dib != NULL, "ret NULL\n");
 
    orig_bm = SelectObject(mem_dc, dib);
    DeleteObject( SelectPalette( mem_dc, create_default_palette(1), FALSE ));
 
    dst_format = "1";
    current_sha1 = sha1_graphics_1;
    draw_graphics(mem_dc, bmi, bits);
    draw_text(mem_dc, bmi, bits);
 
    DeleteObject( SelectPalette( mem_dc, old_hpal, FALSE ));
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    /* 1 ddb */
    trace("1 ddb\n");
 
    dib = CreateBitmap( 512, 512, 1, 1, NULL );
    ok(dib != NULL, "ret NULL\n");
 
    orig_bm = SelectObject(mem_dc, dib);
 
    dst_format = "1 ddb";
    current_sha1 = sha1_graphics_1_ddb;
    draw_graphics(mem_dc, bmi, NULL);
 
    SetTextColor( mem_dc, RGB(240,230,220) );
    SetBkColor( mem_dc, RGB(10,20,30) );
    dst_format = "1 ddb custom colors inverted";
    current_sha1 = sha1_graphics_1_ddb_inverted;
    draw_graphics(mem_dc, bmi, NULL);
 
    SelectObject(mem_dc, orig_bm);
    DeleteObject(dib);
 
    DeleteDC(mem_dc);
}

Referenced by START_TEST().

Variable Documentation

bias_check

const RECT bias_check[]

static

Initial value:

=
{
    {100, 100, 200, 150},
    {100, 100, 150, 200},
    {100, 100,  50, 200},
    {100, 100,   0, 150},
    {100, 100,   0,  50},
    {100, 100,  50,   0},
    {100, 100, 150,   0},
    {100, 100, 200,  50}
}

Definition at line 1477 of file dib.c.

Referenced by draw_graphics().

crypt_prov

HCRYPTPROV crypt_prov

static

Definition at line 34 of file dib.c.

Referenced by CSignedMsgData_ConstructSignerHandles(), hash_dib(), and START_TEST().

current_bounds

const RECT* current_bounds

static

Definition at line 1338 of file dib.c.

Referenced by compare_bounds(), and reset_bounds().

current_sha1

const char** current_sha1

static

Definition at line 1337 of file dib.c.

Referenced by compare_hash_broken_todo(), and test_simple_graphics().

ddb_brush_bits

const DWORD ddb_brush_bits[8]

static

Initial value:

= { 0x11112222, 0x33334444, 0x55556666, 0x77778888,
                                         0xaaaaaaaa, 0x00000000, 0x98765432, 0xabcdef00 }

Definition at line 1621 of file dib.c.

Referenced by draw_graphics().

default_palette_1

const RGBQUAD default_palette_1[2]

static

Initial value:

=
{
    { 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff }
}

Definition at line 1624 of file dib.c.

Referenced by create_default_palette().

default_palette_4

const RGBQUAD default_palette_4[16]

static

Initial value:

=
{
    { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x80 }, { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x80 },
    { 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x80 }, { 0x80, 0x80, 0x00 }, { 0x80, 0x80, 0x80 },
    { 0xc0, 0xc0, 0xc0 }, { 0x00, 0x00, 0xff }, { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0xff },
    { 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0xff }, { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0xff },
}

Definition at line 1629 of file dib.c.

Referenced by create_default_palette().

default_palette_8

const RGBQUAD default_palette_8[256]

static

Definition at line 1637 of file dib.c.

Referenced by create_default_palette().

dib_brush_header_1

const BITMAPINFOHEADER dib_brush_header_1 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 1, BI_RGB, 0, 0, 0, 0, 0}

static

Definition at line 1609 of file dib.c.

Referenced by draw_graphics().

dib_brush_header_24

const BITMAPINFOHEADER dib_brush_header_24 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 24, BI_RGB, 0, 0, 0, 0, 0}

static

Definition at line 1605 of file dib.c.

Referenced by draw_graphics().

dib_brush_header_4

const BITMAPINFOHEADER dib_brush_header_4 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 4, BI_RGB, 0, 0, 0, 0, 0}

static

Definition at line 1608 of file dib.c.

Referenced by draw_graphics().

dib_brush_header_555

const BITMAPINFOHEADER dib_brush_header_555 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 16, BI_RGB, 0, 0, 0, 0, 0}

static

Definition at line 1606 of file dib.c.

Referenced by draw_graphics().

dib_brush_header_8

const BITMAPINFOHEADER dib_brush_header_8 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 8, BI_RGB, 0, 0, 0, 0, 0}

static

Definition at line 1607 of file dib.c.

Referenced by draw_graphics().

dib_brush_header_8888

const BITMAPINFOHEADER dib_brush_header_8888 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 32, BI_RGB, 0, 0, 0, 0, 0}

static

Definition at line 1604 of file dib.c.

Referenced by draw_graphics().

dst_format

const char* dst_format

static

Definition at line 1339 of file dib.c.

Referenced by arbfp_blit_supported(), compare_bounds(), compare_hash_broken_todo(), convert_argb_pixels(), convert_pixels(), copy_format(), d3d8_device_CopyRects(), d3d9_CheckDeviceFormatConversion(), D3DXLoadSurfaceFromMemory(), fbo_blitter_supported(), ffp_blit_supported(), GdipDrawImagePointsRect(), gl_blend_factor(), point_filter_argb_pixels(), surface_convert_format(), surface_cpu_blt(), test_simple_graphics(), and wined3d_check_device_format_conversion().

four_by_four_data

const DWORD four_by_four_data[16]

static

Initial value:

= { 0x000000, 0xff0000, 0x00ff00, 0x0000ff,
                                             0xffffff, 0x00ffff, 0xff00ff, 0xffff00,
                                             0x000000, 0xff0000, 0x00ff00, 0x0000ff,
                                             0xffffff, 0x00ffff, 0xff00ff, 0xffff00 }

Definition at line 1616 of file dib.c.

Referenced by draw_graphics().

graphics_bounds

const RECT graphics_bounds[]

static

Definition at line 1266 of file dib.c.

Referenced by GdipDrawImagePointsRect(), reset_bounds(), and SOFTWARE_GdipFillRegion().

hline_clips

const RECT hline_clips[]

static

Initial value:

=
{
    {120, 120, 140, 120}, 
    {100, 122, 140, 122}, 
    { 99, 124, 140, 124}, 
    {120, 126, 200, 126}, 
    {120, 128, 201, 128}, 
    { 99, 130, 201, 130}, 
    {120, 100, 140, 100}, 
    {120,  99, 140,  99}, 
    {120, 199, 140, 199}, 
    {120, 200, 140, 200}, 
    {120, 132, 310, 132}, 
    { 10, 134, 101, 134}, 
    { 10, 136, 100, 136}, 
    {199, 138, 220, 138}, 
    {200, 140, 220, 140}  
}

Definition at line 1489 of file dib.c.

Referenced by draw_graphics().

line_clips

const RECT line_clips[]

static

Initial value:

=
{
    { 90, 110, 310, 120},
    { 90, 120, 295, 130},
    { 90, 190, 110, 240}, 
    { 90, 130, 100, 135}, 
    { 90, 132, 101, 137}, 
    {200, 140, 210, 141}, 
    {199, 142, 210, 143}  
}

Definition at line 1527 of file dib.c.

Referenced by draw_graphics().

masks

const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01}

static

Definition at line 3008 of file dib.c.

Referenced by bitmap_info_size(), calc_color_correction(), DIB_BitmapInfoSize(), draw_text_2(), gen_arbfp_ffp_shader(), gen_color_correction(), get_color_masks(), SetDIBits(), shader_hw_sample(), and surface_cpu_blt().

patblt_clips

const RECT patblt_clips[]

static

Initial value:

=
{
    {120, 120, 140, 126}, 
    {100, 130, 140, 136}, 
    { 99, 140, 140, 146}, 
    {180, 130, 200, 136}, 
    {180, 140, 201, 146}, 
    {120, 100, 130, 110}, 
    {140,  99, 150, 110}, 
    {120, 180, 130, 200}, 
    {140, 180, 150, 201}, 
    {199, 150, 210, 156}, 
    {200, 160, 210, 166}, 
    { 90, 150, 101, 156}, 
    { 90, 160, 100, 166}, 
    {160,  90, 166, 101}, 
    {170,  90, 176, 101}, 
    {160, 199, 166, 210}, 
    {170, 200, 176, 210}, 
}

Definition at line 1565 of file dib.c.

Referenced by draw_graphics().

poly_lines

const POINT poly_lines[]

static

Initial value:

=
{
    {100, 100}, {200, 100}, {200, 200}, {100, 200}
}

Definition at line 1550 of file dib.c.

Referenced by draw_graphics().

polypoly_counts

const DWORD polypoly_counts[]

static

Initial value:

=
{
 
}

Definition at line 1560 of file dib.c.

Referenced by draw_graphics().

polypoly_lines

const POINT polypoly_lines[]

static

Initial value:

=
{
    {100, 100}, {200, 100}, {200, 100}, {200, 200}
}

Definition at line 1555 of file dib.c.

Referenced by draw_graphics().

ramp

const BYTE ramp[17]

static

Initial value:

=
{
    0,    0x4d, 0x68, 0x7c,
    0x8c, 0x9a, 0xa7, 0xb2,
    0xbd, 0xc7, 0xd0, 0xd9,
    0xe1, 0xe9, 0xf0, 0xf8,
    0xff
}

Definition at line 2957 of file dib.c.

Referenced by d3d8_device_GetGammaRamp(), d3d8_device_SetGammaRamp(), d3d9_device_GetGammaRamp(), d3d9_device_SetGammaRamp(), DECLARE_INTERFACE_(), EnumEffects(), get_range(), test_device_caps(), test_gamma(), wined3d_device_get_gamma_ramp(), wined3d_device_set_gamma_ramp(), wined3d_swapchain_get_gamma_ramp(), and wined3d_swapchain_set_gamma_ramp().

rectangles

const RECT rectangles[]

static

Initial value:

=
{
    {10,   11, 100, 101},
    {250, 100, 350,  10},
    {120,  10, 120,  20}, 
    {120,  10, 130,  10}, 
    {120,  40, 121,  41}, 
    {130,  50, 132,  52}, 
    {140,  60, 143,  63}, 
    {150,  70, 154,  74}, 
    {120,  20, 121,  30}, 
    {130,  20, 132,  30}, 
    {140,  20, 143,  30}, 
    {200,  20, 210,  21}, 
    {200,  30, 210,  32}, 
    {200,  40, 210,  43}  
}

Definition at line 1586 of file dib.c.

Referenced by draw_graphics().

rle8_data

const BYTE rle8_data[20]

static

Initial value:

= { 0x03, 0x02, 0x04, 0xf0, 0x00, 0x00,     
                                    0x00, 0x03, 0x04, 0x05, 0x06, 0x00,     
                                    0x00, 0x02, 0x01, 0x02, 0x05, 0x80,     
                                    0x00, 0x01 }

Definition at line 1611 of file dib.c.

Referenced by draw_graphics(), test_SetDIBits_RLE8(), and test_SetDIBitsToDevice_RLE8().

rop3

const DWORD rop3[256]

static

Definition at line 36 of file dib.c.

Referenced by draw_graphics().

sha1_graphics_1

const char* sha1_graphics_1[]

static

Definition at line 1007 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_1_ddb

const char* sha1_graphics_1_ddb[]

static

Definition at line 1080 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_1_ddb_inverted

const char* sha1_graphics_1_ddb_inverted[]

static

Definition at line 1173 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_24

const char* sha1_graphics_24[]

static

Definition at line 437 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_4

const char* sha1_graphics_4[]

static

Definition at line 865 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_4_grayscale

const char* sha1_graphics_4_grayscale[]

static

Definition at line 936 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_8

const char* sha1_graphics_8[]

static

Definition at line 794 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_8_color

const char* sha1_graphics_8_color[]

static

Definition at line 651 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_8_grayscale

const char* sha1_graphics_8_grayscale[]

static

Definition at line 722 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_a8b8g8r8

const char* sha1_graphics_a8b8g8r8[]

static

Definition at line 221 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_a8r8g8b8

const char* sha1_graphics_a8r8g8b8[]

static

Definition at line 77 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_a8r8g8b8_bitfields

const char* sha1_graphics_a8r8g8b8_bitfields[]

static

Definition at line 149 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_r10g10b10

const char* sha1_graphics_r10g10b10[]

static

Definition at line 293 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_r4g4b4

const char* sha1_graphics_r4g4b4[]

static

Definition at line 580 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_r5g5b5

const char* sha1_graphics_r5g5b5[]

static

Definition at line 509 of file dib.c.

Referenced by test_simple_graphics().

sha1_graphics_r6g6b6

const char* sha1_graphics_r6g6b6[]

static

Definition at line 365 of file dib.c.

Referenced by test_simple_graphics().

vline_clips

const RECT vline_clips[]

static

Initial value:

=
{
    {120, 120, 120, 140}, 
    {100, 120, 100, 140}, 
    { 99, 120,  99, 140}, 
    {199, 120, 199, 140}, 
    {200, 120, 200, 140}, 
    {122,  99, 122, 201}, 
    {124, 100, 124, 140}, 
    {126,  99, 126, 140}, 
    {128, 120, 128, 200}, 
    {130, 120, 130, 201}, 
    {132,  12, 132, 140}, 
    {134,  90, 134, 101}, 
    {136,  90, 136, 100}, 
    {138, 199, 138, 220}, 
    {140, 200, 140, 220}  
}

Definition at line 1508 of file dib.c.

Referenced by draw_graphics().

wide_lines

const RECT wide_lines[]

static

Initial value:

=
{
    {100,  10, 200,  10},
    {100,  21, 200,  21},
    {200,  40, 100,  40},
    {200,  61, 100,  61},
    { 10, 100,  10, 200},
    { 21, 100,  21, 200},
    { 40, 200,  40, 100},
    { 61, 200,  61, 100},
}

Definition at line 1538 of file dib.c.

Referenced by draw_graphics().