ReactOS 0.4.15-dev-7712-gbbbcd8e
bitmap.c File Reference
#include <stdarg.h>
#include <stdio.h>
#include <assert.h>
#include <math.h>
#include "windef.h"
#include "objbase.h"
#include "wincodec.h"
#include "wine/test.h"
#include "initguid.h"
Include dependency graph for bitmap.c:

Go to the source code of this file.

Macros

#define COBJMACROS
 
#define CONST_VTABLE
 
#define INTERFACE   IMILBitmapSource
 
#define INTERFACE   IMILBitmap
 
#define INTERFACE   IMILBitmapScaler
 

Functions

 DEFINE_GUID (IID_IMILUnknown, 0x0ccd7824, 0xdc16, 0x4d09, 0xbc, 0xa8, 0x6b, 0x09, 0xc4, 0xef, 0x55, 0x35)
 
 DEFINE_GUID (IID_IMILBitmap, 0xb1784d3f, 0x8115, 0x4763, 0x13, 0xaa, 0x32, 0xed, 0xdb, 0x68, 0x29, 0x4a)
 
 DEFINE_GUID (IID_IMILBitmapSource, 0x7543696a, 0xbc8d, 0x46b0, 0x5f, 0x81, 0x8d, 0x95, 0x72, 0x89, 0x72, 0xbe)
 
 DEFINE_GUID (IID_IMILBitmapLock, 0xa67b2b53, 0x8fa1, 0x4155, 0x8f, 0x64, 0x0c, 0x24, 0x7a, 0x8f, 0x84, 0xcd)
 
 DEFINE_GUID (IID_IMILBitmapScaler, 0xa767b0f0, 0x1c8c, 0x4aef, 0x56, 0x8f, 0xad, 0xf9, 0x6d, 0xcf, 0xd5, 0xcb)
 
 DEFINE_GUID (IID_IMILFormatConverter, 0x7e2a746f, 0x25c5, 0x4851, 0xb3, 0xaf, 0x44, 0x3b, 0x79, 0x63, 0x9e, 0xc0)
 
 DEFINE_GUID (IID_IMILPalette, 0xca8e206f, 0xf22c, 0x4af7, 0x6f, 0xba, 0x7b, 0xed, 0x5e, 0xb1, 0xc9, 0x2f)
 
 DECLARE_INTERFACE_ (IMILBitmapSource, IUnknown)
 
 DECLARE_INTERFACE_ (IMILBitmap, IMILBitmapSource)
 
 DECLARE_INTERFACE_ (IMILBitmapScaler, IMILBitmapSource)
 
static HRESULT WINAPI bitmapsource_QueryInterface (IWICBitmapSource *iface, REFIID iid, void **ppv)
 
static ULONG WINAPI bitmapsource_AddRef (IWICBitmapSource *iface)
 
static ULONG WINAPI bitmapsource_Release (IWICBitmapSource *iface)
 
static HRESULT WINAPI bitmapsource_GetSize (IWICBitmapSource *iface, UINT *width, UINT *height)
 
static HRESULT WINAPI bitmapsource_GetPixelFormat (IWICBitmapSource *iface, WICPixelFormatGUID *format)
 
static HRESULT WINAPI bitmapsource_GetResolution (IWICBitmapSource *iface, double *dpiX, double *dpiY)
 
static HRESULT WINAPI bitmapsource_CopyPalette (IWICBitmapSource *iface, IWICPalette *palette)
 
static HRESULT WINAPI bitmapsource_CopyPixels (IWICBitmapSource *iface, const WICRect *rc, UINT stride, UINT buffer_size, BYTE *buffer)
 
static HBITMAP create_dib (int width, int height, int bpp, LOGPALETTE *pal, const void *data)
 
static void test_createbitmap (void)
 
static void test_createbitmapfromsource (void)
 
static void test_CreateBitmapFromMemory (void)
 
static void test_CreateBitmapFromHICON (void)
 
static void test_CreateBitmapFromHBITMAP (void)
 
static void test_clipper (void)
 
static HRESULT (WINAPI *pWICCreateBitmapFromSectionEx)(UINT
 
static IWICBitmap **static void test_WICCreateBitmapFromSectionEx (void)
 
static void test_bitmap_scaler (void)
 
static LONG obj_refcount (void *obj)
 
static void test_IMILBitmap (void)
 
 START_TEST (bitmap)
 

Variables

static IWICImagingFactoryfactory
 
static WICRect g_rect
 
static BOOL called_CopyPixels
 
static const IWICBitmapSourceVtbl sourcevtbl
 
static IWICBitmapSource bitmapsource = { &sourcevtbl }
 
static UINT
 
static REFWICPixelFormatGUID
 
static HANDLE
 
static WICSectionAccessLevel
 

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 25 of file bitmap.c.

◆ CONST_VTABLE

#define CONST_VTABLE

Definition at line 26 of file bitmap.c.

◆ INTERFACE [1/3]

#define INTERFACE   IMILBitmapSource

Definition at line 80 of file bitmap.c.

◆ INTERFACE [2/3]

#define INTERFACE   IMILBitmap

Definition at line 80 of file bitmap.c.

◆ INTERFACE [3/3]

#define INTERFACE   IMILBitmapScaler

Definition at line 80 of file bitmap.c.

Function Documentation

◆ bitmapsource_AddRef()

static ULONG WINAPI bitmapsource_AddRef ( IWICBitmapSource iface)
static

Definition at line 116 of file bitmap.c.

117{
118 return 2;
119}

◆ bitmapsource_CopyPalette()

static HRESULT WINAPI bitmapsource_CopyPalette ( IWICBitmapSource iface,
IWICPalette palette 
)
static

Definition at line 144 of file bitmap.c.

146{
147 return E_NOTIMPL;
148}
#define E_NOTIMPL
Definition: ddrawi.h:99

◆ bitmapsource_CopyPixels()

static HRESULT WINAPI bitmapsource_CopyPixels ( IWICBitmapSource iface,
const WICRect rc,
UINT  stride,
UINT  buffer_size,
BYTE buffer 
)
static

Definition at line 153 of file bitmap.c.

155{
156 if (rc) g_rect = *rc;
158 return S_OK;
159}
#define TRUE
Definition: types.h:120
#define S_OK
Definition: intsafe.h:52
static WICRect g_rect
Definition: bitmap.c:150
static BOOL called_CopyPixels
Definition: bitmap.c:151

◆ bitmapsource_GetPixelFormat()

static HRESULT WINAPI bitmapsource_GetPixelFormat ( IWICBitmapSource iface,
WICPixelFormatGUID format 
)
static

Definition at line 132 of file bitmap.c.

134{
135 return E_NOTIMPL;
136}

◆ bitmapsource_GetResolution()

static HRESULT WINAPI bitmapsource_GetResolution ( IWICBitmapSource iface,
double dpiX,
double dpiY 
)
static

Definition at line 138 of file bitmap.c.

140{
141 return E_NOTIMPL;
142}

◆ bitmapsource_GetSize()

static HRESULT WINAPI bitmapsource_GetSize ( IWICBitmapSource iface,
UINT width,
UINT height 
)
static

Definition at line 126 of file bitmap.c.

127{
128 *width = *height = 10;
129 return S_OK;
130}
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546

◆ bitmapsource_QueryInterface()

static HRESULT WINAPI bitmapsource_QueryInterface ( IWICBitmapSource iface,
REFIID  iid,
void **  ppv 
)
static

Definition at line 100 of file bitmap.c.

101{
102 if (IsEqualIID(&IID_IUnknown, iid) ||
103 IsEqualIID(&IID_IWICBitmapSource, iid))
104 {
105 *ppv = iface;
106 }
107 else
108 {
109 *ppv = NULL;
110 return E_NOINTERFACE;
111 }
112
113 return S_OK;
114}
const GUID IID_IUnknown
#define NULL
Definition: types.h:112
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define E_NOINTERFACE
Definition: winerror.h:2364

◆ bitmapsource_Release()

static ULONG WINAPI bitmapsource_Release ( IWICBitmapSource iface)
static

Definition at line 121 of file bitmap.c.

122{
123 return 1;
124}

◆ create_dib()

static HBITMAP create_dib ( int  width,
int  height,
int  bpp,
LOGPALETTE pal,
const void data 
)
static

Definition at line 174 of file bitmap.c.

175{
176 char bmibuf[sizeof(BITMAPINFO) + sizeof(RGBQUAD) * 255];
177 BITMAPINFO *bmi = (BITMAPINFO *)bmibuf;
178 void *bits;
179 HBITMAP hdib;
180 BITMAP bm;
181
182 memset(bmibuf, 0, sizeof(bmibuf));
183 bmi->bmiHeader.biSize = sizeof(bmi->bmiHeader);
184 bmi->bmiHeader.biWidth = width;
185 bmi->bmiHeader.biHeight = -height;
186 bmi->bmiHeader.biBitCount = bpp;
187 bmi->bmiHeader.biPlanes = 1;
189 if (pal)
190 {
191 WORD i;
192
193 assert(pal->palNumEntries <= 256);
194 for (i = 0; i < pal->palNumEntries; i++)
195 {
196 bmi->bmiColors[i].rgbRed = pal->palPalEntry[i].peRed;
197 bmi->bmiColors[i].rgbGreen = pal->palPalEntry[i].peGreen;
198 bmi->bmiColors[i].rgbBlue = pal->palPalEntry[i].peBlue;
199 bmi->bmiColors[i].rgbReserved = 0;
200 }
201
204 }
205 hdib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, &bits, NULL, 0);
206 ok(hdib != 0, "CreateDIBSection(%dx%d,%d bpp) failed\n", width, height, bpp);
207
208 GetObjectW(hdib, sizeof(bm), &bm);
209 ok(bm.bmWidth == width, "expected %d, got %d\n", width, bm.bmWidth);
210 ok(bm.bmHeight == height, "expected %d, got %d\n", height, bm.bmHeight);
211 ok(bm.bmPlanes == 1, "expected 1, got %d\n", bm.bmPlanes);
212 ok(bm.bmBitsPixel == bpp, "expected %d, got %d\n", bpp, bm.bmBitsPixel);
213
214 if (data) memcpy(bits, data, bm.bmWidthBytes * bm.bmHeight);
215
216 return hdib;
217}
#define ok(value,...)
Definition: atltest.h:57
DWORD bpp
Definition: surface.c:185
#define assert(x)
Definition: debug.h:53
#define BI_RGB
Definition: precomp.h:47
ULONG RGBQUAD
Definition: precomp.h:50
unsigned short WORD
Definition: ntddk_ex.h:93
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
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
#define bits
Definition: infblock.c:15
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static HBITMAP
Definition: button.c:44
#define memset(x, y, z)
Definition: compat.h:39
Definition: bl.h:1331
ULONG biClrImportant
Definition: precomp.h:43
USHORT biBitCount
Definition: precomp.h:37
ULONG biCompression
Definition: precomp.h:38
BITMAPINFOHEADER bmiHeader
Definition: wingdi.h:1476
RGBQUAD bmiColors[1]
Definition: wingdi.h:1477
WORD palNumEntries
Definition: wingdi.h:1834
UCHAR rgbReserved
Definition: bootanim.c:106
UCHAR rgbBlue
Definition: bootanim.c:103
UCHAR rgbRed
Definition: bootanim.c:105
UCHAR rgbGreen
Definition: bootanim.c:104
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
int WINAPI GetObjectW(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
struct tagBITMAPINFO BITMAPINFO

Referenced by test_CreateBitmapFromHBITMAP().

◆ DECLARE_INTERFACE_() [1/3]

DECLARE_INTERFACE_ ( IMILBitmap  ,
IMILBitmapSource   
)

Definition at line 59 of file bitmap.c.

60{
64 /*** IWICBitmapSource methods ***/
67 STDMETHOD_(HRESULT,GetResolution)(THIS_ double *,double *) PURE;
68 STDMETHOD_(HRESULT,CopyPalette)(THIS_ IWICPalette *) PURE;
69 STDMETHOD_(HRESULT,CopyPixels)(THIS_ const WICRect *,UINT,UINT,BYTE *) PURE;
70 /*** IMILBitmap methods ***/
71 STDMETHOD_(HRESULT,unknown1)(THIS_ void **) PURE;
76 STDMETHOD_(HRESULT,AddDirtyRect)(THIS_ const WICRect *) PURE;
77};
#define THIS_
Definition: basetyps.h:65
#define THIS
Definition: basetyps.h:66
#define PURE
Definition: basetyps.h:64
#define STDMETHOD_(t, m)
Definition: basetyps.h:63
_In_ BOOLEAN Release
Definition: cdrom.h:920
DWORD WINAPI GetSize(LPVOID)
static HRESULT QueryInterface(REFIID, void **)
Definition: events.c:2587
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
static ULONG WINAPI AddRef(IStream *iface)
Definition: clist.c:90
static UINT
Definition: bitmap.c:1091
unsigned int UINT
Definition: ndis.h:50
#define DWORD
Definition: nt_native.h:44
@ Unlock
Definition: ntsecapi.h:294
#define REFIID
Definition: guiddef.h:118
uint32_t ULONG
Definition: typedefs.h:59
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:127
int WINAPI GetPixelFormat(_In_ HDC)
_In_ BOOLEAN SetResolution
Definition: exfuncs.h:1078
unsigned char BYTE
Definition: xxhash.c:193

◆ DECLARE_INTERFACE_() [2/3]

DECLARE_INTERFACE_ ( IMILBitmapScaler  ,
IMILBitmapSource   
)

Definition at line 81 of file bitmap.c.

82{
83 /*** IUnknown methods ***/
87 /*** IWICBitmapSource methods ***/
90 STDMETHOD_(HRESULT,GetResolution)(THIS_ double *,double *) PURE;
91 STDMETHOD_(HRESULT,CopyPalette)(THIS_ IWICPalette *) PURE;
92 STDMETHOD_(HRESULT,CopyPixels)(THIS_ const WICRect *,UINT,UINT,BYTE *) PURE;
93 /*** IMILBitmapScaler methods ***/
94 STDMETHOD_(HRESULT,unknown1)(THIS_ void **) PURE;
96};
WICBitmapInterpolationMode
Definition: wincodec.idl:76
static void Initialize()
Definition: xlate.c:212

◆ DECLARE_INTERFACE_() [3/3]

DECLARE_INTERFACE_ ( IMILBitmapSource  ,
IUnknown   
)

Definition at line 44 of file bitmap.c.

45{
49 /*** IWICBitmapSource methods ***/
52 STDMETHOD_(HRESULT,GetResolution)(THIS_ double *,double *) PURE;
53 STDMETHOD_(HRESULT,CopyPalette)(THIS_ IWICPalette *) PURE;
54 STDMETHOD_(HRESULT,CopyPixels)(THIS_ const WICRect *,UINT,UINT,BYTE *) PURE;
55};

◆ DEFINE_GUID() [1/7]

DEFINE_GUID ( IID_IMILBitmap  ,
0xb1784d3f  ,
0x8115  ,
0x4763  ,
0x13  ,
0xaa  ,
0x32  ,
0xed  ,
0xdb  ,
0x68  ,
0x29  ,
0x4a   
)

◆ DEFINE_GUID() [2/7]

DEFINE_GUID ( IID_IMILBitmapLock  ,
0xa67b2b53  ,
0x8fa1  ,
0x4155  ,
0x8f  ,
0x64  ,
0x0c  ,
0x24  ,
0x7a  ,
0x8f  ,
0x84  ,
0xcd   
)

◆ DEFINE_GUID() [3/7]

DEFINE_GUID ( IID_IMILBitmapScaler  ,
0xa767b0f0  ,
0x1c8c  ,
0x4aef  ,
0x56  ,
0x8f  ,
0xad  ,
0xf9  ,
0x6d  ,
0xcf  ,
0xd5  ,
0xcb   
)

◆ DEFINE_GUID() [4/7]

DEFINE_GUID ( IID_IMILBitmapSource  ,
0x7543696a  ,
0xbc8d  ,
0x46b0  ,
0x5f  ,
0x81  ,
0x8d  ,
0x95  ,
0x72  ,
0x89  ,
0x72  ,
0xbe   
)

◆ DEFINE_GUID() [5/7]

DEFINE_GUID ( IID_IMILFormatConverter  ,
0x7e2a746f  ,
0x25c5  ,
0x4851  ,
0xb3  ,
0xaf  ,
0x44  ,
0x3b  ,
0x79  ,
0x63  ,
0x9e  ,
0xc0   
)

◆ DEFINE_GUID() [6/7]

DEFINE_GUID ( IID_IMILPalette  ,
0xca8e206f  ,
0xf22c  ,
0x4af7  ,
0x6f  ,
0xba  ,
0x7b  ,
0xed  ,
0x5e  ,
0xb1  ,
0xc9  ,
0x2f   
)

◆ DEFINE_GUID() [7/7]

DEFINE_GUID ( IID_IMILUnknown  ,
0x0ccd7824  ,
0xdc16  ,
0x4d09  ,
0xbc  ,
0xa8  ,
0x6b  ,
0x09  ,
0xc4  ,
0xef  ,
0x55  ,
0x35   
)

◆ HRESULT()

static HRESULT ( WINAPI pWICCreateBitmapFromSectionEx)
static

◆ obj_refcount()

static LONG obj_refcount ( void obj)
static

Definition at line 1317 of file bitmap.c.

1318{
1319 IUnknown_AddRef((IUnknown *)obj);
1320 return IUnknown_Release((IUnknown *)obj);
1321}

Referenced by test_IMILBitmap().

◆ START_TEST()

START_TEST ( bitmap  )

Definition at line 1469 of file bitmap.c.

1470{
1471 HRESULT hr;
1472
1474
1475 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1476 &IID_IWICImagingFactory, (void**)&factory);
1477 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
1478
1485 test_clipper();
1487
1488 IWICImagingFactory_Release(factory);
1489
1491
1493}
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
Definition: compobj.c:2002
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
#define SUCCEEDED(hr)
Definition: intsafe.h:50
static void test_bitmap_scaler(void)
Definition: bitmap.c:1148
static void test_CreateBitmapFromMemory(void)
Definition: bitmap.c:659
static void test_CreateBitmapFromHICON(void)
Definition: bitmap.c:734
static void test_CreateBitmapFromHBITMAP(void)
Definition: bitmap.c:809
static IWICBitmap **static void test_WICCreateBitmapFromSectionEx(void)
Definition: bitmap.c:1093
static void test_createbitmap(void)
Definition: bitmap.c:219
static void test_IMILBitmap(void)
Definition: bitmap.c:1323
static void test_clipper(void)
Definition: bitmap.c:984
static void test_createbitmapfromsource(void)
Definition: bitmap.c:455
@ COINIT_APARTMENTTHREADED
Definition: objbase.h:278
HRESULT hr
Definition: shlfolder.c:183
Definition: main.c:439

◆ test_bitmap_scaler()

static void test_bitmap_scaler ( void  )
static

Definition at line 1148 of file bitmap.c.

1149{
1151 IWICBitmapScaler *scaler;
1153 double res_x, res_y;
1155 UINT width, height;
1156 BYTE buf[16];
1157 HRESULT hr;
1158
1159 hr = IWICImagingFactory_CreateBitmap(factory, 4, 2, &GUID_WICPixelFormat24bppBGR, WICBitmapCacheOnLoad, &bitmap);
1160 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
1161
1162 hr = IWICBitmap_GetSize(bitmap, &width, &height);
1163 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
1164 ok(width == 4, "Unexpected width %u.\n", width);
1165 ok(height == 2, "Unexpected height %u.\n", height);
1166
1167 hr = IWICBitmap_GetResolution(bitmap, &res_x, &res_y);
1168 ok(hr == S_OK, "Failed to get bitmap resolution, hr %#x.\n", hr);
1169 ok(res_x == 0.0 && res_y == 0.0, "Unexpected resolution %f x %f.\n", res_x, res_y);
1170
1171 hr = IWICImagingFactory_CreateBitmapScaler(factory, &scaler);
1172 ok(hr == S_OK, "Failed to create bitmap scaler, hr %#x.\n", hr);
1173
1174 hr = IWICBitmapScaler_Initialize(scaler, NULL, 0, 0,
1176 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1177
1178 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 0, 0,
1180 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1181
1182 hr = IWICBitmapScaler_GetSize(scaler, NULL, &height);
1183 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1184
1185 hr = IWICBitmapScaler_GetSize(scaler, &width, NULL);
1186 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1187
1188 hr = IWICBitmapScaler_GetResolution(scaler, NULL, NULL);
1189 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1190
1191 res_x = 0.1;
1192 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, NULL);
1193 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1194 ok(res_x == 0.1, "Unexpected resolution %f.\n", res_x);
1195
1196 hr = IWICBitmapScaler_GetResolution(scaler, NULL, &res_y);
1197 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1198
1199 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, &res_y);
1200 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1201
1202 hr = IWICBitmapScaler_GetPixelFormat(scaler, NULL);
1203 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1204
1205 memset(&pixel_format, 0, sizeof(pixel_format));
1206 hr = IWICBitmapScaler_GetPixelFormat(scaler, &pixel_format);
1207 ok(hr == S_OK, "Failed to get pixel format, hr %#x.\n", hr);
1208 ok(IsEqualGUID(&pixel_format, &GUID_WICPixelFormatDontCare), "Unexpected pixel format %s.\n",
1210
1211 width = 123;
1212 height = 321;
1213 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1214 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1215 ok(width == 123, "Unexpected width %u.\n", width);
1216 ok(height == 321, "Unexpected height %u.\n", height);
1217
1218 hr = IWICBitmapScaler_CopyPalette(scaler, NULL);
1219 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1220
1221 hr = IWICImagingFactory_CreatePalette(factory, &palette);
1222 ok(hr == S_OK, "Failed to create a palette, hr %#x.\n", hr);
1223 hr = IWICBitmapScaler_CopyPalette(scaler, palette);
1224 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "Unexpected hr %#x.\n", hr);
1225 IWICPalette_Release(palette);
1226
1227 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 4, 0,
1229 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1230
1231 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1232 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1233
1234 hr = IWICBitmapScaler_CopyPixels(scaler, NULL, 1, sizeof(buf), buf);
1235 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1236
1237 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 0, 2,
1239 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1240
1241 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1242 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1243
1244 hr = IWICBitmapScaler_Initialize(scaler, NULL, 8, 4,
1246 ok(hr == E_INVALIDARG, "Failed to initialize bitmap scaler, hr %#x.\n", hr);
1247
1248 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 8, 4,
1250 ok(hr == S_OK, "Failed to initialize bitmap scaler, hr %#x.\n", hr);
1251
1252 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 0, 4,
1254 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1255
1256 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 8, 0,
1258 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1259
1260 hr = IWICBitmapScaler_Initialize(scaler, NULL, 8, 4, WICBitmapInterpolationModeNearestNeighbor);
1261 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1262
1263 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 8, 4,
1265 ok(hr == WINCODEC_ERR_WRONGSTATE, "Unexpected hr %#x.\n", hr);
1266
1267 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1268 ok(hr == S_OK, "Failed to get scaler size, hr %#x.\n", hr);
1269 ok(width == 8, "Unexpected width %u.\n", width);
1270 ok(height == 4, "Unexpected height %u.\n", height);
1271
1272 hr = IWICBitmapScaler_GetSize(scaler, NULL, &height);
1273 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1274
1275 hr = IWICBitmapScaler_GetSize(scaler, &width, NULL);
1276 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1277
1278 hr = IWICBitmapScaler_GetSize(scaler, NULL, NULL);
1279 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1280
1281 hr = IWICBitmapScaler_GetPixelFormat(scaler, NULL);
1282 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1283
1284 memset(&pixel_format, 0, sizeof(pixel_format));
1285 hr = IWICBitmapScaler_GetPixelFormat(scaler, &pixel_format);
1286 ok(hr == S_OK, "Failed to get pixel format, hr %#x.\n", hr);
1287 ok(IsEqualGUID(&pixel_format, &GUID_WICPixelFormat24bppBGR), "Unexpected pixel format %s.\n",
1289
1290 hr = IWICBitmapScaler_GetResolution(scaler, NULL, NULL);
1291 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1292
1293 res_x = 0.1;
1294 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, NULL);
1295 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1296 ok(res_x == 0.1, "Unexpected resolution %f.\n", res_x);
1297
1298 hr = IWICBitmapScaler_GetResolution(scaler, NULL, &res_y);
1299 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1300
1301 res_x = res_y = 1.0;
1302 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, &res_y);
1303 ok(hr == S_OK, "Failed to get scaler resolution, hr %#x.\n", hr);
1304 ok(res_x == 0.0 && res_y == 0.0, "Unexpected resolution %f x %f.\n", res_x, res_y);
1305
1306 hr = IWICImagingFactory_CreatePalette(factory, &palette);
1307 ok(hr == S_OK, "Failed to create a palette, hr %#x.\n", hr);
1308 hr = IWICBitmapScaler_CopyPalette(scaler, palette);
1309 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "Unexpected hr %#x.\n", hr);
1310 IWICPalette_Release(palette);
1311
1312 IWICBitmapScaler_Release(scaler);
1313
1314 IWICBitmap_Release(bitmap);
1315}
#define E_INVALIDARG
Definition: ddrawi.h:101
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
static HPALETTE palette
Definition: clipboard.c:1345
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
static __inline const char * wine_dbgstr_guid(const GUID *id)
Definition: debug.h:197
Definition: uimain.c:89
@ WICBitmapInterpolationModeNearestNeighbor
Definition: wincodec.idl:77
@ WICBitmapCacheOnLoad
Definition: wincodec.idl:36
#define WINCODEC_ERR_WRONGSTATE
Definition: winerror.h:3281
#define WINCODEC_ERR_NOTINITIALIZED
Definition: winerror.h:3285
#define WINCODEC_ERR_PALETTEUNAVAILABLE
Definition: winerror.h:3292

Referenced by START_TEST().

◆ test_clipper()

static void test_clipper ( void  )
static

Definition at line 984 of file bitmap.c.

985{
986 IWICBitmapClipper *clipper;
989 BYTE buffer[500];
991 HRESULT hr;
992
993 hr = IWICImagingFactory_CreateBitmap(factory, 10, 10, &GUID_WICPixelFormat24bppBGR,
995 ok(hr == S_OK, "got 0x%08x\n", hr);
996
997 hr = IWICImagingFactory_CreateBitmapClipper(factory, &clipper);
998 ok(hr == S_OK, "got 0x%08x\n", hr);
999
1000 rect.X = rect.Y = 0;
1001 rect.Width = rect.Height = 11;
1002 hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
1003 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1004
1005 rect.X = rect.Y = 5;
1006 rect.Width = rect.Height = 6;
1007 hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
1008 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1009
1010 rect.X = rect.Y = 5;
1011 rect.Width = rect.Height = 5;
1012 hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
1013 ok(hr == S_OK, "got 0x%08x\n", hr);
1014
1015 width = height = 0;
1016 hr = IWICBitmapClipper_GetSize(clipper, &width, &height);
1017 ok(hr == S_OK, "got 0x%08x\n", hr);
1018 ok(width == 5, "got %d\n", width);
1019 ok(height == 5, "got %d\n", height);
1020
1021 IWICBitmapClipper_Release(clipper);
1022 IWICBitmap_Release(bitmap);
1023
1024 /* CopyPixels */
1025 hr = IWICImagingFactory_CreateBitmapClipper(factory, &clipper);
1026 ok(hr == S_OK, "got 0x%08x\n", hr);
1027
1028 rect.X = rect.Y = 5;
1029 rect.Width = rect.Height = 5;
1030 hr = IWICBitmapClipper_Initialize(clipper, &bitmapsource, &rect);
1031 ok(hr == S_OK, "got 0x%08x\n", hr);
1032
1033 rect.X = rect.Y = 0;
1034 rect.Width = rect.Height = 2;
1035
1036 /* passed rectangle is relative to clipper rectangle, underlying source gets intersected
1037 rectangle */
1038 memset(&g_rect, 0, sizeof(g_rect));
1040 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
1041 ok(hr == S_OK, "got 0x%08x\n", hr);
1042 ok(called_CopyPixels, "CopyPixels not called\n");
1043 ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 2 && g_rect.Height == 2,
1044 "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
1045
1046 /* whole clipping rectangle */
1047 memset(&g_rect, 0, sizeof(g_rect));
1049
1050 rect.X = rect.Y = 0;
1051 rect.Width = rect.Height = 5;
1052
1053 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
1054 ok(hr == S_OK, "got 0x%08x\n", hr);
1055 ok(called_CopyPixels, "CopyPixels not called\n");
1056 ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 5 && g_rect.Height == 5,
1057 "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
1058
1059 /* larger than clipping rectangle */
1060 memset(&g_rect, 0, sizeof(g_rect));
1062
1063 rect.X = rect.Y = 0;
1064 rect.Width = rect.Height = 20;
1065
1066 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
1067 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1068 ok(!called_CopyPixels, "CopyPixels called\n");
1069
1070 rect.X = rect.Y = 5;
1071 rect.Width = rect.Height = 5;
1072
1073 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
1074 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1075 ok(!called_CopyPixels, "CopyPixels called\n");
1076
1077 /* null rectangle */
1078 memset(&g_rect, 0, sizeof(g_rect));
1080
1081 hr = IWICBitmapClipper_CopyPixels(clipper, NULL, 0, sizeof(buffer), buffer);
1082 ok(hr == S_OK, "got 0x%08x\n", hr);
1083 ok(called_CopyPixels, "CopyPixels not called\n");
1084 ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 5 && g_rect.Height == 5,
1085 "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
1086
1087 IWICBitmapClipper_Release(clipper);
1088}
#define FALSE
Definition: types.h:117
GLuint buffer
Definition: glext.h:5915
static IWICBitmapSource bitmapsource
Definition: bitmap.c:172
& rect
Definition: startmenu.cpp:1413
INT Height
Definition: wincodec.idl:301
INT Width
Definition: wincodec.idl:300

Referenced by START_TEST().

◆ test_createbitmap()

static void test_createbitmap ( void  )
static

Definition at line 219 of file bitmap.c.

220{
221 HRESULT hr;
224 IWICBitmapLock *lock, *lock2;
225 WICBitmapPaletteType palettetype;
226 int i;
227 WICRect rc;
228 const BYTE bitmap_data[27] = {
229 128,128,255, 128,128,128, 128,255,128,
230 128,128,128, 128,128,128, 255,255,255,
231 255,128,128, 255,255,255, 255,255,255};
232 BYTE returned_data[27] = {0};
233 BYTE *lock_buffer=NULL, *base_lock_buffer=NULL;
234 UINT lock_buffer_size=0;
235 UINT lock_buffer_stride=0;
237 UINT width=0, height=0;
238 double dpix=10.0, dpiy=10.0;
239 int can_lock_null = 1;
240
241 hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
243 ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
244
245 if (FAILED(hr))
246 return;
247
248 hr = IWICImagingFactory_CreatePalette(factory, &palette);
249 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
250
251 /* Palette is unavailable until explicitly set */
252 hr = IWICBitmap_CopyPalette(bitmap, palette);
253 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
254
255 hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
256 ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
257
258 hr = IWICBitmap_SetPalette(bitmap, palette);
259 ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
260
261 hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray4, FALSE);
262 ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
263
264 hr = IWICBitmap_CopyPalette(bitmap, palette);
265 ok(hr == S_OK, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
266
267 hr = IWICPalette_GetType(palette, &palettetype);
268 ok(hr == S_OK, "IWICPalette_GetType failed hr=%x\n", hr);
270 "expected WICBitmapPaletteTypeFixedGray256, got %x\n", palettetype);
271
272 IWICPalette_Release(palette);
273
274 /* pixel data is initially zeroed */
275 hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, 27, returned_data);
276 ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
277
278 for (i=0; i<27; i++)
279 ok(returned_data[i] == 0, "returned_data[%i] == %i\n", i, returned_data[i]);
280
281 /* Invalid lock rects */
282 rc.X = rc.Y = 0;
283 rc.Width = 4;
284 rc.Height = 3;
285 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
286 ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
287 if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
288
289 rc.Width = 3;
290 rc.Height = 4;
291 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
292 ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
293 if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
294
295 rc.Height = 3;
296 rc.X = 4;
297 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
298 ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
299 if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
300
301 rc.X = 0;
302 rc.Y = 4;
303 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
304 ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
305 if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
306
307 /* NULL lock rect */
308 hr = IWICBitmap_Lock(bitmap, NULL, WICBitmapLockRead, &lock);
309 ok(hr == S_OK || broken(hr == E_INVALIDARG) /* winxp */, "IWICBitmap_Lock failed hr=%x\n", hr);
310
311 if (SUCCEEDED(hr))
312 {
313 /* entire bitmap is locked */
314 hr = IWICBitmapLock_GetSize(lock, &width, &height);
315 ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr);
316 ok(width == 3, "got %d, expected 3\n", width);
317 ok(height == 3, "got %d, expected 3\n", height);
318
319 IWICBitmapLock_Release(lock);
320 }
321 else
322 can_lock_null = 0;
323
324 /* lock with a valid rect */
325 rc.Y = 0;
326 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
327 ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
328 if (SUCCEEDED(hr))
329 {
330 hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
331 ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
332 /* stride is divisible by 4 */
333 ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
334
335 hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
336 ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
337 /* buffer size does not include padding from the last row */
338 ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
339 ok(lock_buffer != NULL, "got NULL data pointer\n");
340 base_lock_buffer = lock_buffer;
341
342 hr = IWICBitmapLock_GetPixelFormat(lock, &pixelformat);
343 ok(hr == S_OK, "IWICBitmapLock_GetPixelFormat failed hr=%x\n", hr);
344 ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
345
346 hr = IWICBitmapLock_GetSize(lock, &width, &height);
347 ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr);
348 ok(width == 3, "got %d, expected 3\n", width);
349 ok(height == 3, "got %d, expected 3\n", height);
350
351 /* We can have multiple simultaneous read locks */
352 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock2);
353 ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
354
355 if (SUCCEEDED(hr))
356 {
357 hr = IWICBitmapLock_GetDataPointer(lock2, &lock_buffer_size, &lock_buffer);
358 ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
359 ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
360 ok(lock_buffer == base_lock_buffer, "got %p, expected %p\n", lock_buffer, base_lock_buffer);
361
362 IWICBitmapLock_Release(lock2);
363 }
364
365 if (can_lock_null) /* this hangs on xp/vista */
366 {
367 /* But not a read and a write lock */
368 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock2);
369 ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
370 }
371
372 /* But we don't need a write lock to write */
373 if (base_lock_buffer)
374 {
375 for (i=0; i<3; i++)
376 memcpy(base_lock_buffer + lock_buffer_stride*i, bitmap_data + i*9, 9);
377 }
378
379 IWICBitmapLock_Release(lock);
380 }
381
382 /* test that the data we wrote is returned by CopyPixels */
383 hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, 27, returned_data);
384 ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
385
386 for (i=0; i<27; i++)
387 ok(returned_data[i] == bitmap_data[i], "returned_data[%i] == %i\n", i, returned_data[i]);
388
389 /* try a valid partial rect, and write mode */
390 rc.X = 2;
391 rc.Y = 0;
392 rc.Width = 1;
393 rc.Height = 2;
394 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock);
395 ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
396
397 if (SUCCEEDED(hr))
398 {
399 if (can_lock_null) /* this hangs on xp/vista */
400 {
401 /* Can't lock again while locked for writing */
402 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock2);
403 ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
404
405 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock2);
406 ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
407 }
408
409 hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
410 ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
411 ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
412
413 hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
414 ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
415 ok(lock_buffer_size == 15, "got %i, expected 15\n", lock_buffer_size);
416 ok(lock_buffer == base_lock_buffer+6, "got %p, expected %p+6\n", lock_buffer, base_lock_buffer);
417
418 hr = IWICBitmapLock_GetPixelFormat(lock, &pixelformat);
419 ok(hr == S_OK, "IWICBitmapLock_GetPixelFormat failed hr=%x\n", hr);
420 ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
421
422 hr = IWICBitmapLock_GetSize(lock, &width, &height);
423 ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr);
424 ok(width == 1, "got %d, expected 1\n", width);
425 ok(height == 2, "got %d, expected 2\n", height);
426
427 IWICBitmapLock_Release(lock);
428 }
429
430 hr = IWICBitmap_GetPixelFormat(bitmap, &pixelformat);
431 ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
432 ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
433
434 hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
435 ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
436 ok(dpix == 0.0, "got %f, expected 0.0\n", dpix);
437 ok(dpiy == 0.0, "got %f, expected 0.0\n", dpiy);
438
439 hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0);
440 ok(hr == S_OK, "IWICBitmap_SetResolution failed hr=%x\n", hr);
441
442 hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
443 ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
444 ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
445 ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
446
447 hr = IWICBitmap_GetSize(bitmap, &width, &height);
448 ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
449 ok(width == 3, "got %d, expected 3\n", width);
450 ok(height == 3, "got %d, expected 3\n", height);
451
452 IWICBitmap_Release(bitmap);
453}
#define broken(x)
Definition: _sntprintf.h:21
pixelformat
Definition: converter.c:40
#define FAILED(hr)
Definition: intsafe.h:51
static void lock_buffer(struct buffer_head *bh)
Definition: module.h:1028
rwlock_t lock
Definition: tcpcore.h:0
@ WICBitmapLockWrite
Definition: wincodec.idl:86
@ WICBitmapLockRead
Definition: wincodec.idl:85
WICBitmapPaletteType
Definition: wincodec.idl:90
@ WICBitmapPaletteTypeFixedGray256
Definition: wincodec.idl:104
@ WICBitmapPaletteTypeFixedGray4
Definition: wincodec.idl:102
#define WINCODEC_ERR_ALREADYLOCKED
Definition: winerror.h:3286

Referenced by START_TEST().

◆ test_CreateBitmapFromHBITMAP()

static void test_CreateBitmapFromHBITMAP ( void  )
static

Definition at line 809 of file bitmap.c.

810{
811 /* 8 bpp data must be aligned to a DWORD boundary for a DIB */
812 static const BYTE data_8bpp_pal_dib[12] = { 0,1,2,0, 1,2,0,0, 2,1,0,0 };
813 static const BYTE data_8bpp_rgb_dib[12] = { 0xf0,0x0f,0xff,0, 0x0f,0xff,0xf0,0, 0xf0,0x0f,0xff,0 };
814 static const BYTE data_8bpp_pal_wic[12] = { 0xd,0xe,0x10,0, 0xe,0x10,0xd,0, 0x10,0xe,0xd,0 };
815 static const PALETTEENTRY pal_data[3] = { {0xff,0,0,0}, {0,0xff,0,0}, {0,0,0xff,0} };
816 char pal_buf[sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * 255];
817 LOGPALETTE *pal = (LOGPALETTE *)pal_buf;
819 HPALETTE hpal;
820 BYTE data[12];
821 HRESULT hr;
827
828 /* 8 bpp without palette */
829 hbmp = create_dib(3, 3, 8, NULL, data_8bpp_rgb_dib);
830 ok(hbmp != 0, "failed to create bitmap\n");
831
832 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, 0, 0, WICBitmapIgnoreAlpha, &bitmap);
833 ok(hr == WINCODEC_ERR_WIN32ERROR || hr == 0x88980003 /*XP*/, "expected WINCODEC_ERR_WIN32ERROR, got %#x\n", hr);
834
835 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, 0, WICBitmapIgnoreAlpha, NULL);
836 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
837
838 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, 0, WICBitmapIgnoreAlpha, &bitmap);
839 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
840
841 IWICBitmap_GetPixelFormat(bitmap, &format);
842 ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
843 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
844
845 hr = IWICBitmap_GetSize(bitmap, &width, &height);
846 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
847 ok(width == 3, "expected 3, got %u\n", width);
848 ok(height == 3, "expected 3, got %u\n", height);
849
850 memset(data, 0, sizeof(data));
851 hr = IWICBitmap_CopyPixels(bitmap, NULL, 4, sizeof(data), data);
852 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
853 for (i = 0; i < sizeof(data); i++)
854 ok(data[i] == data_8bpp_rgb_dib[i], "%u: expected %#x, got %#x\n", i, data_8bpp_rgb_dib[i], data[i]);
855
856 IWICBitmap_Release(bitmap);
858
859 /* 8 bpp with a 3 entries palette */
860 memset(pal_buf, 0, sizeof(pal_buf));
861 pal->palVersion = 0x300;
862 pal->palNumEntries = 3;
863 memcpy(pal->palPalEntry, pal_data, sizeof(pal_data));
864 hpal = CreatePalette(pal);
865 ok(hpal != 0, "CreatePalette failed\n");
866
867 hbmp = create_dib(3, 3, 8, pal, data_8bpp_pal_dib);
868 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, hpal, WICBitmapIgnoreAlpha, &bitmap);
869 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
870
871 IWICBitmap_GetPixelFormat(bitmap, &format);
873 ok(IsEqualGUID(&format, &GUID_WICPixelFormat4bppIndexed),
874 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
875
876 hr = IWICBitmap_GetSize(bitmap, &width, &height);
877 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
878 ok(width == 3, "expected 3, got %u\n", width);
879 ok(height == 3, "expected 3, got %u\n", height);
880
881 hr = IWICImagingFactory_CreatePalette(factory, &palette);
882 ok(hr == S_OK, "CreatePalette error %#x\n", hr);
883 hr = IWICBitmap_CopyPalette(bitmap, palette);
884 ok(hr == S_OK, "CopyPalette error %#x\n", hr);
885
886 hr = IWICPalette_GetType(palette, &type);
887 ok(hr == S_OK, "%u: GetType error %#x\n", i, hr);
888 ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %#x\n", type);
889
890 hr = IWICPalette_GetColorCount(palette, &count);
891 ok(hr == S_OK, "GetColorCount error %#x\n", hr);
893 ok(count == 16, "expected 16, got %u\n", count);
894
895 IWICPalette_Release(palette);
896
897 IWICBitmap_Release(bitmap);
899 DeleteObject(hpal);
900
901 /* 8 bpp with a 256 entries palette */
902 memset(pal_buf, 0, sizeof(pal_buf));
903 pal->palVersion = 0x300;
904 pal->palNumEntries = 256;
905 memcpy(pal->palPalEntry, pal_data, sizeof(pal_data));
906 hpal = CreatePalette(pal);
907 ok(hpal != 0, "CreatePalette failed\n");
908
909 hbmp = create_dib(3, 3, 8, pal, data_8bpp_pal_dib);
910 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, hpal, WICBitmapIgnoreAlpha, &bitmap);
911 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
912
913 IWICBitmap_GetPixelFormat(bitmap, &format);
914 ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
915 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
916
917 hr = IWICBitmap_GetSize(bitmap, &width, &height);
918 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
919 ok(width == 3, "expected 3, got %u\n", width);
920 ok(height == 3, "expected 3, got %u\n", height);
921
922 hr = IWICImagingFactory_CreatePalette(factory, &palette);
923 ok(hr == S_OK, "CreatePalette error %#x\n", hr);
924 hr = IWICBitmap_CopyPalette(bitmap, palette);
925 ok(hr == S_OK, "CopyPalette error %#x\n", hr);
926
927 hr = IWICPalette_GetType(palette, &type);
928 ok(hr == S_OK, "%u: GetType error %#x\n", i, hr);
929 ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %#x\n", type);
930
931 hr = IWICPalette_GetColorCount(palette, &count);
932 ok(hr == S_OK, "GetColorCount error %#x\n", hr);
933 ok(count == 256, "expected 256, got %u\n", count);
934
935 IWICPalette_Release(palette);
936
937 memset(data, 0, sizeof(data));
938 hr = IWICBitmap_CopyPixels(bitmap, NULL, 4, sizeof(data), data);
939 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
940 for (i = 0; i < sizeof(data); i++)
941 todo_wine_if (data[i] != data_8bpp_pal_wic[i])
942 ok(data[i] == data_8bpp_pal_wic[i], "%u: expected %#x, got %#x\n", i, data_8bpp_pal_wic[i], data[i]);
943
944 IWICBitmap_Release(bitmap);
946 DeleteObject(hpal);
947
948 /* 32bpp alpha */
949 hbmp = create_dib(2, 2, 32, NULL, NULL);
950 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapUseAlpha, &bitmap);
951 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
952
953 hr = IWICBitmap_GetPixelFormat(bitmap, &format);
954 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
955 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
956 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
957
958 IWICBitmap_Release(bitmap);
959
960 /* 32bpp pre-multiplied alpha */
961 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapUsePremultipliedAlpha, &bitmap);
962 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
963
964 hr = IWICBitmap_GetPixelFormat(bitmap, &format);
965 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
966 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppPBGRA),
967 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
968
969 IWICBitmap_Release(bitmap);
970
971 /* 32bpp no alpha */
972 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapIgnoreAlpha, &bitmap);
973 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
974
975 hr = IWICBitmap_GetPixelFormat(bitmap, &format);
976 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
977 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGR),
978 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
979
980 IWICBitmap_Release(bitmap);
982}
HBITMAP hbmp
pKey DeleteObject()
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
#define todo_wine_if(is_todo)
Definition: custom.c:76
#define todo_wine
Definition: custom.c:79
static HBITMAP create_dib(int width, int height, int bpp, LOGPALETTE *pal, const void *data)
Definition: bitmap.c:174
WORD palVersion
Definition: wingdi.h:1833
@ WICBitmapPaletteTypeCustom
Definition: wincodec.idl:91
@ WICBitmapIgnoreAlpha
Definition: wincodec.idl:43
@ WICBitmapUseAlpha
Definition: wincodec.idl:41
@ WICBitmapUsePremultipliedAlpha
Definition: wincodec.idl:42
#define WINCODEC_ERR_WIN32ERROR
Definition: winerror.h:3319
HPALETTE WINAPI CreatePalette(_In_reads_(_Inexpressible_(2 *sizeof(WORD)+plpal->palNumEntries *sizeof(PALETTEENTRY))) const LOGPALETTE *)
struct tagLOGPALETTE LOGPALETTE

Referenced by START_TEST().

◆ test_CreateBitmapFromHICON()

static void test_CreateBitmapFromHICON ( void  )
static

Definition at line 734 of file bitmap.c.

735{
736 static const char bits[4096];
737 HICON icon;
739 HRESULT hr;
743
744 /* 1 bpp mask */
745 info.fIcon = 1;
746 info.xHotspot = 0;
747 info.yHotspot = 0;
748 info.hbmColor = 0;
749 info.hbmMask = CreateBitmap(16, 32, 1, 1, bits);
750 ok(info.hbmMask != 0, "CreateBitmap failed\n");
751 icon = CreateIconIndirect(&info);
752 ok(icon != 0, "CreateIconIndirect failed\n");
753 DeleteObject(info.hbmMask);
754
755 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, 0, NULL);
756 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
757
758 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, 0, &bitmap);
759 ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_CURSOR_HANDLE), "expected ERROR_INVALID_CURSOR_HANDLE, got %#x\n", hr);
760
761 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, NULL);
762 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
763
764 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, &bitmap);
765 ok(hr == S_OK, "CreateBitmapFromHICON error %#x\n", hr);
766 DestroyIcon(icon);
767 if (hr != S_OK) return;
768
769 IWICBitmap_GetPixelFormat(bitmap, &format);
770 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
771 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
772
773 hr = IWICBitmap_GetSize(bitmap, &width, &height);
774 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
775 ok(width == 16, "expected 16, got %u\n", width);
776 ok(height == 16, "expected 16, got %u\n", height);
777
778 IWICBitmap_Release(bitmap);
779
780 /* 24 bpp color, 1 bpp mask */
781 info.fIcon = 1;
782 info.xHotspot = 0;
783 info.yHotspot = 0;
784 info.hbmColor = CreateBitmap(16, 16, 1, 24, bits);
785 ok(info.hbmColor != 0, "CreateBitmap failed\n");
786 info.hbmMask = CreateBitmap(16, 16, 1, 1, bits);
787 ok(info.hbmMask != 0, "CreateBitmap failed\n");
788 icon = CreateIconIndirect(&info);
789 ok(icon != 0, "CreateIconIndirect failed\n");
790 DeleteObject(info.hbmColor);
791 DeleteObject(info.hbmMask);
792
793 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, &bitmap);
794 ok(hr == S_OK, "CreateBitmapFromHICON error %#x\n", hr);
795 DestroyIcon(icon);
796
797 IWICBitmap_GetPixelFormat(bitmap, &format);
798 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
799 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
800
801 hr = IWICBitmap_GetSize(bitmap, &width, &height);
802 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
803 ok(width == 16, "expected 16, got %u\n", width);
804 ok(height == 16, "expected 16, got %u\n", height);
805
806 IWICBitmap_Release(bitmap);
807}
static HICON
Definition: imagelist.c:84
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
#define ERROR_INVALID_CURSOR_HANDLE
Definition: winerror.h:883
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:2564
BOOL WINAPI DestroyIcon(_In_ HICON)
Definition: cursoricon.c:2036

Referenced by START_TEST().

◆ test_CreateBitmapFromMemory()

static void test_CreateBitmapFromMemory ( void  )
static

Definition at line 659 of file bitmap.c.

660{
661 BYTE orig_data3x3[27] = {
662 128,128,255, 128,128,128, 128,255,128,
663 128,128,128, 128,128,128, 255,255,255,
664 255,128,128, 255,255,255, 255,255,255 };
665 BYTE data3x3[27];
666 BYTE data3x2[27] = {
667 128,128,255, 128,128,128, 128,255,128,
668 0,0,0, 0,128,128, 255,255,255,
669 255,128,128, 255,0,0, 0,0,0 };
670 BYTE data[27];
671 HRESULT hr;
673 UINT width, height, i;
674
675 memcpy(data3x3, orig_data3x3, sizeof(data3x3));
676
677 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
678 0, 0, NULL, &bitmap);
679 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
680
681 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
682 0, sizeof(data3x3), data3x3, &bitmap);
683 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
684
685 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
686 6, sizeof(data3x3), data3x3, &bitmap);
687 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
688
689 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
690 12, sizeof(data3x3), data3x3, &bitmap);
691 ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "expected WINCODEC_ERR_INSUFFICIENTBUFFER, got %#x\n", hr);
692
693 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
694 9, sizeof(data3x3) - 1, data3x3, &bitmap);
695 ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "expected WINCODEC_ERR_INSUFFICIENTBUFFER, got %#x\n", hr);
696
697 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
698 9, sizeof(data3x3), data3x3, &bitmap);
699 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromMemory error %#x\n", hr);
700
701 hr = IWICBitmap_GetSize(bitmap, &width, &height);
702 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
703 ok(width == 3, "expected 3, got %u\n", width);
704 ok(height == 3, "expected 3, got %u\n", height);
705
706 data3x3[2] = 192;
707
708 memset(data, 0, sizeof(data));
709 hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, sizeof(data), data);
710 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
711 for (i = 0; i < sizeof(data); i++)
712 ok(data[i] == orig_data3x3[i], "%u: expected %u, got %u\n", i, data[i], data3x3[i]);
713
714 IWICBitmap_Release(bitmap);
715
716 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 2, &GUID_WICPixelFormat24bppBGR,
717 13, sizeof(orig_data3x3), orig_data3x3, &bitmap);
718 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromMemory error %#x\n", hr);
719
720 hr = IWICBitmap_GetSize(bitmap, &width, &height);
721 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
722 ok(width == 3, "expected 3, got %u\n", width);
723 ok(height == 2, "expected 2, got %u\n", height);
724
725 memset(data, 0, sizeof(data));
726 hr = IWICBitmap_CopyPixels(bitmap, NULL, 13, sizeof(data), data);
727 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
728 for (i = 0; i < sizeof(data); i++)
729 ok(data[i] == data3x2[i], "%u: expected %u, got %u\n", i, data3x2[i], data[i]);
730
731 IWICBitmap_Release(bitmap);
732}
#define WINCODEC_ERR_INSUFFICIENTBUFFER
Definition: winerror.h:3311

Referenced by START_TEST().

◆ test_createbitmapfromsource()

static void test_createbitmapfromsource ( void  )
static

Definition at line 455 of file bitmap.c.

456{
457 HRESULT hr;
461 int i;
462 WICRect rc;
463 const BYTE bitmap_data[27] = {
464 128,128,255, 128,128,128, 128,255,128,
465 128,128,128, 128,128,128, 255,255,255,
466 255,128,128, 255,255,255, 255,255,255};
467 BYTE returned_data[27] = {0};
469 UINT lock_buffer_stride=0;
470 UINT lock_buffer_size=0;
472 UINT width=0, height=0;
473 double dpix=10.0, dpiy=10.0;
474 UINT count;
476
477 hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
479 ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
480
481 if (FAILED(hr))
482 return;
483
484 hr = IWICImagingFactory_CreatePalette(factory, &palette);
485 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
486
487 hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
488 ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
489
490 hr = IWICBitmap_SetPalette(bitmap, palette);
491 ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
492
493 IWICPalette_Release(palette);
494
495 rc.X = rc.Y = 0;
496 rc.Width = 3;
497 rc.Height = 3;
498 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock);
499 ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
500 if (SUCCEEDED(hr))
501 {
502 hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
503 ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
504 ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
505
506 hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
507 ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
508 ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
509 ok(lock_buffer != NULL, "got NULL data pointer\n");
510
511 for (i=0; i<3; i++)
512 memcpy(lock_buffer + lock_buffer_stride*i, bitmap_data + i*9, 9);
513
514 IWICBitmapLock_Release(lock);
515 }
516
517 hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0);
518 ok(hr == S_OK, "IWICBitmap_SetResolution failed hr=%x\n", hr);
519
520 /* WICBitmapNoCache */
521 hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource *)bitmap,
523 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
524 ok(bitmap2 == bitmap, "Unexpected bitmap instance.\n");
525
526 IWICBitmap_Release(bitmap2);
527
528 bitmap2 = (void *)0xdeadbeef;
529 hr = IWICImagingFactory_CreateBitmapFromSource(factory, &bitmapsource, WICBitmapNoCache, &bitmap2);
530 ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr);
531 ok(bitmap2 == (void *)0xdeadbeef, "Unexpected pointer %p.\n", bitmap2);
532
533 hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap,
535 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
536
537 IWICBitmap_Release(bitmap);
538
539 if (FAILED(hr)) return;
540
541 hr = IWICImagingFactory_CreatePalette(factory, &palette);
542 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
543
544 /* palette isn't copied for non-indexed formats? */
545 hr = IWICBitmap_CopyPalette(bitmap2, palette);
546 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
547
548 IWICPalette_Release(palette);
549
550 hr = IWICBitmap_CopyPixels(bitmap2, NULL, 9, 27, returned_data);
551 ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
552
553 for (i=0; i<27; i++)
554 ok(returned_data[i] == bitmap_data[i], "returned_data[%i] == %i\n", i, returned_data[i]);
555
556 hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat);
557 ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
558 ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
559
560 hr = IWICBitmap_GetResolution(bitmap2, &dpix, &dpiy);
561 ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
562 ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
563 ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
564
565 hr = IWICBitmap_GetSize(bitmap2, &width, &height);
566 ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
567 ok(width == 3, "got %d, expected 3\n", width);
568 ok(height == 3, "got %d, expected 3\n", height);
569
570 IWICBitmap_Release(bitmap2);
571
572 /* Ensure palette is copied for indexed formats */
573 hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat4bppIndexed,
575 ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
576
577 hr = IWICImagingFactory_CreatePalette(factory, &palette);
578 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
579
580 hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
581 ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
582
583 hr = IWICBitmap_SetPalette(bitmap, palette);
584 ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
585
586 IWICPalette_Release(palette);
587
588 hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap,
590 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
591
592 IWICBitmap_Release(bitmap);
593
594 hr = IWICImagingFactory_CreatePalette(factory, &palette);
595 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
596
597 hr = IWICBitmap_CopyPalette(bitmap2, palette);
598 ok(hr == S_OK, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
599
600 hr = IWICPalette_GetColorCount(palette, &count);
601 ok(hr == S_OK, "IWICPalette_GetColorCount failed hr=%x\n", hr);
602 ok(count == 256, "unexpected count %d\n", count);
603
604 hr = IWICPalette_GetType(palette, &palette_type);
605 ok(hr == S_OK, "IWICPalette_GetType failed hr=%x\n", hr);
606 ok(palette_type == WICBitmapPaletteTypeFixedGray256, "unexpected palette type %d\n", palette_type);
607
608 IWICPalette_Release(palette);
609
610 hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat);
611 ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
612 ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat4bppIndexed), "unexpected pixel format\n");
613
614 hr = IWICBitmap_GetSize(bitmap2, &width, &height);
615 ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
616 ok(width == 3, "got %d, expected 3\n", width);
617 ok(height == 3, "got %d, expected 3\n", height);
618
619 /* CreateBitmapFromSourceRect */
620 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 16, 32, &bitmap);
621 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
622 hr = IWICBitmap_GetSize(bitmap, &width, &height);
623 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
624 ok(width == 3, "Unexpected width %u.\n", width);
625 ok(height == 3, "Unexpected height %u.\n", height);
626 IWICBitmap_Release(bitmap);
627
628 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 1, 1, &bitmap);
629 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
630 hr = IWICBitmap_GetSize(bitmap, &width, &height);
631 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
632 ok(width == 1, "Unexpected width %u.\n", width);
633 ok(height == 1, "Unexpected height %u.\n", height);
634 IWICBitmap_Release(bitmap);
635
636 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 2, 1, 16, 32, &bitmap);
637 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
638 hr = IWICBitmap_GetSize(bitmap, &width, &height);
639 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
640 ok(width == 1, "Unexpected width %u.\n", width);
641 ok(height == 2, "Unexpected height %u.\n", height);
642 IWICBitmap_Release(bitmap);
643
644 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 0, 2, &bitmap);
645 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
646
647 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 2, 0, &bitmap);
648 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
649
650 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 1, 3, 16, 32, &bitmap);
651 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
652
653 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 3, 1, 16, 32, &bitmap);
654 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
655
656 IWICBitmap_Release(bitmap2);
657}
WICBitmapPaletteType palette_type
Definition: image.c:53
static HBITMAP bitmap2
Definition: clipboard.c:1344
@ WICBitmapNoCache
Definition: wincodec.idl:34

Referenced by START_TEST().

◆ test_IMILBitmap()

static void test_IMILBitmap ( void  )
static

Definition at line 1323 of file bitmap.c.

1324{
1325 HRESULT hr;
1327 IWICBitmapScaler *scaler;
1328 IMILBitmap *mil_bitmap;
1329 IMILBitmapSource *mil_source;
1330 IMILBitmapScaler *mil_scaler;
1331 IUnknown *wic_unknown, *mil_unknown;
1333 int MIL_format;
1334 UINT width, height;
1335 double dpix, dpiy;
1336 BYTE buf[256];
1337
1338 /* Bitmap */
1339 hr = IWICImagingFactory_CreateBitmap(factory, 1, 1, &GUID_WICPixelFormat24bppBGR,
1341 ok(hr == S_OK, "CreateBitmap error %#x\n", hr);
1342
1343 ok(obj_refcount(bitmap) == 1, "ref count %d\n", obj_refcount(bitmap));
1344
1345 hr = IWICBitmap_GetPixelFormat(bitmap, &format);
1346 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
1347 ok(IsEqualGUID(&format, &GUID_WICPixelFormat24bppBGR), "wrong format %s\n", wine_dbgstr_guid(&format));
1348
1349 hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
1350 ok(hr == S_OK, "GetResolution error %#x\n", hr);
1351 ok(dpix == 0.0, "got %f, expected 0.0\n", dpix);
1352 ok(dpiy == 0.0, "got %f, expected 0.0\n", dpiy);
1353
1354 hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0);
1355 ok(hr == S_OK, "SetResolution error %#x\n", hr);
1356
1357 hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
1358 ok(hr == S_OK, "GetResolution error %#x\n", hr);
1359 ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
1360 ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
1361
1362 hr = IWICBitmap_GetSize(bitmap, &width, &height);
1363 ok(hr == S_OK, "GetSize error %#x\n", hr);
1364 ok(width == 1, "got %u, expected 1\n", width);
1365 ok(height == 1, "got %u, expected 1\n", height);
1366
1367 hr = IWICBitmap_QueryInterface(bitmap, &IID_IMILBitmap, (void **)&mil_bitmap);
1368 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1369
1370 ok(obj_refcount(bitmap) == 2, "ref count %d\n", obj_refcount(bitmap));
1371 ok(obj_refcount(mil_bitmap) == 2, "ref count %d\n", obj_refcount(mil_bitmap));
1372
1373 hr = IWICBitmap_QueryInterface(bitmap, &IID_IUnknown, (void **)&wic_unknown);
1374 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1375
1376 hr = mil_bitmap->lpVtbl->QueryInterface(mil_bitmap, &IID_IUnknown, (void **)&mil_unknown);
1377 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1378 ok((void *)wic_unknown->lpVtbl == (void *)mil_unknown->lpVtbl, "wrong lpVtbl ptrs %p != %p\n", wic_unknown->lpVtbl, mil_unknown->lpVtbl);
1379
1380 IUnknown_Release(wic_unknown);
1381 IUnknown_Release(mil_unknown);
1382
1383 hr = IWICBitmap_QueryInterface(bitmap, &IID_IMILBitmapSource, (void **)&mil_source);
1384 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1385 ok((void *)mil_source->lpVtbl == (void *)mil_bitmap->lpVtbl, "IMILBitmap->lpVtbl should be equal to IMILBitmapSource->lpVtbl\n");
1386
1387 ok(obj_refcount(bitmap) == 3, "ref count %d\n", obj_refcount(bitmap));
1388 ok(obj_refcount(mil_bitmap) == 3, "ref count %d\n", obj_refcount(mil_bitmap));
1389 ok(obj_refcount(mil_source) == 3, "ref count %d\n", obj_refcount(mil_source));
1390
1391 hr = mil_source->lpVtbl->GetPixelFormat(mil_source, &MIL_format);
1392 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
1393 ok(MIL_format == 0x0c, "wrong format %d\n", MIL_format);
1394
1395 hr = mil_source->lpVtbl->GetResolution(mil_source, &dpix, &dpiy);
1396 ok(hr == S_OK, "GetResolution error %#x\n", hr);
1397 ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
1398 ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
1399
1400 hr = mil_source->lpVtbl->GetSize(mil_source, &width, &height);
1401 ok(hr == S_OK, "GetSize error %#x\n", hr);
1402 ok(width == 1, "got %u, expected 1\n", width);
1403 ok(height == 1, "got %u, expected 1\n", height);
1404
1405 /* Scaler */
1406 hr = IWICImagingFactory_CreateBitmapScaler(factory, &scaler);
1407 ok(hr == S_OK, "CreateBitmapScaler error %#x\n", hr);
1408
1409 ok(obj_refcount(scaler) == 1, "ref count %d\n", obj_refcount(scaler));
1410
1411 hr = IWICBitmapScaler_QueryInterface(scaler, &IID_IMILBitmapScaler, (void **)&mil_scaler);
1412 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1413
1414 ok(obj_refcount(scaler) == 2, "ref count %d\n", obj_refcount(scaler));
1415 ok(obj_refcount(mil_scaler) == 2, "ref count %d\n", obj_refcount(mil_scaler));
1416
1417 hr = IWICBitmapScaler_QueryInterface(scaler, &IID_IUnknown, (void **)&wic_unknown);
1418 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1419
1420 hr = mil_scaler->lpVtbl->QueryInterface(mil_scaler, &IID_IUnknown, (void **)&mil_unknown);
1421 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1422 ok((void *)wic_unknown->lpVtbl == (void *)mil_unknown->lpVtbl, "wrong lpVtbl ptrs %p != %p\n", wic_unknown->lpVtbl, mil_unknown->lpVtbl);
1423
1424 IUnknown_Release(wic_unknown);
1425 IUnknown_Release(mil_unknown);
1426
1427 hr = mil_scaler->lpVtbl->GetPixelFormat(mil_scaler, &MIL_format);
1428 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "GetPixelFormat error %#x\n", hr);
1429
1430 hr = mil_scaler->lpVtbl->GetResolution(mil_scaler, &dpix, &dpiy);
1431 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "GetResolution error %#x\n", hr);
1432
1433 hr = mil_scaler->lpVtbl->GetSize(mil_scaler, &width, &height);
1434 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "GetSize error %#x\n", hr);
1435
1436 memset(buf, 0xde, sizeof(buf));
1437 hr = mil_scaler->lpVtbl->CopyPixels(mil_scaler, NULL, 3, sizeof(buf), buf);
1438 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "CopyPixels error %#x\n", hr);
1439
1440 hr = mil_scaler->lpVtbl->Initialize(mil_scaler, mil_source, 1, 1, 1);
1441 ok(hr == S_OK, "Initialize error %#x\n", hr);
1442
1443 hr = mil_scaler->lpVtbl->GetPixelFormat(mil_scaler, &MIL_format);
1444 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
1445 ok(MIL_format == 0x0c, "wrong format %d\n", MIL_format);
1446
1447 hr = mil_scaler->lpVtbl->GetResolution(mil_scaler, &dpix, &dpiy);
1448 ok(hr == S_OK, "GetResolution error %#x\n", hr);
1449 ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
1450 ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
1451
1452 hr = mil_scaler->lpVtbl->GetSize(mil_scaler, &width, &height);
1453 ok(hr == S_OK, "GetSize error %#x\n", hr);
1454 ok(width == 1, "got %u, expected 1\n", width);
1455 ok(height == 1, "got %u, expected 1\n", height);
1456
1457 memset(buf, 0xde, sizeof(buf));
1458 hr = mil_scaler->lpVtbl->CopyPixels(mil_scaler, NULL, 3, sizeof(buf), buf);
1459 ok(hr == S_OK, "CopyPixels error %#x\n", hr);
1460 ok(buf[0] == 0 && buf[1] == 0 && buf[2] == 0 && buf[3] == 0xde,"wrong data: %02x %02x %02x %02x\n", buf[0], buf[1], buf[2], buf[3]);
1461
1462 mil_scaler->lpVtbl->Release(mil_scaler);
1463 IWICBitmapScaler_Release(scaler);
1464 mil_source->lpVtbl->Release(mil_source);
1465 mil_bitmap->lpVtbl->Release(mil_bitmap);
1466 IWICBitmap_Release(bitmap);
1467}
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
static LONG obj_refcount(void *obj)
Definition: bitmap.c:1317
@ WICBitmapCacheOnDemand
Definition: wincodec.idl:35

Referenced by START_TEST().

◆ test_WICCreateBitmapFromSectionEx()

static IWICBitmap **static void test_WICCreateBitmapFromSectionEx ( void  )
static

Definition at line 1093 of file bitmap.c.

1094{
1096 HANDLE hsection;
1098 void *bits;
1099 HBITMAP hdib;
1101 HRESULT hr;
1102 pWICCreateBitmapFromSectionEx =
1103 (void *)GetProcAddress(LoadLibraryA("windowscodecs"), "WICCreateBitmapFromSectionEx");
1104
1105 if (!pWICCreateBitmapFromSectionEx)
1106 {
1107 win_skip("WICCreateBitmapFromSectionEx not available\n");
1108 return;
1109 }
1110
1114 ok(hsection != NULL, "CreateFileMapping failed %u\n", GetLastError());
1115
1116 memset(&info, 0, sizeof(info));
1117 info.bmiHeader.biSize = sizeof(info.bmiHeader);
1118 info.bmiHeader.biWidth = 3;
1119 info.bmiHeader.biHeight = -3;
1120 info.bmiHeader.biBitCount = 24;
1121 info.bmiHeader.biPlanes = 1;
1122 info.bmiHeader.biCompression = BI_RGB;
1123
1124 hdib = CreateDIBSection(0, &info, DIB_RGB_COLORS, &bits, hsection, 0);
1125 ok(hdib != NULL, "CreateDIBSection failed\n");
1126
1127 hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0, 0,
1129 ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1130 IWICBitmap_Release(bitmap);
1131
1132 /* non-zero offset, smaller than allocation granularity */
1133 hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0, 0x100,
1135 ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1136 IWICBitmap_Release(bitmap);
1137
1138 /* offset larger than allocation granularity */
1139 hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0,
1142 ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1143 IWICBitmap_Release(bitmap);
1144 DeleteObject(hdib);
1145 CloseHandle(hsection);
1146}
#define CloseHandle
Definition: compat.h:739
#define GetProcAddress(x, y)
Definition: compat.h:753
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define CreateFileMappingW(a, b, c, d, e, f)
Definition: compat.h:744
SYSTEM_INFO sysinfo
Definition: dbghelp.c:76
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
VOID WINAPI GetSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
Definition: sysinfo.c:143
#define PAGE_READWRITE
Definition: nt_native.h:1304
#define win_skip
Definition: test.h:160
DWORD dwAllocationGranularity
Definition: winbase.h:1179
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
@ WICSectionAccessLevelReadWrite
Definition: wincodec.idl:192

Referenced by START_TEST().

Variable Documentation

◆ bitmapsource

IWICBitmapSource bitmapsource = { &sourcevtbl }
static

Definition at line 172 of file bitmap.c.

Referenced by test_clipper(), and test_createbitmapfromsource().

◆ called_CopyPixels

BOOL called_CopyPixels
static

Definition at line 151 of file bitmap.c.

Referenced by bitmapsource_CopyPixels(), and test_clipper().

◆ factory

Definition at line 98 of file bitmap.c.

◆ g_rect

WICRect g_rect
static

Definition at line 150 of file bitmap.c.

Referenced by bitmapsource_CopyPixels(), and test_clipper().

◆ HANDLE

Definition at line 1091 of file bitmap.c.

◆ REFWICPixelFormatGUID

Definition at line 1091 of file bitmap.c.

◆ sourcevtbl

const IWICBitmapSourceVtbl sourcevtbl
static
Initial value:
= {
}
static HRESULT WINAPI bitmapsource_QueryInterface(IWICBitmapSource *iface, REFIID iid, void **ppv)
Definition: bitmap.c:100
static HRESULT WINAPI bitmapsource_CopyPalette(IWICBitmapSource *iface, IWICPalette *palette)
Definition: bitmap.c:144
static HRESULT WINAPI bitmapsource_GetPixelFormat(IWICBitmapSource *iface, WICPixelFormatGUID *format)
Definition: bitmap.c:132
static ULONG WINAPI bitmapsource_AddRef(IWICBitmapSource *iface)
Definition: bitmap.c:116
static HRESULT WINAPI bitmapsource_GetSize(IWICBitmapSource *iface, UINT *width, UINT *height)
Definition: bitmap.c:126
static HRESULT WINAPI bitmapsource_GetResolution(IWICBitmapSource *iface, double *dpiX, double *dpiY)
Definition: bitmap.c:138
static ULONG WINAPI bitmapsource_Release(IWICBitmapSource *iface)
Definition: bitmap.c:121
static HRESULT WINAPI bitmapsource_CopyPixels(IWICBitmapSource *iface, const WICRect *rc, UINT stride, UINT buffer_size, BYTE *buffer)
Definition: bitmap.c:153

Definition at line 161 of file bitmap.c.

◆ UINT

Definition at line 1091 of file bitmap.c.

Referenced by DECLARE_INTERFACE_().

◆ WICSectionAccessLevel

Definition at line 1091 of file bitmap.c.