image.c File Reference

#include <math.h>
#include <assert.h>
#include <stdio.h>
#include "initguid.h"
#include "objbase.h"
#include "gdiplus.h"
#include "wine/test.h"
#include "pshpack2.h"
#include "poppack.h"

Include dependency graph for image.c:

Go to the source code of this file.

Classes
struct	BITMAPINFOWITHBITFIELDS
union	BITMAPINFOUNION
struct	IFD_entry
struct	IFD_rational
struct	tiff_data
struct	tiff_1x1_data

Macros
#define	COBJMACROS
#define	expect(expected, got)   ok((got) == (expected), "Expected %d, got %d\n", (UINT)(expected), (UINT)(got))
#define	expectf(expected, got)   ok(fabs((expected) - (got)) < 0.0001, "Expected %f, got %f\n", (expected), (got))
#define	IFD_BYTE   1
#define	IFD_ASCII   2
#define	IFD_SHORT   3
#define	IFD_LONG   4
#define	IFD_RATIONAL   5
#define	IFD_SBYTE   6
#define	IFD_UNDEFINED   7
#define	IFD_SSHORT   8
#define	IFD_SLONG   9
#define	IFD_SRATIONAL   10
#define	IFD_FLOAT   11
#define	IFD_DOUBLE   12
#define	PropertyTagTypeSByte   6
#define	PropertyTagTypeSShort   8
#define	PropertyTagTypeFloat   11
#define	PropertyTagTypeDouble   12
#define	PNG_COLOR_TYPE_GRAY   0
#define	PNG_COLOR_TYPE_RGB   2
#define	PNG_COLOR_TYPE_PALETTE   3
#define	PNG_COLOR_TYPE_GRAY_ALPHA   4
#define	PNG_COLOR_TYPE_RGB_ALPHA   6

Functions
	DEFINE_GUID (BlurEffectGuid, 0x633c80a4, 0x1843, 0x482b, 0x9e, 0xf2, 0xbe, 0x28, 0x34, 0xc5, 0xfd, 0xd4)
	DEFINE_GUID (SharpenEffectGuid, 0x63cbf3ee, 0xc526, 0x402c, 0x8f, 0x71, 0x62, 0xc5, 0x40, 0xbf, 0x51, 0x42)
	DEFINE_GUID (ColorMatrixEffectGuid, 0x718f2615, 0x7933, 0x40e3, 0xa5, 0x11, 0x5f, 0x68, 0xfe, 0x14, 0xdd, 0x74)
	DEFINE_GUID (ColorLUTEffectGuid, 0xa7ce72a9, 0x0f7f, 0x40d7, 0xb3, 0xcc, 0xd0, 0xc0, 0x2d, 0x5c, 0x32, 0x12)
	DEFINE_GUID (BrightnessContrastEffectGuid, 0xd3a1dbe1, 0x8ec4, 0x4c17, 0x9f, 0x4c, 0xea, 0x97, 0xad, 0x1c, 0x34, 0x3d)
	DEFINE_GUID (HueSaturationLightnessEffectGuid, 0x8b2dd6c3, 0xeb07, 0x4d87, 0xa5, 0xf0, 0x71, 0x08, 0xe2, 0x6a, 0x9c, 0x5f)
	DEFINE_GUID (LevelsEffectGuid, 0x99c354ec, 0x2a31, 0x4f3a, 0x8c, 0x34, 0x17, 0xa8, 0x03, 0xb3, 0x3a, 0x25)
	DEFINE_GUID (TintEffectGuid, 0x1077af00, 0x2848, 0x4441, 0x94, 0x89, 0x44, 0xad, 0x4c, 0x2d, 0x7a, 0x2c)
	DEFINE_GUID (ColorBalanceEffectGuid, 0x537e597d, 0x251e, 0x48da, 0x96, 0x64, 0x29, 0xca, 0x49, 0x6b, 0x70, 0xf8)
	DEFINE_GUID (RedEyeCorrectionEffectGuid, 0x74d29d05, 0x69a4, 0x4266, 0x95, 0x49, 0x3c, 0xc5, 0x28, 0x36, 0xb6, 0x32)
	DEFINE_GUID (ColorCurveEffectGuid, 0xdd6a0022, 0x58e4, 0x4a67, 0x9d, 0x9b, 0xd4, 0x8e, 0xb8, 0x81, 0xa5, 0x3d)
static	GpStatus (WINAPI *pGdipBitmapGetHistogramSize)(HistogramFormat
static UINT *static UINT UINT UINT UINT *static GdiplusAbort *static	GpStatus (WINGDIPAPI *pGdipInitializePalette)(ColorPalette *
static BOOL	color_match (ARGB c1, ARGB c2, BYTE max_diff)
static void	expect_guid (REFGUID expected, REFGUID got, int line, BOOL todo)
static void	expect_rawformat (REFGUID expected, GpImage *img, int line, BOOL todo)
static void	test_bufferrawformat (void *buff, int size, REFGUID expected, int line, BOOL todo)
static void	test_Scan0 (void)
static void	test_FromGdiDib (void)
static void	test_GetImageDimension (void)
static void	test_GdipImageGetFrameDimensionsCount (void)
static void	test_LoadingImages (void)
static void	test_SavingImages (void)
static void	test_encoders (void)
static void	test_LockBits (void)
static void	test_LockBits_UserBuf (void)
static void	test_GdipCreateBitmapFromHBITMAP (void)
static void	test_GdipGetImageFlags (void)
static void	test_GdipCloneImage (void)
static void	test_testcontrol (void)
static void	test_fromhicon (void)
static void	test_getrawformat (void)
static void	test_loadwmf (void)
static void	test_createfromwmf (void)
static void	test_createfromwmf_noplaceable (void)
static void	test_resolution (void)
static void	test_createhbitmap (void)
static void	test_getthumbnail (void)
static void	test_getsetpixel (void)
static void	check_halftone_palette (ColorPalette *palette)
static void	test_palette (void)
static void	test_colormatrix (void)
static void	test_gamma (void)
static void	test_multiframegif (void)
static void	test_rotateflip (void)
static void	test_remaptable (void)
static void	test_colorkey (void)
static void	test_dispose (void)
static LONG	obj_refcount (void *obj)
static GpImage *	load_image (const BYTE *image_data, UINT image_size, BOOL valid_data, BOOL todo_load)
static void	test_image_properties (void)
static UINT	documented_type (UINT type)
static void	test_tiff_properties (void)
static void	test_GdipGetAllPropertyItems (void)
static void	test_tiff_palette (void)
static void	test_bitmapbits (void)
static void	test_DrawImage (void)
static void	test_DrawImage_SourceCopy (void)
static void	test_GdipDrawImagePointRect (void)
static void	test_image_format (void)
static void	test_DrawImage_scale (void)
static void	test_gif_properties (void)
static void	test_ARGB_conversion (void)
static void	test_CloneBitmapArea (void)
static BOOL	get_encoder_clsid (LPCWSTR mime, GUID *format, CLSID *clsid)
static void	test_supported_encoders (void)
static void	test_createeffect (void)
static void	test_getadjustedpalette (void)
static void	test_histogram (void)
static void	test_imageabort (void)
static void	test_png_color_formats (void)
static void	test_GdipLoadImageFromStream (void)
static BYTE *	init_bitmap (UINT *width, UINT *height, UINT *stride)
static void	test_GdipInitializePalette (void)
static void	test_tiff_color_formats (void)
	START_TEST (image)

Variables
static UINT *static	HistogramFormat
static UINT *static	UINT
static UINT *static UINT UINT UINT UINT *static GdiplusAbort *static	PaletteType
static UINT *static UINT UINT UINT UINT *static GdiplusAbort *static	INT
static UINT *static UINT UINT UINT UINT *static GdiplusAbort *static	BOOL
static const unsigned char	pngimage [285]
static const unsigned char	gifimage [35]
static const unsigned char	transparentgif []
static const unsigned char	bmpimage [66]
static const unsigned char	jpgimage [285]
static const unsigned char	tiffimage []
static const unsigned char	wmfimage [180]
static const unsigned char	gifanimation [72]
static const unsigned char	gifanimation2 []
static ARGB	gifanimation2_pixels [5][4]
static const struct tiff_data	TIFF_data
static const BYTE	animatedgif []
static const char	png_1x1_data []
static const struct tiff_1x1_data	tiff_1x1_data

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 22 of file image.c.

expect

#define expect	(		expected,
			got
	)		ok((got) == (expected), "Expected %d, got %d\n", (UINT)(expected), (UINT)(got))

Definition at line 56 of file image.c.

expectf

#define expectf	(		expected,
			got
	)		ok(fabs((expected) - (got)) < 0.0001, "Expected %f, got %f\n", (expected), (got))

Definition at line 57 of file image.c.

IFD_ASCII

#define IFD_ASCII   2

Definition at line 3456 of file image.c.

IFD_BYTE

#define IFD_BYTE   1

Definition at line 3455 of file image.c.

IFD_DOUBLE

#define IFD_DOUBLE   12

Definition at line 3466 of file image.c.

IFD_FLOAT

#define IFD_FLOAT   11

Definition at line 3465 of file image.c.

IFD_LONG

#define IFD_LONG   4

Definition at line 3458 of file image.c.

IFD_RATIONAL

#define IFD_RATIONAL   5

Definition at line 3459 of file image.c.

IFD_SBYTE

#define IFD_SBYTE   6

Definition at line 3460 of file image.c.

IFD_SHORT

#define IFD_SHORT   3

Definition at line 3457 of file image.c.

IFD_SLONG

#define IFD_SLONG   9

Definition at line 3463 of file image.c.

IFD_SRATIONAL

#define IFD_SRATIONAL   10

Definition at line 3464 of file image.c.

IFD_SSHORT

#define IFD_SSHORT   8

Definition at line 3462 of file image.c.

IFD_UNDEFINED

#define IFD_UNDEFINED   7

Definition at line 3461 of file image.c.

PNG_COLOR_TYPE_GRAY

#define PNG_COLOR_TYPE_GRAY   0

Definition at line 5164 of file image.c.

PNG_COLOR_TYPE_GRAY_ALPHA

#define PNG_COLOR_TYPE_GRAY_ALPHA   4

Definition at line 5167 of file image.c.

PNG_COLOR_TYPE_PALETTE

#define PNG_COLOR_TYPE_PALETTE   3

Definition at line 5166 of file image.c.

PNG_COLOR_TYPE_RGB

#define PNG_COLOR_TYPE_RGB   2

Definition at line 5165 of file image.c.

PNG_COLOR_TYPE_RGB_ALPHA

#define PNG_COLOR_TYPE_RGB_ALPHA   6

Definition at line 5168 of file image.c.

PropertyTagTypeDouble

#define PropertyTagTypeDouble   12

Definition at line 3472 of file image.c.

PropertyTagTypeFloat

#define PropertyTagTypeFloat   11

Definition at line 3471 of file image.c.

PropertyTagTypeSByte

#define PropertyTagTypeSByte   6

Definition at line 3469 of file image.c.

PropertyTagTypeSShort

#define PropertyTagTypeSShort   8

Definition at line 3470 of file image.c.

Function Documentation

check_halftone_palette()

static void check_halftone_palette ( ColorPalette *  palette )

static

Definition at line 2053 of file image.c.

{
    static const BYTE halftone_values[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
    UINT i;
 
    for (i=0; i<palette->Count; i++)
    {
        ARGB expected=0xff000000;
        if (i<8)
        {
            if (i&1) expected |= 0x800000;
            if (i&2) expected |= 0x8000;
            if (i&4) expected |= 0x80;
        }
        else if (i == 8)
        {
            expected = 0xffc0c0c0;
        }
        else if (i < 16)
        {
            if (i&1) expected |= 0xff0000;
            if (i&2) expected |= 0xff00;
            if (i&4) expected |= 0xff;
        }
        else if (i < 40)
        {
            expected = 0x00000000;
        }
        else
        {
            expected |= halftone_values[(i-40)%6];
            expected |= halftone_values[((i-40)/6)%6] << 8;
            expected |= halftone_values[((i-40)/36)%6] << 16;
        }
        ok(expected == palette->Entries[i], "Expected %.8x, got %.8x, i=%u/%u\n",
            expected, palette->Entries[i], i, palette->Count);
    }
}

Referenced by test_palette().

color_match()

static BOOL color_match ( ARGB  c1, ARGB  c2, BYTE  max_diff  )

static

Definition at line 59 of file image.c.

{
    if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
    c1 >>= 8; c2 >>= 8;
    if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
    c1 >>= 8; c2 >>= 8;
    if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
    c1 >>= 8; c2 >>= 8;
    if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
    return TRUE;
}

Referenced by test_colorkey(), test_colormatrix(), test_gamma(), and test_remaptable().

DEFINE_GUID() [1/11]

DEFINE_GUID	(	BlurEffectGuid	,
		0x633c80a4	,
		0x1843	,
		0x482b	,
		0x9e	,
		0xf2	,
		0xbe	,
		0x28	,
		0x34	,
		0xc5	,
		0xfd	,
		0xd4
	)

DEFINE_GUID() [2/11]

DEFINE_GUID	(	BrightnessContrastEffectGuid	,
		0xd3a1dbe1	,
		0x8ec4	,
		0x4c17	,
		0x9f	,
		0x4c	,
		0xea	,
		0x97	,
		0xad	,
		0x1c	,
		0x34	,
		0x3d
	)

DEFINE_GUID() [3/11]

DEFINE_GUID	(	ColorBalanceEffectGuid	,
		0x537e597d	,
		0x251e	,
		0x48da	,
		0x96	,
		0x64	,
		0x29	,
		0xca	,
		0x49	,
		0x6b	,
		0x70	,
		0xf8
	)

DEFINE_GUID() [4/11]

DEFINE_GUID	(	ColorCurveEffectGuid	,
		0xdd6a0022	,
		0x58e4	,
		0x4a67	,
		0x9d	,
		0x9b	,
		0xd4	,
		0x8e	,
		0xb8	,
		0x81	,
		0xa5	,
		0x3d
	)

DEFINE_GUID() [5/11]

DEFINE_GUID	(	ColorLUTEffectGuid	,
		0xa7ce72a9	,
		0x0f7f	,
		0x40d7	,
		0xb3	,
		0xcc	,
		0xd0	,
		0xc0	,
		0x2d	,
		0x5c	,
		0x32	,
		0x12
	)

DEFINE_GUID() [6/11]

DEFINE_GUID	(	ColorMatrixEffectGuid	,
		0x718f2615	,
		0x7933	,
		0x40e3	,
		0xa5	,
		0x11	,
		0x5f	,
		0x68	,
		0xfe	,
		0x14	,
		0xdd	,
		0x74
	)

DEFINE_GUID() [7/11]

DEFINE_GUID	(	HueSaturationLightnessEffectGuid	,
		0x8b2dd6c3	,
		0xeb07	,
		0x4d87	,
		0xa5	,
		0xf0	,
		0x71	,
		0x08	,
		0xe2	,
		0x6a	,
		0x9c	,
		0x5f
	)

DEFINE_GUID() [8/11]

DEFINE_GUID	(	LevelsEffectGuid	,
		0x99c354ec	,
		0x2a31	,
		0x4f3a	,
		0x8c	,
		0x34	,
		0x17	,
		0xa8	,
		0x03	,
		0xb3	,
		0x3a	,
		0x25
	)

DEFINE_GUID() [9/11]

DEFINE_GUID	(	RedEyeCorrectionEffectGuid	,
		0x74d29d05	,
		0x69a4	,
		0x4266	,
		0x95	,
		0x49	,
		0x3c	,
		0xc5	,
		0x28	,
		0x36	,
		0xb6	,
		0x32
	)

DEFINE_GUID() [10/11]

DEFINE_GUID	(	SharpenEffectGuid	,
		0x63cbf3ee	,
		0xc526	,
		0x402c	,
		0x8f	,
		0x71	,
		0x62	,
		0xc5	,
		0x40	,
		0xbf	,
		0x51	,
		0x42
	)

DEFINE_GUID() [11/11]

DEFINE_GUID	(	TintEffectGuid	,
		0x1077af00	,
		0x2848	,
		0x4441	,
		0x94	,
		0x89	,
		0x44	,
		0xad	,
		0x4c	,
		0x2d	,
		0x7a	,
		0x2c
	)

documented_type()

static UINT documented_type ( UINT  type )

static

Definition at line 3475 of file image.c.

{
    switch (type)
    {
    case PropertyTagTypeSByte: return PropertyTagTypeByte;
    case PropertyTagTypeSShort: return PropertyTagTypeShort;
    case PropertyTagTypeFloat: return PropertyTagTypeUndefined;
    case PropertyTagTypeDouble: return PropertyTagTypeUndefined;
    default: return type;
    }
}

Referenced by test_tiff_properties().

expect_guid()

static void expect_guid ( REFGUID  expected, REFGUID  got, int  line, BOOL  todo  )

static

Definition at line 71 of file image.c.

{
    WCHAR bufferW[39];
    char buffer[39];
    char buffer2[39];
 
    StringFromGUID2(got, bufferW, ARRAY_SIZE(bufferW));
    WideCharToMultiByte(CP_ACP, 0, bufferW, ARRAY_SIZE(bufferW), buffer, sizeof(buffer), NULL, NULL);
    StringFromGUID2(expected, bufferW, ARRAY_SIZE(bufferW));
    WideCharToMultiByte(CP_ACP, 0, bufferW, ARRAY_SIZE(bufferW), buffer2, sizeof(buffer2), NULL, NULL);
    todo_wine_if (todo)
        ok_(__FILE__, line)(IsEqualGUID(expected, got), "Expected %s, got %s\n", buffer2, buffer);
}

expect_rawformat()

static void expect_rawformat ( REFGUID  expected, GpImage *  img, int  line, BOOL  todo  )

static

Definition at line 85 of file image.c.

{
    GUID raw;
    GpStatus stat;
 
    stat = GdipGetImageRawFormat(img, &raw);
    ok_(__FILE__, line)(stat == Ok, "GdipGetImageRawFormat failed with %d\n", stat);
    if(stat != Ok) return;
    expect_guid(expected, &raw, line, todo);
}

Referenced by test_bufferrawformat(), test_fromhicon(), test_GdipCloneImage(), test_GdipCreateBitmapFromHBITMAP(), and test_multiframegif().

get_encoder_clsid()

static BOOL get_encoder_clsid ( LPCWSTR  mime, GUID *  format, CLSID *  clsid  )

static

Definition at line 4782 of file image.c.

{
    GpStatus status;
    UINT n_codecs, info_size, i;
    ImageCodecInfo *info;
    BOOL ret = FALSE;
 
    status = GdipGetImageEncodersSize(&n_codecs, &info_size);
    expect(Ok, status);
 
    info = GdipAlloc(info_size);
 
    status = GdipGetImageEncoders(n_codecs, info_size, info);
    expect(Ok, status);
 
    for (i = 0; i < n_codecs; i++)
    {
        if (!lstrcmpW(info[i].MimeType, mime))
        {
            *format = info[i].FormatID;
            *clsid = info[i].Clsid;
            ret = TRUE;
            break;
        }
    }
 
    GdipFree(info);
    return ret;
}

Referenced by test_supported_encoders().

GpStatus() [1/2]

static GpStatus ( WINAPI *  pGdipBitmapGetHistogramSize )

static

GpStatus() [2/2]

static UINT *static UINT UINT UINT UINT *static GdiplusAbort *static GpStatus ( WINGDIPAPI *  pGdipInitializePalette )

static

init_bitmap()

static BYTE * init_bitmap ( UINT *  width, UINT *  height, UINT *  stride  )

static

Definition at line 5359 of file image.c.

{
    BYTE *src;
    UINT i, j, scale;
 
    *width = 256;
    *height = 256;
    *stride = (*width * 3 + 3) & ~3;
    trace("width %d, height %d, stride %d\n", *width, *height, *stride);
 
    src = HeapAlloc(GetProcessHeap(), 0, *stride * *height);
 
    scale = 256 / *width;
    if (!scale) scale = 1;
 
    for (i = 0; i < *height; i++)
    {
        for (j = 0; j < *width; j++)
        {
            src[i * *stride + j*3 + 0] = scale * i;
            src[i * *stride + j*3 + 1] = scale * (255 - (i+j)/2);
            src[i * *stride + j*3 + 2] = scale * j;
        }
    }
 
    return src;
}

Referenced by test_GdipInitializePalette().

load_image()

static GpImage * load_image ( const BYTE *  image_data, UINT  image_size, BOOL  valid_data, BOOL  todo_load  )

static

Definition at line 3239 of file image.c.

{
    IStream *stream;
    HGLOBAL hmem;
    BYTE *data;
    HRESULT hr;
    GpStatus status;
    GpImage *image = NULL, *clone;
    ImageType image_type;
    LONG refcount, old_refcount;
 
    hmem = GlobalAlloc(0, image_size);
    data = GlobalLock(hmem);
    memcpy(data, image_data, image_size);
    GlobalUnlock(hmem);
 
    hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
    ok(hr == S_OK, "CreateStreamOnHGlobal error %#x\n", hr);
    if (hr != S_OK) return NULL;
 
    refcount = obj_refcount(stream);
    ok(refcount == 1, "expected stream refcount 1, got %d\n", refcount);
 
    status = GdipLoadImageFromStream(stream, &image);
    todo_wine_if(todo_load)
    if (valid_data)
        ok(status == Ok || broken(status == InvalidParameter), /* XP */
           "GdipLoadImageFromStream error %d\n", status);
    else
        ok(status != Ok, "GdipLoadImageFromStream should fail\n");
    if (status != Ok)
    {
        IStream_Release(stream);
        return NULL;
    }
 
    status = GdipGetImageType(image, &image_type);
    ok(status == Ok, "GdipGetImageType error %d\n", status);
 
    refcount = obj_refcount(stream);
    if (image_type == ImageTypeBitmap)
        ok(refcount > 1, "expected stream refcount > 1, got %d\n", refcount);
    else
        ok(refcount == 1, "expected stream refcount 1, got %d\n", refcount);
    old_refcount = refcount;
 
    status = GdipCloneImage(image, &clone);
    ok(status == Ok, "GdipCloneImage error %d\n", status);
    refcount = obj_refcount(stream);
    ok(refcount == old_refcount, "expected stream refcount %d, got %d\n", old_refcount, refcount);
    status = GdipDisposeImage(clone);
    ok(status == Ok, "GdipDisposeImage error %d\n", status);
    refcount = obj_refcount(stream);
    ok(refcount == old_refcount, "expected stream refcount %d, got %d\n", old_refcount, refcount);
 
    refcount = IStream_Release(stream);
    if (image_type == ImageTypeBitmap)
        ok(refcount >= 1, "expected stream refcount != 0\n");
    else
        ok(refcount == 0, "expected stream refcount 0, got %d\n", refcount);
 
    return image;
}

Referenced by test_GdipGetAllPropertyItems(), test_gif_properties(), test_image_properties(), test_png_color_formats(), test_tiff_color_formats(), test_tiff_palette(), and test_tiff_properties().

obj_refcount()

static LONG obj_refcount ( void *  obj )

static

Definition at line 3233 of file image.c.

{
    IUnknown_AddRef((IUnknown *)obj);
    return IUnknown_Release((IUnknown *)obj);
}

Referenced by load_image().

START_TEST()

START_TEST

(

image

)

Definition at line 5700 of file image.c.

{
    HMODULE mod = GetModuleHandleA("gdiplus.dll");
    struct GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR gdiplusToken;
    HMODULE hmsvcrt;
    int (CDECL * _controlfp_s)(unsigned int *cur, unsigned int newval, unsigned int mask);
 
    /* Enable all FP exceptions except _EM_INEXACT, which gdi32 can trigger */
    hmsvcrt = LoadLibraryA("msvcrt");
    _controlfp_s = (void*)GetProcAddress(hmsvcrt, "_controlfp_s");
    if (_controlfp_s) _controlfp_s(0, 0, 0x0008001e);
 
    gdiplusStartupInput.GdiplusVersion              = 1;
    gdiplusStartupInput.DebugEventCallback          = NULL;
    gdiplusStartupInput.SuppressBackgroundThread    = 0;
    gdiplusStartupInput.SuppressExternalCodecs      = 0;
 
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 
    pGdipBitmapGetHistogramSize = (void*)GetProcAddress(mod, "GdipBitmapGetHistogramSize");
    pGdipBitmapGetHistogram = (void*)GetProcAddress(mod, "GdipBitmapGetHistogram");
    pGdipImageSetAbort = (void*)GetProcAddress(mod, "GdipImageSetAbort");
 
    test_tiff_color_formats();
    test_GdipInitializePalette();
    test_png_color_formats();
    test_supported_encoders();
    test_CloneBitmapArea();
    test_ARGB_conversion();
    test_DrawImage_scale();
    test_image_format();
    test_DrawImage();
    test_DrawImage_SourceCopy();
    test_GdipDrawImagePointRect();
    test_bitmapbits();
    test_tiff_palette();
    test_GdipGetAllPropertyItems();
    test_tiff_properties();
    test_gif_properties();
    test_image_properties();
    test_Scan0();
    test_FromGdiDib();
    test_GetImageDimension();
    test_GdipImageGetFrameDimensionsCount();
    test_LoadingImages();
    test_SavingImages();
    test_encoders();
    test_LockBits();
    test_LockBits_UserBuf();
    test_GdipCreateBitmapFromHBITMAP();
    test_GdipGetImageFlags();
    test_GdipCloneImage();
    test_testcontrol();
    test_fromhicon();
    test_getrawformat();
    test_loadwmf();
    test_createfromwmf();
    test_createfromwmf_noplaceable();
    test_resolution();
    test_createhbitmap();
    test_getthumbnail();
    test_getsetpixel();
    test_palette();
    test_colormatrix();
    test_gamma();
    test_multiframegif();
    test_rotateflip();
    test_remaptable();
    test_colorkey();
    test_dispose();
    test_createeffect();
    test_getadjustedpalette();
    test_histogram();
    test_imageabort();
    test_GdipLoadImageFromStream();
 
    GdiplusShutdown(gdiplusToken);
}

test_ARGB_conversion()

static void test_ARGB_conversion ( void  )

static

Definition at line 4686 of file image.c.

{
    BYTE argb[8] = { 0x11,0x22,0x33,0x80, 0xff,0xff,0xff,0 };
    BYTE pargb[8] = { 0x09,0x11,0x1a,0x80, 0,0,0,0 };
    BYTE rgb32_xp[8] = { 0x11,0x22,0x33,0xff, 0xff,0xff,0xff,0xff };
    BYTE rgb24[6] = { 0x11,0x22,0x33, 0xff,0xff,0xff };
    BYTE *bits;
    GpBitmap *bitmap;
    BitmapData data;
    GpStatus status;
    int match;
 
    status = GdipCreateBitmapFromScan0(2, 1, 8, PixelFormat32bppARGB, argb, &bitmap);
    expect(Ok, status);
 
    status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat32bppPARGB, &data);
    expect(Ok, status);
    ok(data.Width == 2, "expected 2, got %d\n", data.Width);
    ok(data.Height == 1, "expected 1, got %d\n", data.Height);
    ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
    ok(data.PixelFormat == PixelFormat32bppPARGB, "expected PixelFormat32bppPARGB, got %d\n", data.PixelFormat);
    match = !memcmp(data.Scan0, pargb, sizeof(pargb));
    ok(match, "bits don't match\n");
    if (!match)
    {
        bits = data.Scan0;
        trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat32bppPARGB,
               bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
    }
    status = GdipBitmapUnlockBits(bitmap, &data);
    expect(Ok, status);
 
    status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat32bppRGB, &data);
    expect(Ok, status);
    ok(data.Width == 2, "expected 2, got %d\n", data.Width);
    ok(data.Height == 1, "expected 1, got %d\n", data.Height);
    ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
    ok(data.PixelFormat == PixelFormat32bppRGB, "expected PixelFormat32bppRGB, got %d\n", data.PixelFormat);
    match = !memcmp(data.Scan0, argb, sizeof(argb)) ||
            !memcmp(data.Scan0, rgb32_xp, sizeof(rgb32_xp));
    ok(match, "bits don't match\n");
    if (!match)
    {
        bits = data.Scan0;
        trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat32bppRGB,
               bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
    }
    status = GdipBitmapUnlockBits(bitmap, &data);
    expect(Ok, status);
 
    status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB, &data);
    expect(Ok, status);
    ok(data.Width == 2, "expected 2, got %d\n", data.Width);
    ok(data.Height == 1, "expected 1, got %d\n", data.Height);
    ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
    ok(data.PixelFormat == PixelFormat24bppRGB, "expected PixelFormat24bppRGB, got %d\n", data.PixelFormat);
    match = !memcmp(data.Scan0, rgb24, sizeof(rgb24));
    ok(match, "bits don't match\n");
    if (!match)
    {
        bits = data.Scan0;
        trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat24bppRGB,
               bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
    }
    status = GdipBitmapUnlockBits(bitmap, &data);
    expect(Ok, status);
 
    GdipDisposeImage((GpImage *)bitmap);
}

Referenced by START_TEST().

test_bitmapbits()

static void test_bitmapbits ( void  )

static

Definition at line 3926 of file image.c.

{
    /* 8 x 2 bitmap */
    static const BYTE pixels_24[48] =
    {
        0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
        0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
        0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
        0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0
    };
    static const BYTE pixels_00[48] =
    {
        0,0,0, 0,0,0, 0,0,0, 0,0,0,
        0,0,0, 0,0,0, 0,0,0, 0,0,0,
        0,0,0, 0,0,0, 0,0,0, 0,0,0,
        0,0,0, 0,0,0, 0,0,0, 0,0,0
    };
    static const BYTE pixels_24_77[64] =
    {
        0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
        0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
        0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
    };
    static const BYTE pixels_77[64] =
    {
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
    };
    static const BYTE pixels_8[16] =
    {
        0x01,0,0x01,0,0x01,0,0x01,0,
        0x01,0,0x01,0,0x01,0,0x01,0
    };
    static const BYTE pixels_8_77[64] =
    {
        0x01,0,0x01,0,0x01,0,0x01,0,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x01,0,0x01,0,0x01,0,0x01,0,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
    };
    static const BYTE pixels_1_77[64] =
    {
        0xaa,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0xaa,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
        0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
    };
    static const BYTE pixels_1[8] = {0xaa,0,0,0,0xaa,0,0,0};
    static const struct test_data
    {
        PixelFormat format;
        UINT bpp;
        ImageLockMode mode;
        UINT stride, size;
        const BYTE *pixels;
        const BYTE *pixels_unlocked;
    } td[] =
    {
        /* 0 */
        { PixelFormat24bppRGB, 24, 0xfff0, 24, 48, pixels_24, pixels_00 },
 
        { PixelFormat24bppRGB, 24, 0, 24, 48, pixels_24, pixels_00 },
        { PixelFormat24bppRGB, 24, ImageLockModeRead, 24, 48, pixels_24, pixels_00 },
        { PixelFormat24bppRGB, 24, ImageLockModeWrite, 24, 48, pixels_24, pixels_00 },
        { PixelFormat24bppRGB, 24, ImageLockModeRead|ImageLockModeWrite, 24, 48, pixels_24, pixels_00 },
        { PixelFormat24bppRGB, 24, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_24_77, pixels_24 },
        { PixelFormat24bppRGB, 24, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
        { PixelFormat24bppRGB, 24, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
        /* 8 */
        { PixelFormat8bppIndexed, 8, 0, 8, 16, pixels_8, pixels_24 },
        { PixelFormat8bppIndexed, 8, ImageLockModeRead, 8, 16, pixels_8, pixels_24 },
        { PixelFormat8bppIndexed, 8, ImageLockModeWrite, 8, 16, pixels_8, pixels_00 },
        { PixelFormat8bppIndexed, 8, ImageLockModeRead|ImageLockModeWrite, 8, 16, pixels_8, pixels_00 },
        { PixelFormat8bppIndexed, 8, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_8_77, pixels_24 },
        { PixelFormat8bppIndexed, 8, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
        { PixelFormat8bppIndexed, 8, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
        /* 15 */
        { PixelFormat1bppIndexed, 1, 0, 4, 8, pixels_1, pixels_24 },
        { PixelFormat1bppIndexed, 1, ImageLockModeRead, 4, 8, pixels_1, pixels_24 },
        { PixelFormat1bppIndexed, 1, ImageLockModeWrite, 4, 8, pixels_1, pixels_00 },
        { PixelFormat1bppIndexed, 1, ImageLockModeRead|ImageLockModeWrite, 4, 8, pixels_1, pixels_00 },
        { PixelFormat1bppIndexed, 1, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_1_77, pixels_24 },
        { PixelFormat1bppIndexed, 1, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
        { PixelFormat1bppIndexed, 1, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
    };
    BYTE buf[64];
    GpStatus status;
    GpBitmap *bitmap;
    UINT i;
    BitmapData data;
    struct
    {
        ColorPalette pal;
        ARGB entries[1];
    } palette;
    ARGB *entries = palette.pal.Entries;
 
    for (i = 0; i < ARRAY_SIZE(td); i++)
    {
        BYTE pixels[sizeof(pixels_24)];
        memcpy(pixels, pixels_24, sizeof(pixels_24));
        status = GdipCreateBitmapFromScan0(8, 2, 24, PixelFormat24bppRGB, pixels, &bitmap);
        expect(Ok, status);
 
        /* associate known palette with pixel data */
        palette.pal.Flags = PaletteFlagsGrayScale;
        palette.pal.Count = 2;
        entries[0] = 0xff000000;
        entries[1] = 0xffffffff;
        status = GdipSetImagePalette((GpImage *)bitmap, &palette.pal);
        expect(Ok, status);
 
        memset(&data, 0xfe, sizeof(data));
        if (td[i].mode & ImageLockModeUserInputBuf)
        {
            memset(buf, 0x77, sizeof(buf));
            data.Scan0 = buf;
            data.Stride = 32;
        }
        status = GdipBitmapLockBits(bitmap, NULL, td[i].mode, td[i].format, &data);
        ok(status == Ok || broken(status == InvalidParameter) /* XP */, "%u: GdipBitmapLockBits error %d\n", i, status);
        if (status != Ok)
        {
            GdipDisposeImage((GpImage *)bitmap);
            continue;
        }
        ok(data.Width == 8, "%u: expected 8, got %d\n", i, data.Width);
        ok(data.Height == 2, "%u: expected 2, got %d\n", i, data.Height);
        ok(td[i].stride == data.Stride, "%u: expected %d, got %d\n", i, td[i].stride, data.Stride);
        ok(td[i].format == data.PixelFormat, "%u: expected %d, got %d\n", i, td[i].format, data.PixelFormat);
        ok(td[i].size == data.Height * data.Stride, "%u: expected %d, got %d\n", i, td[i].size, data.Height * data.Stride);
        if (td[i].mode & ImageLockModeUserInputBuf)
            ok(data.Scan0 == buf, "%u: got wrong buffer\n", i);
        if (td[i].size == data.Height * data.Stride)
        {
            UINT j, match, width_bytes = (data.Width * td[i].bpp) / 8;
 
            match = 1;
            for (j = 0; j < data.Height; j++)
            {
                if (memcmp((const BYTE *)data.Scan0 + j * data.Stride, td[i].pixels + j * data.Stride, width_bytes) != 0)
                {
                    match = 0;
                    break;
                }
            }
            if ((td[i].mode & (ImageLockModeRead|ImageLockModeUserInputBuf)) || td[i].format == PixelFormat24bppRGB)
            {
                ok(match,
                   "%u: data should match\n", i);
                if (!match)
                {
                    BYTE *bits = data.Scan0;
                    trace("%u: data mismatch for format %#x:", i, td[i].format);
                    for (j = 0; j < td[i].size; j++)
                        trace(" %02x", bits[j]);
                    trace("\n");
                }
            }
            else
                ok(!match, "%u: data shouldn't match\n", i);
 
            memset(data.Scan0, 0, td[i].size);
        }
 
        status = GdipBitmapUnlockBits(bitmap, &data);
        ok(status == Ok, "%u: GdipBitmapUnlockBits error %d\n", i, status);
 
        memset(&data, 0xfe, sizeof(data));
        status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB, &data);
        ok(status == Ok, "%u: GdipBitmapLockBits error %d\n", i, status);
        ok(data.Width == 8, "%u: expected 8, got %d\n", i, data.Width);
        ok(data.Height == 2, "%u: expected 2, got %d\n", i, data.Height);
        ok(data.Stride == 24, "%u: expected 24, got %d\n", i, data.Stride);
        ok(data.PixelFormat == PixelFormat24bppRGB, "%u: got wrong pixel format %d\n", i, data.PixelFormat);
        ok(data.Height * data.Stride == 48, "%u: expected 48, got %d\n", i, data.Height * data.Stride);
        if (data.Height * data.Stride == 48)
        {
            int match = memcmp(data.Scan0, td[i].pixels_unlocked, 48) == 0;
            ok(match, "%u: data should match\n", i);
            if (!match)
            {
                UINT j;
                BYTE *bits = data.Scan0;
                trace("%u: data mismatch for format %#x:", i, td[i].format);
                for (j = 0; j < 48; j++)
                    trace(" %02x", bits[j]);
                trace("\n");
            }
        }
 
        status = GdipBitmapUnlockBits(bitmap, &data);
        ok(status == Ok, "%u: GdipBitmapUnlockBits error %d\n", i, status);
 
        status = GdipDisposeImage((GpImage *)bitmap);
        expect(Ok, status);
    }
}

Referenced by START_TEST().

test_bufferrawformat()

static void test_bufferrawformat ( void *  buff, int  size, REFGUID  expected, int  line, BOOL  todo  )

static

Definition at line 96 of file image.c.

{
    LPSTREAM stream;
    HGLOBAL  hglob;
    LPBYTE   data;
    HRESULT  hres;
    GpStatus stat;
    GpImage *img;
 
    hglob = GlobalAlloc (0, size);
    data = GlobalLock (hglob);
    memcpy(data, buff, size);
    GlobalUnlock(hglob); data = NULL;
 
    hres = CreateStreamOnHGlobal(hglob, TRUE, &stream);
    ok_(__FILE__, line)(hres == S_OK, "Failed to create a stream\n");
    if(hres != S_OK) return;
 
    stat = GdipLoadImageFromStream(stream, &img);
    ok_(__FILE__, line)(stat == Ok, "Failed to create a Bitmap\n");
    if(stat != Ok){
        IStream_Release(stream);
        return;
    }
 
    expect_rawformat(expected, img, line, todo);
 
    GdipDisposeImage(img);
    IStream_Release(stream);
}

Referenced by test_getrawformat().

test_CloneBitmapArea()

static void test_CloneBitmapArea ( void  )

static

Definition at line 4757 of file image.c.

{
    GpStatus status;
    GpBitmap *bitmap, *copy;
    BitmapData data, data2;
 
    status = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat24bppRGB, NULL, &bitmap);
    expect(Ok, status);
 
    status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead | ImageLockModeWrite, PixelFormat24bppRGB, &data);
    expect(Ok, status);
 
    status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB, &data2);
    expect(WrongState, status);
 
    status = GdipCloneBitmapAreaI(0, 0, 1, 1, PixelFormat24bppRGB, bitmap, &copy);
    expect(Ok, status);
 
    status = GdipBitmapUnlockBits(bitmap, &data);
    expect(Ok, status);
 
    GdipDisposeImage((GpImage *)copy);
    GdipDisposeImage((GpImage *)bitmap);
}

Referenced by START_TEST().

test_colorkey()

static void test_colorkey ( void  )

static

Definition at line 3116 of file image.c.

{
    GpStatus stat;
    GpImageAttributes *imageattr;
    GpBitmap *bitmap1, *bitmap2;
    GpGraphics *graphics;
    ARGB color;
 
    stat = GdipSetImageAttributesColorKeys(NULL, ColorAdjustTypeDefault, TRUE, 0xff405060, 0xff708090);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateImageAttributes(&imageattr);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeCount, TRUE, 0xff405060, 0xff708090);
    expect(InvalidParameter, stat);
 
    stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeAny, TRUE, 0xff405060, 0xff708090);
    expect(InvalidParameter, stat);
 
    stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeDefault, TRUE, 0xff405060, 0xff708090);
    expect(Ok, stat);
 
    stat = GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB, NULL, &bitmap1);
    expect(Ok, stat);
 
    stat = GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB, NULL, &bitmap2);
    expect(Ok, stat);
 
    stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0x20405060);
    expect(Ok, stat);
 
    stat = GdipBitmapSetPixel(bitmap1, 0, 1, 0x40506070);
    expect(Ok, stat);
 
    stat = GdipBitmapSetPixel(bitmap1, 1, 0, 0x60708090);
    expect(Ok, stat);
 
    stat = GdipBitmapSetPixel(bitmap1, 1, 1, 0xffffffff);
    expect(Ok, stat);
 
    stat = GdipGetImageGraphicsContext((GpImage*)bitmap2, &graphics);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,2,2, 0,0,2,2,
    UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0x00000000, color, 1), "Expected 00000000, got %.8x\n", color);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 1, &color);
    expect(Ok, stat);
    ok(color_match(0x00000000, color, 1), "Expected 00000000, got %.8x\n", color);
 
    stat = GdipBitmapGetPixel(bitmap2, 1, 0, &color);
    expect(Ok, stat);
    ok(color_match(0x00000000, color, 1), "Expected 00000000, got %.8x\n", color);
 
    stat = GdipBitmapGetPixel(bitmap2, 1, 1, &color);
    expect(Ok, stat);
    ok(color_match(0xffffffff, color, 1), "Expected ffffffff, got %.8x\n", color);
 
    stat = GdipResetImageAttributes(imageattr, ColorAdjustTypeDefault);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,2,2, 0,0,2,2,
    UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0x20405060, color, 1), "Expected 20405060, got %.8x\n", color);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 1, &color);
    expect(Ok, stat);
    ok(color_match(0x40506070, color, 1), "Expected 40506070, got %.8x\n", color);
 
    stat = GdipBitmapGetPixel(bitmap2, 1, 0, &color);
    expect(Ok, stat);
    ok(color_match(0x60708090, color, 1), "Expected 60708090, got %.8x\n", color);
 
    stat = GdipBitmapGetPixel(bitmap2, 1, 1, &color);
    expect(Ok, stat);
    ok(color_match(0xffffffff, color, 1), "Expected ffffffff, got %.8x\n", color);
 
 
    GdipDeleteGraphics(graphics);
    GdipDisposeImage((GpImage*)bitmap1);
    GdipDisposeImage((GpImage*)bitmap2);
    GdipDisposeImageAttributes(imageattr);
}

Referenced by START_TEST().

test_colormatrix()

static void test_colormatrix ( void  )

static

Definition at line 2278 of file image.c.

{
    GpStatus stat;
    ColorMatrix colormatrix, graymatrix;
    GpImageAttributes *imageattr;
    const ColorMatrix identity = {{
        {1.0,0.0,0.0,0.0,0.0},
        {0.0,1.0,0.0,0.0,0.0},
        {0.0,0.0,1.0,0.0,0.0},
        {0.0,0.0,0.0,1.0,0.0},
        {0.0,0.0,0.0,0.0,1.0}}};
    const ColorMatrix double_red = {{
        {2.0,0.0,0.0,0.0,0.0},
        {0.0,1.0,0.0,0.0,0.0},
        {0.0,0.0,1.0,0.0,0.0},
        {0.0,0.0,0.0,1.0,0.0},
        {0.0,0.0,0.0,0.0,1.0}}};
    const ColorMatrix asymmetric = {{
        {0.0,1.0,0.0,0.0,0.0},
        {0.0,0.0,1.0,0.0,0.0},
        {0.0,0.0,0.0,1.0,0.0},
        {1.0,0.0,0.0,0.0,0.0},
        {0.0,0.0,0.0,0.0,1.0}}};
    GpBitmap *bitmap1, *bitmap2;
    GpGraphics *graphics;
    ARGB color;
 
    colormatrix = identity;
    graymatrix = identity;
 
    stat = GdipSetImageAttributesColorMatrix(NULL, ColorAdjustTypeDefault,
        TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateImageAttributes(&imageattr);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        TRUE, NULL, NULL, ColorMatrixFlagsDefault);
    expect(InvalidParameter, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        TRUE, &colormatrix, NULL, ColorMatrixFlagsSkipGrays);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        TRUE, &colormatrix, NULL, ColorMatrixFlagsAltGray);
    expect(InvalidParameter, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsAltGray);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        TRUE, &colormatrix, &graymatrix, 3);
    expect(InvalidParameter, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeCount,
        TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
    expect(InvalidParameter, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeAny,
        TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
    expect(InvalidParameter, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        FALSE, NULL, NULL, ColorMatrixFlagsDefault);
    expect(Ok, stat);
 
    /* Drawing a bitmap transforms the colors */
    colormatrix = double_red;
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
    expect(Ok, stat);
 
    stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppARGB, NULL, &bitmap1);
    expect(Ok, stat);
 
    stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppARGB, NULL, &bitmap2);
    expect(Ok, stat);
 
    stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0xff40ccee);
    expect(Ok, stat);
 
    stat = GdipGetImageGraphicsContext((GpImage*)bitmap2, &graphics);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    expect(0xff80ccee, color);
 
    colormatrix = asymmetric;
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
    expect(Ok, stat);
 
    stat = GdipBitmapSetPixel(bitmap2, 0, 0, 0);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xeeff40cc, color, 3), "expected 0xeeff40cc, got 0x%08x\n", color);
 
    /* Toggle NoOp */
    stat = GdipSetImageAttributesNoOp(imageattr, ColorAdjustTypeDefault, FALSE);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xfefe40cc, color, 3), "expected 0xfefe40cc, got 0x%08x\n", color);
 
    stat = GdipSetImageAttributesNoOp(imageattr, ColorAdjustTypeDefault, TRUE);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
 
    stat = GdipResetImageAttributes(imageattr, ColorAdjustTypeDefault);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesNoOp(imageattr, ColorAdjustTypeDefault, FALSE);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xff40ccee, color, 1), "Expected ff40ccee, got %.8x\n", color);
 
    /* Disable adjustment, toggle NoOp */
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        FALSE, &colormatrix, NULL, ColorMatrixFlagsDefault);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesNoOp(imageattr, ColorAdjustTypeDefault, FALSE);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
 
    stat = GdipSetImageAttributesNoOp(imageattr, ColorAdjustTypeDefault, TRUE);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
 
    /* Reset with NoOp on, enable adjustment. */
    stat = GdipResetImageAttributes(imageattr, ColorAdjustTypeDefault);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
        TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xfff24ace, color, 3), "expected 0xfff24ace, got 0x%08x\n", color);
 
    /* Now inhibit specific category. */
    stat = GdipResetImageAttributes(imageattr, ColorAdjustTypeDefault);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeBitmap,
        TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xfffe41cc, color, 3), "expected 0xfffe41cc, got 0x%08x\n", color);
 
    stat = GdipSetImageAttributesNoOp(imageattr, ColorAdjustTypeBitmap, TRUE);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
 
    stat = GdipSetImageAttributesNoOp(imageattr, ColorAdjustTypeBitmap, FALSE);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesNoOp(imageattr, ColorAdjustTypeDefault, TRUE);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xfff24ace, color, 3), "expected 0xfff24ace, got 0x%08x\n", color);
 
    stat = GdipResetImageAttributes(imageattr, ColorAdjustTypeBitmap);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
 
    GdipDeleteGraphics(graphics);
    GdipDisposeImage((GpImage*)bitmap1);
    GdipDisposeImage((GpImage*)bitmap2);
    GdipDisposeImageAttributes(imageattr);
}

Referenced by START_TEST().

test_createeffect()

static void test_createeffect ( void  )

static

Definition at line 4863 of file image.c.

{
    static const GUID noneffect = { 0xcd0c3d4b, 0xe15e, 0x4cf2, { 0x9e, 0xa8, 0x6e, 0x1d, 0x65, 0x48, 0xc5, 0xa5 } };
    GpStatus (WINAPI *pGdipCreateEffect)( const GUID guid, CGpEffect **effect);
    GpStatus (WINAPI *pGdipDeleteEffect)( CGpEffect *effect);
    GpStatus stat;
    CGpEffect *effect;
    HMODULE mod = GetModuleHandleA("gdiplus.dll");
    int i;
    const GUID * const effectlist[] =
               {&BlurEffectGuid, &SharpenEffectGuid, &ColorMatrixEffectGuid, &ColorLUTEffectGuid,
                &BrightnessContrastEffectGuid, &HueSaturationLightnessEffectGuid, &LevelsEffectGuid,
                &TintEffectGuid, &ColorBalanceEffectGuid, &RedEyeCorrectionEffectGuid, &ColorCurveEffectGuid};
 
    pGdipCreateEffect = (void*)GetProcAddress( mod, "GdipCreateEffect");
    pGdipDeleteEffect = (void*)GetProcAddress( mod, "GdipDeleteEffect");
    if(!pGdipCreateEffect || !pGdipDeleteEffect)
    {
        /* GdipCreateEffect/GdipDeleteEffect was introduced in Windows Vista. */
        win_skip("GDIPlus version 1.1 not available\n");
        return;
    }
 
    stat = pGdipCreateEffect(BlurEffectGuid, NULL);
    expect(InvalidParameter, stat);
 
    stat = pGdipCreateEffect(noneffect, &effect);
    todo_wine expect(Win32Error, stat);
 
    for(i=0; i < ARRAY_SIZE(effectlist); i++)
    {
        stat = pGdipCreateEffect(*effectlist[i], &effect);
        todo_wine expect(Ok, stat);
        if(stat == Ok)
        {
            stat = pGdipDeleteEffect(effect);
            expect(Ok, stat);
        }
    }
}

Referenced by START_TEST().

test_createfromwmf()

static void test_createfromwmf ( void  )

static

Definition at line 1511 of file image.c.

{
    HMETAFILE hwmf;
    GpImage *img;
    GpStatus stat;
    GpRectF bounds;
    GpUnit unit;
    REAL res = 12345.0;
    MetafileHeader header;
 
    hwmf = SetMetaFileBitsEx(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader),
        wmfimage+sizeof(WmfPlaceableFileHeader));
    ok(hwmf != 0, "SetMetaFileBitsEx failed\n");
 
    stat = GdipCreateMetafileFromWmf(hwmf, TRUE,
        (WmfPlaceableFileHeader*)wmfimage, (GpMetafile**)&img);
    expect(Ok, stat);
 
    stat = GdipGetImageBounds(img, &bounds, &unit);
    expect(Ok, stat);
    expect(UnitPixel, unit);
    expectf(0.0, bounds.X);
    expectf(0.0, bounds.Y);
    expectf(320.0, bounds.Width);
    expectf(320.0, bounds.Height);
 
    stat = GdipGetImageHorizontalResolution(img, &res);
    expect(Ok, stat);
    expectf(1440.0, res);
 
    stat = GdipGetImageVerticalResolution(img, &res);
    expect(Ok, stat);
    expectf(1440.0, res);
 
    memset(&header, 0, sizeof(header));
    stat = GdipGetMetafileHeaderFromMetafile((GpMetafile*)img, &header);
    expect(Ok, stat);
    if (stat == Ok)
    {
        expect(MetafileTypeWmfPlaceable, header.Type);
        todo_wine expect(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader), header.Size);
        todo_wine expect(0x300, header.Version);
        expect(0, header.EmfPlusFlags);
        expectf(1440.0, header.DpiX);
        expectf(1440.0, header.DpiY);
        expect(0, header.X);
        expect(0, header.Y);
        expect(320, header.Width);
        expect(320, header.Height);
        expect(1, U(header).WmfHeader.mtType);
        expect(0, header.EmfPlusHeaderSize);
        expect(0, header.LogicalDpiX);
        expect(0, header.LogicalDpiY);
    }
 
    GdipDisposeImage(img);
}

Referenced by START_TEST().

test_createfromwmf_noplaceable()

static void test_createfromwmf_noplaceable ( void  )

static

Definition at line 1569 of file image.c.

{
    HMETAFILE hwmf;
    GpImage *img;
    GpStatus stat;
 
    hwmf = SetMetaFileBitsEx(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader),
        wmfimage+sizeof(WmfPlaceableFileHeader));
    ok(hwmf != 0, "SetMetaFileBitsEx failed\n");
 
    stat = GdipCreateMetafileFromWmf(hwmf, TRUE, NULL, (GpMetafile**)&img);
    expect(Ok, stat);
 
    GdipDisposeImage(img);
}

Referenced by START_TEST().

test_createhbitmap()

static void test_createhbitmap ( void  )

static

Definition at line 1679 of file image.c.

{
    GpStatus stat;
    GpBitmap *bitmap;
    HBITMAP hbitmap, oldhbitmap;
    BITMAP bm;
    int ret;
    HDC hdc;
    COLORREF pixel;
    BYTE bits[640];
    BitmapData lockeddata;
 
    memset(bits, 0x68, 640);
 
    /* create Bitmap */
    stat = GdipCreateBitmapFromScan0(10, 20, 32, PixelFormat24bppRGB, bits, &bitmap);
    expect(Ok, stat);
 
    /* test NULL values */
    stat = GdipCreateHBITMAPFromBitmap(NULL, &hbitmap, 0);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateHBITMAPFromBitmap(bitmap, NULL, 0);
    expect(InvalidParameter, stat);
 
    /* create HBITMAP */
    stat = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
    expect(Ok, stat);
 
    if (stat == Ok)
    {
        ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
        expect(sizeof(BITMAP), ret);
 
        expect(0, bm.bmType);
        expect(10, bm.bmWidth);
        expect(20, bm.bmHeight);
        expect(40, bm.bmWidthBytes);
        expect(1, bm.bmPlanes);
        expect(32, bm.bmBitsPixel);
        ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
 
        if (bm.bmBits)
        {
            DWORD val = *(DWORD*)bm.bmBits;
            ok(val == 0xff686868, "got %x, expected 0xff686868\n", val);
        }
 
        hdc = CreateCompatibleDC(NULL);
 
        oldhbitmap = SelectObject(hdc, hbitmap);
        pixel = GetPixel(hdc, 5, 5);
        SelectObject(hdc, oldhbitmap);
 
        DeleteDC(hdc);
 
        expect(0x686868, pixel);
 
        DeleteObject(hbitmap);
    }
 
    stat = GdipDisposeImage((GpImage*)bitmap);
    expect(Ok, stat);
 
    /* make (1,0) have no alpha and (2,0) a different blue value. */
    bits[7] = 0x00;
    bits[8] = 0x40;
 
    /* create alpha Bitmap */
    stat = GdipCreateBitmapFromScan0(8, 20, 32, PixelFormat32bppARGB, bits, &bitmap);
    expect(Ok, stat);
 
    /* create HBITMAP */
    stat = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
    expect(Ok, stat);
 
    if (stat == Ok)
    {
        ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
        expect(sizeof(BITMAP), ret);
 
        expect(0, bm.bmType);
        expect(8, bm.bmWidth);
        expect(20, bm.bmHeight);
        expect(32, bm.bmWidthBytes);
        expect(1, bm.bmPlanes);
        expect(32, bm.bmBitsPixel);
        ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
 
        if (bm.bmBits)
        {
            DWORD val = *(DWORD*)bm.bmBits;
            ok(val == 0x682a2a2a, "got %x, expected 0x682a2a2a\n", val);
            val = *((DWORD*)bm.bmBits + (bm.bmHeight-1) * bm.bmWidthBytes/4 + 1);
            ok(val == 0x0, "got %x, expected 0x682a2a2a\n", val);
        }
 
        hdc = CreateCompatibleDC(NULL);
 
        oldhbitmap = SelectObject(hdc, hbitmap);
        pixel = GetPixel(hdc, 5, 5);
        expect(0x2a2a2a, pixel);
        pixel = GetPixel(hdc, 1, 0);
        expect(0x0, pixel);
 
        SelectObject(hdc, oldhbitmap);
 
        DeleteDC(hdc);
 
 
        DeleteObject(hbitmap);
    }
 
    /* create HBITMAP with bkgnd colour */
    /* gdiplus.dll 5.1 is broken and only applies the blue value */
    stat = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0xff00ff);
    expect(Ok, stat);
 
    if (stat == Ok)
    {
        ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
        expect(sizeof(BITMAP), ret);
 
        expect(0, bm.bmType);
        expect(8, bm.bmWidth);
        expect(20, bm.bmHeight);
        expect(32, bm.bmWidthBytes);
        expect(1, bm.bmPlanes);
        expect(32, bm.bmBitsPixel);
        ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
 
        if (bm.bmBits)
        {
            DWORD val = *(DWORD*)bm.bmBits;
            ok(val == 0x68c12ac1 || broken(val == 0x682a2ac1), "got %x, expected 0x68c12ac1\n", val);
            val = *((DWORD*)bm.bmBits + (bm.bmHeight-1) * bm.bmWidthBytes/4 + 1);
            ok(val == 0xff00ff || broken(val == 0xff), "got %x, expected 0xff00ff\n", val);
        }
 
        hdc = CreateCompatibleDC(NULL);
 
        oldhbitmap = SelectObject(hdc, hbitmap);
        pixel = GetPixel(hdc, 5, 5);
        ok(pixel == 0xc12ac1 || broken(pixel == 0xc12a2a), "got %x, expected 0xc12ac1\n", pixel);
        pixel = GetPixel(hdc, 1, 0);
        ok(pixel == 0xff00ff || broken(pixel == 0xff0000), "got %x, expected 0xff00ff\n", pixel);
        pixel = GetPixel(hdc, 2, 0);
        ok(pixel == 0xb12ac1 || broken(pixel == 0xb12a2a), "got %x, expected 0xb12ac1\n", pixel);
 
        SelectObject(hdc, oldhbitmap);
        DeleteDC(hdc);
        DeleteObject(hbitmap);
    }
 
    /* create HBITMAP with bkgnd colour with alpha and show it behaves with no alpha. */
    stat = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0x80ff00ff);
    expect(Ok, stat);
 
    if (stat == Ok)
    {
        ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
        expect(sizeof(BITMAP), ret);
 
        expect(0, bm.bmType);
        expect(8, bm.bmWidth);
        expect(20, bm.bmHeight);
        expect(32, bm.bmWidthBytes);
        expect(1, bm.bmPlanes);
        expect(32, bm.bmBitsPixel);
        ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
 
        if (bm.bmBits)
        {
            DWORD val = *(DWORD*)bm.bmBits;
            ok(val == 0x68c12ac1 || broken(val == 0x682a2ac1), "got %x, expected 0x68c12ac1\n", val);
            val = *((DWORD*)bm.bmBits + (bm.bmHeight-1) * bm.bmWidthBytes/4 + 1);
            ok(val == 0xff00ff || broken(val == 0xff), "got %x, expected 0xff00ff\n", val);
        }
 
        hdc = CreateCompatibleDC(NULL);
 
        oldhbitmap = SelectObject(hdc, hbitmap);
        pixel = GetPixel(hdc, 5, 5);
        ok(pixel == 0xc12ac1 || broken(pixel == 0xc12a2a), "got %x, expected 0xc12ac1\n", pixel);
        pixel = GetPixel(hdc, 1, 0);
        ok(pixel == 0xff00ff || broken(pixel == 0xff0000), "got %x, expected 0xff00ff\n", pixel);
        pixel = GetPixel(hdc, 2, 0);
        ok(pixel == 0xb12ac1 || broken(pixel == 0xb12a2a), "got %x, expected 0xb12ac1\n", pixel);
 
        SelectObject(hdc, oldhbitmap);
        DeleteDC(hdc);
        DeleteObject(hbitmap);
    }
 
    stat = GdipDisposeImage((GpImage*)bitmap);
    expect(Ok, stat);
 
    /* create HBITMAP from locked data */
    memset(bits, 0x68, 640);
    stat = GdipCreateBitmapFromScan0(10, 20, 32, PixelFormat24bppRGB, bits, &bitmap);
    expect(Ok, stat);
 
    memset(&lockeddata, 0, sizeof(lockeddata));
    stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead | ImageLockModeWrite,
            PixelFormat32bppRGB, &lockeddata);
    expect(Ok, stat);
    ((DWORD*)lockeddata.Scan0)[0] = 0xff242424;
    stat = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
    expect(Ok, stat);
    stat = GdipBitmapUnlockBits(bitmap, &lockeddata);
    expect(Ok, stat);
    stat = GdipDisposeImage((GpImage*)bitmap);
    expect(Ok, stat);
 
    hdc = CreateCompatibleDC(NULL);
    oldhbitmap = SelectObject(hdc, hbitmap);
    pixel = GetPixel(hdc, 0, 0);
    expect(0x686868, pixel);
    SelectObject(hdc, oldhbitmap);
    DeleteDC(hdc);
}

Referenced by START_TEST().

test_dispose()

static void test_dispose ( void  )

static

Definition at line 3210 of file image.c.

{
    GpStatus stat;
    GpImage *image;
    char invalid_image[256];
 
    stat = GdipDisposeImage(NULL);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB, NULL, (GpBitmap**)&image);
    expect(Ok, stat);
 
    stat = GdipDisposeImage(image);
    expect(Ok, stat);
 
    stat = GdipDisposeImage(image);
    expect(ObjectBusy, stat);
 
    memset(invalid_image, 0, 256);
    stat = GdipDisposeImage((GpImage*)invalid_image);
    expect(ObjectBusy, stat);
}

Referenced by START_TEST().

test_DrawImage()

static void test_DrawImage ( void  )

static

Definition at line 4142 of file image.c.

{
    BYTE black_1x1[4] = { 0,0,0,0 };
    BYTE white_2x2[16] = { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
                           0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff };
    BYTE black_2x2[16] = { 0,0,0,0,0,0,0xff,0xff,
                           0,0,0,0,0,0,0xff,0xff };
    GpStatus status;
    union
    {
        GpBitmap *bitmap;
        GpImage *image;
    } u1, u2;
    GpGraphics *graphics;
    int match;
 
    status = GdipCreateBitmapFromScan0(1, 1, 4, PixelFormat24bppRGB, black_1x1, &u1.bitmap);
    expect(Ok, status);
    status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
    expect(Ok, status);
 
    status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat24bppRGB, white_2x2, &u2.bitmap);
    expect(Ok, status);
    status = GdipBitmapSetResolution(u2.bitmap, 300.0, 300.0);
    expect(Ok, status);
    status = GdipGetImageGraphicsContext(u2.image, &graphics);
    expect(Ok, status);
    status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
    expect(Ok, status);
 
    status = GdipDrawImageI(graphics, u1.image, 0, 0);
    expect(Ok, status);
 
    match = memcmp(white_2x2, black_2x2, sizeof(black_2x2)) == 0;
    ok(match, "data should match\n");
    if (!match)
    {
        UINT i, size = sizeof(white_2x2);
        BYTE *bits = white_2x2;
        for (i = 0; i < size; i++)
            trace(" %02x", bits[i]);
        trace("\n");
    }
 
    status = GdipDeleteGraphics(graphics);
    expect(Ok, status);
    status = GdipDisposeImage(u1.image);
    expect(Ok, status);
    status = GdipDisposeImage(u2.image);
    expect(Ok, status);
}

Referenced by START_TEST().

test_DrawImage_scale()

static void test_DrawImage_scale ( void  )

static

Definition at line 4369 of file image.c.

{
    static const BYTE back_8x1[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
                                       0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
    static const BYTE image_080[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,
                                        0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
    static const BYTE image_100[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40,
                                        0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
    static const BYTE image_120[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x40,
                                        0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
    static const BYTE image_150[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
                                        0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
    static const BYTE image_180[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
                                        0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
    static const BYTE image_200[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
                                        0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
    static const BYTE image_250[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,
                                        0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40 };
    static const BYTE image_120_half[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
                                        0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
    static const BYTE image_150_half[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
                                        0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
    static const BYTE image_200_half[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
                                        0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40 };
    static const BYTE image_250_half[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
                                        0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40 };
    static const struct test_data
    {
        REAL scale_x;
        PixelOffsetMode pixel_offset_mode;
        const BYTE *image;
        BOOL todo;
    } td[] =
    {
        { 0.8, PixelOffsetModeNone, image_080 }, /* 0 */
        { 1.0, PixelOffsetModeNone, image_100 },
        { 1.2, PixelOffsetModeNone, image_120 },
        { 1.5, PixelOffsetModeNone, image_150 },
        { 1.8, PixelOffsetModeNone, image_180 },
        { 2.0, PixelOffsetModeNone, image_200 },
        { 2.5, PixelOffsetModeNone, image_250 },
 
        { 0.8, PixelOffsetModeHighSpeed, image_080 }, /* 7 */
        { 1.0, PixelOffsetModeHighSpeed, image_100 },
        { 1.2, PixelOffsetModeHighSpeed, image_120 },
        { 1.5, PixelOffsetModeHighSpeed, image_150 },
        { 1.8, PixelOffsetModeHighSpeed, image_180 },
        { 2.0, PixelOffsetModeHighSpeed, image_200 },
        { 2.5, PixelOffsetModeHighSpeed, image_250 },
 
        { 0.8, PixelOffsetModeHalf, image_080 }, /* 14 */
        { 1.0, PixelOffsetModeHalf, image_100 },
        { 1.2, PixelOffsetModeHalf, image_120_half, TRUE },
        { 1.5, PixelOffsetModeHalf, image_150_half, TRUE },
        { 1.8, PixelOffsetModeHalf, image_180 },
        { 2.0, PixelOffsetModeHalf, image_200_half, TRUE },
        { 2.5, PixelOffsetModeHalf, image_250_half, TRUE },
 
        { 0.8, PixelOffsetModeHighQuality, image_080 }, /* 21 */
        { 1.0, PixelOffsetModeHighQuality, image_100 },
        { 1.2, PixelOffsetModeHighQuality, image_120_half, TRUE },
        { 1.5, PixelOffsetModeHighQuality, image_150_half, TRUE },
        { 1.8, PixelOffsetModeHighQuality, image_180 },
        { 2.0, PixelOffsetModeHighQuality, image_200_half, TRUE },
        { 2.5, PixelOffsetModeHighQuality, image_250_half, TRUE },
    };
    BYTE src_2x1[6] = { 0x80,0x80,0x80,0x80,0x80,0x80 };
    BYTE dst_8x1[24];
    GpStatus status;
    union
    {
        GpBitmap *bitmap;
        GpImage *image;
    } u1, u2;
    GpGraphics *graphics;
    GpMatrix *matrix;
    int i, match;
 
    status = GdipCreateBitmapFromScan0(2, 1, 4, PixelFormat24bppRGB, src_2x1, &u1.bitmap);
    expect(Ok, status);
    status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
    expect(Ok, status);
 
    status = GdipCreateBitmapFromScan0(8, 1, 24, PixelFormat24bppRGB, dst_8x1, &u2.bitmap);
    expect(Ok, status);
    status = GdipBitmapSetResolution(u2.bitmap, 100.0, 100.0);
    expect(Ok, status);
    status = GdipGetImageGraphicsContext(u2.image, &graphics);
    expect(Ok, status);
    status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
    expect(Ok, status);
 
    for (i = 0; i < ARRAY_SIZE(td); i++)
    {
        status = GdipSetPixelOffsetMode(graphics, td[i].pixel_offset_mode);
        expect(Ok, status);
 
        status = GdipCreateMatrix2(td[i].scale_x, 0.0, 0.0, 1.0, 0.0, 0.0, &matrix);
        expect(Ok, status);
        status = GdipSetWorldTransform(graphics, matrix);
        expect(Ok, status);
        GdipDeleteMatrix(matrix);
 
        memcpy(dst_8x1, back_8x1, sizeof(dst_8x1));
        status = GdipDrawImageI(graphics, u1.image, 1, 0);
        expect(Ok, status);
 
        match = memcmp(dst_8x1, td[i].image, sizeof(dst_8x1)) == 0;
        todo_wine_if (!match && td[i].todo)
            ok(match, "%d: data should match\n", i);
        if (!match)
        {
            UINT i, size = sizeof(dst_8x1);
            const BYTE *bits = dst_8x1;
            for (i = 0; i < size; i++)
                trace(" %02x", bits[i]);
            trace("\n");
        }
    }
 
    status = GdipDeleteGraphics(graphics);
    expect(Ok, status);
    status = GdipDisposeImage(u1.image);
    expect(Ok, status);
    status = GdipDisposeImage(u2.image);
    expect(Ok, status);
}

Referenced by START_TEST().

test_DrawImage_SourceCopy()

static void test_DrawImage_SourceCopy ( void  )

static

Definition at line 4194 of file image.c.

{
    DWORD dst_pixels[4] = { 0xffffffff, 0xffffffff,
                            0xffffffff, 0xffffffff };
    DWORD src_pixels[4] = { 0, 0xffff0000,
                            0, 0xff00ff };
 
    GpStatus status;
    union
    {
        GpBitmap *bitmap;
        GpImage *image;
    } u1, u2;
    GpGraphics *graphics;
 
    status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppARGB, (BYTE*)dst_pixels, &u1.bitmap);
    expect(Ok, status);
 
    status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppARGB, (BYTE*)src_pixels, &u2.bitmap);
    expect(Ok, status);
    status = GdipGetImageGraphicsContext(u1.image, &graphics);
    expect(Ok, status);
    status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
    expect(Ok, status);
 
    status = GdipSetCompositingMode(graphics, CompositingModeSourceCopy);
    expect(Ok, status);
 
    status = GdipDrawImageI(graphics, u2.image, 0, 0);
    expect(Ok, status);
 
    todo_wine expect(0, dst_pixels[0]);
    expect(0xffff0000, dst_pixels[1]);
    todo_wine expect(0, dst_pixels[2]);
    todo_wine expect(0, dst_pixels[3]);
 
    status = GdipDeleteGraphics(graphics);
    expect(Ok, status);
    status = GdipDisposeImage(u1.image);
    expect(Ok, status);
    status = GdipDisposeImage(u2.image);
    expect(Ok, status);
}

Referenced by START_TEST().

test_encoders()

static void test_encoders ( void  )

static

Definition at line 507 of file image.c.

{
    GpStatus stat;
    UINT n;
    UINT s;
    ImageCodecInfo *codecs;
    int i;
    int bmp_found;
 
    static const CHAR bmp_format[] = "BMP";
 
    stat = GdipGetImageEncodersSize(&n, &s);
    expect(stat, Ok);
 
    codecs = GdipAlloc(s);
    if (!codecs)
        return;
 
    stat = GdipGetImageEncoders(n, s, NULL);
    expect(GenericError, stat);
 
    stat = GdipGetImageEncoders(0, s, codecs);
    expect(GenericError, stat);
 
    stat = GdipGetImageEncoders(n, s-1, codecs);
    expect(GenericError, stat);
 
    stat = GdipGetImageEncoders(n, s+1, codecs);
    expect(GenericError, stat);
 
    stat = GdipGetImageEncoders(n, s, codecs);
    expect(stat, Ok);
 
    bmp_found = FALSE;
    for (i = 0; i < n; i++)
        {
            CHAR desc[32];
 
            WideCharToMultiByte(CP_ACP, 0, codecs[i].FormatDescription, -1,
                                desc, 32, 0, 0);
 
            if (CompareStringA(LOCALE_SYSTEM_DEFAULT, 0,
                               desc, -1,
                               bmp_format, -1) == CSTR_EQUAL) {
                bmp_found = TRUE;
                break;
            }
        }
    if (!bmp_found)
        ok(FALSE, "No BMP codec found.\n");
 
    GdipFree(codecs);
}

Referenced by START_TEST().

test_FromGdiDib()

static void test_FromGdiDib ( void  )

static

Definition at line 185 of file image.c.

{
    GpBitmap *bm;
    GpStatus stat;
    BYTE buff[400];
    BYTE rbmi[sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD)];
    BITMAPINFO *bmi = (BITMAPINFO*)rbmi;
    PixelFormat format;
 
    bm = NULL;
 
    memset(rbmi, 0, sizeof(rbmi));
 
    bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi->bmiHeader.biWidth = 10;
    bmi->bmiHeader.biHeight = 10;
    bmi->bmiHeader.biPlanes = 1;
    bmi->bmiHeader.biBitCount = 32;
    bmi->bmiHeader.biCompression = BI_RGB;
 
    stat = GdipCreateBitmapFromGdiDib(NULL, buff, &bm);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateBitmapFromGdiDib(bmi, NULL, &bm);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateBitmapFromGdiDib(bmi, buff, NULL);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
    expect(Ok, stat);
    ok(NULL != bm, "Expected bitmap to be initialized\n");
    if (stat == Ok)
    {
        stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
        expect(Ok, stat);
        expect(PixelFormat32bppRGB, format);
 
        GdipDisposeImage((GpImage*)bm);
    }
 
    bmi->bmiHeader.biBitCount = 24;
    stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
    expect(Ok, stat);
    ok(NULL != bm, "Expected bitmap to be initialized\n");
    if (stat == Ok)
    {
        stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
        expect(Ok, stat);
        expect(PixelFormat24bppRGB, format);
 
        GdipDisposeImage((GpImage*)bm);
    }
 
    bmi->bmiHeader.biBitCount = 16;
    stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
    expect(Ok, stat);
    ok(NULL != bm, "Expected bitmap to be initialized\n");
    if (stat == Ok)
    {
        stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
        expect(Ok, stat);
        expect(PixelFormat16bppRGB555, format);
 
        GdipDisposeImage((GpImage*)bm);
    }
 
    bmi->bmiHeader.biBitCount = 8;
    stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
    expect(Ok, stat);
    ok(NULL != bm, "Expected bitmap to be initialized\n");
    if (stat == Ok)
    {
        stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
        expect(Ok, stat);
        expect(PixelFormat8bppIndexed, format);
 
        GdipDisposeImage((GpImage*)bm);
    }
 
    bmi->bmiHeader.biBitCount = 4;
    stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
    expect(Ok, stat);
    ok(NULL != bm, "Expected bitmap to be initialized\n");
    if (stat == Ok)
    {
        stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
        expect(Ok, stat);
        expect(PixelFormat4bppIndexed, format);
 
        GdipDisposeImage((GpImage*)bm);
    }
 
    bmi->bmiHeader.biBitCount = 1;
    stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
    expect(Ok, stat);
    ok(NULL != bm, "Expected bitmap to be initialized\n");
    if (stat == Ok)
    {
        stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
        expect(Ok, stat);
        expect(PixelFormat1bppIndexed, format);
 
        GdipDisposeImage((GpImage*)bm);
    }
 
    bmi->bmiHeader.biBitCount = 0;
    stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
    expect(InvalidParameter, stat);
}

Referenced by START_TEST().

test_fromhicon()

static void test_fromhicon ( void  )

static

Definition at line 1249 of file image.c.

{
    static const BYTE bmp_bits[1024];
    HBITMAP hbmMask, hbmColor;
    ICONINFO info;
    HICON hIcon;
    GpStatus stat;
    GpBitmap *bitmap = NULL;
    UINT dim;
    ImageType type;
    PixelFormat format;
 
    /* NULL */
    stat = GdipCreateBitmapFromHICON(NULL, NULL);
    expect(InvalidParameter, stat);
    stat = GdipCreateBitmapFromHICON(NULL, &bitmap);
    expect(InvalidParameter, stat);
 
    /* color icon 1 bit */
    hbmMask = CreateBitmap(16, 16, 1, 1, bmp_bits);
    ok(hbmMask != 0, "CreateBitmap failed\n");
    hbmColor = CreateBitmap(16, 16, 1, 1, bmp_bits);
    ok(hbmColor != 0, "CreateBitmap failed\n");
    info.fIcon = TRUE;
    info.xHotspot = 8;
    info.yHotspot = 8;
    info.hbmMask = hbmMask;
    info.hbmColor = hbmColor;
    hIcon = CreateIconIndirect(&info);
    ok(hIcon != 0, "CreateIconIndirect failed\n");
    DeleteObject(hbmMask);
    DeleteObject(hbmColor);
 
    stat = GdipCreateBitmapFromHICON(hIcon, &bitmap);
    ok(stat == Ok ||
       broken(stat == InvalidParameter), /* Win98 */
       "Expected Ok, got %.8x\n", stat);
    if(stat == Ok){
       /* check attributes */
       stat = GdipGetImageHeight((GpImage*)bitmap, &dim);
       expect(Ok, stat);
       expect(16, dim);
       stat = GdipGetImageWidth((GpImage*)bitmap, &dim);
       expect(Ok, stat);
       expect(16, dim);
       stat = GdipGetImageType((GpImage*)bitmap, &type);
       expect(Ok, stat);
       expect(ImageTypeBitmap, type);
       stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
       expect(Ok, stat);
       expect(PixelFormat32bppARGB, format);
       /* raw format */
       expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bitmap, __LINE__, FALSE);
       GdipDisposeImage((GpImage*)bitmap);
    }
    DestroyIcon(hIcon);
 
    /* color icon 8 bpp */
    hbmMask = CreateBitmap(16, 16, 1, 8, bmp_bits);
    ok(hbmMask != 0, "CreateBitmap failed\n");
    hbmColor = CreateBitmap(16, 16, 1, 8, bmp_bits);
    ok(hbmColor != 0, "CreateBitmap failed\n");
    info.fIcon = TRUE;
    info.xHotspot = 8;
    info.yHotspot = 8;
    info.hbmMask = hbmMask;
    info.hbmColor = hbmColor;
    hIcon = CreateIconIndirect(&info);
    ok(hIcon != 0, "CreateIconIndirect failed\n");
    DeleteObject(hbmMask);
    DeleteObject(hbmColor);
 
    stat = GdipCreateBitmapFromHICON(hIcon, &bitmap);
    expect(Ok, stat);
    if(stat == Ok){
        /* check attributes */
        stat = GdipGetImageHeight((GpImage*)bitmap, &dim);
        expect(Ok, stat);
        expect(16, dim);
        stat = GdipGetImageWidth((GpImage*)bitmap, &dim);
        expect(Ok, stat);
        expect(16, dim);
        stat = GdipGetImageType((GpImage*)bitmap, &type);
        expect(Ok, stat);
        expect(ImageTypeBitmap, type);
        stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
    expect(Ok, stat);
        expect(PixelFormat32bppARGB, format);
        /* raw format */
        expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bitmap, __LINE__, FALSE);
        GdipDisposeImage((GpImage*)bitmap);
    }
    DestroyIcon(hIcon);
}

Referenced by START_TEST().

test_gamma()

static void test_gamma ( void  )

static

Definition at line 2543 of file image.c.

{
    GpStatus stat;
    GpImageAttributes *imageattr;
    GpBitmap *bitmap1, *bitmap2;
    GpGraphics *graphics;
    ARGB color;
 
    stat = GdipSetImageAttributesGamma(NULL, ColorAdjustTypeDefault, TRUE, 1.0);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateImageAttributes(&imageattr);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 1.0);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeAny, TRUE, 1.0);
    expect(InvalidParameter, stat);
 
    stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, -1.0);
    expect(InvalidParameter, stat);
 
    stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 0.0);
    expect(InvalidParameter, stat);
 
    stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 0.5);
    expect(Ok, stat);
 
    stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, FALSE, 0.0);
    expect(Ok, stat);
 
    /* Drawing a bitmap transforms the colors */
    stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 3.0);
    expect(Ok, stat);
 
    stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB, NULL, &bitmap1);
    expect(Ok, stat);
 
    stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB, NULL, &bitmap2);
    expect(Ok, stat);
 
    stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0xff80ffff);
    expect(Ok, stat);
 
    stat = GdipGetImageGraphicsContext((GpImage*)bitmap2, &graphics);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xff20ffff, color, 1), "Expected ff20ffff, got %.8x\n", color);
 
    stat = GdipResetImageAttributes(imageattr, ColorAdjustTypeDefault);
    expect(Ok, stat);
 
    stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
        UnitPixel, imageattr, NULL, NULL);
    expect(Ok, stat);
 
    stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
    expect(Ok, stat);
    ok(color_match(0xff80ffff, color, 1), "Expected ff80ffff, got %.8x\n", color);
 
    GdipDeleteGraphics(graphics);
    GdipDisposeImage((GpImage*)bitmap1);
    GdipDisposeImage((GpImage*)bitmap2);
    GdipDisposeImageAttributes(imageattr);
}

Referenced by START_TEST().

test_GdipCloneImage()

static void test_GdipCloneImage ( void  )

static

Definition at line 1206 of file image.c.

{
    GpStatus stat;
    GpRectF rectF;
    GpUnit unit;
    GpBitmap *bm;
    GpImage *image_src, *image_dest = NULL;
    const INT WIDTH = 10, HEIGHT = 20;
 
    /* Create an image, clone it, delete the original, make sure the copy works */
    stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
    expect(Ok, stat);
    expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bm, __LINE__, FALSE);
 
    image_src = ((GpImage*)bm);
    stat = GdipCloneImage(image_src, &image_dest);
    expect(Ok, stat);
    expect_rawformat(&ImageFormatMemoryBMP, image_dest, __LINE__, FALSE);
 
    stat = GdipDisposeImage((GpImage*)bm);
    expect(Ok, stat);
    stat = GdipGetImageBounds(image_dest, &rectF, &unit);
    expect(Ok, stat);
 
    /* Treat FP values carefully */
    expectf((REAL)WIDTH, rectF.Width);
    expectf((REAL)HEIGHT, rectF.Height);
 
    stat = GdipDisposeImage(image_dest);
    expect(Ok, stat);
}

Referenced by START_TEST().

test_GdipCreateBitmapFromHBITMAP()

static void test_GdipCreateBitmapFromHBITMAP ( void  )

static

Definition at line 895 of file image.c.

{
    GpBitmap* gpbm = NULL;
    HBITMAP hbm = NULL;
    HPALETTE hpal = NULL;
    GpStatus stat;
    BYTE buff[1000];
    LOGPALETTE* LogPal = NULL;
    REAL width, height;
    const REAL WIDTH1 = 5;
    const REAL HEIGHT1 = 15;
    const REAL WIDTH2 = 10;
    const REAL HEIGHT2 = 20;
    HDC hdc;
    union BITMAPINFOUNION bmi;
    BYTE *bits;
    PixelFormat format;
 
    stat = GdipCreateBitmapFromHBITMAP(NULL, NULL, NULL);
    expect(InvalidParameter, stat);
 
    hbm = CreateBitmap(WIDTH1, HEIGHT1, 1, 1, NULL);
    stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, NULL);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
    expect(Ok, stat);
    expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
    expectf(WIDTH1,  width);
    expectf(HEIGHT1, height);
    if (stat == Ok)
        GdipDisposeImage((GpImage*)gpbm);
    DeleteObject(hbm);
 
    memset(buff, 0, sizeof(buff));
    hbm = CreateBitmap(WIDTH2, HEIGHT2, 1, 1, &buff);
    stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
    expect(Ok, stat);
    /* raw format */
    expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)gpbm, __LINE__, FALSE);
 
    expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
    expectf(WIDTH2,  width);
    expectf(HEIGHT2, height);
    if (stat == Ok)
        GdipDisposeImage((GpImage*)gpbm);
    DeleteObject(hbm);
 
    hdc = CreateCompatibleDC(0);
    ok(hdc != NULL, "CreateCompatibleDC failed\n");
    bmi.bi.bmiHeader.biSize = sizeof(bmi.bi.bmiHeader);
    bmi.bi.bmiHeader.biHeight = HEIGHT1;
    bmi.bi.bmiHeader.biWidth = WIDTH1;
    bmi.bi.bmiHeader.biBitCount = 24;
    bmi.bi.bmiHeader.biPlanes = 1;
    bmi.bi.bmiHeader.biCompression = BI_RGB;
    bmi.bi.bmiHeader.biClrUsed = 0;
 
    hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hbm != NULL, "CreateDIBSection failed\n");
 
    bits[0] = 0;
 
    stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
    expect(Ok, stat);
    expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
    expectf(WIDTH1,  width);
    expectf(HEIGHT1, height);
    if (stat == Ok)
    {
        /* test whether writing to the bitmap affects the original */
        stat = GdipBitmapSetPixel(gpbm, 0, 0, 0xffffffff);
        expect(Ok, stat);
 
        expect(0, bits[0]);
 
        GdipDisposeImage((GpImage*)gpbm);
    }
 
    LogPal = GdipAlloc(sizeof(LOGPALETTE));
    ok(LogPal != NULL, "unable to allocate LOGPALETTE\n");
    LogPal->palVersion = 0x300;
    LogPal->palNumEntries = 1;
    hpal = CreatePalette(LogPal);
    ok(hpal != NULL, "CreatePalette failed\n");
    GdipFree(LogPal);
 
    stat = GdipCreateBitmapFromHBITMAP(hbm, hpal, &gpbm);
    expect(Ok, stat);
 
    if (stat == Ok)
        GdipDisposeImage((GpImage*)gpbm);
 
    DeleteObject(hpal);
    DeleteObject(hbm);
 
    /* 16-bit 555 dib, rgb */
    bmi.bi.bmiHeader.biBitCount = 16;
    bmi.bi.bmiHeader.biCompression = BI_RGB;
 
    hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hbm != NULL, "CreateDIBSection failed\n");
 
    bits[0] = 0;
 
    stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
    expect(Ok, stat);
 
    if (stat == Ok)
    {
        stat = GdipGetImageDimension((GpImage*) gpbm, &width, &height);
        expect(Ok, stat);
        expectf(WIDTH1,  width);
        expectf(HEIGHT1, height);
 
        stat = GdipGetImagePixelFormat((GpImage*) gpbm, &format);
        expect(Ok, stat);
        expect(PixelFormat16bppRGB555, format);
 
        GdipDisposeImage((GpImage*)gpbm);
    }
    DeleteObject(hbm);
 
    /* 16-bit 555 dib, with bitfields */
    bmi.bi.bmiHeader.biSize = sizeof(bmi);
    bmi.bi.bmiHeader.biCompression = BI_BITFIELDS;
    bmi.bf.masks[0] = 0x7c00;
    bmi.bf.masks[1] = 0x3e0;
    bmi.bf.masks[2] = 0x1f;
 
    hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hbm != NULL, "CreateDIBSection failed\n");
 
    bits[0] = 0;
 
    stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
    expect(Ok, stat);
 
    if (stat == Ok)
    {
        stat = GdipGetImageDimension((GpImage*) gpbm, &width, &height);
        expect(Ok, stat);
        expectf(WIDTH1,  width);
        expectf(HEIGHT1, height);
 
        stat = GdipGetImagePixelFormat((GpImage*) gpbm, &format);
        expect(Ok, stat);
        expect(PixelFormat16bppRGB555, format);
 
        GdipDisposeImage((GpImage*)gpbm);
    }
    DeleteObject(hbm);
 
    /* 16-bit 565 dib, with bitfields */
    bmi.bf.masks[0] = 0xf800;
    bmi.bf.masks[1] = 0x7e0;
    bmi.bf.masks[2] = 0x1f;
 
    hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hbm != NULL, "CreateDIBSection failed\n");
 
    bits[0] = 0;
 
    stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
    expect(Ok, stat);
 
    if (stat == Ok)
    {
        stat = GdipGetImageDimension((GpImage*) gpbm, &width, &height);
        expect(Ok, stat);
        expectf(WIDTH1,  width);
        expectf(HEIGHT1, height);
 
        stat = GdipGetImagePixelFormat((GpImage*) gpbm, &format);
        expect(Ok, stat);
        expect(PixelFormat16bppRGB565, format);
 
        GdipDisposeImage((GpImage*)gpbm);
    }
    DeleteObject(hbm);
 
    DeleteDC(hdc);
}

Referenced by START_TEST().

test_GdipDrawImagePointRect()

static void test_GdipDrawImagePointRect ( void  )

static

Definition at line 4238 of file image.c.

{
    BYTE black_1x1[4] = { 0,0,0,0 };
    BYTE white_2x2[16] = { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
                           0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff };
    BYTE black_2x2[16] = { 0,0,0,0,0,0,0xff,0xff,
                           0,0,0,0,0,0,0xff,0xff };
    GpStatus status;
    union
    {
        GpBitmap *bitmap;
        GpImage *image;
    } u1, u2;
    GpGraphics *graphics;
    int match;
 
    status = GdipCreateBitmapFromScan0(1, 1, 4, PixelFormat24bppRGB, black_1x1, &u1.bitmap);
    expect(Ok, status);
    status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
    expect(Ok, status);
 
    status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat24bppRGB, white_2x2, &u2.bitmap);
    expect(Ok, status);
    status = GdipBitmapSetResolution(u2.bitmap, 300.0, 300.0);
    expect(Ok, status);
    status = GdipGetImageGraphicsContext(u2.image, &graphics);
    expect(Ok, status);
    status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
    expect(Ok, status);
 
    status = GdipDrawImagePointRectI(graphics, u1.image, 0, 0, 0, 0, 1, 1, UnitPixel);
    expect(Ok, status);
 
    match = memcmp(white_2x2, black_2x2, sizeof(black_2x2)) == 0;
    ok(match, "data should match\n");
    if (!match)
    {
        UINT i, size = sizeof(white_2x2);
        BYTE *bits = white_2x2;
        for (i = 0; i < size; i++)
            trace(" %02x", bits[i]);
        trace("\n");
    }
 
    status = GdipDeleteGraphics(graphics);
    expect(Ok, status);
    status = GdipDisposeImage(u1.image);
    expect(Ok, status);
    status = GdipDisposeImage(u2.image);
    expect(Ok, status);
}

Referenced by START_TEST().

test_GdipGetAllPropertyItems()

static void test_GdipGetAllPropertyItems ( void  )

static

Definition at line 3710 of file image.c.

{
    static const struct test_data
    {
        ULONG type, id, length;
        BYTE value[32];
    } td[16] =
    {
        { PropertyTagTypeLong, 0xfe, 4, { 0 } },
        { PropertyTagTypeShort, 0x100, 2, { 1 } },
        { PropertyTagTypeShort, 0x101, 2, { 1 } },
        { PropertyTagTypeShort, 0x102, 6, { 8,0,8,0,8,0 } },
        { PropertyTagTypeShort, 0x103, 2, { 1 } },
        { PropertyTagTypeShort, 0x106, 2, { 2,0 } },
        { PropertyTagTypeASCII, 0x10d, 27, "/home/meh/Desktop/test.tif" },
        { PropertyTagTypeLong, 0x111, 4, { 8,0,0,0 } },
        { PropertyTagTypeShort, 0x112, 2, { 1 } },
        { PropertyTagTypeShort, 0x115, 2, { 3,0 } },
        { PropertyTagTypeShort, 0x116, 2, { 0x40,0 } },
        { PropertyTagTypeLong, 0x117, 4, { 3,0,0,0 } },
        { PropertyTagTypeRational, 0x11a, 8, { 0,0,0,72,0,0,0,1 } },
        { PropertyTagTypeRational, 0x11b, 8, { 0,0,0,72,0,0,0,1 } },
        { PropertyTagTypeShort, 0x11c, 2, { 1 } },
        { PropertyTagTypeShort, 0x128, 2, { 2 } }
    };
    GpStatus status;
    GpImage *image;
    GUID guid;
    UINT dim_count, frame_count, prop_count, prop_size, i;
    UINT total_size, total_count;
    PROPID *prop_id;
    PropertyItem *prop_item;
    const char *item_data;
 
    image = load_image(tiffimage, sizeof(tiffimage), TRUE, FALSE);
    ok(image != 0, "Failed to load TIFF image data\n");
    if (!image) return;
 
    dim_count = 0xdeadbeef;
    status = GdipImageGetFrameDimensionsCount(image, &dim_count);
    expect(Ok, status);
    expect(1, dim_count);
 
    status = GdipImageGetFrameDimensionsList(image, &guid, 1);
    expect(Ok, status);
    expect_guid(&FrameDimensionPage, &guid, __LINE__, FALSE);
 
    frame_count = 0xdeadbeef;
    status = GdipImageGetFrameCount(image, &guid, &frame_count);
    expect(Ok, status);
    expect(1, frame_count);
 
    prop_count = 0xdeadbeef;
    status = GdipGetPropertyCount(image, &prop_count);
    expect(Ok, status);
    ok(prop_count == ARRAY_SIZE(td),
       "expected property count %u, got %u\n", (UINT) ARRAY_SIZE(td), prop_count);
 
    prop_id = HeapAlloc(GetProcessHeap(), 0, prop_count * sizeof(*prop_id));
 
    status = GdipGetPropertyIdList(image, prop_count, prop_id);
    expect(Ok, status);
 
    prop_size = 0;
    for (i = 0; i < prop_count; i++)
    {
        UINT size;
        status = GdipGetPropertyItemSize(image, prop_id[i], &size);
        expect(Ok, status);
        if (status != Ok) break;
        ok(size > sizeof(*prop_item), "%u: too small item length %u\n", i, size);
 
        prop_size += size;
 
        prop_item = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
        status = GdipGetPropertyItem(image, prop_id[i], size, prop_item);
        expect(Ok, status);
        ok(prop_item->value == prop_item + 1, "expected item->value %p, got %p\n", prop_item + 1, prop_item->value);
        ok(td[i].type == prop_item->type,
            "%u: expected type %u, got %u\n", i, td[i].type, prop_item->type);
        ok(td[i].id == prop_item->id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item->id);
        size -= sizeof(*prop_item);
        ok(prop_item->length == size, "%u: expected length %u, got %u\n", i, size, prop_item->length);
        ok(td[i].length == prop_item->length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item->length);
        if (td[i].length == prop_item->length)
        {
            int match = memcmp(td[i].value, prop_item->value, td[i].length) == 0;
            ok(match, "%u: data mismatch\n", i);
            if (!match)
            {
                UINT j;
                BYTE *data = prop_item->value;
                trace("id %#x:", prop_item->id);
                for (j = 0; j < prop_item->length; j++)
                    trace(" %02x", data[j]);
                trace("\n");
            }
        }
        HeapFree(GetProcessHeap(), 0, prop_item);
    }
 
    HeapFree(GetProcessHeap(), 0, prop_id);
 
    status = GdipGetPropertySize(NULL, &total_size, &total_count);
    expect(InvalidParameter, status);
    status = GdipGetPropertySize(image, &total_size, NULL);
    expect(InvalidParameter, status);
    status = GdipGetPropertySize(image, NULL, &total_count);
    expect(InvalidParameter, status);
    status = GdipGetPropertySize(image, NULL, NULL);
    expect(InvalidParameter, status);
    total_size = 0xdeadbeef;
    total_count = 0xdeadbeef;
    status = GdipGetPropertySize(image, &total_size, &total_count);
    expect(Ok, status);
    ok(prop_count == total_count,
       "expected total property count %u, got %u\n", prop_count, total_count);
    ok(prop_size == total_size,
       "expected total property size %u, got %u\n", prop_size, total_size);
 
    prop_item = HeapAlloc(GetProcessHeap(), 0, prop_size);
 
    status = GdipGetAllPropertyItems(image, 0, prop_count, prop_item);
    expect(InvalidParameter, status);
    status = GdipGetAllPropertyItems(image, prop_size, 1, prop_item);
    expect(InvalidParameter, status);
    status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
    expect(InvalidParameter, status);
    status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
    expect(InvalidParameter, status);
    status = GdipGetAllPropertyItems(image, 0, 0, NULL);
    expect(InvalidParameter, status);
    status = GdipGetAllPropertyItems(image, prop_size + 1, prop_count, prop_item);
    expect(InvalidParameter, status);
    status = GdipGetAllPropertyItems(image, prop_size, prop_count, prop_item);
    expect(Ok, status);
 
    item_data = (const char *)(prop_item + prop_count);
    for (i = 0; i < prop_count; i++)
    {
        ok(prop_item[i].value == item_data, "%u: expected value %p, got %p\n",
           i, item_data, prop_item[i].value);
        ok(td[i].type == prop_item[i].type,
            "%u: expected type %u, got %u\n", i, td[i].type, prop_item[i].type);
        ok(td[i].id == prop_item[i].id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item[i].id);
        ok(td[i].length == prop_item[i].length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item[i].length);
        if (td[i].length == prop_item[i].length)
        {
            int match = memcmp(td[i].value, prop_item[i].value, td[i].length) == 0;
            ok(match, "%u: data mismatch\n", i);
            if (!match)
            {
                UINT j;
                BYTE *data = prop_item[i].value;
                trace("id %#x:", prop_item[i].id);
                for (j = 0; j < prop_item[i].length; j++)
                    trace(" %02x", data[j]);
                trace("\n");
            }
        }
        item_data += prop_item[i].length;
    }
 
    HeapFree(GetProcessHeap(), 0, prop_item);
 
    GdipDisposeImage(image);
}

Referenced by START_TEST().

test_GdipGetImageFlags()

static void test_GdipGetImageFlags ( void  )

static

Definition at line 1079 of file image.c.

{
    GpImage *img;
    GpStatus stat;
    UINT flags;
 
    img = (GpImage*)0xdeadbeef;
 
    stat = GdipGetImageFlags(NULL, NULL);
    expect(InvalidParameter, stat);
 
    stat = GdipGetImageFlags(NULL, &flags);
    expect(InvalidParameter, stat);
 
    stat = GdipGetImageFlags(img, NULL);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat1bppIndexed, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    stat = GdipGetImageFlags(img, &flags);
    expect(Ok, stat);
    expect(ImageFlagsHasAlpha, flags);
    GdipDisposeImage(img);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat4bppIndexed, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    stat = GdipGetImageFlags(img, &flags);
    expect(Ok, stat);
    expect(ImageFlagsHasAlpha, flags);
    GdipDisposeImage(img);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat8bppIndexed, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    stat = GdipGetImageFlags(img, &flags);
    expect(Ok, stat);
    expect(ImageFlagsHasAlpha, flags);
    GdipDisposeImage(img);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppGrayScale, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    stat = GdipGetImageFlags(img, &flags);
    expect(Ok, stat);
    expect(ImageFlagsNone, flags);
    GdipDisposeImage(img);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppRGB555, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    stat = GdipGetImageFlags(img, &flags);
    expect(Ok, stat);
    expect(ImageFlagsNone, flags);
    GdipDisposeImage(img);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppRGB565, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    stat = GdipGetImageFlags(img, &flags);
    expect(Ok, stat);
    expect(ImageFlagsNone, flags);
    GdipDisposeImage(img);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppARGB1555, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    stat = GdipGetImageFlags(img, &flags);
    expect(Ok, stat);
    expect(ImageFlagsHasAlpha, flags);
    GdipDisposeImage(img);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    stat = GdipGetImageFlags(img, &flags);
    expect(Ok, stat);
    expect(ImageFlagsNone, flags);
    GdipDisposeImage(img);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppRGB, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    stat = GdipGetImageFlags(img, &flags);
    expect(Ok, stat);
    expect(ImageFlagsNone, flags);
    GdipDisposeImage(img);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppARGB, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    stat = GdipGetImageFlags(img, &flags);
    expect(Ok, stat);
    expect(ImageFlagsHasAlpha, flags);
    GdipDisposeImage(img);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppPARGB, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    stat = GdipGetImageFlags(img, &flags);
    expect(Ok, stat);
    expect(ImageFlagsHasAlpha, flags);
    GdipDisposeImage(img);
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat48bppRGB, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    if (stat == Ok)
    {
        stat = GdipGetImageFlags(img, &flags);
        expect(Ok, stat);
        expect(ImageFlagsNone, flags);
        GdipDisposeImage(img);
    }
 
    stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat64bppARGB, NULL, (GpBitmap**)&img);
    expect(Ok, stat);
    if (stat == Ok)
    {