ReactOS 0.4.15-dev-8102-g108db8f
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 GpImageload_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 BYTEinit_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.

2054{
2055 static const BYTE halftone_values[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
2056 UINT i;
2057
2058 for (i=0; i<palette->Count; i++)
2059 {
2060 ARGB expected=0xff000000;
2061 if (i<8)
2062 {
2063 if (i&1) expected |= 0x800000;
2064 if (i&2) expected |= 0x8000;
2065 if (i&4) expected |= 0x80;
2066 }
2067 else if (i == 8)
2068 {
2069 expected = 0xffc0c0c0;
2070 }
2071 else if (i < 16)
2072 {
2073 if (i&1) expected |= 0xff0000;
2074 if (i&2) expected |= 0xff00;
2075 if (i&4) expected |= 0xff;
2076 }
2077 else if (i < 40)
2078 {
2079 expected = 0x00000000;
2080 }
2081 else
2082 {
2083 expected |= halftone_values[(i-40)%6];
2084 expected |= halftone_values[((i-40)/6)%6] << 8;
2085 expected |= halftone_values[((i-40)/36)%6] << 16;
2086 }
2087 ok(expected == palette->Entries[i], "Expected %.8x, got %.8x, i=%u/%u\n",
2088 expected, palette->Entries[i], i, palette->Count);
2089 }
2090}
#define ok(value,...)
Definition: atltest.h:57
DWORD ARGB
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
BOOL expected
Definition: store.c:2063
static HPALETTE palette
Definition: clipboard.c:1345
unsigned int UINT
Definition: ndis.h:50
unsigned char BYTE
Definition: xxhash.c:193

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.

60{
61 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
62 c1 >>= 8; c2 >>= 8;
63 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
64 c1 >>= 8; c2 >>= 8;
65 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
66 c1 >>= 8; c2 >>= 8;
67 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
68 return TRUE;
69}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define abs(i)
Definition: fconv.c:206

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.

3476{
3477 switch (type)
3478 {
3483 default: return type;
3484 }
3485}
#define PropertyTagTypeSShort
Definition: image.c:2585
#define PropertyTagTypeFloat
Definition: image.c:2586
#define PropertyTagTypeDouble
Definition: image.c:2587
#define PropertyTagTypeSByte
Definition: image.c:2584
#define PropertyTagTypeShort
#define PropertyTagTypeUndefined
#define PropertyTagTypeByte
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545

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.

72{
73 WCHAR bufferW[39];
74 char buffer[39];
75 char buffer2[39];
76
77 StringFromGUID2(got, bufferW, ARRAY_SIZE(bufferW));
78 WideCharToMultiByte(CP_ACP, 0, bufferW, ARRAY_SIZE(bufferW), buffer, sizeof(buffer), NULL, NULL);
79 StringFromGUID2(expected, bufferW, ARRAY_SIZE(bufferW));
80 WideCharToMultiByte(CP_ACP, 0, bufferW, ARRAY_SIZE(bufferW), buffer2, sizeof(buffer2), NULL, NULL);
82 ok_(__FILE__, line)(IsEqualGUID(expected, got), "Expected %s, got %s\n", buffer2, buffer);
83}
#define ok_(x1, x2)
Definition: atltest.h:61
#define ARRAY_SIZE(A)
Definition: main.h:33
#define NULL
Definition: types.h:112
#define CP_ACP
Definition: compat.h:109
#define WideCharToMultiByte
Definition: compat.h:111
INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
Definition: compobj.c:2434
GLuint buffer
Definition: glext.h:5915
BOOL todo
Definition: filedlg.c:313
#define todo_wine_if(is_todo)
Definition: custom.c:76
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
Definition: parser.c:49
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ expect_rawformat()

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

Definition at line 85 of file image.c.

86{
87 GUID raw;
89
91 ok_(__FILE__, line)(stat == Ok, "GdipGetImageRawFormat failed with %d\n", stat);
92 if(stat != Ok) return;
94}
#define stat
Definition: acwin.h:99
GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
Definition: image.c:2354
Status
Definition: gdiplustypes.h:25
@ Ok
Definition: gdiplustypes.h:26
GLint GLvoid * img
Definition: gl.h:1956
#define expect_guid(expected, guid)
Definition: typelib.c:49
Definition: stat.h:55

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.

4783{
4785 UINT n_codecs, info_size, i;
4787 BOOL ret = FALSE;
4788
4789 status = GdipGetImageEncodersSize(&n_codecs, &info_size);
4790 expect(Ok, status);
4791
4792 info = GdipAlloc(info_size);
4793
4794 status = GdipGetImageEncoders(n_codecs, info_size, info);
4795 expect(Ok, status);
4796
4797 for (i = 0; i < n_codecs; i++)
4798 {
4799 if (!lstrcmpW(info[i].MimeType, mime))
4800 {
4801 *format = info[i].FormatID;
4802 *clsid = info[i].Clsid;
4803 ret = TRUE;
4804 break;
4805 }
4806 }
4807
4808 GdipFree(info);
4809 return ret;
4810}
GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
Definition: image.c:5045
GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
Definition: image.c:5069
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4242
unsigned int BOOL
Definition: ntddk_ex.h:94
void WINGDIPAPI GdipFree(void *ptr)
Definition: gdiplus.c:150
void *WINGDIPAPI GdipAlloc(SIZE_T size)
Definition: gdiplus.c:142
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
const WCHAR * mime
Definition: mimefilter.c:512
#define expect(expected, got)
Definition: image.c:56
REFCLSID clsid
Definition: msctf.c:82
Definition: ps.c:97
int 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.

5360{
5361 BYTE *src;
5362 UINT i, j, scale;
5363
5364 *width = 256;
5365 *height = 256;
5366 *stride = (*width * 3 + 3) & ~3;
5367 trace("width %d, height %d, stride %d\n", *width, *height, *stride);
5368
5370
5371 scale = 256 / *width;
5372 if (!scale) scale = 1;
5373
5374 for (i = 0; i < *height; i++)
5375 {
5376 for (j = 0; j < *width; j++)
5377 {
5378 src[i * *stride + j*3 + 0] = scale * i;
5379 src[i * *stride + j*3 + 1] = scale * (255 - (i+j)/2);
5380 src[i * *stride + j*3 + 2] = scale * j;
5381 }
5382 }
5383
5384 return src;
5385}
#define trace
Definition: atltest.h:70
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
GLsizei stride
Definition: glext.h:5848
GLenum GLenum GLenum GLenum GLenum scale
Definition: glext.h:9032
GLenum src
Definition: glext.h:6340
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250

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.

3240{
3241 IStream *stream;
3242 HGLOBAL hmem;
3243 BYTE *data;
3244 HRESULT hr;
3246 GpImage *image = NULL, *clone;
3247 ImageType image_type;
3248 LONG refcount, old_refcount;
3249
3250 hmem = GlobalAlloc(0, image_size);
3251 data = GlobalLock(hmem);
3252 memcpy(data, image_data, image_size);
3253 GlobalUnlock(hmem);
3254
3256 ok(hr == S_OK, "CreateStreamOnHGlobal error %#x\n", hr);
3257 if (hr != S_OK) return NULL;
3258
3259 refcount = obj_refcount(stream);
3260 ok(refcount == 1, "expected stream refcount 1, got %d\n", refcount);
3261
3263 todo_wine_if(todo_load)
3264 if (valid_data)
3265 ok(status == Ok || broken(status == InvalidParameter), /* XP */
3266 "GdipLoadImageFromStream error %d\n", status);
3267 else
3268 ok(status != Ok, "GdipLoadImageFromStream should fail\n");
3269 if (status != Ok)
3270 {
3271 IStream_Release(stream);
3272 return NULL;
3273 }
3274
3275 status = GdipGetImageType(image, &image_type);
3276 ok(status == Ok, "GdipGetImageType error %d\n", status);
3277
3278 refcount = obj_refcount(stream);
3279 if (image_type == ImageTypeBitmap)
3280 ok(refcount > 1, "expected stream refcount > 1, got %d\n", refcount);
3281 else
3282 ok(refcount == 1, "expected stream refcount 1, got %d\n", refcount);
3283 old_refcount = refcount;
3284
3285 status = GdipCloneImage(image, &clone);
3286 ok(status == Ok, "GdipCloneImage error %d\n", status);
3287 refcount = obj_refcount(stream);
3288 ok(refcount == old_refcount, "expected stream refcount %d, got %d\n", old_refcount, refcount);
3289 status = GdipDisposeImage(clone);
3290 ok(status == Ok, "GdipDisposeImage error %d\n", status);
3291 refcount = obj_refcount(stream);
3292 ok(refcount == old_refcount, "expected stream refcount %d, got %d\n", old_refcount, refcount);
3293
3294 refcount = IStream_Release(stream);
3295 if (image_type == ImageTypeBitmap)
3296 ok(refcount >= 1, "expected stream refcount != 0\n");
3297 else
3298 ok(refcount == 0, "expected stream refcount 0, got %d\n", refcount);
3299
3300 return image;
3301}
#define broken(x)
Definition: _sntprintf.h:21
GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
Definition: image.c:2155
GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
Definition: image.c:2366
GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream *stream, GpImage **image)
Definition: image.c:4405
GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
Definition: image.c:1308
HRESULT WINAPI CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
ImageType
Definition: gdiplusenums.h:193
@ ImageTypeBitmap
Definition: gdiplusenums.h:195
@ InvalidParameter
Definition: gdiplustypes.h:28
GLeglImageOES image
Definition: gl.h:2204
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
HGLOBAL NTAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:368
#define S_OK
Definition: intsafe.h:52
static GLint image_size(GLint width, GLint height, GLenum format, GLenum type)
Definition: mipmap.c:4858
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static LONG obj_refcount(void *obj)
Definition: image.c:3233
long LONG
Definition: pedump.c:60
HRESULT hr
Definition: shlfolder.c:183
Definition: parse.h:23

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.

3234{
3235 IUnknown_AddRef((IUnknown *)obj);
3236 return IUnknown_Release((IUnknown *)obj);
3237}

Referenced by load_image().

◆ START_TEST()

START_TEST ( image  )

Definition at line 5700 of file image.c.

5701{
5702 HMODULE mod = GetModuleHandleA("gdiplus.dll");
5703 struct GdiplusStartupInput gdiplusStartupInput;
5704 ULONG_PTR gdiplusToken;
5705 HMODULE hmsvcrt;
5706 int (CDECL * _controlfp_s)(unsigned int *cur, unsigned int newval, unsigned int mask);
5707
5708 /* Enable all FP exceptions except _EM_INEXACT, which gdi32 can trigger */
5709 hmsvcrt = LoadLibraryA("msvcrt");
5710 _controlfp_s = (void*)GetProcAddress(hmsvcrt, "_controlfp_s");
5711 if (_controlfp_s) _controlfp_s(0, 0, 0x0008001e);
5712
5713 gdiplusStartupInput.GdiplusVersion = 1;
5714 gdiplusStartupInput.DebugEventCallback = NULL;
5715 gdiplusStartupInput.SuppressBackgroundThread = 0;
5716 gdiplusStartupInput.SuppressExternalCodecs = 0;
5717
5718 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
5719
5720 pGdipBitmapGetHistogramSize = (void*)GetProcAddress(mod, "GdipBitmapGetHistogramSize");
5721 pGdipBitmapGetHistogram = (void*)GetProcAddress(mod, "GdipBitmapGetHistogram");
5722 pGdipImageSetAbort = (void*)GetProcAddress(mod, "GdipImageSetAbort");
5723
5741 test_Scan0();
5747 test_encoders();
5748 test_LockBits();
5756 test_loadwmf();
5763 test_palette();
5765 test_gamma();
5769 test_colorkey();
5770 test_dispose();
5776
5777 GdiplusShutdown(gdiplusToken);
5778}
int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask)
Definition: _controlfp_s.c:19
#define CDECL
Definition: compat.h:29
#define GetProcAddress(x, y)
Definition: compat.h:753
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
FxCollectionEntry * cur
Status WINAPI GdiplusStartup(ULONG_PTR *token, const struct GdiplusStartupInput *input, struct GdiplusStartupOutput *output)
Definition: gdiplus.c:81
void WINAPI GdiplusShutdown(ULONG_PTR)
GLenum GLint GLuint mask
Definition: glext.h:6028
static int mod
Definition: i386-dis.c:1288
static void test_GdipCreateBitmapFromHBITMAP(void)
Definition: image.c:895
static void test_multiframegif(void)
Definition: image.c:2670
static void test_testcontrol(void)
Definition: image.c:1238
static void test_tiff_palette(void)
Definition: image.c:3878
static void test_getsetpixel(void)
Definition: image.c:1973
static void test_createhbitmap(void)
Definition: image.c:1679
static void test_GetImageDimension(void)
Definition: image.c:296
static void test_remaptable(void)
Definition: image.c:3040
static void test_GdipLoadImageFromStream(void)
Definition: image.c:5328
static void test_createfromwmf_noplaceable(void)
Definition: image.c:1569
static void test_encoders(void)
Definition: image.c:507
static void test_DrawImage_SourceCopy(void)
Definition: image.c:4194
static void test_colorkey(void)
Definition: image.c:3116
static void test_GdipCloneImage(void)
Definition: image.c:1206
static void test_imageabort(void)
Definition: image.c:5097
static void test_dispose(void)
Definition: image.c:3210
static void test_GdipInitializePalette(void)
Definition: image.c:5387
static void test_gif_properties(void)
Definition: image.c:4519
static void test_histogram(void)
Definition: image.c:4969
static void test_getthumbnail(void)
Definition: image.c:1901
static void test_FromGdiDib(void)
Definition: image.c:185
static void test_getrawformat(void)
Definition: image.c:1430
static void test_LockBits_UserBuf(void)
Definition: image.c:799
static void test_colormatrix(void)
Definition: image.c:2278
static void test_getadjustedpalette(void)
Definition: image.c:4904
static void test_LockBits(void)
Definition: image.c:561
static void test_GdipDrawImagePointRect(void)
Definition: image.c:4238
static void test_GdipGetImageFlags(void)
Definition: image.c:1079
static void test_SavingImages(void)
Definition: image.c:443
static void test_tiff_color_formats(void)
Definition: image.c:5547
static void test_DrawImage(void)
Definition: image.c:4142
static void test_GdipGetAllPropertyItems(void)
Definition: image.c:3710
static void test_rotateflip(void)
Definition: image.c:2920
static void test_LoadingImages(void)
Definition: image.c:396
static void test_ARGB_conversion(void)
Definition: image.c:4686
static void test_createfromwmf(void)
Definition: image.c:1511
static void test_GdipImageGetFrameDimensionsCount(void)
Definition: image.c:327
static void test_fromhicon(void)
Definition: image.c:1249
static void test_createeffect(void)
Definition: image.c:4863
static void test_CloneBitmapArea(void)
Definition: image.c:4757
static void test_DrawImage_scale(void)
Definition: image.c:4369
static void test_png_color_formats(void)
Definition: image.c:5170
static void test_resolution(void)
Definition: image.c:1585
static void test_image_properties(void)
Definition: image.c:3303
static void test_tiff_properties(void)
Definition: image.c:3581
static void test_gamma(void)
Definition: image.c:2543
static void test_Scan0(void)
Definition: image.c:127
static void test_bitmapbits(void)
Definition: image.c:3926
static void test_supported_encoders(void)
Definition: image.c:4812
static void test_loadwmf(void)
Definition: image.c:1440
static void test_palette(void)
Definition: image.c:2092
static void test_image_format(void)
Definition: image.c:4290
uint32_t ULONG_PTR
Definition: typedefs.h:65

◆ test_ARGB_conversion()

static void test_ARGB_conversion ( void  )
static

Definition at line 4686 of file image.c.

4687{
4688 BYTE argb[8] = { 0x11,0x22,0x33,0x80, 0xff,0xff,0xff,0 };
4689 BYTE pargb[8] = { 0x09,0x11,0x1a,0x80, 0,0,0,0 };
4690 BYTE rgb32_xp[8] = { 0x11,0x22,0x33,0xff, 0xff,0xff,0xff,0xff };
4691 BYTE rgb24[6] = { 0x11,0x22,0x33, 0xff,0xff,0xff };
4692 BYTE *bits;
4696 int match;
4697
4699 expect(Ok, status);
4700
4702 expect(Ok, status);
4703 ok(data.Width == 2, "expected 2, got %d\n", data.Width);
4704 ok(data.Height == 1, "expected 1, got %d\n", data.Height);
4705 ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
4706 ok(data.PixelFormat == PixelFormat32bppPARGB, "expected PixelFormat32bppPARGB, got %d\n", data.PixelFormat);
4707 match = !memcmp(data.Scan0, pargb, sizeof(pargb));
4708 ok(match, "bits don't match\n");
4709 if (!match)
4710 {
4711 bits = data.Scan0;
4712 trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat32bppPARGB,
4713 bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
4714 }
4716 expect(Ok, status);
4717
4719 expect(Ok, status);
4720 ok(data.Width == 2, "expected 2, got %d\n", data.Width);
4721 ok(data.Height == 1, "expected 1, got %d\n", data.Height);
4722 ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
4723 ok(data.PixelFormat == PixelFormat32bppRGB, "expected PixelFormat32bppRGB, got %d\n", data.PixelFormat);
4724 match = !memcmp(data.Scan0, argb, sizeof(argb)) ||
4725 !memcmp(data.Scan0, rgb32_xp, sizeof(rgb32_xp));
4726 ok(match, "bits don't match\n");
4727 if (!match)
4728 {
4729 bits = data.Scan0;
4730 trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat32bppRGB,
4731 bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
4732 }
4734 expect(Ok, status);
4735
4737 expect(Ok, status);
4738 ok(data.Width == 2, "expected 2, got %d\n", data.Width);
4739 ok(data.Height == 1, "expected 1, got %d\n", data.Height);
4740 ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
4741 ok(data.PixelFormat == PixelFormat24bppRGB, "expected PixelFormat24bppRGB, got %d\n", data.PixelFormat);
4742 match = !memcmp(data.Scan0, rgb24, sizeof(rgb24));
4743 ok(match, "bits don't match\n");
4744 if (!match)
4745 {
4746 bits = data.Scan0;
4747 trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat24bppRGB,
4748 bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
4749 }
4751 expect(Ok, status);
4752
4754}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride, PixelFormat format, BYTE *scan0, GpBitmap **bitmap)
Definition: image.c:1760
GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap *bitmap, GDIPCONST GpRect *rect, UINT flags, PixelFormat format, BitmapData *lockeddata)
Definition: image.c:1030
GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap *bitmap, BitmapData *lockeddata)
Definition: image.c:1176
@ ImageLockModeRead
#define PixelFormat32bppPARGB
#define PixelFormat32bppRGB
#define PixelFormat24bppRGB
#define PixelFormat32bppARGB
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
#define bits
Definition: infblock.c:15
Definition: uimain.c:89
Definition: match.c:28

Referenced by START_TEST().

◆ test_bitmapbits()

static void test_bitmapbits ( void  )
static

Definition at line 3926 of file image.c.

3927{
3928 /* 8 x 2 bitmap */
3929 static const BYTE pixels_24[48] =
3930 {
3931 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3932 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3933 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3934 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0
3935 };
3936 static const BYTE pixels_00[48] =
3937 {
3938 0,0,0, 0,0,0, 0,0,0, 0,0,0,
3939 0,0,0, 0,0,0, 0,0,0, 0,0,0,
3940 0,0,0, 0,0,0, 0,0,0, 0,0,0,
3941 0,0,0, 0,0,0, 0,0,0, 0,0,0
3942 };
3943 static const BYTE pixels_24_77[64] =
3944 {
3945 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3946 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3947 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3948 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3949 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3950 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3951 };
3952 static const BYTE pixels_77[64] =
3953 {
3954 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3955 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3956 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3957 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3958 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3959 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3960 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3961 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3962 };
3963 static const BYTE pixels_8[16] =
3964 {
3965 0x01,0,0x01,0,0x01,0,0x01,0,
3966 0x01,0,0x01,0,0x01,0,0x01,0
3967 };
3968 static const BYTE pixels_8_77[64] =
3969 {
3970 0x01,0,0x01,0,0x01,0,0x01,0,
3971 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3972 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3973 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3974 0x01,0,0x01,0,0x01,0,0x01,0,
3975 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3976 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3977 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3978 };
3979 static const BYTE pixels_1_77[64] =
3980 {
3981 0xaa,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3982 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3983 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3984 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3985 0xaa,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3986 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3987 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3988 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3989 };
3990 static const BYTE pixels_1[8] = {0xaa,0,0,0,0xaa,0,0,0};
3991 static const struct test_data
3992 {
3994 UINT bpp;
3996 UINT stride, size;
3997 const BYTE *pixels;
3998 const BYTE *pixels_unlocked;
3999 } td[] =
4000 {
4001 /* 0 */
4002 { PixelFormat24bppRGB, 24, 0xfff0, 24, 48, pixels_24, pixels_00 },
4003
4004 { PixelFormat24bppRGB, 24, 0, 24, 48, pixels_24, pixels_00 },
4005 { PixelFormat24bppRGB, 24, ImageLockModeRead, 24, 48, pixels_24, pixels_00 },
4006 { PixelFormat24bppRGB, 24, ImageLockModeWrite, 24, 48, pixels_24, pixels_00 },
4007 { PixelFormat24bppRGB, 24, ImageLockModeRead|ImageLockModeWrite, 24, 48, pixels_24, pixels_00 },
4008 { PixelFormat24bppRGB, 24, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_24_77, pixels_24 },
4009 { PixelFormat24bppRGB, 24, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
4010 { PixelFormat24bppRGB, 24, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
4011 /* 8 */
4012 { PixelFormat8bppIndexed, 8, 0, 8, 16, pixels_8, pixels_24 },
4013 { PixelFormat8bppIndexed, 8, ImageLockModeRead, 8, 16, pixels_8, pixels_24 },
4014 { PixelFormat8bppIndexed, 8, ImageLockModeWrite, 8, 16, pixels_8, pixels_00 },
4015 { PixelFormat8bppIndexed, 8, ImageLockModeRead|ImageLockModeWrite, 8, 16, pixels_8, pixels_00 },
4016 { PixelFormat8bppIndexed, 8, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_8_77, pixels_24 },
4017 { PixelFormat8bppIndexed, 8, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
4018 { PixelFormat8bppIndexed, 8, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
4019 /* 15 */
4020 { PixelFormat1bppIndexed, 1, 0, 4, 8, pixels_1, pixels_24 },
4021 { PixelFormat1bppIndexed, 1, ImageLockModeRead, 4, 8, pixels_1, pixels_24 },
4022 { PixelFormat1bppIndexed, 1, ImageLockModeWrite, 4, 8, pixels_1, pixels_00 },
4023 { PixelFormat1bppIndexed, 1, ImageLockModeRead|ImageLockModeWrite, 4, 8, pixels_1, pixels_00 },
4024 { PixelFormat1bppIndexed, 1, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_1_77, pixels_24 },
4025 { PixelFormat1bppIndexed, 1, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
4026 { PixelFormat1bppIndexed, 1, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
4027 };
4028 BYTE buf[64];
4031 UINT i;
4033 struct
4034 {
4035 ColorPalette pal;
4036 ARGB entries[1];
4037 } palette;
4038 ARGB *entries = palette.pal.Entries;
4039
4040 for (i = 0; i < ARRAY_SIZE(td); i++)
4041 {
4042 BYTE pixels[sizeof(pixels_24)];
4043 memcpy(pixels, pixels_24, sizeof(pixels_24));
4045 expect(Ok, status);
4046
4047 /* associate known palette with pixel data */
4048 palette.pal.Flags = PaletteFlagsGrayScale;
4049 palette.pal.Count = 2;
4050 entries[0] = 0xff000000;
4051 entries[1] = 0xffffffff;
4053 expect(Ok, status);
4054
4055 memset(&data, 0xfe, sizeof(data));
4057 {
4058 memset(buf, 0x77, sizeof(buf));
4059 data.Scan0 = buf;
4060 data.Stride = 32;
4061 }
4063 ok(status == Ok || broken(status == InvalidParameter) /* XP */, "%u: GdipBitmapLockBits error %d\n", i, status);
4064 if (status != Ok)
4065 {
4067 continue;
4068 }
4069 ok(data.Width == 8, "%u: expected 8, got %d\n", i, data.Width);
4070 ok(data.Height == 2, "%u: expected 2, got %d\n", i, data.Height);
4071 ok(td[i].stride == data.Stride, "%u: expected %d, got %d\n", i, td[i].stride, data.Stride);
4072 ok(td[i].format == data.PixelFormat, "%u: expected %d, got %d\n", i, td[i].format, data.PixelFormat);
4073 ok(td[i].size == data.Height * data.Stride, "%u: expected %d, got %d\n", i, td[i].size, data.Height * data.Stride);
4075 ok(data.Scan0 == buf, "%u: got wrong buffer\n", i);
4076 if (td[i].size == data.Height * data.Stride)
4077 {
4078 UINT j, match, width_bytes = (data.Width * td[i].bpp) / 8;
4079
4080 match = 1;
4081 for (j = 0; j < data.Height; j++)
4082 {
4083 if (memcmp((const BYTE *)data.Scan0 + j * data.Stride, td[i].pixels + j * data.Stride, width_bytes) != 0)
4084 {
4085 match = 0;
4086 break;
4087 }
4088 }
4090 {
4091 ok(match,
4092 "%u: data should match\n", i);
4093 if (!match)
4094 {
4095 BYTE *bits = data.Scan0;
4096 trace("%u: data mismatch for format %#x:", i, td[i].format);
4097 for (j = 0; j < td[i].size; j++)
4098 trace(" %02x", bits[j]);
4099 trace("\n");
4100 }
4101 }
4102 else
4103 ok(!match, "%u: data shouldn't match\n", i);
4104
4105 memset(data.Scan0, 0, td[i].size);
4106 }
4107
4109 ok(status == Ok, "%u: GdipBitmapUnlockBits error %d\n", i, status);
4110
4111 memset(&data, 0xfe, sizeof(data));
4113 ok(status == Ok, "%u: GdipBitmapLockBits error %d\n", i, status);
4114 ok(data.Width == 8, "%u: expected 8, got %d\n", i, data.Width);
4115 ok(data.Height == 2, "%u: expected 2, got %d\n", i, data.Height);
4116 ok(data.Stride == 24, "%u: expected 24, got %d\n", i, data.Stride);
4117 ok(data.PixelFormat == PixelFormat24bppRGB, "%u: got wrong pixel format %d\n", i, data.PixelFormat);
4118 ok(data.Height * data.Stride == 48, "%u: expected 48, got %d\n", i, data.Height * data.Stride);
4119 if (data.Height * data.Stride == 48)
4120 {
4121 int match = memcmp(data.Scan0, td[i].pixels_unlocked, 48) == 0;
4122 ok(match, "%u: data should match\n", i);
4123 if (!match)
4124 {
4125 UINT j;
4126 BYTE *bits = data.Scan0;
4127 trace("%u: data mismatch for format %#x:", i, td[i].format);
4128 for (j = 0; j < 48; j++)
4129 trace(" %02x", bits[j]);
4130 trace("\n");
4131 }
4132 }
4133
4135 ok(status == Ok, "%u: GdipBitmapUnlockBits error %d\n", i, status);
4136
4138 expect(Ok, status);
4139 }
4140}
DWORD bpp
Definition: surface.c:185
GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image, GDIPCONST ColorPalette *palette)
Definition: image.c:4744
ImageLockMode
@ ImageLockModeUserInputBuf
@ ImageLockModeWrite
@ PaletteFlagsGrayScale
#define PixelFormat8bppIndexed
INT PixelFormat
#define PixelFormat1bppIndexed
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
GLenum mode
Definition: glext.h:6217
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
static UINT width_bytes(UINT width, UINT bpp)
Definition: tiffformat.c:888
#define memset(x, y, z)
Definition: compat.h:39

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.

97{
99 HGLOBAL hglob;
100 LPBYTE data;
103 GpImage *img;
104
105 hglob = GlobalAlloc (0, size);
106 data = GlobalLock (hglob);
107 memcpy(data, buff, size);
108 GlobalUnlock(hglob); data = NULL;
109
111 ok_(__FILE__, line)(hres == S_OK, "Failed to create a stream\n");
112 if(hres != S_OK) return;
113
115 ok_(__FILE__, line)(stat == Ok, "Failed to create a Bitmap\n");
116 if(stat != Ok){
117 IStream_Release(stream);
118 return;
119 }
120
122
124 IStream_Release(stream);
125}
static unsigned char buff[32768]
Definition: fatten.c:17
static void expect_rawformat(REFGUID expected, GpImage *img, int line, BOOL todo)
Definition: image.c:85
HRESULT hres
Definition: protocol.c:465
interface IStream * LPSTREAM
Definition: objfwd.h:10
unsigned char * LPBYTE
Definition: typedefs.h:53

Referenced by test_getrawformat().

◆ test_CloneBitmapArea()

static void test_CloneBitmapArea ( void  )
static

Definition at line 4757 of file image.c.

4758{
4760 GpBitmap *bitmap, *copy;
4762
4764 expect(Ok, status);
4765
4767 expect(Ok, status);
4768
4771
4773 expect(Ok, status);
4774
4776 expect(Ok, status);
4777
4780}
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height, PixelFormat format, GpBitmap *srcBitmap, GpBitmap **dstBitmap)
Definition: image.c:1300
@ WrongState
Definition: gdiplustypes.h:34
Definition: tftpd.h:138

Referenced by START_TEST().

◆ test_colorkey()

static void test_colorkey ( void  )
static

Definition at line 3116 of file image.c.

3117{
3118 GpStatus stat;
3119 GpImageAttributes *imageattr;
3120 GpBitmap *bitmap1, *bitmap2;
3121 GpGraphics *graphics;
3122 ARGB color;
3123
3126
3127 stat = GdipCreateImageAttributes(&imageattr);
3128 expect(Ok, stat);
3129
3130 stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeCount, TRUE, 0xff405060, 0xff708090);
3132
3133 stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeAny, TRUE, 0xff405060, 0xff708090);
3135
3136 stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeDefault, TRUE, 0xff405060, 0xff708090);
3137 expect(Ok, stat);
3138
3140 expect(Ok, stat);
3141
3143 expect(Ok, stat);
3144
3145 stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0x20405060);
3146 expect(Ok, stat);
3147
3148 stat = GdipBitmapSetPixel(bitmap1, 0, 1, 0x40506070);
3149 expect(Ok, stat);
3150
3151 stat = GdipBitmapSetPixel(bitmap1, 1, 0, 0x60708090);
3152 expect(Ok, stat);
3153
3154 stat = GdipBitmapSetPixel(bitmap1, 1, 1, 0xffffffff);
3155 expect(Ok, stat);
3156
3158 expect(Ok, stat);
3159
3160 stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,2,2, 0,0,2,2,
3161 UnitPixel, imageattr, NULL, NULL);
3162 expect(Ok, stat);
3163
3165 expect(Ok, stat);
3166 ok(color_match(0x00000000, color, 1), "Expected 00000000, got %.8x\n", color);
3167
3169 expect(Ok, stat);
3170 ok(color_match(0x00000000, color, 1), "Expected 00000000, got %.8x\n", color);
3171
3173 expect(Ok, stat);
3174 ok(color_match(0x00000000, color, 1), "Expected 00000000, got %.8x\n", color);
3175
3177 expect(Ok, stat);
3178 ok(color_match(0xffffffff, color, 1), "Expected ffffffff, got %.8x\n", color);
3179
3181 expect(Ok, stat);
3182
3183 stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,2,2, 0,0,2,2,
3184 UnitPixel, imageattr, NULL, NULL);
3185 expect(Ok, stat);
3186
3188 expect(Ok, stat);
3189 ok(color_match(0x20405060, color, 1), "Expected 20405060, got %.8x\n", color);
3190
3192 expect(Ok, stat);
3193 ok(color_match(0x40506070, color, 1), "Expected 40506070, got %.8x\n", color);
3194
3196 expect(Ok, stat);
3197 ok(color_match(0x60708090, color, 1), "Expected 60708090, got %.8x\n", color);
3198
3200 expect(Ok, stat);
3201 ok(color_match(0xffffffff, color, 1), "Expected ffffffff, got %.8x\n", color);
3202
3203
3204 GdipDeleteGraphics(graphics);
3205 GdipDisposeImage((GpImage*)bitmap1);
3207 GdipDisposeImageAttributes(imageattr);
3208}
GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics *graphics)
Definition: graphics.c:2581
GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics *graphics, GpImage *image, INT dstx, INT dsty, INT dstwidth, INT dstheight, INT srcx, INT srcy, INT srcwidth, INT srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes *imageAttributes, DrawImageAbort callback, VOID *callbackData)
Definition: graphics.c:3517
GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image, GpGraphics **graphics)
Definition: image.c:2249
GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap *bitmap, INT x, INT y, ARGB *color)
Definition: image.c:288
GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap *bitmap, INT x, INT y, ARGB color)
Definition: image.c:494
@ ColorAdjustTypeCount
@ ColorAdjustTypeAny
@ ColorAdjustTypeDefault
@ UnitPixel
Definition: gdiplusenums.h:29
GLuint color
Definition: glext.h:6243
GpStatus WINGDIPAPI GdipCreateImageAttributes(GpImageAttributes **imageattr)
GpStatus WINGDIPAPI GdipSetImageAttributesColorKeys(GpImageAttributes *imageattr, ColorAdjustType type, BOOL enableFlag, ARGB colorLow, ARGB colorHigh)
GpStatus WINGDIPAPI GdipDisposeImageAttributes(GpImageAttributes *imageattr)
GpStatus WINGDIPAPI GdipResetImageAttributes(GpImageAttributes *imageAttr, ColorAdjustType type)
static BOOL color_match(ARGB c1, ARGB c2, BYTE max_diff)
Definition: image.c:59
static HBITMAP bitmap2
Definition: clipboard.c:1344

Referenced by START_TEST().

◆ test_colormatrix()

static void test_colormatrix ( void  )
static

Definition at line 2278 of file image.c.

2279{
2280 GpStatus stat;
2281 ColorMatrix colormatrix, graymatrix;
2282 GpImageAttributes *imageattr;
2283 const ColorMatrix identity = {{
2284 {1.0,0.0,0.0,0.0,0.0},
2285 {0.0,1.0,0.0,0.0,0.0},
2286 {0.0,0.0,1.0,0.0,0.0},
2287 {0.0,0.0,0.0,1.0,0.0},
2288 {0.0,0.0,0.0,0.0,1.0}}};
2289 const ColorMatrix double_red = {{
2290 {2.0,0.0,0.0,0.0,0.0},
2291 {0.0,1.0,0.0,0.0,0.0},
2292 {0.0,0.0,1.0,0.0,0.0},
2293 {0.0,0.0,0.0,1.0,0.0},
2294 {0.0,0.0,0.0,0.0,1.0}}};
2295 const ColorMatrix asymmetric = {{
2296 {0.0,1.0,0.0,0.0,0.0},
2297 {0.0,0.0,1.0,0.0,0.0},
2298 {0.0,0.0,0.0,1.0,0.0},
2299 {1.0,0.0,0.0,0.0,0.0},
2300 {0.0,0.0,0.0,0.0,1.0}}};
2301 GpBitmap *bitmap1, *bitmap2;
2302 GpGraphics *graphics;
2303 ARGB color;
2304
2305 colormatrix = identity;
2306 graymatrix = identity;
2307
2309 TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2311
2312 stat = GdipCreateImageAttributes(&imageattr);
2313 expect(Ok, stat);
2314
2316 TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2317 expect(Ok, stat);
2318
2322
2324 TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2325 expect(Ok, stat);
2326
2328 TRUE, &colormatrix, NULL, ColorMatrixFlagsSkipGrays);
2329 expect(Ok, stat);
2330
2332 TRUE, &colormatrix, NULL, ColorMatrixFlagsAltGray);
2334
2336 TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsAltGray);
2337 expect(Ok, stat);
2338
2340 TRUE, &colormatrix, &graymatrix, 3);
2342
2344 TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2346
2348 TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2350
2353 expect(Ok, stat);
2354
2355 /* Drawing a bitmap transforms the colors */
2356 colormatrix = double_red;
2358 TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2359 expect(Ok, stat);
2360
2362 expect(Ok, stat);
2363
2365 expect(Ok, stat);
2366
2367 stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0xff40ccee);
2368 expect(Ok, stat);
2369
2371 expect(Ok, stat);
2372
2373 stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2374 UnitPixel, imageattr, NULL, NULL);
2375 expect(Ok, stat);
2376
2378 expect(Ok, stat);
2379 expect(0xff80ccee, color);
2380
2381 colormatrix = asymmetric;
2383 TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2384 expect(Ok, stat);
2385
2386 stat = GdipBitmapSetPixel(bitmap2, 0, 0, 0);
2387 expect(Ok, stat);
2388
2389 stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2390 UnitPixel, imageattr, NULL, NULL);
2391 expect(Ok, stat);
2392
2394 expect(Ok, stat);
2395 ok(color_match(0xeeff40cc, color, 3), "expected 0xeeff40cc, got 0x%08x\n", color);
2396
2397 /* Toggle NoOp */
2399 expect(Ok, stat);
2400
2401 stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
2402 UnitPixel, imageattr, NULL, NULL);
2403 expect(Ok, stat);
2404
2406 expect(Ok, stat);
2407 ok(color_match(0xfefe40cc, color, 3), "expected 0xfefe40cc, got 0x%08x\n", color);
2408
2410 expect(Ok, stat);
2411
2412 stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
2413 UnitPixel, imageattr, NULL, NULL);
2414 expect(Ok, stat);
2415
2417 expect(Ok, stat);
2418 ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
2419
2421 expect(Ok, stat);
2422
2424 expect(Ok, stat);
2425
2426 stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
2427 UnitPixel, imageattr, NULL, NULL);
2428 expect(Ok, stat);
2429
2431 expect(Ok, stat);
2432 ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
2433
2434 stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
2435 UnitPixel, imageattr, NULL, NULL);
2436 expect(Ok, stat);
2437
2439 expect(Ok, stat);
2440 ok(color_match(0xff40ccee, color, 1), "Expected ff40ccee, got %.8x\n", color);
2441
2442 /* Disable adjustment, toggle NoOp */
2444 FALSE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2445 expect(Ok, stat);
2446
2448 expect(Ok, stat);
2449
2450 stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
2451 UnitPixel, imageattr, NULL, NULL);
2452 expect(Ok, stat);
2453
2455 expect(Ok, stat);
2456 ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
2457
2459 expect(Ok, stat);
2460
2461 stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
2462 UnitPixel, imageattr, NULL, NULL);
2463 expect(Ok, stat);
2464
2466 expect(Ok, stat);
2467 ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
2468
2469 /* Reset with NoOp on, enable adjustment. */
2471 expect(Ok, stat);
2472
2474 TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2475 expect(Ok, stat);
2476
2477 stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
2478 UnitPixel, imageattr, NULL, NULL);
2479 expect(Ok, stat);
2480
2482 expect(Ok, stat);
2483 ok(color_match(0xfff24ace, color, 3), "expected 0xfff24ace, got 0x%08x\n", color);
2484
2485 /* Now inhibit specific category. */
2487 expect(Ok, stat);
2488
2490 TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2491 expect(Ok, stat);
2492
2493 stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
2494 UnitPixel, imageattr, NULL, NULL);
2495 expect(Ok, stat);
2496
2498 expect(Ok, stat);
2499 ok(color_match(0xfffe41cc, color, 3), "expected 0xfffe41cc, got 0x%08x\n", color);
2500
2502 expect(Ok, stat);
2503
2504 stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
2505 UnitPixel, imageattr, NULL, NULL);
2506 expect(Ok, stat);
2507
2509 expect(Ok, stat);
2510 ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
2511
2513 expect(Ok, stat);
2514
2516 expect(Ok, stat);
2517
2518 stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
2519 UnitPixel, imageattr, NULL, NULL);
2520 expect(Ok, stat);
2521
2523 expect(Ok, stat);
2524 ok(color_match(0xfff24ace, color, 3), "expected 0xfff24ace, got 0x%08x\n", color);
2525
2527 expect(Ok, stat);
2528
2529 stat = GdipDrawImageRectRectI(graphics, (GpImage *)bitmap1, 0, 0, 1, 1, 0, 0, 1, 1,
2530 UnitPixel, imageattr, NULL, NULL);
2531 expect(Ok, stat);
2532
2534 expect(Ok, stat);
2535 ok(color_match(0xff40ccee, color, 3), "expected 0xff40ccee, got 0x%08x\n", color);
2536
2537 GdipDeleteGraphics(graphics);
2538 GdipDisposeImage((GpImage*)bitmap1);
2540 GdipDisposeImageAttributes(imageattr);
2541}
@ ColorAdjustTypeBitmap
@ ColorMatrixFlagsSkipGrays
@ ColorMatrixFlagsAltGray
@ ColorMatrixFlagsDefault
GpStatus WINGDIPAPI GdipSetImageAttributesColorMatrix(GpImageAttributes *imageattr, ColorAdjustType type, BOOL enableFlag, GDIPCONST ColorMatrix *colorMatrix, GDIPCONST ColorMatrix *grayMatrix, ColorMatrixFlags flags)
GpStatus WINGDIPAPI GdipSetImageAttributesNoOp(GpImageAttributes *imageAttr, ColorAdjustType type, BOOL enableFlag)

Referenced by START_TEST().

◆ test_createeffect()

static void test_createeffect ( void  )
static

Definition at line 4863 of file image.c.

4864{
4865 static const GUID noneffect = { 0xcd0c3d4b, 0xe15e, 0x4cf2, { 0x9e, 0xa8, 0x6e, 0x1d, 0x65, 0x48, 0xc5, 0xa5 } };
4866 GpStatus (WINAPI *pGdipCreateEffect)( const GUID guid, CGpEffect **effect);
4867 GpStatus (WINAPI *pGdipDeleteEffect)( CGpEffect *effect);
4868 GpStatus stat;
4869 CGpEffect *effect;
4870 HMODULE mod = GetModuleHandleA("gdiplus.dll");
4871 int i;
4872 const GUID * const effectlist[] =
4873 {&BlurEffectGuid, &SharpenEffectGuid, &ColorMatrixEffectGuid, &ColorLUTEffectGuid,
4874 &BrightnessContrastEffectGuid, &HueSaturationLightnessEffectGuid, &LevelsEffectGuid,
4875 &TintEffectGuid, &ColorBalanceEffectGuid, &RedEyeCorrectionEffectGuid, &ColorCurveEffectGuid};
4876
4877 pGdipCreateEffect = (void*)GetProcAddress( mod, "GdipCreateEffect");
4878 pGdipDeleteEffect = (void*)GetProcAddress( mod, "GdipDeleteEffect");
4879 if(!pGdipCreateEffect || !pGdipDeleteEffect)
4880 {
4881 /* GdipCreateEffect/GdipDeleteEffect was introduced in Windows Vista. */
4882 win_skip("GDIPlus version 1.1 not available\n");
4883 return;
4884 }
4885
4886 stat = pGdipCreateEffect(BlurEffectGuid, NULL);
4888
4889 stat = pGdipCreateEffect(noneffect, &effect);
4891
4892 for(i=0; i < ARRAY_SIZE(effectlist); i++)
4893 {
4894 stat = pGdipCreateEffect(*effectlist[i], &effect);
4896 if(stat == Ok)
4897 {
4898 stat = pGdipDeleteEffect(effect);
4899 expect(Ok, stat);
4900 }
4901 }
4902}
struct CGpEffect CGpEffect
Status GpStatus
@ Win32Error
Definition: gdiplustypes.h:33
const GUID * guid
#define todo_wine
Definition: custom.c:79
#define win_skip
Definition: test.h:163
#define WINAPI
Definition: msvc.h:6

Referenced by START_TEST().

◆ test_createfromwmf()

static void test_createfromwmf ( void  )
static

Definition at line 1511 of file image.c.

1512{
1513 HMETAFILE hwmf;
1514 GpImage *img;
1515 GpStatus stat;
1516 GpRectF bounds;
1517 GpUnit unit;
1518 REAL res = 12345.0;
1520
1521 hwmf = SetMetaFileBitsEx(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader),
1523 ok(hwmf != 0, "SetMetaFileBitsEx failed\n");
1524
1527 expect(Ok, stat);
1528
1529 stat = GdipGetImageBounds(img, &bounds, &unit);
1530 expect(Ok, stat);
1532 expectf(0.0, bounds.X);
1533 expectf(0.0, bounds.Y);
1534 expectf(320.0, bounds.Width);
1535 expectf(320.0, bounds.Height);
1536
1538 expect(Ok, stat);
1539 expectf(1440.0, res);
1540
1542 expect(Ok, stat);
1543 expectf(1440.0, res);
1544
1545 memset(&header, 0, sizeof(header));
1547 expect(Ok, stat);
1548 if (stat == Ok)
1549 {
1551 todo_wine expect(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader), header.Size);
1552 todo_wine expect(0x300, header.Version);
1553 expect(0, header.EmfPlusFlags);
1554 expectf(1440.0, header.DpiX);
1555 expectf(1440.0, header.DpiY);
1556 expect(0, header.X);
1557 expect(0, header.Y);
1558 expect(320, header.Width);
1559 expect(320, header.Height);
1560 expect(1, U(header).WmfHeader.mtType);
1561 expect(0, header.EmfPlusHeaderSize);
1562 expect(0, header.LogicalDpiX);
1563 expect(0, header.LogicalDpiY);
1564 }
1565
1567}
#define U(x)
Definition: wordpad.c:45
float REAL
Definition: types.h:41
GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
Definition: image.c:2378
GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect, GpUnit *srcUnit)
Definition: image.c:2196
GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
Definition: image.c:2309
GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hwmf, BOOL delete, GDIPCONST WmfPlaceableFileHeader *placeable, GpMetafile **metafile)
Definition: metafile.c:3845
GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile *metafile, MetafileHeader *header)
Definition: metafile.c:3632
Unit
Definition: gdiplusenums.h:26
@ MetafileTypeWmfPlaceable
Definition: gdiplusenums.h:218
GLuint res
Definition: glext.h:9613
static const unsigned char wmfimage[180]
Definition: image.c:1416
#define expectf(expected, got)
Definition: image.c:57
png_const_structrp png_const_inforp int * unit
Definition: png.h:2159
REAL Height
Definition: gdiplustypes.h:664
REAL X
Definition: gdiplustypes.h:661
REAL Width
Definition: gdiplustypes.h:663
REAL Y
Definition: gdiplustypes.h:662
HMETAFILE WINAPI SetMetaFileBitsEx(_In_ UINT cbBuffer, _In_reads_bytes_(cbBuffer) CONST BYTE *lpData)

Referenced by START_TEST().

◆ test_createfromwmf_noplaceable()

static void test_createfromwmf_noplaceable ( void  )
static

Definition at line 1569 of file image.c.

1570{
1571 HMETAFILE hwmf;
1572 GpImage *img;
1573 GpStatus stat;
1574
1575 hwmf = SetMetaFileBitsEx(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader),
1577 ok(hwmf != 0, "SetMetaFileBitsEx failed\n");
1578
1580 expect(Ok, stat);
1581
1583}

Referenced by START_TEST().

◆ test_createhbitmap()

static void test_createhbitmap ( void  )
static

Definition at line 1679 of file image.c.

1680{
1681 GpStatus stat;
1683 HBITMAP hbitmap, oldhbitmap;
1684 BITMAP bm;
1685 int ret;
1686 HDC hdc;
1687 COLORREF pixel;
1688 BYTE bits[640];
1689 BitmapData lockeddata;
1690
1691 memset(bits, 0x68, 640);
1692
1693 /* create Bitmap */
1695 expect(Ok, stat);
1696
1697 /* test NULL values */
1700
1703
1704 /* create HBITMAP */
1706 expect(Ok, stat);
1707
1708 if (stat == Ok)
1709 {
1710 ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
1711 expect(sizeof(BITMAP), ret);
1712
1713 expect(0, bm.bmType);
1714 expect(10, bm.bmWidth);
1715 expect(20, bm.bmHeight);
1716 expect(40, bm.bmWidthBytes);
1717 expect(1, bm.bmPlanes);
1718 expect(32, bm.bmBitsPixel);
1719 ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
1720
1721 if (bm.bmBits)
1722 {
1723 DWORD val = *(DWORD*)bm.bmBits;
1724 ok(val == 0xff686868, "got %x, expected 0xff686868\n", val);
1725 }
1726
1728
1729 oldhbitmap = SelectObject(hdc, hbitmap);
1730 pixel = GetPixel(hdc, 5, 5);
1731 SelectObject(hdc, oldhbitmap);
1732
1733 DeleteDC(hdc);
1734
1735 expect(0x686868, pixel);
1736
1738 }
1739
1741 expect(Ok, stat);
1742
1743 /* make (1,0) have no alpha and (2,0) a different blue value. */
1744 bits[7] = 0x00;
1745 bits[8] = 0x40;
1746
1747 /* create alpha Bitmap */
1749 expect(Ok, stat);
1750
1751 /* create HBITMAP */
1753 expect(Ok, stat);
1754
1755 if (stat == Ok)
1756 {
1757 ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
1758 expect(sizeof(BITMAP), ret);
1759
1760 expect(0, bm.bmType);
1761 expect(8, bm.bmWidth);
1762 expect(20, bm.bmHeight);
1763 expect(32, bm.bmWidthBytes);
1764 expect(1, bm.bmPlanes);
1765 expect(32, bm.bmBitsPixel);
1766 ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
1767
1768 if (bm.bmBits)
1769 {
1770 DWORD val = *(DWORD*)bm.bmBits;
1771 ok(val == 0x682a2a2a, "got %x, expected 0x682a2a2a\n", val);
1772 val = *((DWORD*)bm.bmBits + (bm.bmHeight-1) * bm.bmWidthBytes/4 + 1);
1773 ok(val == 0x0, "got %x, expected 0x682a2a2a\n", val);
1774 }
1775
1777
1778 oldhbitmap = SelectObject(hdc, hbitmap);
1779 pixel = GetPixel(hdc, 5, 5);
1780 expect(0x2a2a2a, pixel);
1781 pixel = GetPixel(hdc, 1, 0);
1782 expect(0x0, pixel);
1783
1784 SelectObject(hdc, oldhbitmap);
1785
1786 DeleteDC(hdc);
1787
1788
1790 }
1791
1792 /* create HBITMAP with bkgnd colour */
1793 /* gdiplus.dll 5.1 is broken and only applies the blue value */
1795 expect(Ok, stat);
1796
1797 if (stat == Ok)
1798 {
1799 ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
1800 expect(sizeof(BITMAP), ret);
1801
1802 expect(0, bm.bmType);
1803 expect(8, bm.bmWidth);
1804 expect(20, bm.bmHeight);
1805 expect(32, bm.bmWidthBytes);
1806 expect(1, bm.bmPlanes);
1807 expect(32, bm.bmBitsPixel);
1808 ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
1809
1810 if (bm.bmBits)
1811 {
1812 DWORD val = *(DWORD*)bm.bmBits;
1813 ok(val == 0x68c12ac1 || broken(val == 0x682a2ac1), "got %x, expected 0x68c12ac1\n", val);
1814 val = *((DWORD*)bm.bmBits + (bm.bmHeight-1) * bm.bmWidthBytes/4 + 1);
1815 ok(val == 0xff00ff || broken(val == 0xff), "got %x, expected 0xff00ff\n", val);
1816 }
1817
1819
1820 oldhbitmap = SelectObject(hdc, hbitmap);
1821 pixel = GetPixel(hdc, 5, 5);
1822 ok(pixel == 0xc12ac1 || broken(pixel == 0xc12a2a), "got %x, expected 0xc12ac1\n", pixel);
1823 pixel = GetPixel(hdc, 1, 0);
1824 ok(pixel == 0xff00ff || broken(pixel == 0xff0000), "got %x, expected 0xff00ff\n", pixel);
1825 pixel = GetPixel(hdc, 2, 0);
1826 ok(pixel == 0xb12ac1 || broken(pixel == 0xb12a2a), "got %x, expected 0xb12ac1\n", pixel);
1827
1828 SelectObject(hdc, oldhbitmap);
1829 DeleteDC(hdc);
1831 }
1832
1833 /* create HBITMAP with bkgnd colour with alpha and show it behaves with no alpha. */
1835 expect(Ok, stat);
1836
1837 if (stat == Ok)
1838 {
1839 ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
1840 expect(sizeof(BITMAP), ret);
1841
1842 expect(0, bm.bmType);
1843 expect(8, bm.bmWidth);
1844 expect(20, bm.bmHeight);
1845 expect(32, bm.bmWidthBytes);
1846 expect(1, bm.bmPlanes);
1847 expect(32, bm.bmBitsPixel);
1848 ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
1849
1850 if (bm.bmBits)
1851 {
1852 DWORD val = *(DWORD*)bm.bmBits;
1853 ok(val == 0x68c12ac1 || broken(val == 0x682a2ac1), "got %x, expected 0x68c12ac1\n", val);
1854 val = *((DWORD*)bm.bmBits + (bm.bmHeight-1) * bm.bmWidthBytes/4 + 1);
1855 ok(val == 0xff00ff || broken(val == 0xff), "got %x, expected 0xff00ff\n", val);
1856 }
1857
1859
1860 oldhbitmap = SelectObject(hdc, hbitmap);
1861 pixel = GetPixel(hdc, 5, 5);
1862 ok(pixel == 0xc12ac1 || broken(pixel == 0xc12a2a), "got %x, expected 0xc12ac1\n", pixel);
1863 pixel = GetPixel(hdc, 1, 0);
1864 ok(pixel == 0xff00ff || broken(pixel == 0xff0000), "got %x, expected 0xff00ff\n", pixel);
1865 pixel = GetPixel(hdc, 2, 0);
1866 ok(pixel == 0xb12ac1 || broken(pixel == 0xb12a2a), "got %x, expected 0xb12ac1\n", pixel);
1867
1868 SelectObject(hdc, oldhbitmap);
1869 DeleteDC(hdc);
1871 }
1872
1874 expect(Ok, stat);
1875
1876 /* create HBITMAP from locked data */
1877 memset(bits, 0x68, 640);
1879 expect(Ok, stat);
1880
1881 memset(&lockeddata, 0, sizeof(lockeddata));
1883 PixelFormat32bppRGB, &lockeddata);
1884 expect(Ok, stat);
1885 ((DWORD*)lockeddata.Scan0)[0] = 0xff242424;
1887 expect(Ok, stat);
1888 stat = GdipBitmapUnlockBits(bitmap, &lockeddata);
1889 expect(Ok, stat);
1891 expect(Ok, stat);
1892
1894 oldhbitmap = SelectObject(hdc, hbitmap);
1895 pixel = GetPixel(hdc, 0, 0);
1896 expect(0x686868, pixel);
1897 SelectObject(hdc, oldhbitmap);
1898 DeleteDC(hdc);
1899}
static HBITMAP hbitmap
DWORD GetPixel(LPDIRECTDRAWSURFACE7 Surface, UINT x, UINT y)
Definition: blt.cpp:2
GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap *bitmap, HBITMAP *hbmReturn, ARGB background)
Definition: image.c:1479
unsigned long DWORD
Definition: ntddk_ex.h:95
pKey DeleteObject()
GLuint GLfloat * val
Definition: glext.h:7180
HDC hdc
Definition: main.c:9
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:92
Definition: bl.h:1331
DWORD COLORREF
Definition: windef.h:300
int WINAPI GetObjectA(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1539
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
BOOL WINAPI DeleteDC(_In_ HDC)

Referenced by START_TEST().

◆ test_dispose()

static void test_dispose ( void  )
static

Definition at line 3210 of file image.c.

3211{
3212 GpStatus stat;
3213 GpImage *image;
3214 char invalid_image[256];
3215
3218
3220 expect(Ok, stat);
3221
3223 expect(Ok, stat);
3224
3227
3228 memset(invalid_image, 0, 256);
3229 stat = GdipDisposeImage((GpImage*)invalid_image);
3231}
@ ObjectBusy
Definition: gdiplustypes.h:30

Referenced by START_TEST().

◆ test_DrawImage()

static void test_DrawImage ( void  )
static

Definition at line 4142 of file image.c.

4143{
4144 BYTE black_1x1[4] = { 0,0,0,0 };
4145 BYTE white_2x2[16] = { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
4146 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff };
4147 BYTE black_2x2[16] = { 0,0,0,0,0,0,0xff,0xff,
4148 0,0,0,0,0,0,0xff,0xff };
4150 union
4151 {
4153 GpImage *image;
4154 } u1, u2;
4155 GpGraphics *graphics;
4156 int match;
4157
4158 status = GdipCreateBitmapFromScan0(1, 1, 4, PixelFormat24bppRGB, black_1x1, &u1.bitmap);
4159 expect(Ok, status);
4160 status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
4161 expect(Ok, status);
4162
4163 status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat24bppRGB, white_2x2, &u2.bitmap);
4164 expect(Ok, status);
4165 status = GdipBitmapSetResolution(u2.bitmap, 300.0, 300.0);
4166 expect(Ok, status);
4167 status = GdipGetImageGraphicsContext(u2.image, &graphics);
4168 expect(Ok, status);
4170 expect(Ok, status);
4171
4172 status = GdipDrawImageI(graphics, u1.image, 0, 0);
4173 expect(Ok, status);
4174
4175 match = memcmp(white_2x2, black_2x2, sizeof(black_2x2)) == 0;
4176 ok(match, "data should match\n");
4177 if (!match)
4178 {
4179 UINT i, size = sizeof(white_2x2);
4180 BYTE *bits = white_2x2;
4181 for (i = 0; i < size; i++)
4182 trace(" %02x", bits[i]);
4183 trace("\n");
4184 }
4185
4186 status = GdipDeleteGraphics(graphics);
4187 expect(Ok, status);
4188 status = GdipDisposeImage(u1.image);
4189 expect(Ok, status);
4190 status = GdipDisposeImage(u2.image);
4191 expect(Ok, status);
4192}
GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics *graphics, GpImage *image, INT x, INT y)
Definition: graphics.c:2985
GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics *graphics, InterpolationMode mode)
Definition: graphics.c:6143
GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap *bitmap, REAL xdpi, REAL ydpi)
Definition: image.c:1163
@ InterpolationModeNearestNeighbor
Definition: gdiplusenums.h:148
GLdouble GLdouble u2
Definition: glext.h:8308
GLdouble u1
Definition: glext.h:8308

Referenced by START_TEST().

◆ test_DrawImage_scale()

static void test_DrawImage_scale ( void  )
static

Definition at line 4369 of file image.c.

4370{
4371 static const BYTE back_8x1[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
4372 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4373 static const BYTE image_080[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,
4374 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4375 static const BYTE image_100[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40,
4376 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4377 static const BYTE image_120[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x40,
4378 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4379 static const BYTE image_150[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
4380 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4381 static const BYTE image_180[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
4382 0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4383 static const BYTE image_200[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
4384 0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4385 static const BYTE image_250[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,
4386 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40 };
4387 static const BYTE image_120_half[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
4388 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4389 static const BYTE image_150_half[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
4390 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4391 static const BYTE image_200_half[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
4392 0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40 };
4393 static const BYTE image_250_half[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
4394 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40 };
4395 static const struct test_data
4396 {
4397 REAL scale_x;
4398 PixelOffsetMode pixel_offset_mode;
4399 const BYTE *image;
4400 BOOL todo;
4401 } td[] =
4402 {
4403 { 0.8, PixelOffsetModeNone, image_080 }, /* 0 */
4404 { 1.0, PixelOffsetModeNone, image_100 },
4405 { 1.2, PixelOffsetModeNone, image_120 },
4406 { 1.5, PixelOffsetModeNone, image_150 },
4407 { 1.8, PixelOffsetModeNone, image_180 },
4408 { 2.0, PixelOffsetModeNone, image_200 },
4409 { 2.5, PixelOffsetModeNone, image_250 },
4410
4411 { 0.8, PixelOffsetModeHighSpeed, image_080 }, /* 7 */
4412 { 1.0, PixelOffsetModeHighSpeed, image_100 },
4413 { 1.2, PixelOffsetModeHighSpeed, image_120 },
4414 { 1.5, PixelOffsetModeHighSpeed, image_150 },
4415 { 1.8, PixelOffsetModeHighSpeed, image_180 },
4416 { 2.0, PixelOffsetModeHighSpeed, image_200 },
4417 { 2.5, PixelOffsetModeHighSpeed, image_250 },
4418
4419 { 0.8, PixelOffsetModeHalf, image_080 }, /* 14 */
4420 { 1.0, PixelOffsetModeHalf, image_100 },
4421 { 1.2, PixelOffsetModeHalf, image_120_half, TRUE },
4422 { 1.5, PixelOffsetModeHalf, image_150_half, TRUE },
4423 { 1.8, PixelOffsetModeHalf, image_180 },
4424 { 2.0, PixelOffsetModeHalf, image_200_half, TRUE },
4425 { 2.5, PixelOffsetModeHalf, image_250_half, TRUE },
4426
4427 { 0.8, PixelOffsetModeHighQuality, image_080 }, /* 21 */
4428 { 1.0, PixelOffsetModeHighQuality, image_100 },
4429 { 1.2, PixelOffsetModeHighQuality, image_120_half, TRUE },
4430 { 1.5, PixelOffsetModeHighQuality, image_150_half, TRUE },
4431 { 1.8, PixelOffsetModeHighQuality, image_180 },
4432 { 2.0, PixelOffsetModeHighQuality, image_200_half, TRUE },
4433 { 2.5, PixelOffsetModeHighQuality, image_250_half, TRUE },
4434 };
4435 BYTE src_2x1[6] = { 0x80,0x80,0x80,0x80,0x80,0x80 };
4436 BYTE dst_8x1[24];
4438 union
4439 {
4441 GpImage *image;
4442 } u1, u2;
4443 GpGraphics *graphics;
4445 int i, match;
4446
4447 status = GdipCreateBitmapFromScan0(2, 1, 4, PixelFormat24bppRGB, src_2x1, &u1.bitmap);
4448 expect(Ok, status);
4449 status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
4450 expect(Ok, status);
4451
4452 status = GdipCreateBitmapFromScan0(8, 1, 24, PixelFormat24bppRGB, dst_8x1, &u2.bitmap);
4453 expect(Ok, status);
4454 status = GdipBitmapSetResolution(u2.bitmap, 100.0, 100.0);
4455 expect(Ok, status);
4456 status = GdipGetImageGraphicsContext(u2.image, &graphics);
4457 expect(Ok, status);
4459 expect(Ok, status);
4460
4461 for (i = 0; i < ARRAY_SIZE(td); i++)
4462 {
4463 status = GdipSetPixelOffsetMode(graphics, td[i].pixel_offset_mode);
4464 expect(Ok, status);
4465
4466 status = GdipCreateMatrix2(td[i].scale_x, 0.0, 0.0, 1.0, 0.0, 0.0, &matrix);
4467 expect(Ok, status);
4468 status = GdipSetWorldTransform(graphics, matrix);
4469 expect(Ok, status);
4471
4472 memcpy(dst_8x1, back_8x1, sizeof(dst_8x1));
4473 status = GdipDrawImageI(graphics, u1.image, 1, 0);
4474 expect(Ok, status);
4475
4476 match = memcmp(dst_8x1, td[i].image, sizeof(dst_8x1)) == 0;
4477 todo_wine_if (!match && td[i].todo)
4478 ok(match, "%d: data should match\n", i);
4479 if (!match)
4480 {
4481 UINT i, size = sizeof(dst_8x1);
4482 const BYTE *bits = dst_8x1;
4483 for (i = 0; i < size; i++)
4484 trace(" %02x", bits[i]);
4485 trace("\n");
4486 }
4487 }
4488
4489 status = GdipDeleteGraphics(graphics);
4490 expect(Ok, status);
4491 status = GdipDisposeImage(u1.image);
4492 expect(Ok, status);
4493 status = GdipDisposeImage(u2.image);
4494 expect(Ok, status);
4495}
GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
Definition: graphics.c:6358
GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode mode)
Definition: graphics.c:6229
GpStatus WINGDIPAPI GdipCreateMatrix2(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy, GpMatrix **matrix)
Definition: matrix.c:61
GpStatus WINGDIPAPI GdipDeleteMatrix(GpMatrix *matrix)
Definition: matrix.c:160
PixelOffsetMode
Definition: gdiplusenums.h:160
@ PixelOffsetModeHighSpeed
Definition: gdiplusenums.h:163
@ PixelOffsetModeHalf
Definition: gdiplusenums.h:166
@ PixelOffsetModeHighQuality
Definition: gdiplusenums.h:164
@ PixelOffsetModeNone
Definition: gdiplusenums.h:165
GLuint GLenum matrix
Definition: glext.h:9407

Referenced by START_TEST().

◆ test_DrawImage_SourceCopy()

static void test_DrawImage_SourceCopy ( void  )
static

Definition at line 4194 of file image.c.

4195{
4196 DWORD dst_pixels[4] = { 0xffffffff, 0xffffffff,
4197 0xffffffff, 0xffffffff };
4198 DWORD src_pixels[4] = { 0, 0xffff0000,
4199 0, 0xff00ff };
4200
4202 union
4203 {
4205 GpImage *image;
4206 } u1, u2;
4207 GpGraphics *graphics;
4208
4209 status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppARGB, (BYTE*)dst_pixels, &u1.bitmap);
4210 expect(Ok, status);
4211
4212 status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppARGB, (BYTE*)src_pixels, &u2.bitmap);
4213 expect(Ok, status);
4214 status = GdipGetImageGraphicsContext(u1.image, &graphics);
4215 expect(Ok, status);
4217 expect(Ok, status);
4218
4220 expect(Ok, status);
4221
4222 status = GdipDrawImageI(graphics, u2.image, 0, 0);
4223 expect(Ok, status);
4224
4225 todo_wine expect(0, dst_pixels[0]);
4226 expect(0xffff0000, dst_pixels[1]);
4227 todo_wine expect(0, dst_pixels[2]);
4228 todo_wine expect(0, dst_pixels[3]);
4229
4230 status = GdipDeleteGraphics(graphics);
4231 expect(Ok, status);
4232 status = GdipDisposeImage(u1.image);
4233 expect(Ok, status);
4234 status = GdipDisposeImage(u2.image);
4235 expect(Ok, status);
4236}
GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics *graphics, CompositingMode mode)
Definition: graphics.c:6085
@ CompositingModeSourceCopy
Definition: gdiplusenums.h:250

Referenced by START_TEST().

◆ test_encoders()

static void test_encoders ( void  )
static

Definition at line 507 of file image.c.

508{
510 UINT n;
511 UINT s;
513 int i;
514 int bmp_found;
515
516 static const CHAR bmp_format[] = "BMP";
517
519 expect(stat, Ok);
520
521 codecs = GdipAlloc(s);
522 if (!codecs)
523 return;
524
527
530
533
536
538 expect(stat, Ok);
539
540 bmp_found = FALSE;
541 for (i = 0; i < n; i++)
542 {
543 CHAR desc[32];
544
545 WideCharToMultiByte(CP_ACP, 0, codecs[i].FormatDescription, -1,
546 desc, 32, 0, 0);
547
549 desc, -1,
550 bmp_format, -1) == CSTR_EQUAL) {
551 bmp_found = TRUE;
552 break;
553 }
554 }
555 if (!bmp_found)
556 ok(FALSE, "No BMP codec found.\n");
557
559}
static const WCHAR bmp_format[]
Definition: image.c:4775
static const struct image_codec codecs[NUM_CODECS]
Definition: image.c:4283
INT WINAPI CompareStringA(LCID lcid, DWORD flags, LPCSTR str1, INT len1, LPCSTR str2, INT len2)
Definition: locale.c:4082
@ GenericError
Definition: gdiplustypes.h:27
GLdouble s
Definition: gl.h:2039
GLdouble n
Definition: glext.h:7729
static const WCHAR desc[]
Definition: protectdata.c:36
#define LOCALE_SYSTEM_DEFAULT
#define CSTR_EQUAL
Definition: winnls.h:456
char CHAR
Definition: xmlstorage.h:175

Referenced by START_TEST().

◆ test_FromGdiDib()

static void test_FromGdiDib ( void  )
static

Definition at line 185 of file image.c.

186{
187 GpBitmap *bm;
189 BYTE buff[400];
190 BYTE rbmi[sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD)];
191 BITMAPINFO *bmi = (BITMAPINFO*)rbmi;
193
194 bm = NULL;
195
196 memset(rbmi, 0, sizeof(rbmi));
197
198 bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
199 bmi->bmiHeader.biWidth = 10;
200 bmi->bmiHeader.biHeight = 10;
201 bmi->bmiHeader.biPlanes = 1;
202 bmi->bmiHeader.biBitCount = 32;
204
207
210
213
215 expect(Ok, stat);
216 ok(NULL != bm, "Expected bitmap to be initialized\n");
217 if (stat == Ok)
218 {
220 expect(Ok, stat);
222
224 }
225
226 bmi->bmiHeader.biBitCount = 24;
228 expect(Ok, stat);
229 ok(NULL != bm, "Expected bitmap to be initialized\n");
230 if (stat == Ok)
231 {
233 expect(Ok, stat);
235
237 }
238
239 bmi->bmiHeader.biBitCount = 16;
241 expect(Ok, stat);
242 ok(NULL != bm, "Expected bitmap to be initialized\n");
243 if (stat == Ok)
244 {
246 expect(Ok, stat);
248
250 }
251
252 bmi->bmiHeader.biBitCount = 8;
254 expect(Ok, stat);
255 ok(NULL != bm, "Expected bitmap to be initialized\n");
256 if (stat == Ok)
257 {
259 expect(Ok, stat);
261
263 }
264
265 bmi->bmiHeader.biBitCount = 4;
267 expect(Ok, stat);
268 ok(NULL != bm, "Expected bitmap to be initialized\n");
269 if (stat == Ok)
270 {
272 expect(Ok, stat);
274
276 }
277
278 bmi->bmiHeader.biBitCount = 1;
280 expect(Ok, stat);
281 ok(NULL != bm, "Expected bitmap to be initialized\n");
282 if (stat == Ok)
283 {
285 expect(Ok, stat);
287
289 }
290
291 bmi->bmiHeader.biBitCount = 0;
294}
GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO *info, VOID *bits, GpBitmap **bitmap)
Definition: image.c:1385
GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
Definition: image.c:2339
#define BI_RGB
Definition: precomp.h:56
ULONG RGBQUAD
Definition: precomp.h:59
#define PixelFormat4bppIndexed
#define PixelFormat16bppRGB555
USHORT biBitCount
Definition: precomp.h:46
ULONG biCompression
Definition: precomp.h:47
BITMAPINFOHEADER bmiHeader
Definition: wingdi.h:1476

Referenced by START_TEST().

◆ test_fromhicon()

static void test_fromhicon ( void  )
static

Definition at line 1249 of file image.c.

1250{
1251 static const BYTE bmp_bits[1024];
1252 HBITMAP hbmMask, hbmColor;
1253 ICONINFO info;
1254 HICON hIcon;
1255 GpStatus stat;
1256 GpBitmap *bitmap = NULL;
1257 UINT dim;
1260
1261 /* NULL */
1266
1267 /* color icon 1 bit */
1268 hbmMask = CreateBitmap(16, 16, 1, 1, bmp_bits);
1269 ok(hbmMask != 0, "CreateBitmap failed\n");
1270 hbmColor = CreateBitmap(16, 16, 1, 1, bmp_bits);
1271 ok(hbmColor != 0, "CreateBitmap failed\n");
1272 info.fIcon = TRUE;
1273 info.xHotspot = 8;
1274 info.yHotspot = 8;
1275 info.hbmMask = hbmMask;
1276 info.hbmColor = hbmColor;
1278 ok(hIcon != 0, "CreateIconIndirect failed\n");
1279 DeleteObject(hbmMask);
1280 DeleteObject(hbmColor);
1281
1283 ok(stat == Ok ||
1284 broken(stat == InvalidParameter), /* Win98 */
1285 "Expected Ok, got %.8x\n", stat);
1286 if(stat == Ok){
1287 /* check attributes */
1289 expect(Ok, stat);
1290 expect(16, dim);
1292 expect(Ok, stat);
1293 expect(16, dim);
1295 expect(Ok, stat);
1298 expect(Ok, stat);
1300 /* raw format */
1301 expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bitmap, __LINE__, FALSE);
1303 }
1305
1306 /* color icon 8 bpp */
1307 hbmMask = CreateBitmap(16, 16, 1, 8, bmp_bits);
1308 ok(hbmMask != 0, "CreateBitmap failed\n");
1309 hbmColor = CreateBitmap(16, 16, 1, 8, bmp_bits);
1310 ok(hbmColor != 0, "CreateBitmap failed\n");
1311 info.fIcon = TRUE;
1312 info.xHotspot = 8;
1313 info.yHotspot = 8;
1314 info.hbmMask = hbmMask;
1315 info.hbmColor = hbmColor;
1317 ok(hIcon != 0, "CreateIconIndirect failed\n");
1318 DeleteObject(hbmMask);
1319 DeleteObject(hbmColor);
1320
1322 expect(Ok, stat);
1323 if(stat == Ok){
1324 /* check attributes */
1326 expect(Ok, stat);
1327 expect(16, dim);
1329 expect(Ok, stat);
1330 expect(16, dim);
1332 expect(Ok, stat);
1335 expect(Ok, stat);
1337 /* raw format */
1338 expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bitmap, __LINE__, FALSE);
1340 }
1342}
GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
Definition: image.c:2390
GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
Definition: image.c:2287
GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap **bitmap)
Definition: image.c:1564
static HICON
Definition: imagelist.c:84
HICON hIcon
Definition: msconfig.c:44
HBITMAP WINAPI CreateBitmap(_In_ INT cx, _In_ INT cy, _In_ UINT cPlanes, _In_ UINT cBitsPerPel, _In_opt_ const VOID *pvBits)
HICON WINAPI CreateIconIndirect(_In_ PICONINFO)
Definition: cursoricon.c:2612
BOOL WINAPI DestroyIcon(_In_ HICON)
Definition: cursoricon.c:2084

Referenced by START_TEST().

◆ test_gamma()

static void test_gamma ( void  )
static

Definition at line 2543 of file image.c.

2544{
2545 GpStatus stat;
2546 GpImageAttributes *imageattr;
2547 GpBitmap *bitmap1, *bitmap2;
2548 GpGraphics *graphics;
2549 ARGB color;
2550
2553
2554 stat = GdipCreateImageAttributes(&imageattr);
2555 expect(Ok, stat);
2556
2558 expect(Ok, stat);
2559
2562
2565
2568
2570 expect(Ok, stat);
2571
2573 expect(Ok, stat);
2574
2575 /* Drawing a bitmap transforms the colors */
2577 expect(Ok, stat);
2578
2580 expect(Ok, stat);
2581
2583 expect(Ok, stat);
2584
2585 stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0xff80ffff);
2586 expect(Ok, stat);
2587
2589 expect(Ok, stat);
2590
2591 stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2592 UnitPixel, imageattr, NULL, NULL);
2593 expect(Ok, stat);
2594
2596 expect(Ok, stat);
2597 ok(color_match(0xff20ffff, color, 1), "Expected ff20ffff, got %.8x\n", color);
2598
2600 expect(Ok, stat);
2601
2602 stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2603 UnitPixel, imageattr, NULL, NULL);
2604 expect(Ok, stat);
2605
2607 expect(Ok, stat);
2608 ok(color_match(0xff80ffff, color, 1), "Expected ff80ffff, got %.8x\n", color);
2609
2610 GdipDeleteGraphics(graphics);
2611 GdipDisposeImage((GpImage*)bitmap1);
2613 GdipDisposeImageAttributes(imageattr);
2614}
GpStatus WINGDIPAPI GdipSetImageAttributesGamma(GpImageAttributes *imageAttr, ColorAdjustType type, BOOL enableFlag, REAL gamma)

Referenced by START_TEST().

◆ test_GdipCloneImage()

static void test_GdipCloneImage ( void  )
static

Definition at line 1206 of file image.c.

1207{
1208 GpStatus stat;
1209 GpRectF rectF;
1210 GpUnit unit;
1211 GpBitmap *bm;
1212 GpImage *image_src, *image_dest = NULL;
1213 const INT WIDTH = 10, HEIGHT = 20;
1214
1215 /* Create an image, clone it, delete the original, make sure the copy works */
1217 expect(Ok, stat);
1218 expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bm, __LINE__, FALSE);
1219
1220 image_src = ((GpImage*)bm);
1221 stat = GdipCloneImage(image_src, &image_dest);
1222 expect(Ok, stat);
1223 expect_rawformat(&ImageFormatMemoryBMP, image_dest, __LINE__, FALSE);
1224
1226 expect(Ok, stat);
1227 stat = GdipGetImageBounds(image_dest, &rectF, &unit);
1228 expect(Ok, stat);
1229
1230 /* Treat FP values carefully */
1231 expectf((REAL)WIDTH, rectF.Width);
1232 expectf((REAL)HEIGHT, rectF.Height);
1233
1234 stat = GdipDisposeImage(image_dest);
1235 expect(Ok, stat);
1236}
#define WIDTH
Definition: d3dtest.c:13
#define HEIGHT
Definition: d3dtest.c:14
int32_t INT
Definition: typedefs.h:58

Referenced by START_TEST().

◆ test_GdipCreateBitmapFromHBITMAP()

static void test_GdipCreateBitmapFromHBITMAP ( void  )
static

Definition at line 895 of file image.c.

896{
897 GpBitmap* gpbm = NULL;
898 HBITMAP hbm = NULL;
899 HPALETTE hpal = NULL;
901 BYTE buff[1000];
902 LOGPALETTE* LogPal = NULL;
904 const REAL WIDTH1 = 5;
905 const REAL HEIGHT1 = 15;
906 const REAL WIDTH2 = 10;
907 const REAL HEIGHT2 = 20;
908 HDC hdc;
909 union BITMAPINFOUNION bmi;
910 BYTE *bits;
912
915
916 hbm = CreateBitmap(WIDTH1, HEIGHT1, 1, 1, NULL);
919
921 expect(Ok, stat);
923 expectf(WIDTH1, width);
924 expectf(HEIGHT1, height);
925 if (stat == Ok)
928
929 memset(buff, 0, sizeof(buff));
930 hbm = CreateBitmap(WIDTH2, HEIGHT2, 1, 1, &buff);
932 expect(Ok, stat);
933 /* raw format */
934 expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)gpbm, __LINE__, FALSE);
935
937 expectf(WIDTH2, width);
938 expectf(HEIGHT2, height);
939 if (stat == Ok)
942
944 ok(hdc != NULL, "CreateCompatibleDC failed\n");
945 bmi.bi.bmiHeader.biSize = sizeof(bmi.bi.bmiHeader);
946 bmi.bi.bmiHeader.biHeight = HEIGHT1;
947 bmi.bi.bmiHeader.biWidth = WIDTH1;
948 bmi.bi.bmiHeader.biBitCount = 24;
949 bmi.bi.bmiHeader.biPlanes = 1;
950 bmi.bi.bmiHeader.biCompression = BI_RGB;
951 bmi.bi.bmiHeader.biClrUsed = 0;
952
953 hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
954 ok(hbm != NULL, "CreateDIBSection failed\n");
955
956 bits[0] = 0;
957
959 expect(Ok, stat);
961 expectf(WIDTH1, width);
962 expectf(HEIGHT1, height);
963 if (stat == Ok)
964 {
965 /* test whether writing to the bitmap affects the original */
966 stat = GdipBitmapSetPixel(gpbm, 0, 0, 0xffffffff);
967 expect(Ok, stat);
968
969 expect(0, bits[0]);
970
972 }
973
974 LogPal = GdipAlloc(sizeof(LOGPALETTE));
975 ok(LogPal != NULL, "unable to allocate LOGPALETTE\n");
976 LogPal->palVersion = 0x300;
977 LogPal->palNumEntries = 1;
978 hpal = CreatePalette(LogPal);
979 ok(hpal != NULL, "CreatePalette failed\n");
980 GdipFree(LogPal);
981
982 stat = GdipCreateBitmapFromHBITMAP(hbm, hpal, &gpbm);
983 expect(Ok, stat);
984
985 if (stat == Ok)
987
988 DeleteObject(hpal);
990
991 /* 16-bit 555 dib, rgb */
992 bmi.bi.bmiHeader.biBitCount = 16;
993 bmi.bi.bmiHeader.biCompression = BI_RGB;
994
995 hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
996 ok(hbm != NULL, "CreateDIBSection failed\n");
997
998 bits[0] = 0;
999
1001 expect(Ok, stat);
1002
1003 if (stat == Ok)
1004 {
1006 expect(Ok, stat);
1007 expectf(WIDTH1, width);
1008 expectf(HEIGHT1, height);
1009
1011 expect(Ok, stat);
1013
1014 GdipDisposeImage((GpImage*)gpbm);
1015 }
1017
1018 /* 16-bit 555 dib, with bitfields */
1019 bmi.bi.bmiHeader.biSize = sizeof(bmi);
1020 bmi.bi.bmiHeader.biCompression = BI_BITFIELDS;
1021 bmi.bf.masks[0] = 0x7c00;
1022 bmi.bf.masks[1] = 0x3e0;
1023 bmi.bf.masks[2] = 0x1f;
1024
1025 hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1026 ok(hbm != NULL, "CreateDIBSection failed\n");
1027
1028 bits[0] = 0;
1029
1031 expect(Ok, stat);
1032
1033 if (stat == Ok)
1034 {
1036 expect(Ok, stat);
1037 expectf(WIDTH1, width);
1038 expectf(HEIGHT1, height);
1039
1041 expect(Ok, stat);
1043
1044 GdipDisposeImage((GpImage*)gpbm);
1045 }
1047
1048 /* 16-bit 565 dib, with bitfields */
1049 bmi.bf.masks[0] = 0xf800;
1050 bmi.bf.masks[1] = 0x7e0;
1051 bmi.bf.masks[2] = 0x1f;
1052
1053 hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1054 ok(hbm != NULL, "CreateDIBSection failed\n");
1055
1056 bits[0] = 0;
1057
1059 expect(Ok, stat);
1060
1061 if (stat == Ok)
1062 {
1064 expect(Ok, stat);
1065 expectf(WIDTH1, width);
1066 expectf(HEIGHT1, height);
1067
1069 expect(Ok, stat);
1071
1072 GdipDisposeImage((GpImage*)gpbm);
1073 }
1075
1076 DeleteDC(hdc);
1077}
GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width, REAL *height)
Definition: image.c:2224
GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap **bitmap)
Definition: image.c:5152
#define PixelFormat16bppRGB565
#define BI_BITFIELDS
Definition: mmreg.h:507
_In_ HBITMAP hbm
Definition: ntgdi.h:2776
WORD palNumEntries
Definition: wingdi.h:1834
WORD palVersion
Definition: wingdi.h:1833
HBITMAP WINAPI CreateDIBSection(HDC hDC, CONST BITMAPINFO *BitmapInfo, UINT Usage, VOID **Bits, HANDLE hSection, DWORD dwOffset)
Definition: bitmap.c:245
#define DIB_RGB_COLORS
Definition: wingdi.h:367
HPALETTE WINAPI CreatePalette(_In_reads_(_Inexpressible_(2 *sizeof(WORD)+plpal->palNumEntries *sizeof(PALETTEENTRY))) const LOGPALETTE *)

Referenced by START_TEST().

◆ test_GdipDrawImagePointRect()

static void test_GdipDrawImagePointRect ( void  )
static

Definition at line 4238 of file image.c.

4239{
4240 BYTE black_1x1[4] = { 0,0,0,0 };
4241 BYTE white_2x2[16] = { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
4242 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff };
4243 BYTE black_2x2[16] = { 0,0,0,0,0,0,0xff,0xff,
4244 0,0,0,0,0,0,0xff,0xff };
4246 union
4247 {
4249 GpImage *image;
4250 } u1, u2;
4251 GpGraphics *graphics;
4252 int match;
4253
4254 status = GdipCreateBitmapFromScan0(1, 1, 4, PixelFormat24bppRGB, black_1x1, &u1.bitmap);
4255 expect(Ok, status);
4256 status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
4257 expect(Ok, status);
4258
4259 status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat24bppRGB, white_2x2, &u2.bitmap);
4260 expect(Ok, status);
4261 status = GdipBitmapSetResolution(u2.bitmap, 300.0, 300.0);
4262 expect(Ok, status);
4263 status = GdipGetImageGraphicsContext(u2.image, &graphics);
4264 expect(Ok, status);
4266 expect(Ok, status);
4267
4268 status = GdipDrawImagePointRectI(graphics, u1.image, 0, 0, 0, 0, 1, 1, UnitPixel);
4269 expect(Ok, status);
4270
4271 match = memcmp(white_2x2, black_2x2, sizeof(black_2x2)) == 0;
4272 ok(match, "data should match\n");
4273 if (!match)
4274 {
4275 UINT i, size = sizeof(white_2x2);
4276 BYTE *bits = white_2x2;
4277 for (i = 0; i < size; i++)
4278 trace(" %02x", bits[i]);
4279 trace("\n");
4280 }
4281
4282 status = GdipDeleteGraphics(graphics);
4283 expect(Ok, status);
4284 status = GdipDisposeImage(u1.image);
4285 expect(Ok, status);
4286 status = GdipDisposeImage(u2.image);
4287 expect(Ok, status);
4288}
GpStatus WINGDIPAPI GdipDrawImagePointRectI(GpGraphics *graphics, GpImage *image, INT x, INT y, INT srcx, INT srcy, INT srcwidth, INT srcheight, GpUnit srcUnit)
Definition: graphics.c:3020

Referenced by START_TEST().

◆ test_GdipGetAllPropertyItems()

static void test_GdipGetAllPropertyItems ( void  )
static

Definition at line 3710 of file image.c.

3711{
3712 static const struct test_data
3713 {
3714 ULONG type, id, length;
3715 BYTE value[32];
3716 } td[16] =
3717 {
3718 { PropertyTagTypeLong, 0xfe, 4, { 0 } },
3719 { PropertyTagTypeShort, 0x100, 2, { 1 } },
3720 { PropertyTagTypeShort, 0x101, 2, { 1 } },
3721 { PropertyTagTypeShort, 0x102, 6, { 8,0,8,0,8,0 } },
3722 { PropertyTagTypeShort, 0x103, 2, { 1 } },
3723 { PropertyTagTypeShort, 0x106, 2, { 2,0 } },
3724 { PropertyTagTypeASCII, 0x10d, 27, "/home/meh/Desktop/test.tif" },
3725 { PropertyTagTypeLong, 0x111, 4, { 8,0,0,0 } },
3726 { PropertyTagTypeShort, 0x112, 2, { 1 } },
3727 { PropertyTagTypeShort, 0x115, 2, { 3,0 } },
3728 { PropertyTagTypeShort, 0x116, 2, { 0x40,0 } },
3729 { PropertyTagTypeLong, 0x117, 4, { 3,0,0,0 } },
3730 { PropertyTagTypeRational, 0x11a, 8, { 0,0,0,72,0,0,0,1 } },
3731 { PropertyTagTypeRational, 0x11b, 8, { 0,0,0,72,0,0,0,1 } },
3732 { PropertyTagTypeShort, 0x11c, 2, { 1 } },
3733 { PropertyTagTypeShort, 0x128, 2, { 2 } }
3734 };
3736 GpImage *image;
3737 GUID guid;
3738 UINT dim_count, frame_count, prop_count, prop_size, i;
3739 UINT total_size, total_count;
3740 PROPID *prop_id;
3741 PropertyItem *prop_item;
3742 const char *item_data;
3743
3745 ok(image != 0, "Failed to load TIFF image data\n");
3746 if (!image) return;
3747
3748 dim_count = 0xdeadbeef;
3750 expect(Ok, status);
3751 expect(1, dim_count);
3752
3754 expect(Ok, status);
3755 expect_guid(&FrameDimensionPage, &guid, __LINE__, FALSE);
3756
3757 frame_count = 0xdeadbeef;
3758 status = GdipImageGetFrameCount(image, &guid, &frame_count);
3759 expect(Ok, status);
3760 expect(1, frame_count);
3761
3762 prop_count = 0xdeadbeef;
3763 status = GdipGetPropertyCount(image, &prop_count);
3764 expect(Ok, status);
3765 ok(prop_count == ARRAY_SIZE(td),
3766 "expected property count %u, got %u\n", (UINT) ARRAY_SIZE(td), prop_count);
3767
3768 prop_id = HeapAlloc(GetProcessHeap(), 0, prop_count * sizeof(*prop_id));
3769
3770 status = GdipGetPropertyIdList(image, prop_count, prop_id);
3771 expect(Ok, status);
3772
3773 prop_size = 0;
3774 for (i = 0; i < prop_count; i++)
3775 {
3776 UINT size;
3777 status = GdipGetPropertyItemSize(image, prop_id[i], &size);
3778 expect(Ok, status);
3779 if (status != Ok) break;
3780 ok(size > sizeof(*prop_item), "%u: too small item length %u\n", i, size);
3781
3782 prop_size += size;
3783
3785 status = GdipGetPropertyItem(image, prop_id[i], size, prop_item);
3786 expect(Ok, status);
3787 ok(prop_item->value == prop_item + 1, "expected item->value %p, got %p\n", prop_item + 1, prop_item->value);
3788 ok(td[i].type == prop_item->type,
3789 "%u: expected type %u, got %u\n", i, td[i].type, prop_item->type);
3790 ok(td[i].id == prop_item->id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item->id);
3791 size -= sizeof(*prop_item);
3792 ok(prop_item->length == size, "%u: expected length %u, got %u\n", i, size, prop_item->length);
3793 ok(td[i].length == prop_item->length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item->length);
3794 if (td[i].length == prop_item->length)
3795 {
3796 int match = memcmp(td[i].value, prop_item->value, td[i].length) == 0;
3797 ok(match, "%u: data mismatch\n", i);
3798 if (!match)
3799 {
3800 UINT j;
3801 BYTE *data = prop_item->value;
3802 trace("id %#x:", prop_item->id);
3803 for (j = 0; j < prop_item->length; j++)
3804 trace(" %02x", data[j]);
3805 trace("\n");
3806 }
3807 }
3808 HeapFree(GetProcessHeap(), 0, prop_item);
3809 }
3810
3811 HeapFree(GetProcessHeap(), 0, prop_id);
3812
3813 status = GdipGetPropertySize(NULL, &total_size, &total_count);
3815 status = GdipGetPropertySize(image, &total_size, NULL);
3817 status = GdipGetPropertySize(image, NULL, &total_count);
3821 total_size = 0xdeadbeef;
3822 total_count = 0xdeadbeef;
3823 status = GdipGetPropertySize(image, &total_size, &total_count);
3824 expect(Ok, status);
3825 ok(prop_count == total_count,
3826 "expected total property count %u, got %u\n", prop_count, total_count);
3827 ok(prop_size == total_size,
3828 "expected total property size %u, got %u\n", prop_size, total_size);
3829
3830 prop_item = HeapAlloc(GetProcessHeap(), 0, prop_size);
3831
3832 status = GdipGetAllPropertyItems(image, 0, prop_count, prop_item);
3834 status = GdipGetAllPropertyItems(image, prop_size, 1, prop_item);
3836 status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
3838 status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
3842 status = GdipGetAllPropertyItems(image, prop_size + 1, prop_count, prop_item);
3844 status = GdipGetAllPropertyItems(image, prop_size, prop_count, prop_item);
3845 expect(Ok, status);
3846
3847 item_data = (const char *)(prop_item + prop_count);
3848 for (i = 0; i < prop_count; i++)
3849 {
3850 ok(prop_item[i].value == item_data, "%u: expected value %p, got %p\n",
3851 i, item_data, prop_item[i].value);
3852 ok(td[i].type == prop_item[i].type,
3853 "%u: expected type %u, got %u\n", i, td[i].type, prop_item[i].type);
3854 ok(td[i].id == prop_item[i].id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item[i].id);
3855 ok(td[i].length == prop_item[i].length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item[i].length);
3856 if (td[i].length == prop_item[i].length)
3857 {
3858 int match = memcmp(td[i].value, prop_item[i].value, td[i].length) == 0;
3859 ok(match, "%u: data mismatch\n", i);
3860 if (!match)
3861 {
3862 UINT j;
3863 BYTE *data = prop_item[i].value;
3864 trace("id %#x:", prop_item[i].id);
3865 for (j = 0; j < prop_item[i].length; j++)
3866 trace(" %02x", data[j]);
3867 trace("\n");
3868 }
3869 }
3870 item_data += prop_item[i].length;
3871 }
3872
3873 HeapFree(GetProcessHeap(), 0, prop_item);
3874
3876}
#define HeapFree(x, y, z)
Definition: compat.h:735
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT *size, UINT *count)
Definition: image.c:2735
GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size, UINT count, PropertyItem *buf)
Definition: image.c:2805
GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image, GDIPCONST GUID *dimensionID, UINT *count)
Definition: image.c:2913
GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image, UINT *count)
Definition: image.c:2933
GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT *num)
Definition: image.c:2412
GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID *list)
Definition: image.c:2435
GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID propid, UINT size, PropertyItem *buffer)
Definition: image.c:2682
GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID propid, UINT *size)
Definition: image.c:2536
GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage *image, GUID *dimensionIDs, UINT count)
Definition: image.c:2948
#define PropertyTagTypeLong
#define PropertyTagTypeRational
#define PropertyTagTypeASCII
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
static GpImage * load_image(const BYTE *image_data, UINT image_size, BOOL valid_data, BOOL todo_load)
Definition: image.c:3239
static const unsigned char tiffimage[]
Definition: image.c:1396
static const CLSID IPropertyStorage UINT *static const PROPSPEC PROPVARIANT *static UINT const PROPSPEC PROPVARIANT PROPID
Definition: shellole.c:78
ULONG id
Definition: metadata.c:648
ULONG type
Definition: metadata.c:648
uint32_t ULONG
Definition: typedefs.h:59
Definition: pdh_main.c:94

Referenced by START_TEST().

◆ test_GdipGetImageFlags()

static void test_GdipGetImageFlags ( void  )
static

Definition at line 1079 of file image.c.

1080{
1081 GpImage *img;
1082 GpStatus stat;
1083 UINT flags;
1084
1085 img = (GpImage*)0xdeadbeef;
1086
1089
1092
1095
1097 expect(Ok, stat);
1099 expect(Ok, stat);
1102
1104 expect(Ok, stat);
1106 expect(Ok, stat);
1109
1111 expect(Ok, stat);
1113 expect(Ok, stat);
1116
1118 expect(Ok, stat);
1120 expect(Ok, stat);
1123
1125 expect(Ok, stat);
1127 expect(Ok, stat);
1130
1132 expect(Ok, stat);
1134 expect(Ok, stat);
1137
1139 expect(Ok, stat);
1141 expect(Ok, stat);
1144
1146 expect(Ok, stat);
1148 expect(Ok, stat);
1151
1153 expect(Ok, stat);
1155 expect(Ok, stat);
1158
1160 expect(Ok, stat);
1162 expect(Ok, stat);
1165
1167 expect(Ok, stat);
1169 expect(Ok, stat);
1172
1174 expect(Ok, stat);
1175 if (stat == Ok)
1176 {
1178 expect(Ok, stat);
1181 }
1182
1184 expect(Ok, stat);
1185 if (stat == Ok)
1186 {
1187 exp