ReactOS  0.4.15-dev-1384-g878186b
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
static BOOL called_CopyPixels
Definition: bitmap.c:151
static WICRect g_rect
Definition: bitmap.c:150
#define S_OK
Definition: intsafe.h:51

◆ 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 }
#define E_NOTIMPL
Definition: ddrawi.h:99

◆ 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 }
#define E_NOTIMPL
Definition: ddrawi.h:99

◆ 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 width
Definition: gl.h:1546
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define S_OK
Definition: intsafe.h:51

◆ 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 }
#define E_NOINTERFACE
Definition: winerror.h:2364
REFIID LPVOID * ppv
Definition: atlbase.h:39
const GUID IID_IUnknown
#define S_OK
Definition: intsafe.h:51
#define NULL
Definition: types.h:112
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95

◆ 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 
202  bmi->bmiHeader.biClrUsed = pal->palNumEntries;
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 }
GLint GLint GLsizei width
Definition: gl.h:1546
BITMAPINFOHEADER bmiHeader
Definition: wingdi.h:1475
DWORD biClrImportant
Definition: amvideo.idl:40
#define assert(x)
Definition: debug.h:53
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
DWORD biCompression
Definition: amvideo.idl:35
ULONG RGBQUAD
Definition: precomp.h:50
RGBQUAD bmiColors[1]
Definition: wingdi.h:1476
unsigned short WORD
Definition: ntddk_ex.h:93
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
int WINAPI GetObjectW(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
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
HBITMAP WINAPI CreateDIBSection(HDC hDC, CONST BITMAPINFO *BitmapInfo, UINT Usage, VOID **Bits, HANDLE hSection, DWORD dwOffset)
Definition: bitmap.c:197
#define ok(value,...)
Definition: atltest.h:57
Definition: bl.h:1331
#define NULL
Definition: types.h:112
DWORD bpp
Definition: surface.c:182
WORD palNumEntries
Definition: wingdi.h:1833
static HBITMAP
Definition: button.c:44
#define DIB_RGB_COLORS
Definition: wingdi.h:366
#define memset(x, y, z)
Definition: compat.h:39
#define BI_RGB
Definition: precomp.h:47
struct tagBITMAPINFO BITMAPINFO

Referenced by test_CreateBitmapFromHBITMAP().

◆ DECLARE_INTERFACE_() [1/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 REFIID
Definition: guiddef.h:118
#define THIS_
Definition: basetyps.h:65
int WINAPI GetPixelFormat(_In_ HDC)
#define THIS
Definition: basetyps.h:66
static HRESULT QueryInterface(REFIID, void **)
Definition: events.c:2587
DWORD WINAPI GetSize(LPVOID)
LONG HRESULT
Definition: typedefs.h:79
static UINT
Definition: bitmap.c:1091
unsigned char BYTE
Definition: xxhash.c:193
_In_ BOOLEAN Release
Definition: cdrom.h:920
#define PURE
Definition: basetyps.h:64
unsigned int UINT
Definition: ndis.h:50
static ULONG WINAPI AddRef(IStream *iface)
Definition: clist.c:90
unsigned int ULONG
Definition: retypes.h:1
#define STDMETHOD_(t, m)
Definition: basetyps.h:63

◆ DECLARE_INTERFACE_() [2/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;
74  STDMETHOD_(HRESULT,SetPalette)(THIS_ IWICPalette *) PURE;
76  STDMETHOD_(HRESULT,AddDirtyRect)(THIS_ const WICRect *) PURE;
77 };
#define REFIID
Definition: guiddef.h:118
#define THIS_
Definition: basetyps.h:65
static DWORD(WINAPI *pSetLayout)(HDC hdc
int WINAPI GetPixelFormat(_In_ HDC)
#define THIS
Definition: basetyps.h:66
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
DWORD WINAPI GetSize(LPVOID)
LONG HRESULT
Definition: typedefs.h:79
static UINT
Definition: bitmap.c:1091
unsigned char BYTE
Definition: xxhash.c:193
_In_ BOOLEAN SetResolution
Definition: exfuncs.h:1078
_In_ BOOLEAN Release
Definition: cdrom.h:920
#define PURE
Definition: basetyps.h:64
unsigned int UINT
Definition: ndis.h:50
static ULONG WINAPI AddRef(IStream *iface)
Definition: clist.c:90
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124
unsigned int ULONG
Definition: retypes.h:1
#define STDMETHOD_(t, m)
Definition: basetyps.h:63

◆ DECLARE_INTERFACE_() [3/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 };
#define REFIID
Definition: guiddef.h:118
#define THIS_
Definition: basetyps.h:65
int WINAPI GetPixelFormat(_In_ HDC)
#define THIS
Definition: basetyps.h:66
static HRESULT QueryInterface(REFIID, void **)
Definition: events.c:2587
DWORD WINAPI GetSize(LPVOID)
LONG HRESULT
Definition: typedefs.h:79
static UINT
Definition: bitmap.c:1091
WICBitmapInterpolationMode
Definition: wincodec.idl:76
unsigned char BYTE
Definition: xxhash.c:193
_In_ BOOLEAN Release
Definition: cdrom.h:920
BOOL Initialize(HINSTANCE hInstance)
Definition: msconfig.c:341
#define PURE
Definition: basetyps.h:64
unsigned int UINT
Definition: ndis.h:50
static ULONG WINAPI AddRef(IStream *iface)
Definition: clist.c:90
unsigned int ULONG
Definition: retypes.h:1
#define STDMETHOD_(t, m)
Definition: basetyps.h:63

◆ DEFINE_GUID() [1/7]

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

◆ DEFINE_GUID() [2/7]

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

◆ DEFINE_GUID() [3/7]

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

◆ DEFINE_GUID() [4/7]

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

◆ DEFINE_GUID() [5/7]

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

◆ DEFINE_GUID() [6/7]

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

◆ DEFINE_GUID() [7/7]

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

◆ 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 
1479  test_IMILBitmap();
1485  test_clipper();
1487 
1488  IWICImagingFactory_Release(factory);
1489 
1490  CoUninitialize();
1491 
1493 }
static void test_createbitmap(void)
Definition: bitmap.c:219
HRESULT hr
Definition: shlfolder.c:183
static void test_CreateBitmapFromHICON(void)
Definition: bitmap.c:734
static void test_CreateBitmapFromMemory(void)
Definition: bitmap.c:659
static void test_bitmap_scaler(void)
Definition: bitmap.c:1148
Definition: main.c:438
static void test_CreateBitmapFromHBITMAP(void)
Definition: bitmap.c:809
if SUCCEEDED(hr)
static void test_createbitmapfromsource(void)
Definition: bitmap.c:455
LONG HRESULT
Definition: typedefs.h:79
static void test_clipper(void)
Definition: bitmap.c:984
static void test_IMILBitmap(void)
Definition: bitmap.c:1323
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
#define ok(value,...)
Definition: atltest.h:57
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
Definition: compobj.c:2002
#define NULL
Definition: types.h:112
static IWICBitmap **static void test_WICCreateBitmapFromSectionEx(void)
Definition: bitmap.c:1093

◆ 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;
1154  IWICBitmap *bitmap;
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 }
GLint GLint GLsizei width
Definition: gl.h:1546
HRESULT hr
Definition: shlfolder.c:183
const char * wine_dbgstr_guid(const GUID *guid)
#define WINCODEC_ERR_NOTINITIALIZED
Definition: winerror.h:3277
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
Definition: main.c:438
#define E_INVALIDARG
Definition: ddrawi.h:101
#define WINCODEC_ERR_PALETTEUNAVAILABLE
Definition: winerror.h:3284
Definition: uimain.c:88
LONG HRESULT
Definition: typedefs.h:79
unsigned char BYTE
Definition: xxhash.c:193
static HPALETTE palette
Definition: clipboard.c:1345
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define WINCODEC_ERR_WRONGSTATE
Definition: winerror.h:3273
#define S_OK
Definition: intsafe.h:51
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
static HBITMAP bitmap
Definition: clipboard.c:1344
#define memset(x, y, z)
Definition: compat.h:39

Referenced by START_TEST().

◆ test_clipper()

static void test_clipper ( void  )
static

Definition at line 984 of file bitmap.c.

985 {
986  IWICBitmapClipper *clipper;
987  UINT height, width;
989  BYTE buffer[500];
990  WICRect rect;
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 }
GLint GLint GLsizei width
Definition: gl.h:1546
HRESULT hr
Definition: shlfolder.c:183
static IWICBitmapSource bitmapsource
Definition: bitmap.c:172
GLuint buffer
Definition: glext.h:5915
& rect
Definition: startmenu.cpp:1413
static BOOL called_CopyPixels
Definition: bitmap.c:151
#define FALSE
Definition: types.h:117
Definition: main.c:438
#define E_INVALIDARG
Definition: ddrawi.h:101
INT Height
Definition: wincodec.idl:239
Definition: uimain.c:88
LONG HRESULT
Definition: typedefs.h:79
static WICRect g_rect
Definition: bitmap.c:150
unsigned char BYTE
Definition: xxhash.c:193
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define S_OK
Definition: intsafe.h:51
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
INT Width
Definition: wincodec.idl:238
static HBITMAP bitmap
Definition: clipboard.c:1344
#define memset(x, y, z)
Definition: compat.h:39

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);
269  ok(palettetype == WICBitmapPaletteTypeFixedGray256,
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 }
GLint GLint GLsizei width
Definition: gl.h:1546
rwlock_t lock
Definition: tcpcore.h:1163
HRESULT hr
Definition: shlfolder.c:183
#define FALSE
Definition: types.h:117
Definition: main.c:438
if SUCCEEDED(hr)
#define E_INVALIDARG
Definition: ddrawi.h:101
#define WINCODEC_ERR_PALETTEUNAVAILABLE
Definition: winerror.h:3284
pixelformat
Definition: converter.c:40
INT Height
Definition: wincodec.idl:239
Definition: uimain.c:88
WICBitmapPaletteType
Definition: wincodec.idl:90
LONG HRESULT
Definition: typedefs.h:79
#define WINCODEC_ERR_ALREADYLOCKED
Definition: winerror.h:3278
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned char BYTE
Definition: xxhash.c:193
static HPALETTE palette
Definition: clipboard.c:1345
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define broken(x)
Definition: _sntprintf.h:21
#define S_OK
Definition: intsafe.h:51
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
static void lock_buffer(struct buffer_head *bh)
Definition: module.h:1018
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
INT Width
Definition: wincodec.idl:238
static HBITMAP bitmap
Definition: clipboard.c:1344

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;
818  HBITMAP hbmp;
819  HPALETTE hpal;
820  BYTE data[12];
821  HRESULT hr;
823  UINT width, height, i, count;
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);
872 todo_wine
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);
892 todo_wine
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 }
GLint GLint GLsizei width
Definition: gl.h:1546
HRESULT hr
Definition: shlfolder.c:183
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define WINCODEC_ERR_WIN32ERROR
Definition: winerror.h:3311
const char * wine_dbgstr_guid(const GUID *guid)
BOOL WINAPI DeleteObject(_In_ HGDIOBJ)
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
WORD palVersion
Definition: wingdi.h:1832
Definition: main.c:438
#define E_INVALIDARG
Definition: ddrawi.h:101
HBITMAP hbmp
#define todo_wine_if(is_todo)
Definition: test.h:163
Definition: uimain.c:88
WICBitmapPaletteType
Definition: wincodec.idl:90
LONG HRESULT
Definition: typedefs.h:79
HPALETTE WINAPI CreatePalette(_In_reads_(_Inexpressible_(2 *sizeof(WORD)+plpal->palNumEntries *sizeof(PALETTEENTRY))) const LOGPALETTE *)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define todo_wine
Definition: test.h:162
static HBITMAP create_dib(int width, int height, int bpp, LOGPALETTE *pal, const void *data)
Definition: bitmap.c:174
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned char BYTE
Definition: xxhash.c:193
static HPALETTE palette
Definition: clipboard.c:1345
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define S_OK
Definition: intsafe.h:51
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 ok(value,...)
Definition: atltest.h:57
struct tagLOGPALETTE LOGPALETTE
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
static HBITMAP bitmap
Definition: clipboard.c:1344
WORD palNumEntries
Definition: wingdi.h:1833
static HBITMAP
Definition: button.c:44
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define memset(x, y, z)
Definition: compat.h:39

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;
738  ICONINFO info;
739  HRESULT hr;
741  UINT width, height;
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 }
GLint GLint GLsizei width
Definition: gl.h:1546
#define ERROR_INVALID_CURSOR_HANDLE
Definition: winerror.h:883
static HICON
Definition: imagelist.c:84
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
HRESULT hr
Definition: shlfolder.c:183
BOOL WINAPI DestroyIcon(_In_ HICON)
Definition: cursoricon.c:2022
HBITMAP WINAPI CreateBitmap(INT Width, INT Height, UINT Planes, UINT BitsPixel, CONST VOID *pUnsafeBits)
Definition: bitmap.c:252
const char * wine_dbgstr_guid(const GUID *guid)
BOOL WINAPI DeleteObject(_In_ HGDIOBJ)
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
Definition: main.c:438
#define E_INVALIDARG
Definition: ddrawi.h:101
Definition: uimain.c:88
LONG HRESULT
Definition: typedefs.h:79
HICON WINAPI CreateIconIndirect(_In_ PICONINFO)
Definition: cursoricon.c:2546
struct _test_info info[]
Definition: SetCursorPos.c:19
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define S_OK
Definition: intsafe.h:51
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
static HBITMAP bitmap
Definition: clipboard.c:1344

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 }
GLint GLint GLsizei width
Definition: gl.h:1546
HRESULT hr
Definition: shlfolder.c:183
Definition: main.c:438
#define E_INVALIDARG
Definition: ddrawi.h:101
Definition: uimain.c:88
LONG HRESULT
Definition: typedefs.h:79
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned char BYTE
Definition: xxhash.c:193
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define S_OK
Definition: intsafe.h:51
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 ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
static HBITMAP bitmap
Definition: clipboard.c:1344
#define WINCODEC_ERR_INSUFFICIENTBUFFER
Definition: winerror.h:3303
#define memset(x, y, z)
Definition: compat.h:39

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 }
GLint GLint GLsizei width
Definition: gl.h:1546
rwlock_t lock
Definition: tcpcore.h:1163
HRESULT hr
Definition: shlfolder.c:183
GLuint GLuint GLsizei count
Definition: gl.h:1545
static IWICBitmapSource bitmapsource
Definition: bitmap.c:172
#define FALSE
Definition: types.h:117
Definition: main.c:438
if SUCCEEDED(hr)
#define E_INVALIDARG
Definition: ddrawi.h:101
#define WINCODEC_ERR_PALETTEUNAVAILABLE
Definition: winerror.h:3284
pixelformat
Definition: converter.c:40
INT Height
Definition: wincodec.idl:239
Definition: uimain.c:88
WICBitmapPaletteType
Definition: wincodec.idl:90
LONG HRESULT
Definition: typedefs.h:79
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned char BYTE
Definition: xxhash.c:193
static HPALETTE palette
Definition: clipboard.c:1345
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define S_OK
Definition: intsafe.h:51
WICBitmapPaletteType palette_type
Definition: image.c:53
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
static void lock_buffer(struct buffer_head *bh)
Definition: module.h:1018
#define ok(value,...)
Definition: atltest.h:57
#define E_NOTIMPL
Definition: ddrawi.h:99
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
INT Width
Definition: wincodec.idl:238
static HBITMAP bitmap
Definition: clipboard.c:1344
static HBITMAP bitmap2
Definition: clipboard.c:1344

Referenced by START_TEST().

◆ test_IMILBitmap()

static void test_IMILBitmap ( void  )
static

Definition at line 1323 of file bitmap.c.

1324 {
1325  HRESULT hr;
1326  IWICBitmap *bitmap;
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 }
GLint GLint GLsizei width
Definition: gl.h:1546
HRESULT hr
Definition: shlfolder.c:183
const char * wine_dbgstr_guid(const GUID *guid)
#define WINCODEC_ERR_NOTINITIALIZED
Definition: winerror.h:3277
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
Definition: main.c:438
Definition: uimain.c:88
LONG HRESULT
Definition: typedefs.h:79
const GUID IID_IUnknown
unsigned char BYTE
Definition: xxhash.c:193
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define S_OK
Definition: intsafe.h:51
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
static LONG obj_refcount(void *obj)
Definition: bitmap.c:1317
static HBITMAP bitmap
Definition: clipboard.c:1344
#define memset(x, y, z)
Definition: compat.h:39

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;
1097  BITMAPINFO info;
1098  void *bits;
1099  HBITMAP hdib;
1100  IWICBitmap *bitmap;
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:598
HRESULT hr
Definition: shlfolder.c:183
DWORD dwAllocationGranularity
Definition: winbase.h:1145
#define INVALID_HANDLE_VALUE
Definition: compat.h:590
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
BOOL WINAPI DeleteObject(_In_ HGDIOBJ)
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
Definition: uimain.c:88
LONG HRESULT
Definition: typedefs.h:79
#define CreateFileMappingW(a, b, c, d, e, f)
Definition: compat.h:603
SYSTEM_INFO sysinfo
Definition: dbghelp.c:76
struct _test_info info[]
Definition: SetCursorPos.c:19
#define S_OK
Definition: intsafe.h:51
HBITMAP WINAPI CreateDIBSection(HDC hDC, CONST BITMAPINFO *BitmapInfo, UINT Usage, VOID **Bits, HANDLE hSection, DWORD dwOffset)
Definition: bitmap.c:197
#define ok(value,...)
Definition: atltest.h:57
VOID WINAPI GetSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
Definition: sysinfo.c:142
#define NULL
Definition: types.h:112
#define GetProcAddress(x, y)
Definition: compat.h:612
static HBITMAP bitmap
Definition: clipboard.c:1344
static HBITMAP
Definition: button.c:44
#define DIB_RGB_COLORS
Definition: wingdi.h:366
#define memset(x, y, z)
Definition: compat.h:39
#define win_skip
Definition: test.h:149
#define BI_RGB
Definition: precomp.h:47
#define PAGE_READWRITE
Definition: nt_native.h:1304

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 96 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_GetSize(IWICBitmapSource *iface, UINT *width, UINT *height)
Definition: bitmap.c:126
static ULONG WINAPI bitmapsource_AddRef(IWICBitmapSource *iface)
Definition: bitmap.c:116
static HRESULT WINAPI bitmapsource_CopyPixels(IWICBitmapSource *iface, const WICRect *rc, UINT stride, UINT buffer_size, BYTE *buffer)
Definition: bitmap.c:153
static HRESULT WINAPI bitmapsource_QueryInterface(IWICBitmapSource *iface, REFIID iid, void **ppv)
Definition: bitmap.c:100
static HRESULT WINAPI bitmapsource_GetPixelFormat(IWICBitmapSource *iface, WICPixelFormatGUID *format)
Definition: bitmap.c:132
static ULONG WINAPI bitmapsource_Release(IWICBitmapSource *iface)
Definition: bitmap.c:121
static HRESULT WINAPI bitmapsource_GetResolution(IWICBitmapSource *iface, double *dpiX, double *dpiY)
Definition: bitmap.c:138
static HRESULT WINAPI bitmapsource_CopyPalette(IWICBitmapSource *iface, IWICPalette *palette)
Definition: bitmap.c:144

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.