ReactOS  0.4.15-dev-2355-gaf9df93
surface.c File Reference
#include <assert.h>
#include "wine/test.h"
#include "d3dx9tex.h"
#include "resources.h"
Include dependency graph for surface.c:

Go to the source code of this file.

Classes

struct  dds_pixel_format
 
struct  dds_header
 

Macros

#define COBJMACROS
 
#define check_release(obj, exp)   _check_release(__LINE__, obj, exp)
 
#define DDS_CAPS   0x00000001
 
#define DDS_HEIGHT   0x00000002
 
#define DDS_WIDTH   0x00000004
 
#define DDS_PITCH   0x00000008
 
#define DDS_PIXELFORMAT   0x00001000
 
#define DDS_MIPMAPCOUNT   0x00020000
 
#define DDS_LINEARSIZE   0x00080000
 
#define DDSCAPS_ALPHA   0x00000002
 
#define DDS_CAPS_TEXTURE   0x00001000
 
#define DDS_PF_ALPHA   0x00000001
 
#define DDS_PF_ALPHA_ONLY   0x00000002
 
#define DDS_PF_FOURCC   0x00000004
 
#define DDS_PF_RGB   0x00000040
 
#define DDS_PF_LUMINANCE   0x00020000
 
#define DDS_PF_BUMPLUMINANCE   0x00040000
 
#define DDS_PF_BUMPDUDV   0x00080000
 
#define check_dds_pixel_format(flags, fourcc, bpp, rmask, gmask, bmask, amask, format)   check_dds_pixel_format_(__LINE__, flags, fourcc, bpp, rmask, gmask, bmask, amask, format)
 
#define check_pixel_2bpp(lockrect, x, y, color)   _check_pixel_2bpp(__LINE__, lockrect, x, y, color)
 
#define check_pixel_4bpp(lockrect, x, y, color)   _check_pixel_4bpp(__LINE__, lockrect, x, y, color)
 

Functions

static void _check_release (unsigned int line, IUnknown *obj, int exp)
 
static HRESULT create_file (const char *filename, const unsigned char *data, const unsigned int size)
 
static void fill_dds_header (struct dds_header *header)
 
static void check_dds_pixel_format_ (unsigned int line, DWORD flags, DWORD fourcc, DWORD bpp, DWORD rmask, DWORD gmask, DWORD bmask, DWORD amask, D3DFORMAT expected_format)
 
static void test_dds_header_handling (void)
 
static void test_D3DXGetImageInfo (void)
 
static void _check_pixel_2bpp (unsigned int line, const D3DLOCKED_RECT *lockrect, int x, int y, WORD expected_color)
 
static void _check_pixel_4bpp (unsigned int line, const D3DLOCKED_RECT *lockrect, int x, int y, DWORD expected_color)
 
static void test_D3DXLoadSurface (IDirect3DDevice9 *device)
 
static void test_D3DXSaveSurfaceToFileInMemory (IDirect3DDevice9 *device)
 
static void test_D3DXSaveSurfaceToFile (IDirect3DDevice9 *device)
 
 START_TEST (surface)
 

Variables

static const unsigned char bmp_1bpp []
 
static const unsigned char bmp_2bpp []
 
static const unsigned char bmp_4bpp []
 
static const unsigned char bmp_8bpp []
 
static const unsigned char bmp_32bpp_xrgb []
 
static const unsigned char bmp_32bpp_argb []
 
static const unsigned char png_grayscale []
 
static const unsigned char pixdata []
 
static const unsigned char noimage [4]
 
static const unsigned char dds_8bit []
 
static const unsigned char dds_24bit []
 
static const unsigned char dds_16bit []
 
static const unsigned char dds_cube_map []
 
static const unsigned char dds_volume_map []
 
static const BYTE dds_dxt5 []
 
static const BYTE dds_dxt5_8_8 []
 

Macro Definition Documentation

◆ check_dds_pixel_format

#define check_dds_pixel_format (   flags,
  fourcc,
  bpp,
  rmask,
  gmask,
  bmask,
  amask,
  format 
)    check_dds_pixel_format_(__LINE__, flags, fourcc, bpp, rmask, gmask, bmask, amask, format)

Definition at line 373 of file surface.c.

◆ check_pixel_2bpp

#define check_pixel_2bpp (   lockrect,
  x,
  y,
  color 
)    _check_pixel_2bpp(__LINE__, lockrect, x, y, color)

Definition at line 821 of file surface.c.

◆ check_pixel_4bpp

#define check_pixel_4bpp (   lockrect,
  x,
  y,
  color 
)    _check_pixel_4bpp(__LINE__, lockrect, x, y, color)

Definition at line 828 of file surface.c.

◆ check_release

#define check_release (   obj,
  exp 
)    _check_release(__LINE__, obj, exp)

Definition at line 27 of file surface.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 21 of file surface.c.

◆ DDS_CAPS

#define DDS_CAPS   0x00000001

Definition at line 301 of file surface.c.

◆ DDS_CAPS_TEXTURE

#define DDS_CAPS_TEXTURE   0x00001000

Definition at line 311 of file surface.c.

◆ DDS_HEIGHT

#define DDS_HEIGHT   0x00000002

Definition at line 302 of file surface.c.

◆ DDS_LINEARSIZE

#define DDS_LINEARSIZE   0x00080000

Definition at line 307 of file surface.c.

◆ DDS_MIPMAPCOUNT

#define DDS_MIPMAPCOUNT   0x00020000

Definition at line 306 of file surface.c.

◆ DDS_PF_ALPHA

#define DDS_PF_ALPHA   0x00000001

Definition at line 314 of file surface.c.

◆ DDS_PF_ALPHA_ONLY

#define DDS_PF_ALPHA_ONLY   0x00000002

Definition at line 315 of file surface.c.

◆ DDS_PF_BUMPDUDV

#define DDS_PF_BUMPDUDV   0x00080000

Definition at line 320 of file surface.c.

◆ DDS_PF_BUMPLUMINANCE

#define DDS_PF_BUMPLUMINANCE   0x00040000

Definition at line 319 of file surface.c.

◆ DDS_PF_FOURCC

#define DDS_PF_FOURCC   0x00000004

Definition at line 316 of file surface.c.

◆ DDS_PF_LUMINANCE

#define DDS_PF_LUMINANCE   0x00020000

Definition at line 318 of file surface.c.

◆ DDS_PF_RGB

#define DDS_PF_RGB   0x00000040

Definition at line 317 of file surface.c.

◆ DDS_PITCH

#define DDS_PITCH   0x00000008

Definition at line 304 of file surface.c.

◆ DDS_PIXELFORMAT

#define DDS_PIXELFORMAT   0x00001000

Definition at line 305 of file surface.c.

◆ DDS_WIDTH

#define DDS_WIDTH   0x00000004

Definition at line 303 of file surface.c.

◆ DDSCAPS_ALPHA

#define DDSCAPS_ALPHA   0x00000002

Definition at line 310 of file surface.c.

Function Documentation

◆ _check_pixel_2bpp()

static void _check_pixel_2bpp ( unsigned int  line,
const D3DLOCKED_RECT lockrect,
int  x,
int  y,
WORD  expected_color 
)
inlinestatic

Definition at line 822 of file surface.c.

823 {
824  WORD color = ((WORD*)lockrect->pBits)[x + y * lockrect->Pitch / 2];
825  ok_(__FILE__, line)(color == expected_color, "Got color 0x%04x, expected 0x%04x\n", color, expected_color);
826 }
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLuint color
Definition: glext.h:6243
Definition: parser.c:48
unsigned short WORD
Definition: ntddk_ex.h:93
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define ok_(x1, x2)
Definition: atltest.h:61

◆ _check_pixel_4bpp()

static void _check_pixel_4bpp ( unsigned int  line,
const D3DLOCKED_RECT lockrect,
int  x,
int  y,
DWORD  expected_color 
)
inlinestatic

Definition at line 829 of file surface.c.

830 {
831  DWORD color = ((DWORD*)lockrect->pBits)[x + y * lockrect->Pitch / 4];
832  ok_(__FILE__, line)(color == expected_color, "Got color 0x%08x, expected 0x%08x\n", color, expected_color);
833 }
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLuint color
Definition: glext.h:6243
Definition: parser.c:48
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define ok_(x1, x2)
Definition: atltest.h:61

◆ _check_release()

static void _check_release ( unsigned int  line,
IUnknown obj,
int  exp 
)
inlinestatic

Definition at line 28 of file surface.c.

29 {
30  int ref = IUnknown_Release(obj);
31  ok_(__FILE__, line)(ref == exp, "Invalid refcount. Expected %d, got %d\n", exp, ref);
32 }
Definition: send.c:48
GLenum GLint ref
Definition: glext.h:6028
Definition: parser.c:48
DWORD exp
Definition: msg.c:16033
#define ok_(x1, x2)
Definition: atltest.h:61

◆ check_dds_pixel_format_()

static void check_dds_pixel_format_ ( unsigned int  line,
DWORD  flags,
DWORD  fourcc,
DWORD  bpp,
DWORD  rmask,
DWORD  gmask,
DWORD  bmask,
DWORD  amask,
D3DFORMAT  expected_format 
)
static

Definition at line 375 of file surface.c.

379 {
380  HRESULT hr;
382  struct
383  {
384  DWORD magic;
385  struct dds_header header;
386  BYTE data[256];
387  } dds;
388 
389  dds.magic = MAKEFOURCC('D','D','S',' ');
390  fill_dds_header(&dds.header);
391  dds.header.pixel_format.flags = flags;
392  dds.header.pixel_format.fourcc = fourcc;
393  dds.header.pixel_format.bpp = bpp;
394  dds.header.pixel_format.rmask = rmask;
395  dds.header.pixel_format.gmask = gmask;
396  dds.header.pixel_format.bmask = bmask;
397  dds.header.pixel_format.amask = amask;
398  memset(dds.data, 0, sizeof(dds.data));
399 
400  hr = D3DXGetImageInfoFromFileInMemory(&dds, sizeof(dds), &info);
401  ok_(__FILE__, line)(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x for pixel format %#x, expected %#x\n",
402  hr, expected_format, D3D_OK);
403  if (SUCCEEDED(hr))
404  {
405  ok_(__FILE__, line)(info.Format == expected_format, "D3DXGetImageInfoFromFileInMemory returned format %#x, expected %#x\n",
406  info.Format, expected_format);
407  }
408 }
DWORD amask
Definition: surface.c:189
DWORD bmask
Definition: surface.c:188
HRESULT hr
Definition: shlfolder.c:183
u32_t magic(void)
static void fill_dds_header(struct dds_header *header)
Definition: surface.c:353
if SUCCEEDED(hr)
DWORD gmask
Definition: surface.c:187
Definition: parser.c:48
LONG HRESULT
Definition: typedefs.h:79
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLbitfield flags
Definition: glext.h:7161
struct _test_info info[]
Definition: SetCursorPos.c:19
unsigned char BYTE
Definition: xxhash.c:193
#define D3D_OK
Definition: d3d.h:106
HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(const void *data, UINT datasize, D3DXIMAGE_INFO *info)
Definition: surface.c:985
DWORD bpp
Definition: surface.c:185
DWORD rmask
Definition: surface.c:186
#define memset(x, y, z)
Definition: compat.h:39
#define MAKEFOURCC(ch0, ch1, ch2, ch3)
Definition: dmdls.h:24
#define ok_(x1, x2)
Definition: atltest.h:61

◆ create_file()

static HRESULT create_file ( const char filename,
const unsigned char data,
const unsigned int  size 
)
static

Definition at line 282 of file surface.c.

283 {
284  DWORD received;
285  HANDLE hfile;
286 
289 
290  if(WriteFile(hfile, data, size, &received, NULL))
291  {
292  CloseHandle(hfile);
293  return D3D_OK;
294  }
295 
296  CloseHandle(hfile);
297  return D3DERR_INVALIDCALL;
298 }
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
#define CloseHandle
Definition: compat.h:598
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
r received
Definition: btrfs.c:2939
#define D3DERR_INVALIDCALL
#define INVALID_HANDLE_VALUE
Definition: compat.h:590
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
const char * filename
Definition: ioapi.h:135
#define GENERIC_WRITE
Definition: nt_native.h:90
GLsizeiptr size
Definition: glext.h:5919
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define CREATE_ALWAYS
Definition: disk.h:72
#define D3D_OK
Definition: d3d.h:106
#define NULL
Definition: types.h:112
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:599

Referenced by test_D3DXGetImageInfo(), and test_D3DXLoadSurface().

◆ fill_dds_header()

static void fill_dds_header ( struct dds_header header)
static

Definition at line 353 of file surface.c.

354 {
355  memset(header, 0, sizeof(*header));
356 
357  header->size = sizeof(*header);
359  header->height = 4;
360  header->width = 4;
361  header->pixel_format.size = sizeof(header->pixel_format);
362  /* X8R8G8B8 */
363  header->pixel_format.flags = DDS_PF_RGB;
364  header->pixel_format.fourcc = 0;
365  header->pixel_format.bpp = 32;
366  header->pixel_format.rmask = 0xff0000;
367  header->pixel_format.gmask = 0x00ff00;
368  header->pixel_format.bmask = 0x0000ff;
369  header->pixel_format.amask = 0;
370  header->caps = DDS_CAPS_TEXTURE;
371 }
#define DDS_PF_RGB
Definition: surface.c:317
#define DDS_HEIGHT
Definition: surface.c:302
#define DDS_CAPS_TEXTURE
Definition: surface.c:311
#define DDS_WIDTH
Definition: surface.c:303
#define DDS_CAPS
Definition: surface.c:301
#define memset(x, y, z)
Definition: compat.h:39
#define DDS_PIXELFORMAT
Definition: surface.c:305

Referenced by check_dds_pixel_format_(), and test_dds_header_handling().

◆ START_TEST()

START_TEST ( surface  )

Definition at line 1756 of file surface.c.

1757 {
1758  HWND wnd;
1759  IDirect3D9 *d3d;
1760  IDirect3DDevice9 *device;
1761  D3DPRESENT_PARAMETERS d3dpp;
1762  HRESULT hr;
1763 
1764  if (!(wnd = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
1765  640, 480, NULL, NULL, NULL, NULL)))
1766  {
1767  skip("Couldn't create application window\n");
1768  return;
1769  }
1771  if (!d3d) {
1772  skip("Couldn't create IDirect3D9 object\n");
1773  DestroyWindow(wnd);
1774  return;
1775  }
1776 
1777  ZeroMemory(&d3dpp, sizeof(d3dpp));
1778  d3dpp.Windowed = TRUE;
1781  if(FAILED(hr)) {
1782  skip("Failed to create IDirect3DDevice9 object %#x\n", hr);
1783  IDirect3D9_Release(d3d);
1784  DestroyWindow(wnd);
1785  return;
1786  }
1787 
1792 
1794  check_release((IUnknown*)d3d, 0);
1795  DestroyWindow(wnd);
1796 }
#define IDirect3D9_CreateDevice(p, a, b, c, d, e, f)
Definition: d3d9.h:235
#define D3DADAPTER_DEFAULT
Definition: d3d8.h:57
#define D3DCREATE_SOFTWARE_VERTEXPROCESSING
Definition: d3d8.h:44
HRESULT hr
Definition: shlfolder.c:183
static void test_D3DXGetImageInfo(void)
Definition: surface.c:561
#define TRUE
Definition: types.h:120
static void test_D3DXLoadSurface(IDirect3DDevice9 *device)
Definition: surface.c:835
#define ZeroMemory
Definition: winbase.h:1664
BOOL WINAPI DestroyWindow(_In_ HWND)
IDirect3D9 *WINAPI Direct3DCreate9(UINT SDKVersion)
Definition: d3d9.c:57
FxDevice * device
#define IDirect3D9_Release(p)
Definition: d3d9.h:220
Definition: devices.h:37
#define CreateWindowA(a, b, c, d, e, f, g, h, i, j, k)
Definition: winuser.h:4290
#define D3D_SDK_VERSION
Definition: d3d8.h:56
LONG HRESULT
Definition: typedefs.h:79
static void test_D3DXSaveSurfaceToFile(IDirect3DDevice9 *device)
Definition: surface.c:1630
static void test_D3DXSaveSurfaceToFileInMemory(IDirect3DDevice9 *device)
Definition: surface.c:1527
#define NULL
Definition: types.h:112
#define skip(...)
Definition: atltest.h:64
#define WS_OVERLAPPEDWINDOW
Definition: pedump.c:637
#define check_release(obj, exp)
Definition: surface.c:27
D3DSWAPEFFECT SwapEffect
Definition: d3d8types.h:1128

◆ test_D3DXGetImageInfo()

static void test_D3DXGetImageInfo ( void  )
static

Definition at line 561 of file surface.c.

562 {
563  HRESULT hr;
565  BOOL testdummy_ok, testbitmap_ok;
566 
567  hr = create_file("testdummy.bmp", noimage, sizeof(noimage)); /* invalid image */
568  testdummy_ok = SUCCEEDED(hr);
569 
570  hr = create_file("testbitmap.bmp", bmp_1bpp, sizeof(bmp_1bpp)); /* valid image */
571  testbitmap_ok = SUCCEEDED(hr);
572 
573  /* D3DXGetImageInfoFromFile */
574  if(testbitmap_ok) {
575  hr = D3DXGetImageInfoFromFileA("testbitmap.bmp", &info);
576  ok(hr == D3D_OK, "D3DXGetImageInfoFromFile returned %#x, expected %#x\n", hr, D3D_OK);
577 
578  hr = D3DXGetImageInfoFromFileA("testbitmap.bmp", NULL); /* valid image, second parameter is NULL */
579  ok(hr == D3D_OK, "D3DXGetImageInfoFromFile returned %#x, expected %#x\n", hr, D3D_OK);
580  } else skip("Couldn't create \"testbitmap.bmp\"\n");
581 
582  if(testdummy_ok) {
583  hr = D3DXGetImageInfoFromFileA("testdummy.bmp", NULL); /* invalid image, second parameter is NULL */
584  ok(hr == D3D_OK, "D3DXGetImageInfoFromFile returned %#x, expected %#x\n", hr, D3D_OK);
585 
586  hr = D3DXGetImageInfoFromFileA("testdummy.bmp", &info);
587  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFile returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
588  } else skip("Couldn't create \"testdummy.bmp\"\n");
589 
590  hr = D3DXGetImageInfoFromFileA("filedoesnotexist.bmp", &info);
591  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFile returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
592 
593  hr = D3DXGetImageInfoFromFileA("filedoesnotexist.bmp", NULL);
594  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFile returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
595 
597  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFile returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
598 
600  ok(hr == D3DERR_INVALIDCALL, "D3DXGetImageInfoFromFile returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
601 
603  ok(hr == D3DERR_INVALIDCALL, "D3DXGetImageInfoFromFile returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
604 
605 
606  /* D3DXGetImageInfoFromResource */
608  ok(hr == D3D_OK, "D3DXGetImageInfoFromResource returned %#x, expected %#x\n", hr, D3D_OK);
609 
611  ok(hr == D3D_OK, "D3DXGetImageInfoFromResource returned %#x, expected %#x\n", hr, D3D_OK);
612 
614  ok(hr == D3D_OK, "D3DXGetImageInfoFromResource returned %#x, expected %#x\n", hr, D3D_OK);
615 
617  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromResource returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
618 
620  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromResource returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
621 
622  hr = D3DXGetImageInfoFromResourceA(NULL, "resourcedoesnotexist", &info);
623  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromResource returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
624 
625  hr = D3DXGetImageInfoFromResourceA(NULL, "resourcedoesnotexist", NULL);
626  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromResource returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
627 
629  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromResource returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
630 
631 
632  /* D3DXGetImageInfoFromFileInMemory */
634  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
635 
636  hr = D3DXGetImageInfoFromFileInMemory(bmp_1bpp, sizeof(bmp_1bpp)+5, &info); /* too large size */
637  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
638 
640  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
641 
643  ok(hr == D3D_OK, "D3DXGetImageInfoFromResource returned %#x, expected %#x\n", hr, D3D_OK);
644 
646  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
647 
648  todo_wine {
650  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
651  }
652 
654  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
655 
657  ok(hr == D3DERR_INVALIDCALL, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
658 
660  ok(hr == D3DERR_INVALIDCALL, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
661 
663  ok(hr == D3DERR_INVALIDCALL, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
664 
666  ok(hr == D3DERR_INVALIDCALL, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
667 
669  ok(hr == D3DERR_INVALIDCALL, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
670 
672  ok(hr == D3DERR_INVALIDCALL, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
673 
675  ok(hr == D3DERR_INVALIDCALL, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
676 
678  ok(hr == D3DERR_INVALIDCALL, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
679 
680  /* test BMP support */
682  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
683  ok(info.Depth == 1, "Got depth %u, expected 1\n", info.Depth);
684  ok(info.Format == D3DFMT_P8, "Got format %u, expected %u\n", info.Format, D3DFMT_P8);
686  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
688  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
689  ok(info.Depth == 1, "Got depth %u, expected 1\n", info.Depth);
690  ok(info.Format == D3DFMT_P8, "Got format %u, expected %u\n", info.Format, D3DFMT_P8);
692  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
693  ok(info.Depth == 1, "Got depth %u, expected 1\n", info.Depth);
694  ok(info.Format == D3DFMT_P8, "Got format %u, expected %u\n", info.Format, D3DFMT_P8);
695 
697  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
698  ok(info.Format == D3DFMT_X8R8G8B8, "Got unexpected format %u.\n", info.Format);
700  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
701  ok(info.Format == D3DFMT_A8R8G8B8, "Got unexpected format %u.\n", info.Format);
702 
703  /* Grayscale PNG */
705  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
706  ok(info.Depth == 1, "Got depth %u, expected 1\n", info.Depth);
707  ok(info.Format == D3DFMT_L8, "Got format %u, expected %u\n", info.Format, D3DFMT_L8);
708 
709  /* test DDS support */
711  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
712  if (hr == D3D_OK) {
713  ok(info.Width == 2, "Got width %u, expected 2\n", info.Width);
714  ok(info.Height == 2, "Got height %u, expected 2\n", info.Height);
715  ok(info.Depth == 1, "Got depth %u, expected 1\n", info.Depth);
716  ok(info.MipLevels == 2, "Got miplevels %u, expected 2\n", info.MipLevels);
717  ok(info.Format == D3DFMT_R8G8B8, "Got format %#x, expected %#x\n", info.Format, D3DFMT_R8G8B8);
718  ok(info.ResourceType == D3DRTYPE_TEXTURE, "Got resource type %#x, expected %#x\n", info.ResourceType, D3DRTYPE_TEXTURE);
719  ok(info.ImageFileFormat == D3DXIFF_DDS, "Got image file format %#x, expected %#x\n", info.ImageFileFormat, D3DXIFF_DDS);
720  } else skip("Couldn't get image info from 24-bit DDS file in memory\n");
721 
723  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
724  if (hr == D3D_OK) {
725  ok(info.Width == 2, "Got width %u, expected 2\n", info.Width);
726  ok(info.Height == 2, "Got height %u, expected 2\n", info.Height);
727  ok(info.Depth == 1, "Got depth %u, expected 1\n", info.Depth);
728  ok(info.MipLevels == 1, "Got miplevels %u, expected 1\n", info.MipLevels);
729  ok(info.Format == D3DFMT_X1R5G5B5, "Got format %#x, expected %#x\n", info.Format, D3DFMT_X1R5G5B5);
730  ok(info.ResourceType == D3DRTYPE_TEXTURE, "Got resource type %#x, expected %#x\n", info.ResourceType, D3DRTYPE_TEXTURE);
731  ok(info.ImageFileFormat == D3DXIFF_DDS, "Got image file format %#x, expected %#x\n", info.ImageFileFormat, D3DXIFF_DDS);
732  } else skip("Couldn't get image info from 16-bit DDS file in memory\n");
733 
734  memset(&info, 0, sizeof(info));
736  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x\n", hr);
737  ok(info.Width == 16, "Got width %u.\n", info.Width);
738  ok(info.Height == 4, "Got height %u.\n", info.Height);
739  ok(info.Depth == 1, "Got depth %u.\n", info.Depth);
740  ok(info.MipLevels == 1, "Got miplevels %u.\n", info.MipLevels);
741  ok(info.Format == D3DFMT_P8, "Got format %#x.\n", info.Format);
742  ok(info.ResourceType == D3DRTYPE_TEXTURE, "Got resource type %#x.\n", info.ResourceType);
743  ok(info.ImageFileFormat == D3DXIFF_DDS, "Got image file format %#x.\n", info.ImageFileFormat);
744 
746  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
747  if (hr == D3D_OK) {
748  ok(info.Width == 4, "Got width %u, expected 4\n", info.Width);
749  ok(info.Height == 4, "Got height %u, expected 4\n", info.Height);
750  ok(info.Depth == 1, "Got depth %u, expected 1\n", info.Depth);
751  ok(info.MipLevels == 1, "Got miplevels %u, expected 1\n", info.MipLevels);
752  ok(info.Format == D3DFMT_DXT5, "Got format %#x, expected %#x\n", info.Format, D3DFMT_DXT5);
753  ok(info.ResourceType == D3DRTYPE_CUBETEXTURE, "Got resource type %#x, expected %#x\n", info.ResourceType, D3DRTYPE_CUBETEXTURE);
754  ok(info.ImageFileFormat == D3DXIFF_DDS, "Got image file format %#x, expected %#x\n", info.ImageFileFormat, D3DXIFF_DDS);
755  } else skip("Couldn't get image info from cube map in memory\n");
756 
758  ok(hr == D3D_OK, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
759  if (hr == D3D_OK) {
760  ok(info.Width == 4, "Got width %u, expected 4\n", info.Width);
761  ok(info.Height == 4, "Got height %u, expected 4\n", info.Height);
762  ok(info.Depth == 2, "Got depth %u, expected 2\n", info.Depth);
763  ok(info.MipLevels == 3, "Got miplevels %u, expected 3\n", info.MipLevels);
764  ok(info.Format == D3DFMT_DXT3, "Got format %#x, expected %#x\n", info.Format, D3DFMT_DXT3);
765  ok(info.ResourceType == D3DRTYPE_VOLUMETEXTURE, "Got resource type %#x, expected %#x\n", info.ResourceType, D3DRTYPE_VOLUMETEXTURE);
766  ok(info.ImageFileFormat == D3DXIFF_DDS, "Got image file format %#x, expected %#x\n", info.ImageFileFormat, D3DXIFF_DDS);
767  } else skip("Couldn't get image info from volume map in memory\n");
768 
778  check_dds_pixel_format(DDS_PF_RGB, 0, 16, 0xf800, 0x07e0, 0x001f, 0, D3DFMT_R5G6B5);
779  check_dds_pixel_format(DDS_PF_RGB | DDS_PF_ALPHA, 0, 16, 0x7c00, 0x03e0, 0x001f, 0x8000, D3DFMT_A1R5G5B5);
780  check_dds_pixel_format(DDS_PF_RGB | DDS_PF_ALPHA, 0, 16, 0x0f00, 0x00f0, 0x000f, 0xf000, D3DFMT_A4R4G4B4);
781  check_dds_pixel_format(DDS_PF_RGB, 0, 8, 0xe0, 0x1c, 0x03, 0, D3DFMT_R3G3B2);
782  check_dds_pixel_format(DDS_PF_ALPHA_ONLY, 0, 8, 0, 0, 0, 0xff, D3DFMT_A8);
783  check_dds_pixel_format(DDS_PF_RGB | DDS_PF_ALPHA, 0, 16, 0x00e0, 0x001c, 0x0003, 0xff00, D3DFMT_A8R3G3B2);
784  check_dds_pixel_format(DDS_PF_RGB, 0, 16, 0xf00, 0x0f0, 0x00f, 0, D3DFMT_X4R4G4B4);
785  check_dds_pixel_format(DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000, D3DFMT_A2B10G10R10);
786  check_dds_pixel_format(DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000, D3DFMT_A2R10G10B10);
787  check_dds_pixel_format(DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000, D3DFMT_A8R8G8B8);
788  check_dds_pixel_format(DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000, D3DFMT_A8B8G8R8);
789  check_dds_pixel_format(DDS_PF_RGB, 0, 32, 0xff0000, 0x00ff00, 0x0000ff, 0, D3DFMT_X8R8G8B8);
790  check_dds_pixel_format(DDS_PF_RGB, 0, 32, 0x0000ff, 0x00ff00, 0xff0000, 0, D3DFMT_X8B8G8R8);
791  check_dds_pixel_format(DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0, D3DFMT_R8G8B8);
792  check_dds_pixel_format(DDS_PF_RGB, 0, 32, 0x0000ffff, 0xffff0000, 0, 0, D3DFMT_G16R16);
793  check_dds_pixel_format(DDS_PF_LUMINANCE, 0, 8, 0xff, 0, 0, 0, D3DFMT_L8);
794  check_dds_pixel_format(DDS_PF_LUMINANCE, 0, 16, 0xffff, 0, 0, 0, D3DFMT_L16);
795  check_dds_pixel_format(DDS_PF_LUMINANCE | DDS_PF_ALPHA, 0, 16, 0x00ff, 0, 0, 0xff00, D3DFMT_A8L8);
797  check_dds_pixel_format(DDS_PF_BUMPDUDV, 0, 16, 0x00ff, 0xff00, 0, 0, D3DFMT_V8U8);
798  check_dds_pixel_format(DDS_PF_BUMPDUDV, 0, 32, 0x0000ffff, 0xffff0000, 0, 0, D3DFMT_V16U16);
799  check_dds_pixel_format(DDS_PF_BUMPLUMINANCE, 0, 32, 0x0000ff, 0x00ff00, 0xff0000, 0, D3DFMT_X8L8V8U8);
800 
802 
804  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
805 
807  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
808 
810  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
811 
813  ok(hr == D3DXERR_INVALIDDATA, "D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
814 
815 
816  /* cleanup */
817  if(testdummy_ok) DeleteFileA("testdummy.bmp");
818  if(testbitmap_ok) DeleteFileA("testbitmap.bmp");
819 }
#define DDS_PF_ALPHA_ONLY
Definition: surface.c:315
#define DDS_PF_BUMPLUMINANCE
Definition: surface.c:319
#define DDS_PF_RGB
Definition: surface.c:317
#define check_dds_pixel_format(flags, fourcc, bpp, rmask, gmask, bmask, amask, format)
Definition: surface.c:373
HRESULT hr
Definition: shlfolder.c:183
#define DDS_PF_BUMPDUDV
Definition: surface.c:320
static const unsigned char bmp_4bpp[]
Definition: surface.c:53
static const unsigned char noimage[4]
Definition: surface.c:106
static const unsigned char bmp_1bpp[]
Definition: surface.c:35
#define IDS_STRING
Definition: resource.h:11
#define D3DERR_INVALIDCALL
#define MAKEINTRESOURCEA(i)
Definition: winuser.h:581
static const unsigned char bmp_32bpp_argb[]
Definition: surface.c:81
static const unsigned char dds_16bit[]
Definition: surface.c:205
#define DDS_PF_LUMINANCE
Definition: surface.c:318
#define DDS_PF_ALPHA
Definition: surface.c:314
unsigned int BOOL
Definition: ntddk_ex.h:94
if SUCCEEDED(hr)
static const unsigned char bmp_32bpp_xrgb[]
Definition: surface.c:71
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
static void test_dds_header_handling(void)
Definition: surface.c:410
LONG HRESULT
Definition: typedefs.h:79
static const unsigned char bmp_2bpp[]
Definition: surface.c:44
HRESULT WINAPI D3DXGetImageInfoFromFileA(const char *file, D3DXIMAGE_INFO *info)
Definition: surface.c:1135
struct _test_info info[]
Definition: SetCursorPos.c:19
static const unsigned char dds_8bit[]
Definition: surface.c:111
#define todo_wine
Definition: test.h:164
static const unsigned char dds_volume_map[]
Definition: surface.c:236
static const unsigned char png_grayscale[]
Definition: surface.c:90
#define IDB_BITMAP_1x1
Definition: resources.h:22
static const unsigned char dds_cube_map[]
Definition: surface.c:218
#define D3D_OK
Definition: d3d.h:106
#define ok(value,...)
Definition: atltest.h:57
static const unsigned char bmp_8bpp[]
Definition: surface.c:62
#define NULL
Definition: types.h:112
static const unsigned char dds_24bit[]
Definition: surface.c:192
#define IDD_BITMAPDATA_1x1
Definition: resources.h:23
HRESULT WINAPI D3DXGetImageInfoFromResourceA(HMODULE module, const char *resource, D3DXIMAGE_INFO *info)
Definition: surface.c:1184
#define skip(...)
Definition: atltest.h:64
#define DDS_PF_FOURCC
Definition: surface.c:316
static HRESULT create_file(const char *filename, const unsigned char *data, const unsigned int size)
Definition: surface.c:282
HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(const void *data, UINT datasize, D3DXIMAGE_INFO *info)
Definition: surface.c:985
#define memset(x, y, z)
Definition: compat.h:39

Referenced by START_TEST().

◆ test_D3DXLoadSurface()

static void test_D3DXLoadSurface ( IDirect3DDevice9 *  device)
static

Definition at line 835 of file surface.c.

836 {
837  HRESULT hr;
838  BOOL testdummy_ok, testbitmap_ok;
839  IDirect3DTexture9 *tex;
840  IDirect3DSurface9 *surf, *newsurf;
841  RECT rect, destrect;
842  D3DLOCKED_RECT lockrect;
843  static const WORD pixdata_a8r3g3b2[] = { 0x57df, 0x98fc, 0xacdd, 0xc891 };
844  static const WORD pixdata_a1r5g5b5[] = { 0x46b5, 0x99c8, 0x06a2, 0x9431 };
845  static const WORD pixdata_r5g6b5[] = { 0x9ef6, 0x658d, 0x0aee, 0x42ee };
846  static const WORD pixdata_a8l8[] = { 0xff00, 0x00ff, 0xff30, 0x7f7f };
847  static const DWORD pixdata_g16r16[] = { 0x07d23fbe, 0xdc7f44a4, 0xe4d8976b, 0x9a84fe89 };
848  static const DWORD pixdata_a8b8g8r8[] = { 0xc3394cf0, 0x235ae892, 0x09b197fd, 0x8dc32bf6 };
849  static const DWORD pixdata_a2r10g10b10[] = { 0x57395aff, 0x5b7668fd, 0xb0d856b5, 0xff2c61d6 };
850 
851  hr = create_file("testdummy.bmp", noimage, sizeof(noimage)); /* invalid image */
852  testdummy_ok = SUCCEEDED(hr);
853 
854  hr = create_file("testbitmap.bmp", bmp_1bpp, sizeof(bmp_1bpp)); /* valid image */
855  testbitmap_ok = SUCCEEDED(hr);
856 
858  if(FAILED(hr)) {
859  skip("Failed to create a surface (%#x)\n", hr);
860  if(testdummy_ok) DeleteFileA("testdummy.bmp");
861  if(testbitmap_ok) DeleteFileA("testbitmap.bmp");
862  return;
863  }
864 
865  /* D3DXLoadSurfaceFromFile */
866  if(testbitmap_ok) {
867  hr = D3DXLoadSurfaceFromFileA(surf, NULL, NULL, "testbitmap.bmp", NULL, D3DX_DEFAULT, 0, NULL);
868  ok(hr == D3D_OK, "D3DXLoadSurfaceFromFile returned %#x, expected %#x\n", hr, D3D_OK);
869 
870  hr = D3DXLoadSurfaceFromFileA(NULL, NULL, NULL, "testbitmap.bmp", NULL, D3DX_DEFAULT, 0, NULL);
871  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromFile returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
872  } else skip("Couldn't create \"testbitmap.bmp\"\n");
873 
874  if(testdummy_ok) {
875  hr = D3DXLoadSurfaceFromFileA(surf, NULL, NULL, "testdummy.bmp", NULL, D3DX_DEFAULT, 0, NULL);
876  ok(hr == D3DXERR_INVALIDDATA, "D3DXLoadSurfaceFromFile returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
877  } else skip("Couldn't create \"testdummy.bmp\"\n");
878 
880  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromFile returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
881 
883  ok(hr == D3DXERR_INVALIDDATA, "D3DXLoadSurfaceFromFile returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
884 
885 
886  /* D3DXLoadSurfaceFromResource */
889  ok(hr == D3D_OK, "D3DXLoadSurfaceFromResource returned %#x, expected %#x\n", hr, D3D_OK);
890 
893  ok(hr == D3D_OK, "D3DXLoadSurfaceFromResource returned %#x, expected %#x\n", hr, D3D_OK);
894 
896  ok(hr == D3DXERR_INVALIDDATA, "D3DXLoadSurfaceFromResource returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
897 
900  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromResource returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
901 
904  ok(hr == D3DXERR_INVALIDDATA, "D3DXLoadSurfaceFromResource returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
905 
906 
907  /* D3DXLoadSurfaceFromFileInMemory */
909  ok(hr == D3D_OK, "D3DXLoadSurfaceFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
910 
912  ok(hr == D3DXERR_INVALIDDATA, "D3DXLoadSurfaceFromFileInMemory returned %#x, expected %#x\n", hr, D3DXERR_INVALIDDATA);
913 
915  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
916 
918  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
919 
921  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
922 
924  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
925 
927  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
928 
929 
930  /* D3DXLoadSurfaceFromMemory */
931  SetRect(&rect, 0, 0, 2, 2);
932 
934  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
935 
937  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
938 
940  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
941 
943  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
944 
946  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
947 
949  ok(hr == E_FAIL, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, E_FAIL);
950 
951  SetRect(&destrect, -1, -1, 1, 1); /* destination rect is partially outside texture boundaries */
953  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
954 
955  SetRect(&destrect, 255, 255, 257, 257); /* destination rect is partially outside texture boundaries */
957  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
958 
959  SetRect(&destrect, 1, 1, 0, 0); /* left > right, top > bottom */
961  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
962 
963  SetRect(&destrect, 1, 2, 1, 2); /* left = right, top = bottom */
965  /* fails when debug version of d3d9 is used */
966  ok(hr == D3D_OK || broken(hr == D3DERR_INVALIDCALL), "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
967 
968  SetRect(&destrect, 257, 257, 257, 257); /* left = right, top = bottom, but invalid values */
970  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
971 
972 
973  /* D3DXLoadSurfaceFromSurface */
975  if(SUCCEEDED(hr)) {
976  hr = D3DXLoadSurfaceFromSurface(newsurf, NULL, NULL, surf, NULL, NULL, D3DX_DEFAULT, 0);
977  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x\n", hr, D3D_OK);
978 
980  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
981 
983  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
984 
985  check_release((IUnknown*)newsurf, 0);
986  } else skip("Failed to create a second surface\n");
987 
989  if (SUCCEEDED(hr))
990  {
991  IDirect3DTexture9_GetSurfaceLevel(tex, 0, &newsurf);
992 
993  hr = D3DXLoadSurfaceFromSurface(newsurf, NULL, NULL, surf, NULL, NULL, D3DX_DEFAULT, 0);
994  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x\n", hr, D3D_OK);
995 
996  IDirect3DSurface9_Release(newsurf);
998  } else skip("Failed to create texture\n");
999 
1000  /* non-lockable render target */
1002  ok(hr == D3D_OK, "Unexpected hr %#x.\n", hr);
1003  hr = D3DXLoadSurfaceFromSurface(surf, NULL, NULL, newsurf, NULL, NULL, D3DX_FILTER_NONE, 0);
1004  ok(hr == D3D_OK, "Unexpected hr %#x.\n", hr);
1005  IDirect3DSurface9_Release(newsurf);
1006 
1007  /* non-lockable multisampled render target */
1009  if (SUCCEEDED(hr))
1010  {
1011  hr = D3DXLoadSurfaceFromSurface(surf, NULL, NULL, newsurf, NULL, NULL, D3DX_FILTER_NONE, 0);
1012  ok(hr == D3D_OK, "Unexpected hr %#x.\n", hr);
1013 
1014  IDirect3DSurface9_Release(newsurf);
1015  }
1016  else
1017  {
1018  skip("Failed to create multisampled render target.\n");
1019  }
1020 
1021  hr = IDirect3DDevice9_GetRenderTarget(device, 0, &newsurf);
1022  ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderTarget returned %#x, expected %#x.\n", hr, D3D_OK);
1023 
1024  hr = D3DXLoadSurfaceFromSurface(newsurf, NULL, NULL, surf, NULL, NULL, D3DX_FILTER_NONE, 0);
1025  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3D_OK);
1026  hr = D3DXLoadSurfaceFromSurface(surf, NULL, NULL, newsurf, NULL, NULL, D3DX_FILTER_NONE, 0);
1027  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3D_OK);
1028  hr = D3DXLoadSurfaceFromSurface(surf, NULL, NULL, newsurf, NULL, NULL, D3DX_FILTER_NONE, 0xff000000);
1029  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3D_OK);
1031  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3D_OK);
1033  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3D_OK);
1034 
1035  /* rects */
1036  SetRect(&rect, 2, 2, 1, 1);
1037  hr = D3DXLoadSurfaceFromSurface(surf, NULL, NULL, newsurf, NULL, &rect, D3DX_FILTER_NONE, 0);
1038  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3DERR_INVALIDCALL);
1039  hr = D3DXLoadSurfaceFromSurface(surf, NULL, NULL, newsurf, NULL, &rect, D3DX_DEFAULT, 0);
1040  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3DERR_INVALIDCALL);
1041  hr = D3DXLoadSurfaceFromSurface(surf, NULL, &rect, newsurf, NULL, NULL, D3DX_FILTER_NONE, 0);
1042  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3DERR_INVALIDCALL);
1043  hr = D3DXLoadSurfaceFromSurface(surf, NULL, &rect, newsurf, NULL, NULL, D3DX_DEFAULT, 0);
1044  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3DERR_INVALIDCALL);
1045  hr = D3DXLoadSurfaceFromSurface(surf, NULL, &rect, newsurf, NULL, NULL, D3DX_FILTER_POINT, 0);
1046  ok(hr == D3DERR_INVALIDCALL, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3DERR_INVALIDCALL);
1047  SetRect(&rect, 1, 1, 1, 1);
1048  hr = D3DXLoadSurfaceFromSurface(surf, NULL, NULL, newsurf, NULL, &rect, D3DX_FILTER_NONE, 0);
1049  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3D_OK);
1050  hr = D3DXLoadSurfaceFromSurface(surf, NULL, &rect, newsurf, NULL, NULL, D3DX_FILTER_NONE, 0);
1051  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3D_OK);
1052  hr = D3DXLoadSurfaceFromSurface(surf, NULL, NULL, newsurf, NULL, &rect, D3DX_DEFAULT, 0);
1053  ok(hr == E_FAIL, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, E_FAIL);
1054  hr = D3DXLoadSurfaceFromSurface(surf, NULL, &rect, newsurf, NULL, NULL, D3DX_DEFAULT, 0);
1055  ok(hr == E_FAIL, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, E_FAIL);
1056  if (0)
1057  {
1058  /* Somehow it crashes with a STATUS_INTEGER_DIVIDE_BY_ZERO exception
1059  * on Windows. */
1060  hr = D3DXLoadSurfaceFromSurface(surf, NULL, &rect, newsurf, NULL, NULL, D3DX_FILTER_POINT, 0);
1061  ok(hr == E_FAIL, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, E_FAIL);
1062  }
1063  SetRect(&rect, 1, 1, 2, 2);
1064  SetRect(&destrect, 1, 1, 2, 2);
1065  hr = D3DXLoadSurfaceFromSurface(surf, NULL, &rect, newsurf, NULL, &destrect, D3DX_FILTER_NONE, 0);
1066  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3D_OK);
1067  hr = D3DXLoadSurfaceFromSurface(surf, NULL, &rect, newsurf, NULL, NULL, D3DX_FILTER_NONE, 0);
1068  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3D_OK);
1069  hr = D3DXLoadSurfaceFromSurface(surf, NULL, NULL, newsurf, NULL, &destrect, D3DX_FILTER_NONE, 0);
1070  ok(hr == D3D_OK, "D3DXLoadSurfaceFromSurface returned %#x, expected %#x.\n", hr, D3D_OK);
1071 
1072  IDirect3DSurface9_Release(newsurf);
1073 
1074  check_release((IUnknown*)surf, 0);
1075 
1076  SetRect(&rect, 1, 1, 2, 2);
1078  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1079  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a8b8g8r8,
1081  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1083  check_pixel_4bpp(&lockrect, 0, 0, 0x8dc32bf6);
1085  check_release((IUnknown *)surf, 0);
1086 
1087  /* test color conversion */
1088  SetRect(&rect, 0, 0, 2, 2);
1089  /* A8R8G8B8 */
1091  if(FAILED(hr)) skip("Failed to create a surface (%#x)\n", hr);
1092  else {
1094 
1095  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a8r3g3b2,
1097  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
1099  check_pixel_4bpp(&lockrect, 0, 0, 0x57dbffff);
1100  check_pixel_4bpp(&lockrect, 1, 0, 0x98ffff00);
1101  check_pixel_4bpp(&lockrect, 0, 1, 0xacdbff55);
1102  check_pixel_4bpp(&lockrect, 1, 1, 0xc8929255);
1104 
1105  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a1r5g5b5,
1107  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
1109  check_pixel_4bpp(&lockrect, 0, 0, 0x008cadad);
1110  check_pixel_4bpp(&lockrect, 1, 0, 0xff317342);
1111  check_pixel_4bpp(&lockrect, 0, 1, 0x0008ad10);
1112  check_pixel_4bpp(&lockrect, 1, 1, 0xff29088c);
1114 
1115  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_r5g6b5,
1117  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
1119  check_pixel_4bpp(&lockrect, 0, 0, 0xff9cdfb5);
1120  check_pixel_4bpp(&lockrect, 1, 0, 0xff63b26b);
1121  check_pixel_4bpp(&lockrect, 0, 1, 0xff085d73);
1122  check_pixel_4bpp(&lockrect, 1, 1, 0xff425d73);
1124 
1125  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_g16r16,
1127  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
1129  todo_wine {
1130  check_pixel_4bpp(&lockrect, 0, 0, 0xff3f08ff);
1131  }
1132  check_pixel_4bpp(&lockrect, 1, 0, 0xff44dcff);
1133  check_pixel_4bpp(&lockrect, 0, 1, 0xff97e4ff);
1134  check_pixel_4bpp(&lockrect, 1, 1, 0xfffe9aff);
1136 
1137  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a8b8g8r8,
1139  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1140  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1141  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1142  check_pixel_4bpp(&lockrect, 0, 0, 0xc3f04c39);
1143  check_pixel_4bpp(&lockrect, 1, 0, 0x2392e85a);
1144  check_pixel_4bpp(&lockrect, 0, 1, 0x09fd97b1);
1145  check_pixel_4bpp(&lockrect, 1, 1, 0x8df62bc3);
1147 
1148  SetRect(&rect, 0, 0, 1, 1);
1149  SetRect(&destrect, 1, 1, 2, 2);
1150  hr = D3DXLoadSurfaceFromMemory(surf, NULL, &destrect, pixdata_a8b8g8r8,
1152  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1154  check_pixel_4bpp(&lockrect, 0, 0, 0xc3f04c39);
1155  check_pixel_4bpp(&lockrect, 1, 0, 0x2392e85a);
1156  check_pixel_4bpp(&lockrect, 0, 1, 0x09fd97b1);
1157  check_pixel_4bpp(&lockrect, 1, 1, 0xc3f04c39);
1159 
1160  SetRect(&rect, 0, 0, 2, 2);
1161 
1162  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a2r10g10b10,
1164  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1166  check_pixel_4bpp(&lockrect, 0, 0, 0x555c95bf);
1167  check_pixel_4bpp(&lockrect, 1, 0, 0x556d663f);
1168  check_pixel_4bpp(&lockrect, 0, 1, 0xaac385ad);
1169  todo_wine {
1170  check_pixel_4bpp(&lockrect, 1, 1, 0xfffcc575);
1171  }
1173 
1174  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a8l8,
1176  ok(SUCCEEDED(hr), "Failed to load surface, hr %#x.\n", hr);
1177  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1178  ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr);
1179  check_pixel_4bpp(&lockrect, 0, 0, 0xff000000);
1180  check_pixel_4bpp(&lockrect, 1, 0, 0x00ffffff);
1181  check_pixel_4bpp(&lockrect, 0, 1, 0xff303030);
1182  check_pixel_4bpp(&lockrect, 1, 1, 0x7f7f7f7f);
1184  ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr);
1185 
1186  /* Test D3DXLoadSurfaceFromMemory with indexed color image */
1187  if (0)
1188  {
1189  /* Crashes on Nvidia Win10. */
1190  palette.peRed = bmp_1bpp[56];
1191  palette.peGreen = bmp_1bpp[55];
1192  palette.peBlue = bmp_1bpp[54];
1193  palette.peFlags = bmp_1bpp[57]; /* peFlags is the alpha component in DX8 and higher */
1195  D3DFMT_P8, 1, (const PALETTEENTRY *)&palette, &rect, D3DX_FILTER_NONE, 0);
1196  ok(hr == D3D_OK, "D3DXLoadSurfaceFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
1197  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1198  ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x\n", hr);
1199  ok(*(DWORD*)lockrect.pBits == 0x80f3f2f1,
1200  "Pixel color mismatch: got %#x, expected 0x80f3f2f1\n", *(DWORD*)lockrect.pBits);
1202  ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x\n", hr);
1203  }
1204 
1205  /* Test D3DXLoadSurfaceFromFileInMemory with indexed color image (alpha is not taken into account for bmp file) */
1207  ok(hr == D3D_OK, "D3DXLoadSurfaceFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
1208  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1209  ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x\n", hr);
1210  ok(*(DWORD*)lockrect.pBits == 0xfff3f2f1, "Pixel color mismatch: got %#x, expected 0xfff3f2f1\n", *(DWORD*)lockrect.pBits);
1212  ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x\n", hr);
1213 
1214  check_release((IUnknown*)surf, 0);
1215  }
1216 
1217  /* A1R5G5B5 */
1219  if(FAILED(hr)) skip("Failed to create a surface (%#x)\n", hr);
1220  else {
1221  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a8r3g3b2,
1223  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
1225  check_pixel_2bpp(&lockrect, 0, 0, 0x6fff);
1226  check_pixel_2bpp(&lockrect, 1, 0, 0xffe0);
1227  check_pixel_2bpp(&lockrect, 0, 1, 0xefea);
1228  check_pixel_2bpp(&lockrect, 1, 1, 0xca4a);
1230 
1231  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a1r5g5b5,
1233  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
1235  check_pixel_2bpp(&lockrect, 0, 0, 0x46b5);
1236  check_pixel_2bpp(&lockrect, 1, 0, 0x99c8);
1237  check_pixel_2bpp(&lockrect, 0, 1, 0x06a2);
1238  check_pixel_2bpp(&lockrect, 1, 1, 0x9431);
1240 
1241  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_r5g6b5,
1243  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
1245  check_pixel_2bpp(&lockrect, 0, 0, 0xcf76);
1246  check_pixel_2bpp(&lockrect, 1, 0, 0xb2cd);
1247  check_pixel_2bpp(&lockrect, 0, 1, 0x856e);
1248  check_pixel_2bpp(&lockrect, 1, 1, 0xa16e);
1250 
1251  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_g16r16,
1253  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
1255  todo_wine {
1256  check_pixel_2bpp(&lockrect, 0, 0, 0xa03f);
1257  }
1258  check_pixel_2bpp(&lockrect, 1, 0, 0xa37f);
1259  check_pixel_2bpp(&lockrect, 0, 1, 0xcb9f);
1260  check_pixel_2bpp(&lockrect, 1, 1, 0xfe7f);
1262 
1263  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a8b8g8r8,
1265  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
1267  todo_wine {
1268  check_pixel_2bpp(&lockrect, 0, 0, 0xf527);
1269  check_pixel_2bpp(&lockrect, 1, 0, 0x4b8b);
1270  }
1271  check_pixel_2bpp(&lockrect, 0, 1, 0x7e56);
1272  check_pixel_2bpp(&lockrect, 1, 1, 0xf8b8);
1274 
1275  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a2r10g10b10,
1277  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
1279  check_pixel_2bpp(&lockrect, 0, 0, 0x2e57);
1280  todo_wine {
1281  check_pixel_2bpp(&lockrect, 1, 0, 0x3588);
1282  }
1283  check_pixel_2bpp(&lockrect, 0, 1, 0xe215);
1284  check_pixel_2bpp(&lockrect, 1, 1, 0xff0e);
1286 
1287  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a8l8,
1289  ok(SUCCEEDED(hr), "Failed to load surface, hr %#x.\n", hr);
1290  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1291  ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr);
1292  check_pixel_2bpp(&lockrect, 0, 0, 0x8000);
1293  check_pixel_2bpp(&lockrect, 1, 0, 0x7fff);
1294  check_pixel_2bpp(&lockrect, 0, 1, 0x98c6);
1295  check_pixel_2bpp(&lockrect, 1, 1, 0x3def);
1297  ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr);
1298 
1299  check_release((IUnknown*)surf, 0);
1300  }
1301 
1302  /* A8L8 */
1304  if (FAILED(hr))
1305  skip("Failed to create A8L8 texture, hr %#x.\n", hr);
1306  else
1307  {
1308  hr = IDirect3DTexture9_GetSurfaceLevel(tex, 0, &surf);
1309  ok(SUCCEEDED(hr), "Failed to get the surface, hr %#x.\n", hr);
1310 
1311  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a8r3g3b2,
1313  ok(SUCCEEDED(hr), "Failed to load surface, hr %#x.\n", hr);
1314  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1315  ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr);
1316  check_pixel_2bpp(&lockrect, 0, 0, 0x57f7);
1317  check_pixel_2bpp(&lockrect, 1, 0, 0x98ed);
1318  check_pixel_2bpp(&lockrect, 0, 1, 0xaceb);
1319  check_pixel_2bpp(&lockrect, 1, 1, 0xc88d);
1321  ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr);
1322 
1323  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a1r5g5b5,
1325  ok(hr == D3D_OK, "D3DXLoadSurfaceFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
1326  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1327  ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr);
1328  check_pixel_2bpp(&lockrect, 0, 0, 0x00a6);
1329  check_pixel_2bpp(&lockrect, 1, 0, 0xff62);
1330  check_pixel_2bpp(&lockrect, 0, 1, 0x007f);
1331  check_pixel_2bpp(&lockrect, 1, 1, 0xff19);
1333  ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr);
1334 
1335  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_r5g6b5,
1337  ok(SUCCEEDED(hr), "Failed to load surface, hr %#x.\n", hr);
1338  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1339  ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr);
1340  check_pixel_2bpp(&lockrect, 0, 0, 0xffce);
1341  check_pixel_2bpp(&lockrect, 1, 0, 0xff9c);
1342  check_pixel_2bpp(&lockrect, 0, 1, 0xff4d);
1343  check_pixel_2bpp(&lockrect, 1, 1, 0xff59);
1345  ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr);
1346 
1347  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_g16r16,
1349  ok(SUCCEEDED(hr), "Failed to load surface, hr %#x.\n", hr);
1350  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1351  ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr);
1352  check_pixel_2bpp(&lockrect, 0, 0, 0xff25);
1353  check_pixel_2bpp(&lockrect, 1, 0, 0xffbe);
1354  check_pixel_2bpp(&lockrect, 0, 1, 0xffd6);
1355  check_pixel_2bpp(&lockrect, 1, 1, 0xffb6);
1357  ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr);
1358 
1359  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a8b8g8r8,
1361  ok(SUCCEEDED(hr), "Failed to load surface, hr %#x.\n", hr);
1362  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1363  ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr);
1364  check_pixel_2bpp(&lockrect, 0, 0, 0xc36d);
1365  check_pixel_2bpp(&lockrect, 1, 0, 0x23cb);
1366  check_pixel_2bpp(&lockrect, 0, 1, 0x09af);
1367  check_pixel_2bpp(&lockrect, 1, 1, 0x8d61);
1369  ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr);
1370 
1371  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a2r10g10b10,
1373  ok(SUCCEEDED(hr), "Failed to load surface, hr %#x.\n", hr);
1374  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1375  ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr);
1376  check_pixel_2bpp(&lockrect, 0, 0, 0x558c);
1377  check_pixel_2bpp(&lockrect, 1, 0, 0x5565);
1378  check_pixel_2bpp(&lockrect, 0, 1, 0xaa95);
1379  check_pixel_2bpp(&lockrect, 1, 1, 0xffcb);
1381  ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr);
1382 
1383  hr = D3DXLoadSurfaceFromMemory(surf, NULL, NULL, pixdata_a8l8,
1385  ok(SUCCEEDED(hr), "Failed to load surface, hr %#x.\n", hr);
1386  hr = IDirect3DSurface9_LockRect(surf, &lockrect, NULL, D3DLOCK_READONLY);
1387  ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr);
1388  check_pixel_2bpp(&lockrect, 0, 0, 0xff00);
1389  check_pixel_2bpp(&lockrect, 1, 0, 0x00ff);
1390  check_pixel_2bpp(&lockrect, 0, 1, 0xff30);
1391  check_pixel_2bpp(&lockrect, 1, 1, 0x7f7f);
1393  ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr);
1394 
1395  check_release((IUnknown*)surf, 1);
1396  check_release((IUnknown*)tex, 0);
1397  }
1398 
1399  /* DXT1, DXT2, DXT3, DXT4, DXT5 */
1401  if (FAILED(hr))
1402  skip("Failed to create A8R8G8B8 surface, hr %#x.\n", hr);
1403  else
1404  {
1406  ok(SUCCEEDED(hr), "Failed to load surface, hr %#x.\n", hr);
1407 
1409  if (FAILED(hr))
1410  skip("Failed to create DXT2 texture, hr %#x.\n", hr);
1411  else
1412  {
1413  hr = IDirect3DTexture9_GetSurfaceLevel(tex, 0, &newsurf);
1414  ok(SUCCEEDED(hr), "Failed to get the surface, hr %#x.\n", hr);
1415  hr = D3DXLoadSurfaceFromSurface(newsurf, NULL, NULL, surf, NULL, NULL, D3DX_FILTER_NONE, 0);
1416  ok(SUCCEEDED(hr), "Failed to convert pixels to DXT2 format.\n");
1417  check_release((IUnknown*)newsurf, 1);
1418  check_release((IUnknown*)tex, 0);
1419  }
1420 
1422  if (FAILED(hr))
1423  skip("Failed to create DXT3 texture, hr %#x.\n", hr);
1424  else
1425  {
1426  hr = IDirect3DTexture9_GetSurfaceLevel(tex, 0, &newsurf);
1427  ok(SUCCEEDED(hr), "Failed to get the surface, hr %#x.\n", hr);
1428  hr = D3DXLoadSurfaceFromSurface(newsurf, NULL, NULL, surf, NULL, NULL, D3DX_FILTER_NONE, 0);
1429  ok(SUCCEEDED(hr), "Failed to convert pixels to DXT3 format.\n");
1430  check_release((IUnknown*)newsurf, 1);
1431  check_release((IUnknown*)tex, 0);
1432  }
1433 
1435  if (FAILED(hr))
1436  skip("Failed to create DXT4 texture, hr %#x.\n", hr);
1437  else
1438  {
1439  hr = IDirect3DTexture9_GetSurfaceLevel(tex, 0, &newsurf);
1440  ok(SUCCEEDED(hr), "Failed to get the surface, hr %#x.\n", hr);
1441  hr = D3DXLoadSurfaceFromSurface(newsurf, NULL, NULL, surf, NULL, NULL, D3DX_FILTER_NONE, 0);
1442  ok(SUCCEEDED(hr), "Failed to convert pixels to DXT4 format.\n");
1443  check_release((IUnknown*)newsurf, 1);
1444  check_release((IUnknown*)tex, 0);
1445  }
1446 
1448  if (FAILED(hr))
1449  skip("Failed to create DXT5 texture, hr %#x.\n", hr);
1450  else
1451  {
1452  hr = IDirect3DTexture9_GetSurfaceLevel(tex, 0, &newsurf);
1453  ok(SUCCEEDED(hr), "Failed to get the surface, hr %#x.\n", hr);
1454  hr = D3DXLoadSurfaceFromSurface(newsurf, NULL, NULL, surf, NULL, NULL, D3DX_FILTER_NONE, 0);
1455  ok(SUCCEEDED(hr), "Failed to convert pixels to DXT5 format.\n");
1456 
1457  SetRect(&rect, 0, 0, 4, 2);
1458  hr = D3DXLoadSurfaceFromSurface(newsurf, NULL, &rect, surf, NULL, &rect, D3DX_FILTER_NONE, 0);
1459  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1460  hr = D3DXLoadSurfaceFromMemory(newsurf, NULL, &rect, &dds_dxt5[128],
1461  D3DFMT_DXT5, 16, NULL, &rect, D3DX_FILTER_NONE, 0);
1462  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1463  check_release((IUnknown *)newsurf, 1);
1464  check_release((IUnknown *)tex, 0);
1465 
1466  /* Test a rect larger than but not an integer multiple of the block size. */
1468  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1469  hr = IDirect3DTexture9_GetSurfaceLevel(tex, 0, &newsurf);
1470  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1471  SetRect(&rect, 0, 0, 4, 6);
1472  hr = D3DXLoadSurfaceFromMemory(newsurf, NULL, &rect, &dds_dxt5[112],
1473  D3DFMT_DXT5, 16, NULL, &rect, D3DX_FILTER_POINT, 0);
1474  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1475 
1476  check_release((IUnknown *)newsurf, 1);
1477  check_release((IUnknown *)tex, 0);
1478 
1479  /* More misalignment tests. */
1481  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1482  hr = IDirect3DTexture9_GetSurfaceLevel(tex, 0, &newsurf);
1483  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1484 
1485  SetRect(&rect, 2, 2, 6, 6);
1486  hr = D3DXLoadSurfaceFromMemory(newsurf, NULL, NULL, &dds_dxt5_8_8[128],
1487  D3DFMT_DXT5, 16 * 2, NULL, &rect, D3DX_FILTER_POINT, 0);
1488  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1489 
1490  hr = D3DXLoadSurfaceFromMemory(newsurf, NULL, &rect, &dds_dxt5_8_8[128],
1491  D3DFMT_DXT5, 16 * 2, NULL, NULL, D3DX_FILTER_POINT, 0);
1492  ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
1493 
1494  hr = D3DXLoadSurfaceFromMemory(newsurf, NULL, &rect, &dds_dxt5_8_8[128],
1495  D3DFMT_DXT5, 16 * 2, NULL, &rect, D3DX_FILTER_POINT, 0);
1496  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1497 
1498  check_release((IUnknown *)newsurf, 1);
1499  check_release((IUnknown *)tex, 0);
1500  }
1501 
1503  if (FAILED(hr))
1504  skip("Failed to create DXT1 texture, hr %#x.\n", hr);
1505  else
1506  {
1507  hr = IDirect3DTexture9_GetSurfaceLevel(tex, 0, &newsurf);
1508  ok(SUCCEEDED(hr), "Failed to get the surface, hr %#x.\n", hr);
1509  hr = D3DXLoadSurfaceFromSurface(newsurf, NULL, NULL, surf, NULL, NULL, D3DX_FILTER_NONE, 0);
1510  ok(SUCCEEDED(hr), "Failed to convert pixels to DXT1 format.\n");
1511 
1512  hr = D3DXLoadSurfaceFromSurface(surf, NULL, NULL, newsurf, NULL, NULL, D3DX_FILTER_NONE, 0);
1513  ok(SUCCEEDED(hr), "Failed to convert pixels from DXT1 format.\n");
1514 
1515  check_release((IUnknown*)newsurf, 1);
1516  check_release((IUnknown*)tex, 0);
1517  }
1518 
1519  check_release((IUnknown*)surf, 0);
1520  }
1521 
1522  /* cleanup */
1523  if(testdummy_ok) DeleteFileA("testdummy.bmp");
1524  if(testbitmap_ok) DeleteFileA("testbitmap.bmp");
1525 }
#define IDirect3DSurface9_Release(p)
Definition: d3d9.h:622
#define check_pixel_2bpp(lockrect, x, y, color)
Definition: surface.c:821
HRESULT hr
Definition: shlfolder.c:183
HRESULT WINAPI D3DXLoadSurfaceFromSurface(IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect, DWORD filter, D3DCOLOR color_key)
Definition: surface.c:2233
static const unsigned char noimage[4]
Definition: surface.c:106
#define IDirect3DTexture9_GetSurfaceLevel(p, a, b)
Definition: d3d9.h:1033
#define D3DX_FILTER_MIRROR
Definition: d3dx9tex.h:35
static const unsigned char bmp_1bpp[]
Definition: surface.c:35
#define IDS_STRING
Definition: resource.h:11
#define IDirect3DTexture9_Release(p)
Definition: d3d9.h:1014
#define D3DX_FILTER_NONE
Definition: d3dx9tex.h:27
#define D3DERR_INVALIDCALL
#define D3DX_FILTER_LINEAR
Definition: d3dx9tex.h:29
#define MAKEINTRESOURCEA(i)
Definition: winuser.h:581
HRESULT WINAPI D3DXLoadSurfaceFromFileA(IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, const char *src_file, const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
Definition: surface.c:1416
#define IDirect3DDevice9_CreateRenderTarget(p, a, b, c, d, e, f, g, h)
Definition: d3d9.h:1535
#define E_FAIL
Definition: ddrawi.h:102
& rect
Definition: startmenu.cpp:1413
#define IDirect3DDevice9_CreateOffscreenPlainSurface(p, a, b, c, d, e, f)
Definition: d3d9.h:1543
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: devices.h:37
if SUCCEEDED(hr)
#define D3DX_DEFAULT
Definition: d3dx9.h:24
HRESULT WINAPI D3DXLoadSurfaceFromResourceA(IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, HMODULE src_module, const char *resource, const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
Definition: surface.c:1469
#define D3DX_FILTER_TRIANGLE
Definition: d3dx9tex.h:30
#define check_pixel_4bpp(lockrect, x, y, color)
Definition: surface.c:828
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
#define IDirect3DDevice9_GetRenderTarget(p, a, b)
Definition: d3d9.h:1545
LONG HRESULT
Definition: typedefs.h:79
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
#define todo_wine
Definition: test.h:164
static const BYTE dds_dxt5[]
Definition: surface.c:252
#define IDB_BITMAP_1x1
Definition: resources.h:22
static HPALETTE palette
Definition: clipboard.c:1345
#define broken(x)
Definition: _sntprintf.h:21
BOOL WINAPI SetRect(_Out_ LPRECT, _In_ int, _In_ int, _In_ int, _In_ int)
#define D3D_OK
Definition: d3d.h:106
HRESULT WINAPI D3DXLoadSurfaceFromMemory(IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, const void *src_memory, D3DFORMAT src_format, UINT src_pitch, const PALETTEENTRY *src_palette, const RECT *src_rect, DWORD filter, D3DCOLOR color_key)
Definition: surface.c:1963
#define IDirect3DDevice9_CreateTexture(p, a, b, c, d, e, f, g, h)
Definition: d3d9.h:1530
#define ok(value,...)
Definition: atltest.h:57
#define NULL
Definition: types.h:112
static const unsigned char dds_24bit[]
Definition: surface.c:192
#define IDD_BITMAPDATA_1x1
Definition: resources.h:23
#define IDirect3DSurface9_UnlockRect(p)
Definition: d3d9.h:636
#define skip(...)
Definition: atltest.h:64
static HRESULT create_file(const char *filename, const unsigned char *data, const unsigned int size)
Definition: surface.c:282
#define D3DX_FILTER_POINT
Definition: d3dx9tex.h:28
#define check_release(obj, exp)
Definition: surface.c:27
#define IDirect3DSurface9_LockRect(p, a, b, c)
Definition: d3d9.h:635
#define D3DLOCK_READONLY
Definition: d3d8types.h:69
static const BYTE dds_dxt5_8_8[]
Definition: surface.c:266
static const unsigned char pixdata[]
Definition: surface.c:101
HRESULT WINAPI D3DXLoadSurfaceFromFileInMemory(IDirect3DSurface9 *pDestSurface, const PALETTEENTRY *pDestPalette, const RECT *pDestRect, const void *pSrcData, UINT SrcDataSize, const RECT *pSrcRect, DWORD dwFilter, D3DCOLOR Colorkey, D3DXIMAGE_INFO *pSrcInfo)
Definition: surface.c:1245

Referenced by START_TEST().

◆ test_D3DXSaveSurfaceToFile()

static void test_D3DXSaveSurfaceToFile ( IDirect3DDevice9 *  device)
static

Definition at line 1630 of file surface.c.

1631 {
1632  static const BYTE pixels[] =
1633  {0xff, 0x00, 0x00, 0x00, 0xff, 0x00,
1634  0x00, 0x00, 0xff, 0x00, 0x00, 0xff,};
1635  DWORD pitch = sizeof(pixels) / 2;
1636  IDirect3DSurface9 *surface;
1637  D3DXIMAGE_INFO image_info;
1638  D3DLOCKED_RECT lock_rect;
1639  HRESULT hr;
1640  RECT rect;
1641 
1643  if (FAILED(hr))
1644  {
1645  skip("Couldn't create surface.\n");
1646  return;
1647  }
1648 
1649  SetRect(&rect, 0, 0, 2, 2);
1651  pitch, NULL, &rect, D3DX_FILTER_NONE, 0);
1652  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1653 
1654  hr = D3DXSaveSurfaceToFileA("saved_surface.bmp", D3DXIFF_BMP, surface, NULL, NULL);
1655  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1656 
1657  hr = D3DXLoadSurfaceFromFileA(surface, NULL, NULL, "saved_surface.bmp",
1658  NULL, D3DX_FILTER_NONE, 0, &image_info);
1659  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1660 
1661  ok(image_info.Width == 2, "Wrong width %u.\n", image_info.Width);
1662  ok(image_info.Height == 2, "Wrong height %u.\n", image_info.Height);
1663  ok(image_info.Format == D3DFMT_R8G8B8, "Wrong format %#x.\n", image_info.Format);
1664  ok(image_info.ImageFileFormat == D3DXIFF_BMP, "Wrong file format %u.\n", image_info.ImageFileFormat);
1665 
1666  hr = IDirect3DSurface9_LockRect(surface, &lock_rect, NULL, D3DLOCK_READONLY);
1667  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1668 
1669  ok(!memcmp(lock_rect.pBits, pixels, pitch),
1670  "Pixel data mismatch in the first row.\n");
1671  ok(!memcmp((BYTE *)lock_rect.pBits + lock_rect.Pitch, pixels + pitch, pitch),
1672  "Pixel data mismatch in the second row.\n");
1673 
1675 
1676  SetRect(&rect, 0, 1, 2, 2);
1677  hr = D3DXSaveSurfaceToFileA("saved_surface.bmp", D3DXIFF_BMP, surface, NULL, &rect);
1678  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1679  SetRect(&rect, 0, 0, 2, 1);
1680  hr = D3DXLoadSurfaceFromFileA(surface, NULL, &rect, "saved_surface.bmp", NULL,
1681  D3DX_FILTER_NONE, 0, &image_info);
1682  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1683 
1684  hr = IDirect3DSurface9_LockRect(surface, &lock_rect, NULL, D3DLOCK_READONLY);
1685  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1686  ok(!memcmp(lock_rect.pBits, pixels + pitch, pitch),
1687  "Pixel data mismatch in the first row.\n");
1688  ok(!memcmp((BYTE *)lock_rect.pBits + lock_rect.Pitch, pixels + pitch, pitch),
1689  "Pixel data mismatch in the second row.\n");
1691 
1692  SetRect(&rect, 0, 0, 2, 2);
1694  pitch, NULL, &rect, D3DX_FILTER_NONE, 0);
1695  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1696 
1698  ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
1699 
1700  /* PPM and TGA are supported, even though MSDN claims they aren't */
1701  todo_wine
1702  {
1703  hr = D3DXSaveSurfaceToFileA("saved_surface.ppm", D3DXIFF_PPM, surface, NULL, NULL);
1704  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1705  hr = D3DXSaveSurfaceToFileA("saved_surface.tga", D3DXIFF_TGA, surface, NULL, NULL);
1706  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1707  }
1708 
1709  hr = D3DXSaveSurfaceToFileA("saved_surface.dds", D3DXIFF_DDS, surface, NULL, NULL);
1710  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1711 
1712  hr = D3DXLoadSurfaceFromFileA(surface, NULL, NULL, "saved_surface.dds",
1713  NULL, D3DX_FILTER_NONE, 0, &image_info);
1714  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1715 
1716  ok(image_info.Width == 2, "Wrong width %u.\n", image_info.Width);
1717  ok(image_info.Format == D3DFMT_R8G8B8, "Wrong format %#x.\n", image_info.Format);
1718  ok(image_info.ImageFileFormat == D3DXIFF_DDS, "Wrong file format %u.\n", image_info.ImageFileFormat);
1719 
1720  hr = IDirect3DSurface9_LockRect(surface, &lock_rect, NULL, D3DLOCK_READONLY);
1721  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1722  ok(!memcmp(lock_rect.pBits, pixels, pitch),
1723  "Pixel data mismatch in the first row.\n");
1724  ok(!memcmp((BYTE *)lock_rect.pBits + lock_rect.Pitch, pixels + pitch, pitch),
1725  "Pixel data mismatch in the second row.\n");
1727 
1728  hr = D3DXSaveSurfaceToFileA("saved_surface", D3DXIFF_PFM + 1, surface, NULL, NULL);
1729  ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
1730 
1731  SetRect(&rect, 0, 0, 4, 4);
1732  hr = D3DXSaveSurfaceToFileA("saved_surface.bmp", D3DXIFF_BMP, surface, NULL, &rect);
1733  ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
1734  SetRect(&rect, 2, 0, 1, 4);
1735  hr = D3DXSaveSurfaceToFileA("saved_surface.bmp", D3DXIFF_BMP, surface, NULL, &rect);
1736  ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
1737  SetRect(&rect, 0, 2, 4, 1);
1738  hr = D3DXSaveSurfaceToFileA("saved_surface.bmp", D3DXIFF_BMP, surface, NULL, &rect);
1739  ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
1740  SetRect(&rect, -1, -1, 2, 2);
1741  hr = D3DXSaveSurfaceToFileA("saved_surface.bmp", D3DXIFF_BMP, surface, NULL, &rect);
1742  ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
1743  SetRectEmpty(&rect);
1744  hr = D3DXSaveSurfaceToFileA("saved_surface.bmp", D3DXIFF_BMP, surface, NULL, &rect);
1745  /* fails when debug version of d3d9 is used */
1746  ok(hr == D3D_OK || broken(hr == D3DERR_INVALIDCALL), "Got unexpected hr %#x.\n", hr);
1747 
1748  DeleteFileA("saved_surface.bmp");
1749  DeleteFileA("saved_surface.ppm");
1750  DeleteFileA("saved_surface.tga");
1751  DeleteFileA("saved_surface.dds");
1752 
1753  IDirect3DSurface9_Release(surface);
1754 }
#define IDirect3DSurface9_Release(p)
Definition: d3d9.h:622
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
HRESULT hr
Definition: shlfolder.c:183
#define D3DX_FILTER_NONE
Definition: d3dx9tex.h:27
#define D3DERR_INVALIDCALL
HRESULT WINAPI D3DXLoadSurfaceFromFileA(IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, const char *src_file, const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
Definition: surface.c:1416
& rect
Definition: startmenu.cpp:1413
#define IDirect3DDevice9_CreateOffscreenPlainSurface(p, a, b, c, d, e, f)
Definition: d3d9.h:1543
Definition: devices.h:37
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
D3DXIMAGE_FILEFORMAT ImageFileFormat
Definition: d3dx9tex.h:84
D3DFORMAT Format
Definition: d3dx9tex.h:82
LONG HRESULT
Definition: typedefs.h:79
unsigned long DWORD
Definition: ntddk_ex.h:95
#define todo_wine
Definition: test.h:164
BOOL WINAPI SetRectEmpty(_Out_ LPRECT)
unsigned char BYTE
Definition: xxhash.c:193
#define broken(x)
Definition: _sntprintf.h:21
BOOL WINAPI SetRect(_Out_ LPRECT, _In_ int, _In_ int, _In_ int, _In_ int)
#define D3D_OK
Definition: d3d.h:106
HRESULT WINAPI D3DXLoadSurfaceFromMemory(IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, const void *src_memory, D3DFORMAT src_format, UINT src_pitch, const PALETTEENTRY *src_palette, const RECT *src_rect, DWORD filter, D3DCOLOR color_key)
Definition: surface.c:1963
HRESULT WINAPI D3DXSaveSurfaceToFileA(const char *dst_filename, D3DXIMAGE_FILEFORMAT file_format, IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect)
Definition: surface.c:2364
#define ok(value,...)
Definition: atltest.h:57
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
#define NULL
Definition: types.h:112
#define IDirect3DSurface9_UnlockRect(p)
Definition: d3d9.h:636
#define skip(...)
Definition: atltest.h:64
#define IDirect3DSurface9_LockRect(p, a, b, c)
Definition: d3d9.h:635
#define D3DLOCK_READONLY
Definition: d3d8types.h:69

Referenced by START_TEST().

◆ test_D3DXSaveSurfaceToFileInMemory()

static void test_D3DXSaveSurfaceToFileInMemory ( IDirect3DDevice9 *  device)
static

Definition at line 1527 of file surface.c.

1528 {
1529  static const struct
1530  {
1531  DWORD usage;
1532  D3DPOOL pool;
1533  }
1534  test_access_types[] =
1535  {
1536  {0, D3DPOOL_MANAGED},
1537  {0, D3DPOOL_DEFAULT},
1539  };
1540 
1541  struct
1542  {
1543  DWORD magic;
1544  struct dds_header header;
1545  BYTE *data;
1546  } *dds;
1547  IDirect3DSurface9 *surface;
1548  IDirect3DTexture9 *texture;
1550  unsigned int i;
1551  HRESULT hr;
1552  RECT rect;
1553 
1555  if (FAILED(hr)) {
1556  skip("Couldn't create surface\n");
1557  return;
1558  }
1559 
1560  SetRectEmpty(&rect);
1562  /* fails with the debug version of d3d9 */
1563  ok(hr == D3D_OK || broken(hr == D3DERR_INVALIDCALL), "D3DXSaveSurfaceToFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
1564  if (SUCCEEDED(hr)) {
1566  ok(size > 0, "ID3DXBuffer_GetBufferSize returned %u, expected > 0\n", size);
1568  }
1569 
1570  SetRectEmpty(&rect);
1572  todo_wine ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1573  if (SUCCEEDED(hr))
1574  {
1576 
1577  ok(dds->magic == MAKEFOURCC('D','D','S',' '), "Got unexpected DDS signature %#x.\n", dds->magic);
1578  ok(dds->header.size == sizeof(dds->header), "Got unexpected DDS size %u.\n", dds->header.size);
1579  ok(!dds->header.height, "Got unexpected height %u.\n", dds->header.height);
1580  ok(!dds->header.width, "Got unexpected width %u.\n", dds->header.width);
1581  ok(!dds->header.depth, "Got unexpected depth %u.\n", dds->header.depth);
1582  ok(!dds->header.miplevels, "Got unexpected miplevels %u.\n", dds->header.miplevels);
1583  ok(!dds->header.pitch_or_linear_size, "Got unexpected pitch_or_linear_size %u.\n", dds->header.pitch_or_linear_size);
1584  ok(dds->header.caps == (DDS_CAPS_TEXTURE | DDSCAPS_ALPHA), "Got unexpected caps %#x.\n", dds->header.caps);
1585  ok(dds->header.flags == (DDS_CAPS | DDS_HEIGHT | DDS_WIDTH | DDS_PIXELFORMAT),
1586  "Got unexpected flags %#x.\n", dds->header.flags);
1588  }
1589 
1591  ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
1592 
1594  ok(dds->magic == MAKEFOURCC('D','D','S',' '), "Got unexpected DDS signature %#x.\n", dds->magic);
1595  ok(dds->header.size == sizeof(dds->header), "Got unexpected DDS size %u.\n", dds->header.size);
1596  ok(dds->header.height == 4, "Got unexpected height %u.\n", dds->header.height);
1597  ok(dds->header.width == 4, "Got unexpected width %u.\n", dds->header.width);
1598  ok(!dds->header.depth, "Got unexpected depth %u.\n", dds->header.depth);
1599  ok(!dds->header.miplevels, "Got unexpected miplevels %u.\n", dds->header.miplevels);
1600  ok(!dds->header.pitch_or_linear_size, "Got unexpected pitch_or_linear_size %u.\n", dds->header.pitch_or_linear_size);
1601  todo_wine ok(dds->header.caps == (DDS_CAPS_TEXTURE | DDSCAPS_ALPHA), "Got unexpected caps %#x.\n", dds->header.caps);
1602  ok(dds->header.flags == (DDS_CAPS | DDS_HEIGHT | DDS_WIDTH | DDS_PIXELFORMAT),
1603  "Got unexpected flags %#x.\n", dds->header.flags);
1605 
1606  IDirect3DSurface9_Release(surface);
1607 
1608  for (i = 0; i < ARRAY_SIZE(test_access_types); ++i)
1609  {
1610  hr = IDirect3DDevice9_CreateTexture(device, 4, 4, 0, test_access_types[i].usage,
1611  D3DFMT_A8R8G8B8, test_access_types[i].pool, &texture, NULL);
1612  ok(hr == D3D_OK, "Unexpected hr %#x, i %u.\n", hr, i);
1613 
1615  ok(hr == D3D_OK, "Unexpected hr %#x, i %u.\n", hr, i);
1616 
1618  ok(hr == D3D_OK, "Unexpected hr %#x, i %u.\n", hr, i);
1620 
1622  ok(hr == D3D_OK, "Unexpected hr %#x, i %u.\n", hr, i);
1624 
1625  IDirect3DSurface9_Release(surface);
1627  }
1628 }
#define IDirect3DSurface9_Release(p)
Definition: d3d9.h:622
#define DDSCAPS_ALPHA
Definition: surface.c:310
HRESULT hr
Definition: shlfolder.c:183
#define IDirect3DTexture9_GetSurfaceLevel(p, a, b)
Definition: d3d9.h:1033
#define IDirect3DTexture9_Release(p)
Definition: d3d9.h:1014
enum _D3DPOOL D3DPOOL
#define D3DERR_INVALIDCALL
u32_t magic(void)
GLuint buffer
Definition: glext.h:5915
#define DDS_HEIGHT
Definition: surface.c:302
& rect
Definition: startmenu.cpp:1413
#define IDirect3DDevice9_CreateOffscreenPlainSurface(p, a, b, c, d, e, f)
Definition: d3d9.h:1543
Definition: devices.h:37
if SUCCEEDED(hr)
struct ID3DXBuffer ID3DXBuffer
Definition: d3dx8core.h:51
#define DDS_CAPS_TEXTURE
Definition: surface.c:311
#define ID3DXBuffer_GetBufferSize(p)
Definition: d3dx9core.h:86
GLsizeiptr size
Definition: glext.h:5919
GLenum GLuint texture
Definition: glext.h:6295
LONG HRESULT
Definition: typedefs.h:79
#define D3DUSAGE_RENDERTARGET
Definition: d3d8types.h:91
#define DDS_WIDTH
Definition: surface.c:303
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
HRESULT WINAPI D3DXSaveSurfaceToFileInMemory(ID3DXBuffer **dst_buffer, D3DXIMAGE_FILEFORMAT file_format, IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect)
Definition: surface.c:2414
#define todo_wine
Definition: test.h:164
GLsizeiptr const GLvoid GLenum usage
Definition: glext.h:5919
BOOL WINAPI SetRectEmpty(_Out_ LPRECT)
unsigned char BYTE
Definition: xxhash.c:193
#define broken(x)
Definition: _sntprintf.h:21
#define D3D_OK
Definition: d3d.h:106
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 IDirect3DDevice9_CreateTexture(p, a, b, c, d, e, f, g, h)
Definition: d3d9.h:1530
#define ARRAY_SIZE(a)
Definition: main.h:24
#define ID3DXBuffer_Release(p)
Definition: d3dx9core.h:83
#define ok(value,...)
Definition: atltest.h:57
#define NULL
Definition: types.h:112
#define skip(...)
Definition: atltest.h:64
#define DDS_CAPS
Definition: surface.c:301
#define MAKEFOURCC(ch0, ch1, ch2, ch3)
Definition: dmdls.h:24
#define ID3DXBuffer_GetBufferPointer(p)
Definition: d3dx9core.h:85
#define DDS_PIXELFORMAT
Definition: surface.c:305

Referenced by START_TEST().

◆ test_dds_header_handling()

static void test_dds_header_handling ( void  )
static

Definition at line 410 of file surface.c.

411 {
412  int i;
413  HRESULT hr;
415  struct
416  {
417  DWORD magic;
418  struct dds_header header;
419  BYTE data[4096 * 1024];
420  } *dds;
421 
422  struct
423  {
425  DWORD flags;
426  DWORD width;
427  DWORD height;
428  DWORD pitch;
429  DWORD miplevels;
430  DWORD pixel_data_size;
431  struct
432  {
433  HRESULT hr;
434  UINT miplevels;
435  }
436  expected;
437  } tests[] = {
438  /* pitch is ignored */
439  { { 32, DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }, 0, 4, 4, 0, 0,
440  63 /* pixel data size */, { D3DXERR_INVALIDDATA, 0 } },
441  { { 32, DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }, DDS_PITCH, 4, 4, 0 /* pitch */, 0,
442  64, { D3D_OK, 1 } },
443  { { 32, DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }, DDS_PITCH, 4, 4, 1 /* pitch */, 0,
444  64, { D3D_OK, 1 } },
445  { { 32, DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }, DDS_PITCH, 4, 4, 2 /* pitch */, 0,
446  64, { D3D_OK, 1 } },
447  { { 32, DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }, DDS_PITCH, 4, 4, 3 /* pitch */, 0,
448  64, { D3D_OK, 1 } },
449  { { 32, DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }, DDS_PITCH, 4, 4, 4 /* pitch */, 0,
450  64, { D3D_OK, 1 } },
451  { { 32, DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }, DDS_PITCH, 4, 4, 16 /* pitch */, 0,
452  64, { D3D_OK, 1 } },
453  { { 32, DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }, DDS_PITCH, 4, 4, 1024 /* pitch */, 0,
454  64, { D3D_OK, 1 } },
455  { { 32, DDS_PF_RGB | DDS_PF_ALPHA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }, DDS_PITCH, 4, 4, -1 /* pitch */, 0,
456  64, { D3D_OK, 1 } },
457  /* linear size is ignored */
458  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, 0, 4, 4, 0, 0,
459  7 /* pixel data size */, { D3DXERR_INVALIDDATA, 1 } },
460  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_LINEARSIZE, 4, 4, 0 /* linear size */, 0,
461  8, { D3D_OK, 1 } },
462  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_LINEARSIZE, 4, 4, 1 /* linear size */, 0,
463  8, { D3D_OK, 1 } },
464  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_LINEARSIZE, 4, 4, 2 /* linear size */, 0,
465  8, { D3D_OK, 1 } },
466  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_LINEARSIZE, 4, 4, 9 /* linear size */, 0,
467  8, { D3D_OK, 1 } },
468  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_LINEARSIZE, 4, 4, 16 /* linear size */, 0,
469  8, { D3D_OK, 1 } },
470  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_LINEARSIZE, 4, 4, -1 /* linear size */, 0,
471  8, { D3D_OK, 1 } },
472  /* integer overflows */
473  { { 32, DDS_PF_RGB, 0, 32, 0xff0000, 0x00ff00, 0x0000ff, 0 }, 0, 0x80000000, 0x80000000 /* 0x80000000 * 0x80000000 * 4 = 0 */, 0, 0,
474  64, { D3D_OK, 1 } },
475  { { 32, DDS_PF_RGB, 0, 32, 0xff0000, 0x00ff00, 0x0000ff, 0 }, 0, 0x8000100, 0x800100 /* 0x8000100 * 0x800100 * 4 = 262144 */, 0, 0,
476  64, { D3DXERR_INVALIDDATA, 0 } },
477  { { 32, DDS_PF_RGB, 0, 32, 0xff0000, 0x00ff00, 0x0000ff, 0 }, 0, 0x80000001, 0x80000001 /* 0x80000001 * 0x80000001 * 4 = 4 */, 0, 0,
478  4, { D3D_OK, 1 } },
479  { { 32, DDS_PF_RGB, 0, 32, 0xff0000, 0x00ff00, 0x0000ff, 0 }, 0, 0x80000001, 0x80000001 /* 0x80000001 * 0x80000001 * 4 = 4 */, 0, 0,
480  3 /* pixel data size */, { D3DXERR_INVALIDDATA, 0 } },
481  /* file size is validated */
482  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, 0, 256, 64, 0, 0, 49151, { D3DXERR_INVALIDDATA, 0 } },
483  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, 0, 256, 64, 0, 0, 49152, { D3D_OK, 1 } },
484  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 64, 0, 4, 65279, { D3DXERR_INVALIDDATA, 0 } },
485  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 64, 0, 4, 65280, { D3D_OK, 4 } },
486  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 64, 0, 9, 65540, { D3DXERR_INVALIDDATA, 0 } },
487  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 64, 0, 9, 65541, { D3D_OK, 9 } },
488  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, 0, 256, 256, 0, 0, 196607, { D3DXERR_INVALIDDATA, 0 } },
489  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, 0, 256, 256, 0, 0, 196608, { D3D_OK, 1 } },
490  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, 0, 256, 256, 0, 0, 196609, { D3D_OK, 1 } },
491  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 256, 0, 1, 196607, { D3DXERR_INVALIDDATA, 0 } },
492  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 256, 0, 1, 196608, { D3D_OK, 1 } },
493  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 256, 0, 0, 196607, { D3DXERR_INVALIDDATA, 0 } },
494  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 256, 0, 0, 196608, { D3D_OK, 1 } },
495  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 256, 0, 0, 400000, { D3D_OK, 1 } },
496  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 256, 0, 9, 262142, { D3DXERR_INVALIDDATA, 0 } },
497  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 256, 0, 9, 262143, { D3D_OK, 9 } },
498  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 256, 0, 10, 262145, { D3DXERR_INVALIDDATA, 0 } },
499  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 256, 0, 10, 262146, { D3D_OK, 10 } },
500  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 256, 0, 20, 262175, { D3DXERR_INVALIDDATA, 0 } },
501  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, DDS_MIPMAPCOUNT, 256, 256, 0, 20, 262176, { D3D_OK, 20 } },
502  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, 0, 256, 256, 0, 0, 32767, { D3DXERR_INVALIDDATA, 0 } },
503  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, 0, 256, 256, 0, 0, 32768, { D3D_OK, 1 } },
504  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 0, 32767, { D3DXERR_INVALIDDATA, 0 } },
505  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 0, 32768, { D3D_OK, 1 } },
506  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 9, 43703, { D3DXERR_INVALIDDATA, 0 } },
507  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 9, 43704, { D3D_OK, 9 } },
508  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 20, 43791, { D3DXERR_INVALIDDATA, 0 } },
509  { { 32, DDS_PF_FOURCC, D3DFMT_DXT1, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 20, 43792, { D3D_OK, 20 } },
510  { { 32, DDS_PF_FOURCC, D3DFMT_DXT4, 0, 0, 0, 0, 0 }, 0, 256, 256, 0, 0, 65535, { D3DXERR_INVALIDDATA, 0 } },
511  { { 32, DDS_PF_FOURCC, D3DFMT_DXT4, 0, 0, 0, 0, 0 }, 0, 256, 256, 0, 0, 65536, { D3D_OK, 1 } },
512  { { 32, DDS_PF_FOURCC, D3DFMT_DXT4, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 0, 65535, { D3DXERR_INVALIDDATA, 0 } },
513  { { 32, DDS_PF_FOURCC, D3DFMT_DXT4, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 0, 65536, { D3D_OK, 1 } },
514  { { 32, DDS_PF_FOURCC, D3DFMT_DXT4, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 9, 87407, { D3DXERR_INVALIDDATA, 0 } },
515  { { 32, DDS_PF_FOURCC, D3DFMT_DXT4, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 9, 87408, { D3D_OK, 9 } },
516  { { 32, DDS_PF_FOURCC, D3DFMT_DXT4, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 20, 87583, { D3DXERR_INVALIDDATA, 0 } },
517  { { 32, DDS_PF_FOURCC, D3DFMT_DXT4, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 256, 0, 20, 87584, { D3D_OK, 20 } },
518  { { 32, DDS_PF_FOURCC, D3DFMT_DXT4, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 64, 0, 4, 21759, { D3DXERR_INVALIDDATA, 0 } },
519  { { 32, DDS_PF_FOURCC, D3DFMT_DXT4, 0, 0, 0, 0, 0 }, DDS_MIPMAPCOUNT, 256, 64, 0, 4, 21760, { D3D_OK, 4 } },
520  /* DDS_MIPMAPCOUNT is ignored */
521  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, 0, 256, 256, 0, 0, 262146, { D3D_OK, 1 } },
522  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, 0, 256, 256, 0, 2, 262146, { D3D_OK, 2 } },
523  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, 0, 256, 256, 0, 9, 262146, { D3D_OK, 9 } },
524  { { 32, DDS_PF_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000 }, 0, 256, 256, 0, 10, 262146, { D3D_OK, 10 } },
525  };
526 
527  dds = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dds));
528  if (!dds)
529  {
530  skip("Failed to allocate memory.\n");
531  return;
532  }
533 
534  for (i = 0; i < ARRAY_SIZE(tests); i++)
535  {
536  DWORD file_size = sizeof(dds->magic) + sizeof(dds->header) + tests[i].pixel_data_size;
537  assert(file_size <= sizeof(*dds));
538 
539  dds->magic = MAKEFOURCC('D','D','S',' ');
540  fill_dds_header(&dds->header);
541  dds->header.flags |= tests[i].flags;
542  dds->header.width = tests[i].width;
543  dds->header.height = tests[i].height;
544  dds->header.pitch_or_linear_size = tests[i].pitch;
545  dds->header.miplevels = tests[i].miplevels;
546  dds->header.pixel_format = tests[i].pixel_format;
547 
549  ok(hr == tests[i].expected.hr, "%d: D3DXGetImageInfoFromFileInMemory returned %#x, expected %#x\n",
550  i, hr, tests[i].expected.hr);
551  if (SUCCEEDED(hr))
552  {
553  ok(info.MipLevels == tests[i].expected.miplevels, "%d: Got MipLevels %u, expected %u\n",
554  i, info.MipLevels, tests[i].expected.miplevels);
555  }
556  }
557 
558  HeapFree(GetProcessHeap(), 0, dds);
559 }
#define DDS_MIPMAPCOUNT
Definition: surface.c:306
GLint GLint GLsizei width
Definition: gl.h:1546
#define DDS_PF_RGB
Definition: surface.c:317
HRESULT hr
Definition: shlfolder.c:183
static struct test_info tests[]
u32_t magic(void)
#define assert(x)
Definition: debug.h:53
static void fill_dds_header(struct dds_header *header)
Definition: surface.c:353
#define DDS_PF_ALPHA
Definition: surface.c:314
if SUCCEEDED(hr)
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define DDS_LINEARSIZE
Definition: surface.c:307
LONG HRESULT
Definition: typedefs.h:79
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLbitfield flags
Definition: glext.h:7161
struct _test_info info[]
Definition: SetCursorPos.c:19
unsigned char BYTE
Definition: xxhash.c:193
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define DDS_PITCH
Definition: surface.c:304
#define D3D_OK
Definition: d3d.h:106
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 ARRAY_SIZE(a)
Definition: main.h:24
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define skip(...)
Definition: atltest.h:64
#define DDS_PF_FOURCC
Definition: surface.c:316
HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(const void *data, UINT datasize, D3DXIMAGE_INFO *info)
Definition: surface.c:985
#define MAKEFOURCC(ch0, ch1, ch2, ch3)
Definition: dmdls.h:24
#define HeapFree(x, y, z)
Definition: compat.h:594
BOOL expected
Definition: store.c:2063
#define file_size(inode)
Definition: reiserfs_fs.h:1869

Referenced by test_D3DXGetImageInfo().

Variable Documentation

◆ bmp_1bpp

const unsigned char bmp_1bpp[]
static
Initial value:
= {
0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0xf1,0xf2,0xf3,0x80,0xf4,0xf5,0xf6,0x81,0x00,0x00,
0x00,0x00
}

Definition at line 35 of file surface.c.

Referenced by test_D3DXGetImageInfo(), and test_D3DXLoadSurface().

◆ bmp_2bpp

const unsigned char bmp_2bpp[]
static
Initial value:
= {
0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x02,0x00,0x00,0x00,
0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0xf1,0xf2,0xf3,0x80,0xf4,0xf5,0xf6,0x81,0x00,0x00,
0x00,0x00
}

Definition at line 44 of file surface.c.

Referenced by test_D3DXGetImageInfo().

◆ bmp_32bpp_argb

const unsigned char bmp_32bpp_argb[]
static
Initial value:
=
{
0x42,0x4d,0x46,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x36,0x00,0x00,0x00,0x28,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x01,0x00,0x20,0x00,0x00,0x00,
0x00,0x00,0x10,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0xa0,0xb0,0xc0,0x00,0xa1,0xb1,0xc1,0x00,0xa2,0xb2,
0xc2,0x00,0xa3,0xb3,0xc3,0x01
}

Definition at line 81 of file surface.c.

Referenced by test_D3DXGetImageInfo().

◆ bmp_32bpp_xrgb

const unsigned char bmp_32bpp_xrgb[]
static
Initial value:
=
{
0x42,0x4d,0x46,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x36,0x00,0x00,0x00,0x28,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x01,0x00,0x20,0x00,0x00,0x00,
0x00,0x00,0x10,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0xa0,0xb0,0xc0,0x00,0xa1,0xb1,0xc1,0x00,0xa2,0xb2,
0xc2,0x00,0xa3,0xb3,0xc3,0x00
}

Definition at line 71 of file surface.c.

Referenced by test_D3DXGetImageInfo().

◆ bmp_4bpp

const unsigned char bmp_4bpp[]
static
Initial value:
= {
0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x04,0x00,0x00,0x00,
0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0xf1,0xf2,0xf3,0x80,0xf4,0xf5,0xf6,0x81,0x00,0x00,
0x00,0x00
}

Definition at line 53 of file surface.c.

Referenced by test_D3DXGetImageInfo().

◆ bmp_8bpp

const unsigned char bmp_8bpp[]
static
Initial value:
= {
0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x08,0x00,0x00,0x00,
0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0xf1,0xf2,0xf3,0x80,0xf4,0xf5,0xf6,0x81,0x00,0x00,
0x00,0x00
}

Definition at line 62 of file surface.c.

Referenced by test_D3DXGetImageInfo().

◆ dds_16bit

const unsigned char dds_16bit[]
static
Initial value:
= {
0x44,0x44,0x53,0x20,0x7c,0x00,0x00,0x00,0x07,0x10,0x08,0x00,0x02,0x00,0x00,0x00,
0x02,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,
0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x7c,0x00,0x00,
0xe0,0x03,0x00,0x00,0x1f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0x7f,0xff,0x7f,0xff,0x7f,0xff,0x7f
}

Definition at line 205 of file surface.c.

Referenced by test_D3DXGetImageInfo().

◆ dds_24bit

const unsigned char dds_24bit[]
static
Initial value:
= {
0x44,0x44,0x53,0x20,0x7c,0x00,0x00,0x00,0x07,0x10,0x0a,0x00,0x02,0x00,0x00,0x00,
0x02,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,
0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0xff,0x00,
0x00,0xff,0x00,0x00,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x10,0x40,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
}

Definition at line 192 of file surface.c.

Referenced by test_D3DXGetImageInfo(), and test_D3DXLoadSurface().

◆ dds_8bit

const unsigned char dds_8bit[]
static

Definition at line 111 of file surface.c.

Referenced by test_D3DXGetImageInfo().

◆ dds_cube_map

const unsigned char dds_cube_map[]
static
Initial value:
= {
0x44,0x44,0x53,0x20,0x7c,0x00,0x00,0x00,0x07,0x10,0x08,0x00,0x04,0x00,0x00,0x00,
0x04,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,
0x04,0x00,0x00,0x00,0x44,0x58,0x54,0x35,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x10,0x00,0x00,
0x00,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0xef,0x87,0x0f,0x78,0x05,0x05,0x50,0x50,
0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0xef,0x87,0x0f,0x78,0x05,0x05,0x50,0x50,
0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0xef,0x87,0x0f,0x78,0x05,0x05,0x50,0x50,
0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0xef,0x87,0x0f,0x78,0x05,0x05,0x50,0x50,
0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0xef,0x87,0x0f,0x78,0x05,0x05,0x50,0x50,
0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0xef,0x87,0x0f,0x78,0x05,0x05,0x50,0x50
}

Definition at line 218 of file surface.c.

Referenced by test_D3DXGetImageInfo().

◆ dds_dxt5

const BYTE dds_dxt5[]
static
Initial value:
=
{
0x44,0x44,0x53,0x20,0x7c,0x00,0x00,0x00,0x07,0x10,0x08,0x00,0x02,0x00,0x00,0x00,
0x04,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,
0x04,0x00,0x00,0x00,0x44,0x58,0x54,0x35,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x10,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0xef,0x87,0x0f,0x78,0x05,0x05,0x50,0x50,
}

Definition at line 252 of file surface.c.

Referenced by test_D3DXLoadSurface().

◆ dds_dxt5_8_8

const BYTE dds_dxt5_8_8[]
static
Initial value:
=
{
0x44,0x44,0x53,0x20,0x7c,0x00,0x00,0x00,0x07,0x10,0x08,0x00,0x08,0x00,0x00,0x00,
0x08,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,
0x04,0x00,0x00,0x00,0x44,0x58,0x54,0x35,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x10,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0x00,0xe0,0x07,0x05,0x05,0x50,0x50,
0x3f,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf8,0xff,0x07,0x05,0x05,0x50,0x50,
0x7f,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0xf8,0xe0,0xff,0x05,0x05,0x50,0x50,
0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x00,0x00,0x05,0x05,0x50,0x50,
}

Definition at line 266 of file surface.c.

Referenced by test_D3DXLoadSurface().

◆ dds_volume_map

const unsigned char dds_volume_map[]
static
Initial value:
= {
0x44,0x44,0x53,0x20,0x7c,0x00,0x00,0x00,0x07,0x10,0x8a,0x00,0x04,0x00,0x00,0x00,
0x04,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,
0x04,0x00,0x00,0x00,0x44,0x58,0x54,0x33,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x10,0x40,0x00,
0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0x87,0x0f,0x78,0x05,0x05,0x50,0x50,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0x87,0x0f,0x78,0x05,0x05,0x50,0x50,
0xff,0x00,0xff,0x00,0x00,0x00,0x00,0x00,0x2f,0x7e,0xcf,0x79,0x01,0x54,0x5c,0x5c,
0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x84,0xef,0x7b,0xaa,0xab,0xab,0xab
}

Definition at line 236 of file surface.c.

Referenced by test_D3DXGetImageInfo().

◆ noimage

const unsigned char noimage[4]
static
Initial value:
= {
0x11,0x22,0x33,0x44
}

Definition at line 106 of file surface.c.

Referenced by test_D3DXGetImageInfo(), and test_D3DXLoadSurface().

◆ pixdata

const unsigned char pixdata[]
static
Initial value:
= {
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
}

Definition at line 101 of file surface.c.

Referenced by D3DXLoadSurfaceFromMemory(), fetch_2d_texel_rgb_dxt1(), fetch_2d_texel_rgba_dxt1(), fetch_2d_texel_rgba_dxt3(), fetch_2d_texel_rgba_dxt5(), and test_D3DXLoadSurface().

◆ png_grayscale

const unsigned char png_grayscale[]
static
Initial value:
=
{
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49,
0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00,
0x00, 0x00, 0x00, 0x3a, 0x7e, 0x9b, 0x55, 0x00, 0x00, 0x00, 0x0a, 0x49, 0x44,
0x41, 0x54, 0x08, 0xd7, 0x63, 0xf8, 0x0f, 0x00, 0x01, 0x01, 0x01, 0x00, 0x1b,
0xb6, 0xee, 0x56, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82
}

Definition at line 90 of file surface.c.

Referenced by test_D3DXGetImageInfo().