ReactOS  0.4.15-dev-3316-g067ca88
surface.c File Reference
#include "d3dx9_private.h"
#include "initguid.h"
#include "ole2.h"
#include "wincodec.h"
#include "txc_dxtn.h"
Include dependency graph for surface.c:

Go to the source code of this file.

Classes

struct  dds_pixel_format
 
struct  dds_header
 
struct  argb_conversion_info
 

Macros

#define DDS_CAPS   0x1
 
#define DDS_HEIGHT   0x2
 
#define DDS_WIDTH   0x4
 
#define DDS_PITCH   0x8
 
#define DDS_PIXELFORMAT   0x1000
 
#define DDS_MIPMAPCOUNT   0x20000
 
#define DDS_LINEARSIZE   0x80000
 
#define DDS_DEPTH   0x800000
 
#define DDS_CAPS_COMPLEX   0x8
 
#define DDS_CAPS_TEXTURE   0x1000
 
#define DDS_CAPS_MIPMAP   0x400000
 
#define DDS_CAPS2_CUBEMAP   0x200
 
#define DDS_CAPS2_CUBEMAP_POSITIVEX   0x400
 
#define DDS_CAPS2_CUBEMAP_NEGATIVEX   0x800
 
#define DDS_CAPS2_CUBEMAP_POSITIVEY   0x1000
 
#define DDS_CAPS2_CUBEMAP_NEGATIVEY   0x2000
 
#define DDS_CAPS2_CUBEMAP_POSITIVEZ   0x4000
 
#define DDS_CAPS2_CUBEMAP_NEGATIVEZ   0x8000
 
#define DDS_CAPS2_CUBEMAP_ALL_FACES
 
#define DDS_CAPS2_VOLUME   0x200000
 
#define DDS_PF_ALPHA   0x1
 
#define DDS_PF_ALPHA_ONLY   0x2
 
#define DDS_PF_FOURCC   0x4
 
#define DDS_PF_INDEXED   0x20
 
#define DDS_PF_RGB   0x40
 
#define DDS_PF_YUV   0x200
 
#define DDS_PF_LUMINANCE   0x20000
 
#define DDS_PF_BUMPLUMINANCE   0x40000
 
#define DDS_PF_BUMPDUDV   0x80000
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (d3dx)
 
HRESULT WINAPI WICCreateImagingFactory_Proxy (UINT, IWICImagingFactory **)
 
 DEFINE_GUID (GUID_WineContainerFormatTga, 0x0c44fda1, 0xa5c5, 0x4298, 0x96, 0x85, 0x47, 0x3f, 0xc1, 0x7c, 0xd3, 0x22)
 
static D3DFORMAT wic_guid_to_d3dformat (const GUID *guid)
 
static const GUIDd3dformat_to_wic_guid (D3DFORMAT format)
 
static D3DFORMAT dds_fourcc_to_d3dformat (DWORD fourcc)
 
HRESULT lock_surface (IDirect3DSurface9 *surface, const RECT *surface_rect, D3DLOCKED_RECT *lock, IDirect3DSurface9 **temp_surface, BOOL write)
 
HRESULT unlock_surface (IDirect3DSurface9 *surface, const RECT *surface_rect, IDirect3DSurface9 *temp_surface, BOOL update)
 
static D3DFORMAT dds_rgb_to_d3dformat (const struct dds_pixel_format *pixel_format)
 
static D3DFORMAT dds_luminance_to_d3dformat (const struct dds_pixel_format *pixel_format)
 
static D3DFORMAT dds_alpha_to_d3dformat (const struct dds_pixel_format *pixel_format)
 
static D3DFORMAT dds_indexed_to_d3dformat (const struct dds_pixel_format *pixel_format)
 
static D3DFORMAT dds_bump_to_d3dformat (const struct dds_pixel_format *pixel_format)
 
static D3DFORMAT dds_bump_luminance_to_d3dformat (const struct dds_pixel_format *pixel_format)
 
static D3DFORMAT dds_pixel_format_to_d3dformat (const struct dds_pixel_format *pixel_format)
 
static HRESULT d3dformat_to_dds_pixel_format (struct dds_pixel_format *pixel_format, D3DFORMAT d3dformat)
 
static HRESULT calculate_dds_surface_size (D3DFORMAT format, UINT width, UINT height, UINT *pitch, UINT *size)
 
static UINT calculate_dds_file_size (D3DFORMAT format, UINT width, UINT height, UINT depth, UINT miplevels, UINT faces)
 
static HRESULT get_image_info_from_dds (const void *buffer, UINT length, D3DXIMAGE_INFO *info)
 
static HRESULT load_surface_from_dds (IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, const void *src_data, const RECT *src_rect, DWORD filter, D3DCOLOR color_key, const D3DXIMAGE_INFO *src_info)
 
static HRESULT save_dds_surface_to_memory (ID3DXBuffer **dst_buffer, IDirect3DSurface9 *src_surface, const RECT *src_rect)
 
static HRESULT get_surface (D3DRESOURCETYPE type, struct IDirect3DBaseTexture9 *tex, int face, UINT level, struct IDirect3DSurface9 **surf)
 
HRESULT save_dds_texture_to_memory (ID3DXBuffer **dst_buffer, IDirect3DBaseTexture9 *src_texture, const PALETTEENTRY *src_palette)
 
HRESULT load_volume_from_dds (IDirect3DVolume9 *dst_volume, const PALETTEENTRY *dst_palette, const D3DBOX *dst_box, const void *src_data, const D3DBOX *src_box, DWORD filter, D3DCOLOR color_key, const D3DXIMAGE_INFO *src_info)
 
HRESULT load_texture_from_dds (IDirect3DTexture9 *texture, const void *src_data, const PALETTEENTRY *palette, DWORD filter, D3DCOLOR color_key, const D3DXIMAGE_INFO *src_info, unsigned int skip_levels, unsigned int *loaded_miplevels)
 
HRESULT load_cube_texture_from_dds (IDirect3DCubeTexture9 *cube_texture, const void *src_data, const PALETTEENTRY *palette, DWORD filter, DWORD color_key, const D3DXIMAGE_INFO *src_info)
 
HRESULT load_volume_texture_from_dds (IDirect3DVolumeTexture9 *volume_texture, const void *src_data, const PALETTEENTRY *palette, DWORD filter, DWORD color_key, const D3DXIMAGE_INFO *src_info)
 
static BOOL convert_dib_to_bmp (const void **data, unsigned int *size)
 
HRESULT WINAPI D3DXGetImageInfoFromFileInMemory (const void *data, UINT datasize, D3DXIMAGE_INFO *info)
 
HRESULT WINAPI D3DXGetImageInfoFromFileA (const char *file, D3DXIMAGE_INFO *info)
 
HRESULT WINAPI D3DXGetImageInfoFromFileW (const WCHAR *file, D3DXIMAGE_INFO *info)
 
HRESULT WINAPI D3DXGetImageInfoFromResourceA (HMODULE module, const char *resource, D3DXIMAGE_INFO *info)
 
HRESULT WINAPI D3DXGetImageInfoFromResourceW (HMODULE module, const WCHAR *resource, D3DXIMAGE_INFO *info)
 
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)
 
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)
 
HRESULT WINAPI D3DXLoadSurfaceFromFileW (IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, const WCHAR *src_file, const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
 
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)
 
HRESULT WINAPI D3DXLoadSurfaceFromResourceW (IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, HMODULE src_module, const WCHAR *resource, const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
 
static void init_argb_conversion_info (const struct pixel_format_desc *srcformat, const struct pixel_format_desc *destformat, struct argb_conversion_info *info)
 
static void get_relevant_argb_components (const struct argb_conversion_info *info, const BYTE *col, DWORD *out)
 
static DWORD make_argb_color (const struct argb_conversion_info *info, const DWORD *in)
 
static void format_to_vec4 (const struct pixel_format_desc *format, const BYTE *src, struct vec4 *dst)
 
static void format_from_vec4 (const struct pixel_format_desc *format, const struct vec4 *src, BYTE *dst)
 
void copy_pixels (const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *size, const struct pixel_format_desc *format)
 
void convert_argb_pixels (const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, const struct volume *src_size, const struct pixel_format_desc *src_format, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *dst_size, const struct pixel_format_desc *dst_format, D3DCOLOR color_key, const PALETTEENTRY *palette)
 
void point_filter_argb_pixels (const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, const struct volume *src_size, const struct pixel_format_desc *src_format, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *dst_size, const struct pixel_format_desc *dst_format, D3DCOLOR color_key, const PALETTEENTRY *palette)
 
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)
 
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)
 
HRESULT WINAPI D3DXSaveSurfaceToFileA (const char *dst_filename, D3DXIMAGE_FILEFORMAT file_format, IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect)
 
HRESULT WINAPI D3DXSaveSurfaceToFileW (const WCHAR *dst_filename, D3DXIMAGE_FILEFORMAT file_format, IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect)
 
HRESULT WINAPI D3DXSaveSurfaceToFileInMemory (ID3DXBuffer **dst_buffer, D3DXIMAGE_FILEFORMAT file_format, IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect)
 

Variables

struct {
   const GUID *   wic_guid
 
   D3DFORMAT   d3dformat
 
wic_pixel_formats []
 
struct {
   DWORD   bpp
 
   DWORD   rmask
 
   DWORD   gmask
 
   DWORD   bmask
 
   DWORD   amask
 
   D3DFORMAT   format
 
rgb_pixel_formats []
 

Macro Definition Documentation

◆ DDS_CAPS

#define DDS_CAPS   0x1

Definition at line 84 of file surface.c.

◆ DDS_CAPS2_CUBEMAP

#define DDS_CAPS2_CUBEMAP   0x200

Definition at line 99 of file surface.c.

◆ DDS_CAPS2_CUBEMAP_ALL_FACES

#define DDS_CAPS2_CUBEMAP_ALL_FACES
Value:
#define DDS_CAPS2_CUBEMAP_NEGATIVEX
Definition: surface.c:101
#define DDS_CAPS2_CUBEMAP_POSITIVEY
Definition: surface.c:102
#define DDS_CAPS2_CUBEMAP_NEGATIVEZ
Definition: surface.c:105
#define DDS_CAPS2_CUBEMAP_NEGATIVEY
Definition: surface.c:103
#define DDS_CAPS2_CUBEMAP_POSITIVEX
Definition: surface.c:100
#define DDS_CAPS2_CUBEMAP_POSITIVEZ
Definition: surface.c:104

Definition at line 106 of file surface.c.

◆ DDS_CAPS2_CUBEMAP_NEGATIVEX

#define DDS_CAPS2_CUBEMAP_NEGATIVEX   0x800

Definition at line 101 of file surface.c.

◆ DDS_CAPS2_CUBEMAP_NEGATIVEY

#define DDS_CAPS2_CUBEMAP_NEGATIVEY   0x2000

Definition at line 103 of file surface.c.

◆ DDS_CAPS2_CUBEMAP_NEGATIVEZ

#define DDS_CAPS2_CUBEMAP_NEGATIVEZ   0x8000

Definition at line 105 of file surface.c.

◆ DDS_CAPS2_CUBEMAP_POSITIVEX

#define DDS_CAPS2_CUBEMAP_POSITIVEX   0x400

Definition at line 100 of file surface.c.

◆ DDS_CAPS2_CUBEMAP_POSITIVEY

#define DDS_CAPS2_CUBEMAP_POSITIVEY   0x1000

Definition at line 102 of file surface.c.

◆ DDS_CAPS2_CUBEMAP_POSITIVEZ

#define DDS_CAPS2_CUBEMAP_POSITIVEZ   0x4000

Definition at line 104 of file surface.c.

◆ DDS_CAPS2_VOLUME

#define DDS_CAPS2_VOLUME   0x200000

Definition at line 109 of file surface.c.

◆ DDS_CAPS_COMPLEX

#define DDS_CAPS_COMPLEX   0x8

Definition at line 94 of file surface.c.

◆ DDS_CAPS_MIPMAP

#define DDS_CAPS_MIPMAP   0x400000

Definition at line 96 of file surface.c.

◆ DDS_CAPS_TEXTURE

#define DDS_CAPS_TEXTURE   0x1000

Definition at line 95 of file surface.c.

◆ DDS_DEPTH

#define DDS_DEPTH   0x800000

Definition at line 91 of file surface.c.

◆ DDS_HEIGHT

#define DDS_HEIGHT   0x2

Definition at line 85 of file surface.c.

◆ DDS_LINEARSIZE

#define DDS_LINEARSIZE   0x80000

Definition at line 90 of file surface.c.

◆ DDS_MIPMAPCOUNT

#define DDS_MIPMAPCOUNT   0x20000

Definition at line 89 of file surface.c.

◆ DDS_PF_ALPHA

#define DDS_PF_ALPHA   0x1

Definition at line 112 of file surface.c.

◆ DDS_PF_ALPHA_ONLY

#define DDS_PF_ALPHA_ONLY   0x2

Definition at line 113 of file surface.c.

◆ DDS_PF_BUMPDUDV

#define DDS_PF_BUMPDUDV   0x80000

Definition at line 120 of file surface.c.

◆ DDS_PF_BUMPLUMINANCE

#define DDS_PF_BUMPLUMINANCE   0x40000

Definition at line 119 of file surface.c.

◆ DDS_PF_FOURCC

#define DDS_PF_FOURCC   0x4

Definition at line 114 of file surface.c.

◆ DDS_PF_INDEXED

#define DDS_PF_INDEXED   0x20

Definition at line 115 of file surface.c.

◆ DDS_PF_LUMINANCE

#define DDS_PF_LUMINANCE   0x20000

Definition at line 118 of file surface.c.

◆ DDS_PF_RGB

#define DDS_PF_RGB   0x40

Definition at line 116 of file surface.c.

◆ DDS_PF_YUV

#define DDS_PF_YUV   0x200

Definition at line 117 of file surface.c.

◆ DDS_PITCH

#define DDS_PITCH   0x8

Definition at line 87 of file surface.c.

◆ DDS_PIXELFORMAT

#define DDS_PIXELFORMAT   0x1000

Definition at line 88 of file surface.c.

◆ DDS_WIDTH

#define DDS_WIDTH   0x4

Definition at line 86 of file surface.c.

Function Documentation

◆ calculate_dds_file_size()

static UINT calculate_dds_file_size ( D3DFORMAT  format,
UINT  width,
UINT  height,
UINT  depth,
UINT  miplevels,
UINT  faces 
)
static

Definition at line 475 of file surface.c.

477 {
478  UINT i, file_size = 0;
479 
480  for (i = 0; i < miplevels; i++)
481  {
482  UINT pitch, size = 0;
484  size *= depth;
485  file_size += size;
486  width = max(1, width / 2);
487  height = max(1, height / 2);
488  depth = max(1, depth / 2);
489  }
490 
491  file_size *= faces;
492  file_size += sizeof(struct dds_header);
493  return file_size;
494 }
GLint GLint GLsizei width
Definition: gl.h:1546
#define max(a, b)
Definition: svc.c:63
static unsigned int file_size
Definition: regtests2xml.c:47
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
static HRESULT calculate_dds_surface_size(D3DFORMAT format, UINT width, UINT height, UINT *pitch, UINT *size)
Definition: surface.c:452
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
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
unsigned int UINT
Definition: ndis.h:50

Referenced by get_image_info_from_dds(), and save_dds_surface_to_memory().

◆ calculate_dds_surface_size()

static HRESULT calculate_dds_surface_size ( D3DFORMAT  format,
UINT  width,
UINT  height,
UINT pitch,
UINT size 
)
static

Definition at line 452 of file surface.c.

454 {
455  const struct pixel_format_desc *format_desc = get_format_info(format);
456  if (format_desc->type == FORMAT_UNKNOWN)
457  return E_NOTIMPL;
458 
459  if (format_desc->block_width != 1 || format_desc->block_height != 1)
460  {
461  *pitch = format_desc->block_byte_count
462  * max(1, (width + format_desc->block_width - 1) / format_desc->block_width);
463  *size = *pitch
464  * max(1, (height + format_desc->block_height - 1) / format_desc->block_height);
465  }
466  else
467  {
468  *pitch = width * format_desc->bytes_per_pixel;
469  *size = *pitch * height;
470  }
471 
472  return D3D_OK;
473 }
GLint GLint GLsizei width
Definition: gl.h:1546
#define max(a, b)
Definition: svc.c:63
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
enum format_type type
Definition: d3dx9_private.h:66
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define D3D_OK
Definition: d3d.h:106
#define E_NOTIMPL
Definition: ddrawi.h:99
const struct pixel_format_desc * get_format_info(D3DFORMAT format) DECLSPEC_HIDDEN
Definition: util.c:217

Referenced by calculate_dds_file_size(), load_cube_texture_from_dds(), load_surface_from_dds(), load_texture_from_dds(), load_volume_from_dds(), load_volume_texture_from_dds(), and save_dds_surface_to_memory().

◆ convert_argb_pixels()

void convert_argb_pixels ( const BYTE src,
UINT  src_row_pitch,
UINT  src_slice_pitch,
const struct volume src_size,
const struct pixel_format_desc src_format,
BYTE dst,
UINT  dst_row_pitch,
UINT  dst_slice_pitch,
const struct volume dst_size,
const struct pixel_format_desc dst_format,
D3DCOLOR  color_key,
const PALETTEENTRY palette 
)

Definition at line 1731 of file surface.c.

1735 {
1736  struct argb_conversion_info conv_info, ck_conv_info;
1737  const struct pixel_format_desc *ck_format = NULL;
1738  DWORD channels[4];
1739  UINT min_width, min_height, min_depth;
1740  UINT x, y, z;
1741 
1742  TRACE("src %p, src_row_pitch %u, src_slice_pitch %u, src_size %p, src_format %p, dst %p, "
1743  "dst_row_pitch %u, dst_slice_pitch %u, dst_size %p, dst_format %p, color_key 0x%08x, palette %p.\n",
1744  src, src_row_pitch, src_slice_pitch, src_size, src_format, dst, dst_row_pitch, dst_slice_pitch, dst_size,
1746 
1747  ZeroMemory(channels, sizeof(channels));
1748  init_argb_conversion_info(src_format, dst_format, &conv_info);
1749 
1750  min_width = min(src_size->width, dst_size->width);
1751  min_height = min(src_size->height, dst_size->height);
1752  min_depth = min(src_size->depth, dst_size->depth);
1753 
1754  if (color_key)
1755  {
1756  /* Color keys are always represented in D3DFMT_A8R8G8B8 format. */
1757  ck_format = get_format_info(D3DFMT_A8R8G8B8);
1758  init_argb_conversion_info(src_format, ck_format, &ck_conv_info);
1759  }
1760 
1761  for (z = 0; z < min_depth; z++) {
1762  const BYTE *src_slice_ptr = src + z * src_slice_pitch;
1763  BYTE *dst_slice_ptr = dst + z * dst_slice_pitch;
1764 
1765  for (y = 0; y < min_height; y++) {
1766  const BYTE *src_ptr = src_slice_ptr + y * src_row_pitch;
1767  BYTE *dst_ptr = dst_slice_ptr + y * dst_row_pitch;
1768 
1769  for (x = 0; x < min_width; x++) {
1770  if (!src_format->to_rgba && !dst_format->from_rgba
1771  && src_format->type == dst_format->type
1772  && src_format->bytes_per_pixel <= 4 && dst_format->bytes_per_pixel <= 4)
1773  {
1774  DWORD val;
1775 
1776  get_relevant_argb_components(&conv_info, src_ptr, channels);
1777  val = make_argb_color(&conv_info, channels);
1778 
1779  if (color_key)
1780  {
1781  DWORD ck_pixel;
1782 
1783  get_relevant_argb_components(&ck_conv_info, src_ptr, channels);
1784  ck_pixel = make_argb_color(&ck_conv_info, channels);
1785  if (ck_pixel == color_key)
1786  val &= ~conv_info.destmask[0];
1787  }
1788  memcpy(dst_ptr, &val, dst_format->bytes_per_pixel);
1789  }
1790  else
1791  {
1792  struct vec4 color, tmp;
1793 
1794  format_to_vec4(src_format, src_ptr, &color);
1795  if (src_format->to_rgba)
1796  src_format->to_rgba(&color, &tmp, palette);
1797  else
1798  tmp = color;
1799 
1800  if (ck_format)
1801  {
1802  DWORD ck_pixel;
1803 
1804  format_from_vec4(ck_format, &tmp, (BYTE *)&ck_pixel);
1805  if (ck_pixel == color_key)
1806  tmp.w = 0.0f;
1807  }
1808 
1809  if (dst_format->from_rgba)
1810  dst_format->from_rgba(&tmp, &color);
1811  else
1812  color = tmp;
1813 
1814  format_from_vec4(dst_format, &color, dst_ptr);
1815  }
1816 
1817  src_ptr += src_format->bytes_per_pixel;
1818  dst_ptr += dst_format->bytes_per_pixel;
1819  }
1820 
1821  if (src_size->width < dst_size->width) /* black out remaining pixels */
1822  memset(dst_ptr, 0, dst_format->bytes_per_pixel * (dst_size->width - src_size->width));
1823  }
1824 
1825  if (src_size->height < dst_size->height) /* black out remaining pixels */
1826  memset(dst + src_size->height * dst_row_pitch, 0, dst_row_pitch * (dst_size->height - src_size->height));
1827  }
1828  if (src_size->depth < dst_size->depth) /* black out remaining pixels */
1829  memset(dst + src_size->depth * dst_slice_pitch, 0, dst_slice_pitch * (dst_size->depth - src_size->depth));
1830 }
UINT width
Definition: d3dx9_private.h:43
static const char * dst_format
Definition: dib.c:1133
#define ZeroMemory
Definition: winbase.h:1664
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
int This channels
Definition: rdpsnd_libao.c:37
void(* to_rgba)(const struct vec4 *src, struct vec4 *dst, const PALETTEENTRY *palette)
Definition: d3dx9_private.h:68
GLuint color
Definition: glext.h:6243
GLdouble GLdouble z
Definition: glext.h:5874
UINT height
Definition: d3dx9_private.h:44
GLuint GLfloat * val
Definition: glext.h:7180
#define TRACE(s)
Definition: solgame.cpp:4
UINT depth
Definition: d3dx9_private.h:45
enum format_type type
Definition: d3dx9_private.h:66
unsigned long DWORD
Definition: ntddk_ex.h:95
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum src
Definition: glext.h:6340
unsigned char BYTE
Definition: xxhash.c:193
static HPALETTE palette
Definition: clipboard.c:1345
static void format_from_vec4(const struct pixel_format_desc *format, const struct vec4 *src, BYTE *dst)
Definition: surface.c:1650
static void init_argb_conversion_info(const struct pixel_format_desc *srcformat, const struct pixel_format_desc *destformat, struct argb_conversion_info *info)
Definition: surface.c:1539
GLenum GLenum dst
Definition: glext.h:6340
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
static void get_relevant_argb_components(const struct argb_conversion_info *info, const BYTE *col, DWORD *out)
Definition: surface.c:1572
const struct pixel_format_desc * get_format_info(D3DFORMAT format) DECLSPEC_HIDDEN
Definition: util.c:217
static void format_to_vec4(const struct pixel_format_desc *format, const BYTE *src, struct vec4 *dst)
Definition: surface.c:1620
#define memset(x, y, z)
Definition: compat.h:39
static DWORD make_argb_color(const struct argb_conversion_info *info, const DWORD *in)
Definition: surface.c:1602

Referenced by D3DXLoadSurfaceFromMemory(), D3DXLoadVolumeFromMemory(), and D3DXSaveSurfaceToFileInMemory().

◆ convert_dib_to_bmp()

static BOOL convert_dib_to_bmp ( const void **  data,
unsigned int size 
)
static

Definition at line 899 of file surface.c.

900 {
901  ULONG header_size;
902  ULONG count = 0;
903  ULONG offset;
905  BYTE *new_data;
906  UINT new_size;
907 
908  if ((*size < 4) || (*size < (header_size = *(ULONG*)*data)))
909  return FALSE;
910 
911  if ((header_size == sizeof(BITMAPINFOHEADER)) ||
912  (header_size == sizeof(BITMAPV4HEADER)) ||
913  (header_size == sizeof(BITMAPV5HEADER)) ||
914  (header_size == 64 /* sizeof(BITMAPCOREHEADER2) */))
915  {
916  /* All structures begin with the same memory layout as BITMAPINFOHEADER */
917  BITMAPINFOHEADER *info_header = (BITMAPINFOHEADER*)*data;
918  count = info_header->biClrUsed;
919 
920  if (!count && info_header->biBitCount <= 8)
921  count = 1 << info_header->biBitCount;
922 
923  offset = sizeof(BITMAPFILEHEADER) + header_size + sizeof(RGBQUAD) * count;
924 
925  /* For BITMAPINFOHEADER with BI_BITFIELDS compression, there are 3 additional color masks after header */
926  if ((info_header->biSize == sizeof(BITMAPINFOHEADER)) && (info_header->biCompression == BI_BITFIELDS))
927  offset += 3 * sizeof(DWORD);
928  }
929  else if (header_size == sizeof(BITMAPCOREHEADER))
930  {
931  BITMAPCOREHEADER *core_header = (BITMAPCOREHEADER*)*data;
932 
933  if (core_header->bcBitCount <= 8)
934  count = 1 << core_header->bcBitCount;
935 
936  offset = sizeof(BITMAPFILEHEADER) + header_size + sizeof(RGBTRIPLE) * count;
937  }
938  else
939  {
940  return FALSE;
941  }
942 
943  TRACE("Converting DIB file to BMP\n");
944 
945  new_size = *size + sizeof(BITMAPFILEHEADER);
946  new_data = HeapAlloc(GetProcessHeap(), 0, new_size);
947  CopyMemory(new_data + sizeof(BITMAPFILEHEADER), *data, *size);
948 
949  /* Add BMP header */
950  header = (BITMAPFILEHEADER*)new_data;
951  header->bfType = 0x4d42; /* BM */
952  header->bfSize = new_size;
953  header->bfReserved1 = 0;
954  header->bfReserved2 = 0;
955  header->bfOffBits = offset;
956 
957  /* Update input data */
958  *data = new_data;
959  *size = new_size;
960 
961  return TRUE;
962 }
#define TRUE
Definition: types.h:120
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define BI_BITFIELDS
Definition: mmreg.h:507
#define FALSE
Definition: types.h:117
DWORD biCompression
Definition: amvideo.idl:35
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
ULONG RGBQUAD
Definition: precomp.h:50
GLintptr offset
Definition: glext.h:5920
#define CopyMemory
Definition: winbase.h:1662
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
unsigned char BYTE
Definition: xxhash.c:193
struct tagBITMAPFILEHEADER BITMAPFILEHEADER
unsigned int UINT
Definition: ndis.h:50
unsigned int ULONG
Definition: retypes.h:1
struct CFHEADER header
Definition: fdi.c:101

Referenced by D3DXGetImageInfoFromFileInMemory(), and D3DXLoadSurfaceFromFileInMemory().

◆ copy_pixels()

void copy_pixels ( const BYTE src,
UINT  src_row_pitch,
UINT  src_slice_pitch,
BYTE dst,
UINT  dst_row_pitch,
UINT  dst_slice_pitch,
const struct volume size,
const struct pixel_format_desc format 
)

Definition at line 1700 of file surface.c.

1703 {
1704  UINT row, slice;
1705  BYTE *dst_addr;
1706  const BYTE *src_addr;
1707  UINT row_block_count = (size->width + format->block_width - 1) / format->block_width;
1708  UINT row_count = (size->height + format->block_height - 1) / format->block_height;
1709 
1710  for (slice = 0; slice < size->depth; slice++)
1711  {
1712  src_addr = src + slice * src_slice_pitch;
1713  dst_addr = dst + slice * dst_slice_pitch;
1714 
1715  for (row = 0; row < row_count; row++)
1716  {
1717  memcpy(dst_addr, src_addr, row_block_count * format->block_byte_count);
1718  src_addr += src_row_pitch;
1719  dst_addr += dst_row_pitch;
1720  }
1721  }
1722 }
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum src
Definition: glext.h:6340
unsigned char BYTE
Definition: xxhash.c:193
GLenum GLenum dst
Definition: glext.h:6340
unsigned int UINT
Definition: ndis.h:50
struct png_info_def *typedef unsigned char **typedef struct png_info_def *typedef struct png_info_def *typedef struct png_info_def *typedef unsigned char ** row
Definition: typeof.h:78

Referenced by BitmapImpl_CopyPixels(), BmpFrameDecode_CopyPixels(), D3DXLoadSurfaceFromMemory(), D3DXLoadVolumeFromMemory(), GifFrameDecode_CopyPixels(), IcoFrameDecode_CopyPixels(), save_dds_surface_to_memory(), and TgaDecoder_Frame_CopyPixels().

◆ d3dformat_to_dds_pixel_format()

static HRESULT d3dformat_to_dds_pixel_format ( struct dds_pixel_format pixel_format,
D3DFORMAT  d3dformat 
)
static

Definition at line 417 of file surface.c.

418 {
419  unsigned int i;
420 
421  memset(pixel_format, 0, sizeof(*pixel_format));
422 
423  pixel_format->size = sizeof(*pixel_format);
424 
425  for (i = 0; i < ARRAY_SIZE(rgb_pixel_formats); i++)
426  {
428  {
429  pixel_format->flags |= DDS_PF_RGB;
430  pixel_format->bpp = rgb_pixel_formats[i].bpp;
431  pixel_format->rmask = rgb_pixel_formats[i].rmask;
432  pixel_format->gmask = rgb_pixel_formats[i].gmask;
433  pixel_format->bmask = rgb_pixel_formats[i].bmask;
434  pixel_format->amask = rgb_pixel_formats[i].amask;
435  if (pixel_format->amask) pixel_format->flags |= DDS_PF_ALPHA;
436  return D3D_OK;
437  }
438  }
439 
440  /* Reuse dds_fourcc_to_d3dformat as D3DFORMAT and FOURCC are DWORD with same values */
442  {
443  pixel_format->flags |= DDS_PF_FOURCC;
444  pixel_format->fourcc = d3dformat;
445  return D3D_OK;
446  }
447 
448  WARN("Unknown pixel format %#x\n", d3dformat);
449  return E_NOTIMPL;
450 }
#define DDS_PF_FOURCC
Definition: surface.c:114
#define WARN(fmt,...)
Definition: debug.h:112
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
static const struct @237 rgb_pixel_formats[]
D3DFORMAT d3dformat
Definition: surface.c:44
static D3DFORMAT dds_fourcc_to_d3dformat(DWORD fourcc)
Definition: surface.c:153
#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 DDS_PF_RGB
Definition: surface.c:116
#define ARRAY_SIZE(a)
Definition: main.h:24
#define E_NOTIMPL
Definition: ddrawi.h:99
#define DDS_PF_ALPHA
Definition: surface.c:112
#define memset(x, y, z)
Definition: compat.h:39

Referenced by save_dds_surface_to_memory().

◆ d3dformat_to_wic_guid()

static const GUID* d3dformat_to_wic_guid ( D3DFORMAT  format)
static

Definition at line 70 of file surface.c.

71 {
72  unsigned int i;
73 
74  for (i = 0; i < ARRAY_SIZE(wic_pixel_formats); i++)
75  {
77  return wic_pixel_formats[i].wic_guid;
78  }
79 
80  return NULL;
81 }
static const struct @236 wic_pixel_formats[]
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
D3DFORMAT d3dformat
Definition: surface.c:44
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 NULL
Definition: types.h:112

Referenced by D3DXSaveSurfaceToFileInMemory().

◆ D3DXGetImageInfoFromFileA()

HRESULT WINAPI D3DXGetImageInfoFromFileA ( const char file,
D3DXIMAGE_INFO info 
)

Definition at line 1135 of file surface.c.

1136 {
1137  WCHAR *widename;
1138  HRESULT hr;
1139  int strlength;
1140 
1141  TRACE("file %s, info %p.\n", debugstr_a(file), info);
1142 
1143  if( !file ) return D3DERR_INVALIDCALL;
1144 
1145  strlength = MultiByteToWideChar(CP_ACP, 0, file, -1, NULL, 0);
1146  widename = HeapAlloc(GetProcessHeap(), 0, strlength * sizeof(*widename));
1147  MultiByteToWideChar(CP_ACP, 0, file, -1, widename, strlength);
1148 
1149  hr = D3DXGetImageInfoFromFileW(widename, info);
1150  HeapFree(GetProcessHeap(), 0, widename);
1151 
1152  return hr;
1153 }
HRESULT hr
Definition: shlfolder.c:183
#define CP_ACP
Definition: compat.h:109
#define D3DERR_INVALIDCALL
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define debugstr_a
Definition: kernel32.h:31
LONG HRESULT
Definition: typedefs.h:79
HRESULT WINAPI D3DXGetImageInfoFromFileW(const WCHAR *file, D3DXIMAGE_INFO *info)
Definition: surface.c:1155
#define NULL
Definition: types.h:112
#define MultiByteToWideChar
Definition: compat.h:110
#define HeapFree(x, y, z)
Definition: compat.h:594
Definition: fci.c:126

Referenced by test_D3DXGetImageInfo().

◆ D3DXGetImageInfoFromFileInMemory()

HRESULT WINAPI D3DXGetImageInfoFromFileInMemory ( const void data,
UINT  datasize,
D3DXIMAGE_INFO info 
)

Definition at line 985 of file surface.c.

986 {
988  IWICBitmapDecoder *decoder = NULL;
990  HRESULT hr;
991  BOOL dib;
992 
993  TRACE("(%p, %d, %p)\n", data, datasize, info);
994 
995  if (!data || !datasize)
996  return D3DERR_INVALIDCALL;
997 
998  if (!info)
999  return D3D_OK;
1000 
1001  if ((datasize >= 4) && !strncmp(data, "DDS ", 4)) {
1002  TRACE("File type is DDS\n");
1004  }
1005 
1006  /* In case of DIB file, convert it to BMP */
1008 
1009  hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
1010 
1011  if (SUCCEEDED(hr)) {
1012  IWICImagingFactory_CreateStream(factory, &stream);
1013  IWICStream_InitializeFromMemory(stream, (BYTE*)data, datasize);
1014  hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream*)stream, NULL, 0, &decoder);
1015  IWICStream_Release(stream);
1016  IWICImagingFactory_Release(factory);
1017  }
1018 
1019  if (FAILED(hr)) {
1020  if ((datasize >= 2) && (!strncmp(data, "P3", 2) || !strncmp(data, "P6", 2)))
1021  FIXME("File type PPM is not supported yet\n");
1022  else if ((datasize >= 10) && !strncmp(data, "#?RADIANCE", 10))
1023  FIXME("File type HDR is not supported yet\n");
1024  else if ((datasize >= 2) && (!strncmp(data, "PF", 2) || !strncmp(data, "Pf", 2)))
1025  FIXME("File type PFM is not supported yet\n");
1026  }
1027 
1028  if (SUCCEEDED(hr)) {
1029  GUID container_format;
1030  UINT frame_count;
1031 
1032  hr = IWICBitmapDecoder_GetContainerFormat(decoder, &container_format);
1033  if (SUCCEEDED(hr)) {
1034  if (IsEqualGUID(&container_format, &GUID_ContainerFormatBmp)) {
1035  if (dib) {
1036  TRACE("File type is DIB\n");
1037  info->ImageFileFormat = D3DXIFF_DIB;
1038  } else {
1039  TRACE("File type is BMP\n");
1040  info->ImageFileFormat = D3DXIFF_BMP;
1041  }
1042  } else if (IsEqualGUID(&container_format, &GUID_ContainerFormatPng)) {
1043  TRACE("File type is PNG\n");
1044  info->ImageFileFormat = D3DXIFF_PNG;
1045  } else if(IsEqualGUID(&container_format, &GUID_ContainerFormatJpeg)) {
1046  TRACE("File type is JPG\n");
1047  info->ImageFileFormat = D3DXIFF_JPG;
1048  } else if(IsEqualGUID(&container_format, &GUID_WineContainerFormatTga)) {
1049  TRACE("File type is TGA\n");
1050  info->ImageFileFormat = D3DXIFF_TGA;
1051  } else {
1052  WARN("Unsupported image file format %s\n", debugstr_guid(&container_format));
1054  }
1055  }
1056 
1057  if (SUCCEEDED(hr))
1058  hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
1059  if (SUCCEEDED(hr) && !frame_count)
1061 
1062  if (SUCCEEDED(hr)) {
1063  IWICBitmapFrameDecode *frame = NULL;
1064 
1065  hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
1066 
1067  if (SUCCEEDED(hr))
1068  hr = IWICBitmapFrameDecode_GetSize(frame, &info->Width, &info->Height);
1069 
1070  if (SUCCEEDED(hr)) {
1072 
1073  hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &pixel_format);
1074  if (SUCCEEDED(hr)) {
1076  if (info->Format == D3DFMT_UNKNOWN) {
1077  WARN("Unsupported pixel format %s\n", debugstr_guid(&pixel_format));
1079  }
1080  }
1081  }
1082 
1083  /* For 32 bpp BMP, windowscodecs.dll never returns a format with alpha while
1084  * d3dx9_xx.dll returns one if at least 1 pixel has a non zero alpha component */
1085  if (SUCCEEDED(hr) && (info->Format == D3DFMT_X8R8G8B8) && (info->ImageFileFormat == D3DXIFF_BMP)) {
1086  DWORD size = sizeof(DWORD) * info->Width * info->Height;
1088  hr = IWICBitmapFrameDecode_CopyPixels(frame, NULL, sizeof(DWORD) * info->Width, size, buffer);
1089  if (SUCCEEDED(hr)) {
1090  DWORD i;
1091  for (i = 0; i < info->Width * info->Height; i++) {
1092  if (buffer[i*4+3]) {
1093  info->Format = D3DFMT_A8R8G8B8;
1094  break;
1095  }
1096  }
1097  }
1099  }
1100 
1101  if (frame)
1102  IWICBitmapFrameDecode_Release(frame);
1103 
1104  info->Depth = 1;
1105  info->MipLevels = 1;
1106  info->ResourceType = D3DRTYPE_TEXTURE;
1107  }
1108  }
1109 
1110  if (decoder)
1111  IWICBitmapDecoder_Release(decoder);
1112 
1113  if (dib)
1114  HeapFree(GetProcessHeap(), 0, (void*)data);
1115 
1116  if (FAILED(hr)) {
1117  TRACE("Invalid or unsupported image file\n");
1118  return D3DXERR_INVALIDDATA;
1119  }
1120 
1121  return D3D_OK;
1122 }
HRESULT hr
Definition: shlfolder.c:183
#define WARN(fmt,...)
Definition: debug.h:112
#define D3DERR_INVALIDCALL
GLuint buffer
Definition: glext.h:5915
#define DWORD
Definition: nt_native.h:44
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: main.c:438
if SUCCEEDED(hr)
#define FIXME(fmt,...)
Definition: debug.h:111
static SIZE_T datasize
Definition: asm.c:30
#define debugstr_guid
Definition: kernel32.h:35
static D3DFORMAT wic_guid_to_d3dformat(const GUID *guid)
Definition: surface.c:57
HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT, IWICImagingFactory **)
Definition: proxy.c:651
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG HRESULT
Definition: typedefs.h:79
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
unsigned long DWORD
Definition: ntddk_ex.h:95
static BOOL convert_dib_to_bmp(const void **data, unsigned int *size)
Definition: surface.c:899
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
Definition: parse.h:22
GLuint GLuint stream
Definition: glext.h:7522
unsigned char BYTE
Definition: xxhash.c:193
#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
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
static const BYTE dib[]
Definition: ole2.c:201
static HRESULT get_image_info_from_dds(const void *buffer, UINT length, D3DXIMAGE_INFO *info)
Definition: surface.c:512
static ClassFactoryImpl factory
Definition: ole_server.c:234
#define HeapFree(x, y, z)
Definition: compat.h:594

Referenced by check_dds_pixel_format_(), D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), D3DXCreateVolumeTextureFromFileInMemoryEx(), D3DXGetImageInfoFromFileW(), D3DXGetImageInfoFromResourceA(), D3DXGetImageInfoFromResourceW(), D3DXLoadSurfaceFromFileInMemory(), D3DXLoadVolumeFromFileInMemory(), test_D3DXGetImageInfo(), test_D3DXSaveTextureToFileInMemory(), and test_dds_header_handling().

◆ D3DXGetImageInfoFromFileW()

HRESULT WINAPI D3DXGetImageInfoFromFileW ( const WCHAR file,
D3DXIMAGE_INFO info 
)

Definition at line 1155 of file surface.c.

1156 {
1157  void *buffer;
1158  HRESULT hr;
1159  DWORD size;
1160 
1161  TRACE("file %s, info %p.\n", debugstr_w(file), info);
1162 
1163  if (!file)
1164  return D3DERR_INVALIDCALL;
1165 
1167  return D3DXERR_INVALIDDATA;
1168 
1171 
1172  return hr;
1173 }
HRESULT hr
Definition: shlfolder.c:183
#define D3DERR_INVALIDCALL
GLuint buffer
Definition: glext.h:5915
#define debugstr_w
Definition: kernel32.h:32
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
LONG HRESULT
Definition: typedefs.h:79
unsigned long DWORD
Definition: ntddk_ex.h:95
HRESULT map_view_of_file(const WCHAR *filename, void **buffer, DWORD *length) DECLSPEC_HIDDEN
Definition: util.c:120
HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(const void *data, UINT datasize, D3DXIMAGE_INFO *info)
Definition: surface.c:985
#define UnmapViewOfFile
Definition: compat.h:605
Definition: fci.c:126

Referenced by D3DXGetImageInfoFromFileA().

◆ D3DXGetImageInfoFromResourceA()

HRESULT WINAPI D3DXGetImageInfoFromResourceA ( HMODULE  module,
const char resource,
D3DXIMAGE_INFO info 
)

Definition at line 1184 of file surface.c.

1185 {
1186  HRSRC resinfo;
1187  void *buffer;
1188  DWORD size;
1189 
1190  TRACE("module %p, resource %s, info %p.\n", module, debugstr_a(resource), info);
1191 
1192  if (!(resinfo = FindResourceA(module, resource, (const char *)RT_RCDATA))
1193  /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */
1194  && !(resinfo = FindResourceA(module, resource, (const char *)RT_BITMAP)))
1195  return D3DXERR_INVALIDDATA;
1196 
1197  if (FAILED(load_resource_into_memory(module, resinfo, &buffer, &size)))
1198  return D3DXERR_INVALIDDATA;
1199 
1201 }
HRSRC WINAPI FindResourceA(HMODULE hModule, LPCSTR name, LPCSTR type)
Definition: res.c:155
GLuint buffer
Definition: glext.h:5915
HRESULT load_resource_into_memory(HMODULE module, HRSRC resinfo, void **buffer, DWORD *length) DECLSPEC_HIDDEN
Definition: util.c:170
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
#define debugstr_a
Definition: kernel32.h:31
unsigned long DWORD
Definition: ntddk_ex.h:95
#define RT_RCDATA
Definition: pedump.c:372
HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(const void *data, UINT datasize, D3DXIMAGE_INFO *info)
Definition: surface.c:985
#define RT_BITMAP
Definition: pedump.c:364

Referenced by test_D3DXGetImageInfo().

◆ D3DXGetImageInfoFromResourceW()

HRESULT WINAPI D3DXGetImageInfoFromResourceW ( HMODULE  module,
const WCHAR resource,
D3DXIMAGE_INFO info 
)

Definition at line 1203 of file surface.c.

1204 {
1205  HRSRC resinfo;
1206  void *buffer;
1207  DWORD size;
1208 
1209  TRACE("module %p, resource %s, info %p.\n", module, debugstr_w(resource), info);
1210 
1211  if (!(resinfo = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA))
1212  /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */
1213  && !(resinfo = FindResourceW(module, resource, (const WCHAR *)RT_BITMAP)))
1214  return D3DXERR_INVALIDDATA;
1215 
1216  if (FAILED(load_resource_into_memory(module, resinfo, &buffer, &size)))
1217  return D3DXERR_INVALIDDATA;
1218 
1220 }
GLuint buffer
Definition: glext.h:5915
HRSRC WINAPI FindResourceW(HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
Definition: res.c:176
#define debugstr_w
Definition: kernel32.h:32
HRESULT load_resource_into_memory(HMODULE module, HRSRC resinfo, void **buffer, DWORD *length) DECLSPEC_HIDDEN
Definition: util.c:170
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned long DWORD
Definition: ntddk_ex.h:95
#define RT_RCDATA
Definition: pedump.c:372
HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(const void *data, UINT datasize, D3DXIMAGE_INFO *info)
Definition: surface.c:985
#define RT_BITMAP
Definition: pedump.c:364

◆ D3DXLoadSurfaceFromFileA()

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 at line 1416 of file surface.c.

1419 {
1420  WCHAR *src_file_w;
1421  HRESULT hr;
1422  int strlength;
1423 
1424  TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_file %s, "
1425  "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
1426  dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), debugstr_a(src_file),
1427  wine_dbgstr_rect(src_rect), filter, color_key, src_info);
1428 
1429  if (!src_file || !dst_surface)
1430  return D3DERR_INVALIDCALL;
1431 
1432  strlength = MultiByteToWideChar(CP_ACP, 0, src_file, -1, NULL, 0);
1433  src_file_w = HeapAlloc(GetProcessHeap(), 0, strlength * sizeof(*src_file_w));
1434  MultiByteToWideChar(CP_ACP, 0, src_file, -1, src_file_w, strlength);
1435 
1436  hr = D3DXLoadSurfaceFromFileW(dst_surface, dst_palette, dst_rect,
1437  src_file_w, src_rect, filter, color_key, src_info);
1438  HeapFree(GetProcessHeap(), 0, src_file_w);
1439 
1440  return hr;
1441 }
HRESULT hr
Definition: shlfolder.c:183
#define CP_ACP
Definition: compat.h:109
#define D3DERR_INVALIDCALL
HRESULT WINAPI D3DXLoadSurfaceFromFileW(IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, const WCHAR *src_file, const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
Definition: surface.c:1443
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define debugstr_a
Definition: kernel32.h:31
LONG HRESULT
Definition: typedefs.h:79
const char * wine_dbgstr_rect(const RECT *rect)
#define NULL
Definition: types.h:112
#define MultiByteToWideChar
Definition: compat.h:110
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
#define HeapFree(x, y, z)
Definition: compat.h:594

Referenced by test_D3DXLoadSurface(), and test_D3DXSaveSurfaceToFile().

◆ D3DXLoadSurfaceFromFileInMemory()

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 at line 1245 of file surface.c.

1248 {
1249  D3DXIMAGE_INFO imginfo;
1250  HRESULT hr;
1251 
1253  IWICBitmapDecoder *decoder;
1254  IWICBitmapFrameDecode *bitmapframe;
1255  IWICStream *stream;
1256 
1257  const struct pixel_format_desc *formatdesc;
1258  WICRect wicrect;
1259  RECT rect;
1260 
1261  TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_data %p, src_data_size %u, "
1262  "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
1263  pDestSurface, pDestPalette, wine_dbgstr_rect(pDestRect), pSrcData, SrcDataSize,
1264  wine_dbgstr_rect(pSrcRect), dwFilter, Colorkey, pSrcInfo);
1265 
1266  if (!pDestSurface || !pSrcData || !SrcDataSize)
1267  return D3DERR_INVALIDCALL;
1268 
1269  hr = D3DXGetImageInfoFromFileInMemory(pSrcData, SrcDataSize, &imginfo);
1270 
1271  if (FAILED(hr))
1272  return hr;
1273 
1274  if (pSrcRect)
1275  {
1276  wicrect.X = pSrcRect->left;
1277  wicrect.Y = pSrcRect->top;
1278  wicrect.Width = pSrcRect->right - pSrcRect->left;
1279  wicrect.Height = pSrcRect->bottom - pSrcRect->top;
1280  }
1281  else
1282  {
1283  wicrect.X = 0;
1284  wicrect.Y = 0;
1285  wicrect.Width = imginfo.Width;
1286  wicrect.Height = imginfo.Height;
1287  }
1288 
1289  SetRect(&rect, wicrect.X, wicrect.Y, wicrect.X + wicrect.Width, wicrect.Y + wicrect.Height);
1290 
1291  if (imginfo.ImageFileFormat == D3DXIFF_DDS)
1292  {
1293  hr = load_surface_from_dds(pDestSurface, pDestPalette, pDestRect, pSrcData, &rect,
1294  dwFilter, Colorkey, &imginfo);
1295  if (SUCCEEDED(hr) && pSrcInfo)
1296  *pSrcInfo = imginfo;
1297  return hr;
1298  }
1299 
1300  if (imginfo.ImageFileFormat == D3DXIFF_DIB)
1301  convert_dib_to_bmp(&pSrcData, &SrcDataSize);
1302 
1303  if (FAILED(WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory)))
1304  goto cleanup_err;
1305 
1306  if (FAILED(IWICImagingFactory_CreateStream(factory, &stream)))
1307  {
1308  IWICImagingFactory_Release(factory);
1309  factory = NULL;
1310  goto cleanup_err;
1311  }
1312 
1313  IWICStream_InitializeFromMemory(stream, (BYTE*)pSrcData, SrcDataSize);
1314 
1315  hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream*)stream, NULL, 0, &decoder);
1316 
1317  IWICStream_Release(stream);
1318 
1319  if (FAILED(hr))
1320  goto cleanup_err;
1321 
1322  hr = IWICBitmapDecoder_GetFrame(decoder, 0, &bitmapframe);
1323 
1324  if (FAILED(hr))
1325  goto cleanup_bmp;
1326 
1327  formatdesc = get_format_info(imginfo.Format);
1328 
1329  if (formatdesc->type == FORMAT_UNKNOWN)
1330  {
1331  FIXME("Unsupported pixel format\n");
1333  }
1334  else
1335  {
1336  BYTE *buffer;
1337  DWORD pitch;
1339  WICColor *colors = NULL;
1340 
1341  pitch = formatdesc->bytes_per_pixel * wicrect.Width;
1342  buffer = HeapAlloc(GetProcessHeap(), 0, pitch * wicrect.Height);
1343 
1344  hr = IWICBitmapFrameDecode_CopyPixels(bitmapframe, &wicrect, pitch,
1345  pitch * wicrect.Height, buffer);
1346 
1347  if (SUCCEEDED(hr) && (formatdesc->type == FORMAT_INDEX))
1348  {
1349  IWICPalette *wic_palette = NULL;
1350  UINT nb_colors;
1351 
1352  hr = IWICImagingFactory_CreatePalette(factory, &wic_palette);
1353  if (SUCCEEDED(hr))
1354  hr = IWICBitmapFrameDecode_CopyPalette(bitmapframe, wic_palette);
1355  if (SUCCEEDED(hr))
1356  hr = IWICPalette_GetColorCount(wic_palette, &nb_colors);
1357  if (SUCCEEDED(hr))
1358  {
1359  colors = HeapAlloc(GetProcessHeap(), 0, nb_colors * sizeof(colors[0]));
1360  palette = HeapAlloc(GetProcessHeap(), 0, nb_colors * sizeof(palette[0]));
1361  if (!colors || !palette)
1362  hr = E_OUTOFMEMORY;
1363  }
1364  if (SUCCEEDED(hr))
1365  hr = IWICPalette_GetColors(wic_palette, nb_colors, colors, &nb_colors);
1366  if (SUCCEEDED(hr))
1367  {
1368  UINT i;
1369 
1370  /* Convert colors from WICColor (ARGB) to PALETTEENTRY (ABGR) */
1371  for (i = 0; i < nb_colors; i++)
1372  {
1373  palette[i].peRed = (colors[i] >> 16) & 0xff;
1374  palette[i].peGreen = (colors[i] >> 8) & 0xff;
1375  palette[i].peBlue = colors[i] & 0xff;
1376  palette[i].peFlags = (colors[i] >> 24) & 0xff; /* peFlags is the alpha component in DX8 and higher */
1377  }
1378  }
1379  if (wic_palette)
1380  IWICPalette_Release(wic_palette);
1381  }
1382 
1383  if (SUCCEEDED(hr))
1384  {
1385  hr = D3DXLoadSurfaceFromMemory(pDestSurface, pDestPalette, pDestRect,
1386  buffer, imginfo.Format, pitch,
1387  palette, &rect, dwFilter, Colorkey);
1388  }
1389 
1390  HeapFree(GetProcessHeap(), 0, colors);
1393  }
1394 
1395  IWICBitmapFrameDecode_Release(bitmapframe);
1396 
1397 cleanup_bmp:
1398  IWICBitmapDecoder_Release(decoder);
1399 
1400 cleanup_err:
1401  if (factory)
1402  IWICImagingFactory_Release(factory);
1403 
1404  if (imginfo.ImageFileFormat == D3DXIFF_DIB)
1405  HeapFree(GetProcessHeap(), 0, (void*)pSrcData);
1406 
1407  if (FAILED(hr))
1408  return D3DXERR_INVALIDDATA;
1409 
1410  if (pSrcInfo)
1411  *pSrcInfo = imginfo;
1412 
1413  return D3D_OK;
1414 }
HRESULT hr
Definition: shlfolder.c:183
LONG top
Definition: windef.h:307
#define D3DERR_INVALIDCALL
GLuint buffer
Definition: glext.h:5915
LONG left
Definition: windef.h:306
LONG right
Definition: windef.h:308
& rect
Definition: startmenu.cpp:1413
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
Definition: main.c:438
if SUCCEEDED(hr)
#define FIXME(fmt,...)
Definition: debug.h:111
INT Height
Definition: wincodec.idl:301
HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT, IWICImagingFactory **)
Definition: proxy.c:651
D3DXIMAGE_FILEFORMAT ImageFileFormat
Definition: d3dx9tex.h:84
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
D3DFORMAT Format
Definition: d3dx9tex.h:82
LONG HRESULT
Definition: typedefs.h:79
const char * wine_dbgstr_rect(const RECT *rect)
enum format_type type
Definition: d3dx9_private.h:66
unsigned long DWORD
Definition: ntddk_ex.h:95
static BOOL convert_dib_to_bmp(const void **data, unsigned int *size)
Definition: surface.c:899
Definition: parse.h:22
GLuint GLuint stream
Definition: glext.h:7522
unsigned char BYTE
Definition: xxhash.c:193
static HPALETTE palette
Definition: clipboard.c:1345
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
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
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
static HRESULT load_surface_from_dds(IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, const void *src_data, const RECT *src_rect, DWORD filter, D3DCOLOR color_key, const D3DXIMAGE_INFO *src_info)
Definition: surface.c:568
INT Width
Definition: wincodec.idl:300
HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(const void *data, UINT datasize, D3DXIMAGE_INFO *info)
Definition: surface.c:985
LONG bottom
Definition: windef.h:309
const struct pixel_format_desc * get_format_info(D3DFORMAT format) DECLSPEC_HIDDEN
Definition: util.c:217
UINT32 WICColor
Definition: wincodec.idl:312
#define HeapFree(x, y, z)
Definition: compat.h:594

Referenced by D3DXCreateTextureFromFileInMemoryEx(), D3DXLoadSurfaceFromFileW(), D3DXLoadSurfaceFromResourceA(), D3DXLoadSurfaceFromResourceW(), test_D3DXCreateTextureFromFileInMemory(), test_D3DXLoadSurface(), and test_D3DXSaveTextureToFileInMemory().

◆ D3DXLoadSurfaceFromFileW()

HRESULT WINAPI D3DXLoadSurfaceFromFileW ( IDirect3DSurface9 *  dst_surface,
const PALETTEENTRY dst_palette,
const RECT dst_rect,
const WCHAR src_file,
const RECT src_rect,
DWORD  filter,
D3DCOLOR  color_key,
D3DXIMAGE_INFO src_info 
)

Definition at line 1443 of file surface.c.

1446 {
1447  UINT data_size;
1448  void *data;
1449  HRESULT hr;
1450 
1451  TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_file %s, "
1452  "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
1453  dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), debugstr_w(src_file),
1454  wine_dbgstr_rect(src_rect), filter, color_key, src_info);
1455 
1456  if (!src_file || !dst_surface)
1457  return D3DERR_INVALIDCALL;
1458 
1459  if (FAILED(map_view_of_file(src_file, &data, &data_size)))
1460  return D3DXERR_INVALIDDATA;
1461 
1462  hr = D3DXLoadSurfaceFromFileInMemory(dst_surface, dst_palette, dst_rect,
1463  data, data_size, src_rect, filter, color_key, src_info);
1465 
1466  return hr;
1467 }
HRESULT hr
Definition: shlfolder.c:183
#define D3DERR_INVALIDCALL
#define debugstr_w
Definition: kernel32.h:32
#define TRACE(s)
Definition: solgame.cpp:4
LONG HRESULT
Definition: typedefs.h:79
const char * wine_dbgstr_rect(const RECT *rect)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
HRESULT map_view_of_file(const WCHAR *filename, void **buffer, DWORD *length) DECLSPEC_HIDDEN
Definition: util.c:120
unsigned int UINT
Definition: ndis.h:50
#define UnmapViewOfFile
Definition: compat.h:605
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
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 D3DXLoadSurfaceFromFileA().

◆ D3DXLoadSurfaceFromMemory()

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 at line 1963 of file surface.c.

1967 {
1968  const struct pixel_format_desc *srcformatdesc, *destformatdesc;
1969  struct volume src_size, dst_size, dst_size_aligned;
1970  RECT dst_rect_temp, dst_rect_aligned;
1971  IDirect3DSurface9 *surface;
1972  D3DSURFACE_DESC surfdesc;
1973  D3DLOCKED_RECT lockrect;
1974  HRESULT hr;
1975 
1976  TRACE("(%p, %p, %s, %p, %#x, %u, %p, %s, %#x, 0x%08x)\n",
1977  dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_memory, src_format,
1978  src_pitch, src_palette, wine_dbgstr_rect(src_rect), filter, color_key);
1979 
1980  if (!dst_surface || !src_memory || !src_rect)
1981  {
1982  WARN("Invalid argument specified.\n");
1983  return D3DERR_INVALIDCALL;
1984  }
1985  if (src_format == D3DFMT_UNKNOWN
1986  || src_rect->left >= src_rect->right
1987  || src_rect->top >= src_rect->bottom)
1988  {
1989  WARN("Invalid src_format or src_rect.\n");
1990  return E_FAIL;
1991  }
1992 
1993  srcformatdesc = get_format_info(src_format);
1994  if (srcformatdesc->type == FORMAT_UNKNOWN)
1995  {
1996  FIXME("Unsupported format %#x.\n", src_format);
1997  return E_NOTIMPL;
1998  }
1999 
2000  src_size.width = src_rect->right - src_rect->left;
2001  src_size.height = src_rect->bottom - src_rect->top;
2002  src_size.depth = 1;
2003 
2004  IDirect3DSurface9_GetDesc(dst_surface, &surfdesc);
2005  destformatdesc = get_format_info(surfdesc.Format);
2006  if (!dst_rect)
2007  {
2008  dst_rect = &dst_rect_temp;
2009  dst_rect_temp.left = 0;
2010  dst_rect_temp.top = 0;
2011  dst_rect_temp.right = surfdesc.Width;
2012  dst_rect_temp.bottom = surfdesc.Height;
2013  }
2014  else
2015  {
2016  if (dst_rect->left > dst_rect->right || dst_rect->right > surfdesc.Width
2017  || dst_rect->top > dst_rect->bottom || dst_rect->bottom > surfdesc.Height
2018  || dst_rect->left < 0 || dst_rect->top < 0)
2019  {
2020  WARN("Invalid dst_rect specified.\n");
2021  return D3DERR_INVALIDCALL;
2022  }
2023  if (dst_rect->left == dst_rect->right || dst_rect->top == dst_rect->bottom)
2024  {
2025  WARN("Empty dst_rect specified.\n");
2026  return D3D_OK;
2027  }
2028  }
2029 
2030  dst_rect_aligned = *dst_rect;
2031  if (dst_rect_aligned.left & (destformatdesc->block_width - 1))
2032  dst_rect_aligned.left = dst_rect_aligned.left & ~(destformatdesc->block_width - 1);
2033  if (dst_rect_aligned.top & (destformatdesc->block_height - 1))
2034  dst_rect_aligned.top = dst_rect_aligned.top & ~(destformatdesc->block_height - 1);
2035  if (dst_rect_aligned.right & (destformatdesc->block_width - 1) && dst_rect_aligned.right != surfdesc.Width)
2036  dst_rect_aligned.right = min((dst_rect_aligned.right + destformatdesc->block_width - 1)
2037  & ~(destformatdesc->block_width - 1), surfdesc.Width);
2038  if (dst_rect_aligned.bottom & (destformatdesc->block_height - 1) && dst_rect_aligned.bottom != surfdesc.Height)
2039  dst_rect_aligned.bottom = min((dst_rect_aligned.bottom + destformatdesc->block_height - 1)
2040  & ~(destformatdesc->block_height - 1), surfdesc.Height);
2041 
2042  dst_size.width = dst_rect->right - dst_rect->left;
2043  dst_size.height = dst_rect->bottom - dst_rect->top;
2044  dst_size.depth = 1;
2045  dst_size_aligned.width = dst_rect_aligned.right - dst_rect_aligned.left;
2046  dst_size_aligned.height = dst_rect_aligned.bottom - dst_rect_aligned.top;
2047  dst_size_aligned.depth = 1;
2048 
2049  if (filter == D3DX_DEFAULT)
2051 
2052  if (FAILED(hr = lock_surface(dst_surface, &dst_rect_aligned, &lockrect, &surface, TRUE)))
2053  return hr;
2054 
2055  src_memory = (BYTE *)src_memory + src_rect->top / srcformatdesc->block_height * src_pitch
2056  + src_rect->left / srcformatdesc->block_width * srcformatdesc->block_byte_count;
2057 
2058  if (src_format == surfdesc.Format
2059  && dst_size.width == src_size.width
2060  && dst_size.height == src_size.height
2061  && color_key == 0
2062  && !(src_rect->left & (srcformatdesc->block_width - 1))
2063  && !(src_rect->top & (srcformatdesc->block_height - 1))
2064  && !(dst_rect->left & (destformatdesc->block_width - 1))
2065  && !(dst_rect->top & (destformatdesc->block_height - 1)))
2066  {
2067  TRACE("Simple copy.\n");
2068  copy_pixels(src_memory, src_pitch, 0, lockrect.pBits, lockrect.Pitch, 0,
2069  &src_size, srcformatdesc);
2070  }
2071  else /* Stretching or format conversion. */
2072  {
2073  const struct pixel_format_desc *dst_format;
2074  DWORD *src_uncompressed = NULL;
2075  BYTE *dst_uncompressed = NULL;
2076  unsigned int dst_pitch;
2077  BYTE *dst_mem;
2078 
2079  if (!is_conversion_from_supported(srcformatdesc)
2080  || !is_conversion_to_supported(destformatdesc))
2081  {
2082  FIXME("Unsupported format conversion %#x -> %#x.\n", src_format, surfdesc.Format);
2083  unlock_surface(dst_surface, &dst_rect_aligned, surface, FALSE);
2084  return E_NOTIMPL;
2085  }
2086 
2087  if (srcformatdesc->type == FORMAT_DXT)
2088  {
2089  void (*fetch_dxt_texel)(int srcRowStride, const BYTE *pixdata,
2090  int i, int j, void *texel);
2091  unsigned int x, y;
2092 
2093  src_pitch = src_pitch * srcformatdesc->block_width / srcformatdesc->block_byte_count;
2094 
2095  src_uncompressed = heap_alloc(src_size.width * src_size.height * sizeof(DWORD));
2096  if (!src_uncompressed)
2097  {
2098  unlock_surface(dst_surface, &dst_rect_aligned, surface, FALSE);
2099  return E_OUTOFMEMORY;
2100  }
2101 
2102  switch(src_format)
2103  {
2104  case D3DFMT_DXT1:
2105  fetch_dxt_texel = fetch_2d_texel_rgba_dxt1;
2106  break;
2107  case D3DFMT_DXT2:
2108  case D3DFMT_DXT3:
2109  fetch_dxt_texel = fetch_2d_texel_rgba_dxt3;
2110  break;
2111  case D3DFMT_DXT4:
2112  case D3DFMT_DXT5:
2113  fetch_dxt_texel = fetch_2d_texel_rgba_dxt5;
2114  break;
2115  default:
2116  FIXME("Unexpected compressed texture format %u.\n", src_format);
2117  fetch_dxt_texel = NULL;
2118  }
2119 
2120  TRACE("Uncompressing DXTn surface.\n");
2121  for (y = 0; y < src_size.height; ++y)
2122  {
2123  DWORD *ptr = &src_uncompressed[y * src_size.width];
2124  for (x = 0; x < src_size.width; ++x)
2125  {
2126  fetch_dxt_texel(src_pitch, src_memory, x + src_rect->left, y + src_rect->top, ptr);
2127  ++ptr;
2128  }
2129  }
2130  src_memory = src_uncompressed;
2131  src_pitch = src_size.width * sizeof(DWORD);
2132  srcformatdesc = get_format_info(D3DFMT_A8B8G8R8);
2133  }
2134 
2135  if (destformatdesc->type == FORMAT_DXT)
2136  {
2137  BOOL dst_misaligned = dst_rect->left != dst_rect_aligned.left
2138  || dst_rect->top != dst_rect_aligned.top
2139  || dst_rect->right != dst_rect_aligned.right
2140  || dst_rect->bottom != dst_rect_aligned.bottom;
2141 
2142  dst_uncompressed = HeapAlloc(GetProcessHeap(), dst_misaligned ? HEAP_ZERO_MEMORY : 0,
2143  dst_size_aligned.width * dst_size_aligned.height * sizeof(DWORD));
2144  if (!dst_uncompressed)
2145  {
2146  heap_free(src_uncompressed);
2147  unlock_surface(dst_surface, &dst_rect_aligned, surface, FALSE);
2148  return E_OUTOFMEMORY;
2149  }
2150  dst_pitch = dst_size_aligned.width * sizeof(DWORD);
2152  dst_mem = dst_uncompressed + (dst_rect->top - dst_rect_aligned.top) * dst_pitch
2153  + (dst_rect->left - dst_rect_aligned.left) * sizeof(DWORD);
2154  }
2155  else
2156  {
2157  dst_mem = lockrect.pBits;
2158  dst_pitch = lockrect.Pitch;
2159  dst_format = destformatdesc;
2160  }
2161 
2162  if ((filter & 0xf) == D3DX_FILTER_NONE)
2163  {
2164  convert_argb_pixels(src_memory, src_pitch, 0, &src_size, srcformatdesc,
2165  dst_mem, dst_pitch, 0, &dst_size, dst_format, color_key, src_palette);
2166  }
2167  else /* if ((filter & 0xf) == D3DX_FILTER_POINT) */
2168  {
2169  if ((filter & 0xf) != D3DX_FILTER_POINT)
2170  FIXME("Unhandled filter %#x.\n", filter);
2171 
2172  /* Always apply a point filter until D3DX_FILTER_LINEAR,
2173  * D3DX_FILTER_TRIANGLE and D3DX_FILTER_BOX are implemented. */
2174  point_filter_argb_pixels(src_memory, src_pitch, 0, &src_size, srcformatdesc,
2175  dst_mem, dst_pitch, 0, &dst_size, dst_format, color_key, src_palette);
2176  }
2177 
2178  heap_free(src_uncompressed);
2179 
2180  if (dst_uncompressed)
2181  {
2182  GLenum gl_format = 0;
2183 
2184  TRACE("Compressing DXTn surface.\n");
2185  switch(surfdesc.Format)
2186  {
2187  case D3DFMT_DXT1:
2189  break;
2190  case D3DFMT_DXT2:
2191  case D3DFMT_DXT3:
2193  break;
2194  case D3DFMT_DXT4:
2195  case D3DFMT_DXT5:
2197  break;
2198  default:
2199  ERR("Unexpected destination compressed format %u.\n", surfdesc.Format);
2200  }
2201  tx_compress_dxtn(4, dst_size_aligned.width, dst_size_aligned.height,
2202  dst_uncompressed, gl_format, lockrect.pBits,
2203  lockrect.Pitch * destformatdesc->block_width / destformatdesc->block_byte_count);
2204  heap_free(dst_uncompressed);
2205  }
2206  }
2207 
2208  return unlock_surface(dst_surface, &dst_rect_aligned, surface, TRUE);
2209 }
#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
Definition: glext.h:3491
void fetch_2d_texel_rgba_dxt5(GLint srcRowStride, const GLubyte *pixdata, GLint i, GLint j, GLvoid *texel)
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
HRESULT hr
Definition: shlfolder.c:183
static const char * dst_format
Definition: dib.c:1133
D3DFORMAT Format
Definition: d3d8types.h:1170
#define TRUE
Definition: types.h:120
#define WARN(fmt,...)
Definition: debug.h:112
#define D3DX_FILTER_NONE
Definition: d3dx9tex.h:27
LONG top
Definition: windef.h:307
#define D3DERR_INVALIDCALL
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
LONG left
Definition: windef.h:306
#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
Definition: glext.h:3490
if(dx==0 &&dy==0)
Definition: linetemp.h:174
LONG right
Definition: windef.h:308
#define E_FAIL
Definition: ddrawi.h:102
#define DWORD
Definition: nt_native.h:44
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
void convert_argb_pixels(const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, const struct volume *src_size, const struct pixel_format_desc *src_format, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *dst_size, const struct pixel_format_desc *dst_format, D3DCOLOR color_key, const PALETTEENTRY *palette)
Definition: surface.c:1731
void tx_compress_dxtn(GLint srccomps, GLint width, GLint height, const GLubyte *srcPixData, GLenum destFormat, GLubyte *dest, GLint dstRowStride)
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
#define FIXME(fmt,...)
Definition: debug.h:111
#define D3DX_DEFAULT
Definition: d3dx9.h:24
static PVOID ptr
Definition: dispmode.c:27
#define D3DX_FILTER_TRIANGLE
Definition: d3dx9tex.h:30
static BOOL is_conversion_from_supported(const struct pixel_format_desc *format)
Definition: d3dx9_private.h:79
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG HRESULT
Definition: typedefs.h:79
const char * wine_dbgstr_rect(const RECT *rect)
enum format_type type
Definition: d3dx9_private.h:66
unsigned long DWORD
Definition: ntddk_ex.h:95
HRESULT lock_surface(IDirect3DSurface9 *surface, const RECT *surface_rect, D3DLOCKED_RECT *lock, IDirect3DSurface9 **temp_surface, BOOL write)
Definition: surface.c:209
unsigned int GLenum
Definition: gl.h:150
#define IDirect3DSurface9_GetDesc(p, a)
Definition: d3d9.h:634
unsigned char BYTE
Definition: xxhash.c:193
#define ERR(fmt,...)
Definition: debug.h:110
#define D3D_OK
Definition: d3d.h:106
#define D3DX_FILTER_DITHER
Definition: d3dx9tex.h:36
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 E_NOTIMPL
Definition: ddrawi.h:99
#define min(a, b)
Definition: monoChain.cc:55
void fetch_2d_texel_rgba_dxt1(GLint srcRowStride, const GLubyte *pixdata, GLint i, GLint j, GLvoid *texel)
#define NULL
Definition: types.h:112
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
HRESULT unlock_surface(IDirect3DSurface9 *surface, const RECT *surface_rect, IDirect3DSurface9 *temp_surface, BOOL update)
Definition: surface.c:267
static BOOL is_conversion_to_supported(const struct pixel_format_desc *format)
Definition: d3dx9_private.h:87
#define D3DX_FILTER_POINT
Definition: d3dx9tex.h:28
void point_filter_argb_pixels(const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, const struct volume *src_size, const struct pixel_format_desc *src_format, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *dst_size, const struct pixel_format_desc *dst_format, D3DCOLOR color_key, const PALETTEENTRY *palette)
Definition: surface.c:1839
LONG bottom
Definition: windef.h:309
const struct pixel_format_desc * get_format_info(D3DFORMAT format) DECLSPEC_HIDDEN
Definition: util.c:217
void copy_pixels(const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *size, const struct pixel_format_desc *format)
Definition: surface.c:1700
static const unsigned char pixdata[]
Definition: surface.c:101
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
Definition: glext.h:3492
static BOOL heap_free(void *mem)
Definition: appwiz.h:75
void fetch_2d_texel_rgba_dxt3(GLint srcRowStride, const GLubyte *pixdata, GLint i, GLint j, GLvoid *texel)

Referenced by D3DXLoadSurfaceFromFileInMemory(), D3DXLoadSurfaceFromSurface(), load_cube_texture_from_dds(), load_surface_from_dds(), load_texture_from_dds(), test_D3DXCreateTextureFromFileInMemory(), test_D3DXLoadSurface(), and test_D3DXSaveSurfaceToFile().

◆ D3DXLoadSurfaceFromResourceA()

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 at line 1469 of file surface.c.

1472 {
1473  UINT data_size;
1474  HRSRC resinfo;
1475  void *data;
1476 
1477  TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_module %p, resource %s, "
1478  "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
1479  dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_module, debugstr_a(resource),
1480  wine_dbgstr_rect(src_rect), filter, color_key, src_info);
1481 
1482  if (!dst_surface)
1483  return D3DERR_INVALIDCALL;
1484 
1485  if (!(resinfo = FindResourceA(src_module, resource, (const char *)RT_RCDATA))
1486  /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */
1487  && !(resinfo = FindResourceA(src_module, resource, (const char *)RT_BITMAP)))
1488  return D3DXERR_INVALIDDATA;
1489 
1490  if (FAILED(load_resource_into_memory(src_module, resinfo, &data, &data_size)))
1491  return D3DXERR_INVALIDDATA;
1492 
1493  return D3DXLoadSurfaceFromFileInMemory(dst_surface, dst_palette, dst_rect,
1494  data, data_size, src_rect, filter, color_key, src_info);
1495 }
HRSRC WINAPI FindResourceA(HMODULE hModule, LPCSTR name, LPCSTR type)
Definition: res.c:155
#define D3DERR_INVALIDCALL
HRESULT load_resource_into_memory(HMODULE module, HRSRC resinfo, void **buffer, DWORD *length) DECLSPEC_HIDDEN
Definition: util.c:170
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
const char * wine_dbgstr_rect(const RECT *rect)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define RT_RCDATA
Definition: pedump.c:372
unsigned int UINT
Definition: ndis.h:50
#define RT_BITMAP
Definition: pedump.c:364
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
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 test_D3DXLoadSurface().

◆ D3DXLoadSurfaceFromResourceW()

HRESULT WINAPI D3DXLoadSurfaceFromResourceW ( IDirect3DSurface9 *  dst_surface,
const PALETTEENTRY dst_palette,
const RECT dst_rect,
HMODULE  src_module,
const WCHAR resource,
const RECT src_rect,
DWORD  filter,
D3DCOLOR  color_key,
D3DXIMAGE_INFO src_info 
)

Definition at line 1497 of file surface.c.

1500 {
1501  UINT data_size;
1502  HRSRC resinfo;
1503  void *data;
1504 
1505  TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_module %p, resource %s, "
1506  "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
1507  dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_module, debugstr_w(resource),
1508  wine_dbgstr_rect(src_rect), filter, color_key, src_info);
1509 
1510  if (!dst_surface)
1511  return D3DERR_INVALIDCALL;
1512 
1513  if (!(resinfo = FindResourceW(src_module, resource, (const WCHAR *)RT_RCDATA))
1514  /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */
1515  && !(resinfo = FindResourceW(src_module, resource, (const WCHAR *)RT_BITMAP)))
1516  return D3DXERR_INVALIDDATA;
1517 
1518  if (FAILED(load_resource_into_memory(src_module, resinfo, &data, &data_size)))
1519  return D3DXERR_INVALIDDATA;
1520 
1521  return D3DXLoadSurfaceFromFileInMemory(dst_surface, dst_palette, dst_rect,
1522  data, data_size, src_rect, filter, color_key, src_info);
1523 }
#define D3DERR_INVALIDCALL
HRSRC WINAPI FindResourceW(HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
Definition: res.c:176
#define debugstr_w
Definition: kernel32.h:32
HRESULT load_resource_into_memory(HMODULE module, HRSRC resinfo, void **buffer, DWORD *length) DECLSPEC_HIDDEN
Definition: util.c:170
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
const char * wine_dbgstr_rect(const RECT *rect)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define RT_RCDATA
Definition: pedump.c:372
unsigned int UINT
Definition: ndis.h:50
#define RT_BITMAP
Definition: pedump.c:364
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
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

◆ D3DXLoadSurfaceFromSurface()

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 at line 2233 of file surface.c.

2236 {
2237  const struct pixel_format_desc *src_format_desc, *dst_format_desc;
2238  D3DSURFACE_DESC src_desc, dst_desc;
2239  struct volume src_size, dst_size;
2240  IDirect3DSurface9 *temp_surface;
2241  D3DTEXTUREFILTERTYPE d3d_filter;
2242  IDirect3DDevice9 *device;
2244  RECT dst_rect_temp;
2245  HRESULT hr;
2246  RECT s;
2247 
2248  TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_surface %p, "
2249  "src_palette %p, src_rect %s, filter %#x, color_key 0x%08x.\n",
2250  dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_surface,
2251  src_palette, wine_dbgstr_rect(src_rect), filter, color_key);
2252 
2253  if (!dst_surface || !src_surface)
2254  return D3DERR_INVALIDCALL;
2255 
2256  IDirect3DSurface9_GetDesc(src_surface, &src_desc);
2257  src_format_desc = get_format_info(src_desc.Format);
2258  if (!src_rect)
2259  {
2260  SetRect(&s, 0, 0, src_desc.Width, src_desc.Height);
2261  src_rect = &s;
2262  }
2263  else if (src_rect->left == src_rect->right || src_rect->top == src_rect->bottom)
2264  {
2265  WARN("Empty src_rect specified.\n");
2266  return filter == D3DX_FILTER_NONE ? D3D_OK : E_FAIL;
2267  }
2268  else if (src_rect->left > src_rect->right || src_rect->right > src_desc.Width
2269  || src_rect->left < 0 || src_rect->left > src_desc.Width
2270  || src_rect->top > src_rect->bottom || src_rect->bottom > src_desc.Height
2271  || src_rect->top < 0 || src_rect->top > src_desc.Height)
2272  {
2273  WARN("Invalid src_rect specified.\n");
2274  return D3DERR_INVALIDCALL;
2275  }
2276 
2277  src_size.width = src_rect->right - src_rect->left;
2278  src_size.height = src_rect->bottom - src_rect->top;
2279  src_size.depth = 1;
2280 
2281  IDirect3DSurface9_GetDesc(dst_surface, &dst_desc);
2282  dst_format_desc = get_format_info(dst_desc.Format);
2283  if (!dst_rect)
2284  {
2285  SetRect(&dst_rect_temp, 0, 0, dst_desc.Width, dst_desc.Height);
2286  dst_rect = &dst_rect_temp;
2287  }
2288  else if (dst_rect->left == dst_rect->right || dst_rect->top == dst_rect->bottom)
2289  {
2290  WARN("Empty dst_rect specified.\n");
2291  return filter == D3DX_FILTER_NONE ? D3D_OK : E_FAIL;
2292  }
2293  else if (dst_rect->left > dst_rect->right || dst_rect->right > dst_desc.Width
2294  || dst_rect->left < 0 || dst_rect->left > dst_desc.Width
2295  || dst_rect->top > dst_rect->bottom || dst_rect->bottom > dst_desc.Height
2296  || dst_rect->top < 0 || dst_rect->top > dst_desc.Height)
2297  {
2298  WARN("Invalid dst_rect specified.\n");
2299  return D3DERR_INVALIDCALL;
2300  }
2301 
2302  dst_size.width = dst_rect->right - dst_rect->left;
2303  dst_size.height = dst_rect->bottom - dst_rect->top;
2304  dst_size.depth = 1;
2305 
2306  if (!dst_palette && !src_palette && !color_key)
2307  {
2308  if (src_desc.Format == dst_desc.Format
2309  && dst_size.width == src_size.width
2310  && dst_size.height == src_size.height
2311  && color_key == 0
2312  && !(src_rect->left & (src_format_desc->block_width - 1))
2313  && !(src_rect->top & (src_format_desc->block_height - 1))
2314  && !(dst_rect->left & (dst_format_desc->block_width - 1))
2315  && !(dst_rect->top & (dst_format_desc->block_height - 1)))
2316  {
2317  d3d_filter = D3DTEXF_NONE;
2318  }
2319  else
2320  {
2321  switch (filter)
2322  {
2323  case D3DX_FILTER_NONE:
2324  d3d_filter = D3DTEXF_NONE;
2325  break;
2326 
2327  case D3DX_FILTER_POINT:
2328  d3d_filter = D3DTEXF_POINT;
2329  break;
2330 
2331  case D3DX_FILTER_LINEAR:
2332  d3d_filter = D3DTEXF_LINEAR;
2333  break;
2334 
2335  default:
2336  d3d_filter = D3DTEXF_FORCE_DWORD;
2337  break;
2338  }
2339  }
2340 
2341  if (d3d_filter != D3DTEXF_FORCE_DWORD)
2342  {
2343  IDirect3DSurface9_GetDevice(src_surface, &device);
2344  hr = IDirect3DDevice9_StretchRect(device, src_surface, src_rect, dst_surface, dst_rect, d3d_filter);
2346  if (SUCCEEDED(hr))
2347  return D3D_OK;
2348  }
2349  }
2350 
2351  if (FAILED(lock_surface(src_surface, NULL, &lock, &temp_surface, FALSE)))
2352  return D3DXERR_INVALIDDATA;
2353 
2354  hr = D3DXLoadSurfaceFromMemory(dst_surface, dst_palette, dst_rect, lock.pBits,
2355  src_desc.Format, lock.Pitch, src_palette, src_rect, filter, color_key);
2356 
2357  if (FAILED(unlock_surface(src_surface, NULL, temp_surface, FALSE)))
2358  return D3DXERR_INVALIDDATA;
2359 
2360  return hr;
2361 }
rwlock_t lock
Definition: tcpcore.h:1163
HRESULT hr
Definition: shlfolder.c:183
D3DFORMAT Format
Definition: d3d8types.h:1170
#define WARN(fmt,...)
Definition: debug.h:112
#define D3DX_FILTER_NONE
Definition: d3dx9tex.h:27
LONG top
Definition: windef.h:307
#define D3DERR_INVALIDCALL
#define D3DX_FILTER_LINEAR
Definition: d3dx9tex.h:29
#define IDirect3DSurface9_GetDevice(p, a)
Definition: d3d9.h:624
LONG left
Definition: windef.h:306
LONG right
Definition: windef.h:308
#define E_FAIL
Definition: ddrawi.h:102
FxDevice * device
#define FALSE
Definition: types.h:117
Definition: devices.h:37
if SUCCEEDED(hr)
#define IDirect3DDevice9_Release(p)
Definition: d3d9.h:1508
#define TRACE(s)
Definition: solgame.cpp:4
LONG HRESULT
Definition: typedefs.h:79
const char * wine_dbgstr_rect(const RECT *rect)
HRESULT lock_surface(IDirect3DSurface9 *surface, const RECT *surface_rect, D3DLOCKED_RECT *lock, IDirect3DSurface9 **temp_surface, BOOL write)
Definition: surface.c:209
GLdouble s
Definition: gl.h:2039
#define IDirect3DSurface9_GetDesc(p, a)
Definition: d3d9.h:634
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 NULL
Definition: types.h:112
HRESULT unlock_surface(IDirect3DSurface9 *surface, const RECT *surface_rect, IDirect3DSurface9 *temp_surface, BOOL update)
Definition: surface.c:267
enum _D3DTEXTUREFILTERTYPE D3DTEXTUREFILTERTYPE
#define D3DX_FILTER_POINT
Definition: d3dx9tex.h:28
LONG bottom
Definition: windef.h:309
const struct pixel_format_desc * get_format_info(D3DFORMAT format) DECLSPEC_HIDDEN
Definition: util.c:217
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
#define IDirect3DDevice9_StretchRect(p, a, b, c, d, e)
Definition: d3d9.h:1541

Referenced by copy_render_target_to_cube_texture_face(), D3DXFilterTexture(), D3DXRenderToSurface_EndScene(), test_D3DXCreateTextureFromFileInMemory(), and test_D3DXLoadSurface().

◆ D3DXSaveSurfaceToFileA()

HRESULT WINAPI D3DXSaveSurfaceToFileA ( const char dst_filename,
D3DXIMAGE_FILEFORMAT  file_format,
IDirect3DSurface9 *  src_surface,
const PALETTEENTRY src_palette,
const RECT src_rect 
)

Definition at line 2364 of file surface.c.

2366 {
2367  int len;
2368  WCHAR *filename;
2369  HRESULT hr;
2371 
2372  TRACE("(%s, %#x, %p, %p, %s): relay\n",
2373  wine_dbgstr_a(dst_filename), file_format, src_surface, src_palette, wine_dbgstr_rect(src_rect));
2374 
2375  if (!dst_filename) return D3DERR_INVALIDCALL;
2376 
2377  len = MultiByteToWideChar(CP_ACP, 0, dst_filename, -1, NULL, 0);
2378  filename = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2379  if (!filename) return E_OUTOFMEMORY;
2380  MultiByteToWideChar(CP_ACP, 0, dst_filename, -1, filename, len);
2381 
2382  hr = D3DXSaveSurfaceToFileInMemory(&buffer, file_format, src_surface, src_palette, src_rect);
2383  if (SUCCEEDED(hr))
2384  {
2387  }
2388 
2390  return hr;
2391 }
const char int int int static __inline const char * wine_dbgstr_a(const char *s)
Definition: debug.h:186
HRESULT hr
Definition: shlfolder.c:183
#define CP_ACP
Definition: compat.h:109
#define D3DERR_INVALIDCALL
GLuint buffer
Definition: glext.h:5915
const char * filename
Definition: ioapi.h:135
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
if SUCCEEDED(hr)
HRESULT write_buffer_to_file(const WCHAR *filename, ID3DXBuffer *buffer) DECLSPEC_HIDDEN
Definition: util.c:186
struct ID3DXBuffer ID3DXBuffer
Definition: d3dx8core.h:51
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
LONG HRESULT
Definition: typedefs.h:79
const char * wine_dbgstr_rect(const RECT *rect)
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
GLenum GLsizei len
Definition: glext.h:6722
#define ID3DXBuffer_Release(p)
Definition: d3dx9core.h:83
#define NULL
Definition: types.h:112
#define MultiByteToWideChar
Definition: compat.h:110
#define HeapFree(x, y, z)
Definition: compat.h:594

Referenced by test_D3DXSaveSurfaceToFile().

◆ D3DXSaveSurfaceToFileInMemory()

HRESULT WINAPI D3DXSaveSurfaceToFileInMemory ( ID3DXBuffer **  dst_buffer,
D3DXIMAGE_FILEFORMAT  file_format,
IDirect3DSurface9 *  src_surface,
const PALETTEENTRY src_palette,
const RECT src_rect 
)

Definition at line 2414 of file surface.c.

2416 {
2417  IWICBitmapEncoder *encoder = NULL;
2418  IWICBitmapFrameEncode *frame = NULL;
2419  IPropertyBag2 *encoder_options = NULL;
2420  IStream *stream = NULL;
2421  HRESULT hr;
2422  const GUID *container_format;
2423  const GUID *pixel_format_guid;
2424  WICPixelFormatGUID wic_pixel_format;
2426  D3DFORMAT d3d_pixel_format;
2427  D3DSURFACE_DESC src_surface_desc;
2428  IDirect3DSurface9 *temp_surface;
2429  D3DLOCKED_RECT locked_rect;
2430  int width, height;
2431  STATSTG stream_stats;
2432  HGLOBAL stream_hglobal;
2434  DWORD size;
2435 
2436  TRACE("dst_buffer %p, file_format %#x, src_surface %p, src_palette %p, src_rect %s.\n",
2437  dst_buffer, file_format, src_surface, src_palette, wine_dbgstr_rect(src_rect));
2438 
2439  if (!dst_buffer || !src_surface) return D3DERR_INVALIDCALL;
2440 
2441  if (src_palette)
2442  {
2443  FIXME("Saving surfaces with palettized pixel formats is not implemented yet\n");
2444  return D3DERR_INVALIDCALL;
2445  }
2446 
2447  switch (file_format)
2448  {
2449  case D3DXIFF_BMP:
2450  case D3DXIFF_DIB:
2451  container_format = &GUID_ContainerFormatBmp;
2452  break;
2453  case D3DXIFF_PNG:
2454  container_format = &GUID_ContainerFormatPng;
2455  break;
2456  case D3DXIFF_JPG:
2457  container_format = &GUID_ContainerFormatJpeg;
2458  break;
2459  case D3DXIFF_DDS:
2460  return save_dds_surface_to_memory(dst_buffer, src_surface, src_rect);
2461  case D3DXIFF_HDR:
2462  case D3DXIFF_PFM:
2463  case D3DXIFF_TGA:
2464  case D3DXIFF_PPM:
2465  FIXME("File format %#x is not supported yet\n", file_format);
2466  return E_NOTIMPL;
2467  default:
2468  return D3DERR_INVALIDCALL;
2469  }
2470 
2471  IDirect3DSurface9_GetDesc(src_surface, &src_surface_desc);
2472  if (src_rect)
2473  {
2474  if (src_rect->left == src_rect->right || src_rect->top == src_rect->bottom)
2475  {
2476  WARN("Invalid rectangle with 0 area\n");
2477  return D3DXCreateBuffer(64, dst_buffer);
2478  }
2479  if (src_rect->left < 0 || src_rect->top < 0)
2480  return D3DERR_INVALIDCALL;
2481  if (src_rect->left > src_rect->right || src_rect->top > src_rect->bottom)
2482  return D3DERR_INVALIDCALL;
2483  if (src_rect->right > src_surface_desc.Width || src_rect->bottom > src_surface_desc.Height)
2484  return D3DERR_INVALIDCALL;
2485 
2486  width = src_rect->right - src_rect->left;
2487  height = src_rect->bottom - src_rect->top;
2488  }
2489  else
2490  {
2491  width = src_surface_desc.Width;
2492  height = src_surface_desc.Height;
2493  }
2494 
2495  hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
2496  if (FAILED(hr)) goto cleanup_err;
2497 
2498  hr = IWICImagingFactory_CreateEncoder(factory, container_format, NULL, &encoder);
2499  IWICImagingFactory_Release(factory);
2500  if (FAILED(hr)) goto cleanup_err;
2501 
2503  if (FAILED(hr)) goto cleanup_err;
2504 
2505  hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
2506  if (FAILED(hr)) goto cleanup_err;
2507 
2508  hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frame, &encoder_options);
2509  if (FAILED(hr)) goto cleanup_err;
2510 
2511  hr = IWICBitmapFrameEncode_Initialize(frame, encoder_options);
2512  if (FAILED(hr)) goto cleanup_err;
2513 
2514  hr = IWICBitmapFrameEncode_SetSize(frame, width, height);
2515  if (FAILED(hr)) goto cleanup_err;
2516 
2517  pixel_format_guid = d3dformat_to_wic_guid(src_surface_desc.Format);
2518  if (!pixel_format_guid)
2519  {
2520  FIXME("Pixel format %#x is not supported yet\n", src_surface_desc.Format);
2521  hr = E_NOTIMPL;
2522  goto cleanup;
2523  }
2524 
2525  memcpy(&wic_pixel_format, pixel_format_guid, sizeof(GUID));
2526  hr = IWICBitmapFrameEncode_SetPixelFormat(frame, &wic_pixel_format);
2527  d3d_pixel_format = wic_guid_to_d3dformat(&wic_pixel_format);
2528  if (SUCCEEDED(hr) && d3d_pixel_format != D3DFMT_UNKNOWN)
2529  {
2530  TRACE("Using pixel format %s %#x\n", debugstr_guid(&wic_pixel_format), d3d_pixel_format);
2531  if (src_surface_desc.Format == d3d_pixel_format) /* Simple copy */
2532  {
2533  if (FAILED(hr = lock_surface(src_surface, src_rect, &locked_rect, &temp_surface, FALSE)))
2534  goto cleanup;
2535 
2536  IWICBitmapFrameEncode_WritePixels(frame, height,
2537  locked_rect.Pitch, height * locked_rect.Pitch, locked_rect.pBits);
2538  unlock_surface(src_surface, src_rect, temp_surface, FALSE);
2539  }
2540  else /* Pixel format conversion */
2541  {
2542  const struct pixel_format_desc *src_format_desc, *dst_format_desc;
2543  struct volume size;
2544  DWORD dst_pitch;
2545  void *dst_data;
2546 
2547  src_format_desc = get_format_info(src_surface_desc.Format);
2548  dst_format_desc = get_format_info(d3d_pixel_format);
2549  if (!is_conversion_from_supported(src_format_desc)
2550  || !is_conversion_to_supported(dst_format_desc))
2551  {
2552  FIXME("Unsupported format conversion %#x -> %#x.\n",
2553  src_surface_desc.Format, d3d_pixel_format);
2554  hr = E_NOTIMPL;
2555  goto cleanup;
2556  }
2557 
2558  size.width = width;
2559  size.height = height;
2560  size.depth = 1;
2561  dst_pitch = width * dst_format_desc->bytes_per_pixel;
2562  dst_data = HeapAlloc(GetProcessHeap(), 0, dst_pitch * height);
2563  if (!dst_data)
2564  {
2565  hr = E_OUTOFMEMORY;
2566  goto cleanup;
2567  }
2568  if (FAILED(hr = lock_surface(src_surface, src_rect, &locked_rect, &temp_surface, FALSE)))
2569  {
2570  HeapFree(GetProcessHeap(), 0, dst_data);
2571  goto cleanup;
2572  }
2573  convert_argb_pixels(locked_rect.pBits, locked_rect.Pitch, 0, &size, src_format_desc,
2574  dst_data, dst_pitch, 0, &size, dst_format_desc, 0, NULL);
2575  unlock_surface(src_surface, src_rect, temp_surface, FALSE);
2576 
2577  IWICBitmapFrameEncode_WritePixels(frame, height, dst_pitch, dst_pitch * height, dst_data);
2578  HeapFree(GetProcessHeap(), 0, dst_data);
2579  }
2580 
2581  hr = IWICBitmapFrameEncode_Commit(frame);
2582  if (SUCCEEDED(hr)) hr = IWICBitmapEncoder_Commit(encoder);
2583  }
2584  else WARN("Unsupported pixel format %#x\n", src_surface_desc.Format);
2585 
2586  /* copy data from stream to ID3DXBuffer */
2587  hr = IStream_Stat(stream, &stream_stats, STATFLAG_NONAME);
2588  if (FAILED(hr)) goto cleanup_err;
2589 
2590  if (stream_stats.cbSize.u.HighPart != 0)
2591  {
2593  goto cleanup;
2594  }
2595  size = stream_stats.cbSize.u.LowPart;
2596 
2597  /* Remove BMP header for DIB */
2598  if (file_format == D3DXIFF_DIB)
2599  size -= sizeof(BITMAPFILEHEADER);
2600 
2602  if (FAILED(hr)) goto cleanup;
2603 
2604  hr = GetHGlobalFromStream(stream, &stream_hglobal);
2605  if (SUCCEEDED(hr))
2606  {
2607  void *buffer_pointer = ID3DXBuffer_GetBufferPointer(buffer);
2608  void *stream_data = GlobalLock(stream_hglobal);
2609  /* Remove BMP header for DIB */
2610  if (file_format == D3DXIFF_DIB)
2611  stream_data = (void*)((BYTE*)stream_data + sizeof(BITMAPFILEHEADER));
2612  memcpy(buffer_pointer, stream_data, size);
2613  GlobalUnlock(stream_hglobal);
2614  *dst_buffer = buffer;
2615  }
2617 
2618 cleanup_err:
2619  if (FAILED(hr) && hr != E_OUTOFMEMORY)
2621 
2622 cleanup:
2623  if (stream) IStream_Release(stream);
2624 
2625  if (frame) IWICBitmapFrameEncode_Release(frame);
2626  if (encoder_options) IPropertyBag2_Release(encoder_options);
2627 
2628  if (encoder) IWICBitmapEncoder_Release(encoder);
2629 
2630  return hr;
2631 }
GLint GLint GLsizei width
Definition: gl.h:1546
HRESULT WINAPI GetHGlobalFromStream(IStream *pstm, HGLOBAL *phglobal)
static const GUID * d3dformat_to_wic_guid(D3DFORMAT format)
Definition: surface.c:70
HRESULT hr
Definition: shlfolder.c:183
D3DFORMAT Format
Definition: d3d8types.h:1170
#define TRUE
Definition: types.h:120
#define WARN(fmt,...)
Definition: debug.h:112
HRESULT WINAPI D3DXCreateBuffer(DWORD size, ID3DXBuffer **buffer)
Definition: core.c:131
LONG top
Definition: windef.h:307
#define D3DERR_INVALIDCALL
GLuint buffer
Definition: glext.h:5915
HRESULT WINAPI CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
LONG left
Definition: windef.h:306
LONG right
Definition: windef.h:308
void convert_argb_pixels(const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, const struct volume *src_size, const struct pixel_format_desc *src_format, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *dst_size, const struct pixel_format_desc *dst_format, D3DCOLOR color_key, const PALETTEENTRY *palette)
Definition: surface.c:1731
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define FALSE
Definition: types.h:117
Definition: main.c:438
if SUCCEEDED(hr)
#define FIXME(fmt,...)
Definition: debug.h:111
static BOOL is_conversion_from_supported(const struct pixel_format_desc *format)
Definition: d3dx9_private.h:79
struct ID3DXBuffer ID3DXBuffer
Definition: d3dx8core.h:51
enum _D3DFORMAT D3DFORMAT
#define debugstr_guid
Definition: kernel32.h:35
static D3DFORMAT wic_guid_to_d3dformat(const GUID *guid)
Definition: surface.c:57
HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT, IWICImagingFactory **)
Definition: proxy.c:651
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG HRESULT
Definition: typedefs.h:79
const char * wine_dbgstr_rect(const RECT *rect)
unsigned long DWORD
Definition: ntddk_ex.h:95
HRESULT lock_surface(IDirect3DSurface9 *surface, const RECT *surface_rect, D3DLOCKED_RECT *lock, IDirect3DSurface9 **temp_surface, BOOL write)
Definition: surface.c:209
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
Definition: parse.h:22
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define IDirect3DSurface9_GetDesc(p, a)
Definition: d3d9.h:634
unsigned char BYTE
Definition: xxhash.c:193
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define ID3DXBuffer_Release(p)
Definition: d3dx9core.h:83
struct tagBITMAPFILEHEADER BITMAPFILEHEADER
#define E_NOTIMPL
Definition: ddrawi.h:99
#define NULL
Definition: types.h:112
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
HRESULT unlock_surface(IDirect3DSurface9 *surface, const RECT *surface_rect, IDirect3DSurface9 *temp_surface, BOOL update)
Definition: surface.c:267
static BOOL is_conversion_to_supported(const struct pixel_format_desc *format)
Definition: d3dx9_private.h:87
static ClassFactoryImpl factory
Definition: ole_server.c:234
LONG bottom
Definition: windef.h:309
char * cleanup(char *str)
Definition: wpickclick.c:99
const struct pixel_format_desc * get_format_info(D3DFORMAT format) DECLSPEC_HIDDEN
Definition: util.c:217
static HRESULT save_dds_surface_to_memory(ID3DXBuffer **dst_buffer, IDirect3DSurface9 *src_surface, const RECT *src_rect)
Definition: surface.c:587
static const char stream_data[]
Definition: mlang.c:2327
#define HeapFree(x, y, z)
Definition: compat.h:594
#define ID3DXBuffer_GetBufferPointer(p)
Definition: d3dx9core.h:85

Referenced by D3DXSaveSurfaceToFileA(), D3DXSaveSurfaceToFileW(), D3DXSaveTextureToFileInMemory(), and test_D3DXSaveSurfaceToFileInMemory().

◆ D3DXSaveSurfaceToFileW()

HRESULT WINAPI D3DXSaveSurfaceToFileW ( const WCHAR dst_filename,
D3DXIMAGE_FILEFORMAT  file_format,
IDirect3DSurface9 *  src_surface,
const PALETTEENTRY src_palette,
const RECT src_rect 
)

Definition at line 2393 of file surface.c.

2395 {
2396  HRESULT hr;
2398 
2399  TRACE("(%s, %#x, %p, %p, %s): relay\n",
2400  wine_dbgstr_w(dst_filename), file_format, src_surface, src_palette, wine_dbgstr_rect(src_rect));
2401 
2402  if (!dst_filename) return D3DERR_INVALIDCALL;
2403 
2404  hr = D3DXSaveSurfaceToFileInMemory(&buffer, file_format, src_surface, src_palette, src_rect);
2405  if (SUCCEEDED(hr))
2406  {
2407  hr = write_buffer_to_file(dst_filename, buffer);
2409  }
2410 
2411  return hr;
2412 }
HRESULT hr
Definition: shlfolder.c:183
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
#define D3DERR_INVALIDCALL
GLuint buffer
Definition: glext.h:5915
if SUCCEEDED(hr)
HRESULT write_buffer_to_file(const WCHAR *filename, ID3DXBuffer *buffer) DECLSPEC_HIDDEN
Definition: util.c:186
struct ID3DXBuffer ID3DXBuffer
Definition: d3dx8core.h:51
#define TRACE(s)
Definition: solgame.cpp:4
LONG HRESULT
Definition: typedefs.h:79
const char * wine_dbgstr_rect(const RECT *rect)
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 ID3DXBuffer_Release(p)
Definition: d3dx9core.h:83

◆ dds_alpha_to_d3dformat()

static D3DFORMAT dds_alpha_to_d3dformat ( const struct dds_pixel_format pixel_format)
static

Definition at line 348 of file surface.c.

349 {
350  if (pixel_format->bpp == 8 && pixel_format->amask == 0xff)
351  return D3DFMT_A8;
352 
353  WARN("Unknown Alpha pixel format (%u, %#x)\n", pixel_format->bpp, pixel_format->rmask);
354  return D3DFMT_UNKNOWN;
355 }
#define WARN(fmt,...)
Definition: debug.h:112

Referenced by dds_pixel_format_to_d3dformat().

◆ dds_bump_luminance_to_d3dformat()

static D3DFORMAT dds_bump_luminance_to_d3dformat ( const struct dds_pixel_format pixel_format)
static

Definition at line 378 of file surface.c.

379 {
380  if (pixel_format->bpp == 32 && pixel_format->rmask == 0x000000ff && pixel_format->gmask == 0x0000ff00
381  && pixel_format->bmask == 0x00ff0000)
382  return D3DFMT_X8L8V8U8;
383 
384  WARN("Unknown bump pixel format (%u, %#x, %#x, %#x, %#x).\n", pixel_format->bpp,
385  pixel_format->rmask, pixel_format->gmask, pixel_format->bmask, pixel_format->amask);
386  return D3DFMT_UNKNOWN;
387 }
#define WARN(fmt,...)
Definition: debug.h:112

Referenced by dds_pixel_format_to_d3dformat().

◆ dds_bump_to_d3dformat()

static D3DFORMAT dds_bump_to_d3dformat ( const struct dds_pixel_format pixel_format)
static

Definition at line 366 of file surface.c.

367 {
368  if (pixel_format->bpp == 16 && pixel_format->rmask == 0x00ff && pixel_format->gmask == 0xff00)
369  return D3DFMT_V8U8;
370  if (pixel_format->bpp == 32 && pixel_format->rmask == 0x0000ffff && pixel_format->gmask == 0xffff0000)
371  return D3DFMT_V16U16;
372 
373  WARN("Unknown bump pixel format (%u, %#x, %#x, %#x, %#x)\n", pixel_format->bpp,
374  pixel_format->rmask, pixel_format->gmask, pixel_format->bmask, pixel_format->amask);
375  return D3DFMT_UNKNOWN;
376 }
#define WARN(fmt,...)
Definition: debug.h:112

Referenced by dds_pixel_format_to_d3dformat().

◆ dds_fourcc_to_d3dformat()

static D3DFORMAT dds_fourcc_to_d3dformat ( DWORD  fourcc)
static

Definition at line 153 of file surface.c.

154 {
155  unsigned int i;
156  static const DWORD known_fourcc[] = {
157  D3DFMT_UYVY,
158  D3DFMT_YUY2,
161  D3DFMT_DXT1,
162  D3DFMT_DXT2,
163  D3DFMT_DXT3,
164  D3DFMT_DXT4,
165  D3DFMT_DXT5,
166  D3DFMT_R16F,
169  D3DFMT_R32F,
172  };
173 
174  for (i = 0; i < ARRAY_SIZE(known_fourcc); i++)
175  {
176  if (known_fourcc[i] == fourcc)
177  return fourcc;
178  }
179 
180  WARN("Unknown FourCC %#x\n", fourcc);
181  return D3DFMT_UNKNOWN;
182 }
#define WARN(fmt,...)
Definition: debug.h:112
unsigned long DWORD
Definition: ntddk_ex.h:95
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

Referenced by d3dformat_to_dds_pixel_format(), and dds_pixel_format_to_d3dformat().

◆ dds_indexed_to_d3dformat()

static D3DFORMAT dds_indexed_to_d3dformat ( const struct dds_pixel_format pixel_format)
static

Definition at line 357 of file surface.c.

358 {
359  if (pixel_format->bpp == 8)
360  return D3DFMT_P8;
361 
362  WARN("Unknown indexed pixel format (%u).\n", pixel_format->bpp);
363  return D3DFMT_UNKNOWN;
364 }
#define WARN(fmt,...)
Definition: debug.h:112

Referenced by dds_pixel_format_to_d3dformat().

◆ dds_luminance_to_d3dformat()

static D3DFORMAT dds_luminance_to_d3dformat ( const struct dds_pixel_format pixel_format)
static

Definition at line 326 of file surface.c.

327 {
328  if (pixel_format->bpp == 8)
329  {
330  if (pixel_format->rmask == 0xff)
331  return D3DFMT_L8;
332  if ((pixel_format->flags & DDS_PF_ALPHA) && pixel_format->rmask == 0x0f && pixel_format->amask == 0xf0)
333  return D3DFMT_A4L4;
334  }
335  if (pixel_format->bpp == 16)
336  {
337  if (pixel_format->rmask == 0xffff)
338  return D3DFMT_L16;
339  if ((pixel_format->flags & DDS_PF_ALPHA) && pixel_format->rmask == 0x00ff && pixel_format->amask == 0xff00)
340  return D3DFMT_A8L8;
341  }
342 
343  WARN("Unknown luminance pixel format (bpp %u, l %#x, a %#x)\n",
344  pixel_format->bpp, pixel_format->rmask, pixel_format->amask);
345  return D3DFMT_UNKNOWN;
346 }
#define WARN(fmt,...)
Definition: debug.h:112
#define DDS_PF_ALPHA
Definition: surface.c:112

Referenced by dds_pixel_format_to_d3dformat().

◆ dds_pixel_format_to_d3dformat()

static D3DFORMAT dds_pixel_format_to_d3dformat ( const struct dds_pixel_format pixel_format)
static

Definition at line 389 of file surface.c.

390 {
391  TRACE("pixel_format: size %u, flags %#x, fourcc %#x, bpp %u.\n", pixel_format->size,
392  pixel_format->flags, pixel_format->fourcc, pixel_format->bpp);
393  TRACE("rmask %#x, gmask %#x, bmask %#x, amask %#x.\n", pixel_format->rmask, pixel_format->gmask,
394  pixel_format->bmask, pixel_format->amask);
395 
396  if (pixel_format->flags & DDS_PF_FOURCC)
397  return dds_fourcc_to_d3dformat(pixel_format->fourcc);
398  if (pixel_format->flags & DDS_PF_INDEXED)
400  if (pixel_format->flags & DDS_PF_RGB)
402  if (pixel_format->flags & DDS_PF_LUMINANCE)
404  if (pixel_format->flags & DDS_PF_ALPHA_ONLY)
406  if (pixel_format->flags & DDS_PF_BUMPDUDV)
408  if (pixel_format->flags & DDS_PF_BUMPLUMINANCE)
410 
411  WARN("Unknown pixel format (flags %#x, fourcc %#x, bpp %u, r %#x, g %#x, b %#x, a %#x)\n",
412  pixel_format->flags, pixel_format->fourcc, pixel_format->bpp,
413  pixel_format->rmask, pixel_format->gmask, pixel_format->bmask, pixel_format->amask);
414  return D3DFMT_UNKNOWN;
415 }
static D3DFORMAT dds_bump_luminance_to_d3dformat(const struct dds_pixel_format *pixel_format)
Definition: surface.c:378
#define DDS_PF_FOURCC
Definition: surface.c:114
#define WARN(fmt,...)
Definition: debug.h:112
static D3DFORMAT dds_alpha_to_d3dformat(const struct dds_pixel_format *pixel_format)
Definition: surface.c:348
#define DDS_PF_BUMPDUDV
Definition: surface.c:120
static D3DFORMAT dds_rgb_to_d3dformat(const struct dds_pixel_format *pixel_format)
Definition: surface.c:303
#define TRACE(s)
Definition: solgame.cpp:4
static D3DFORMAT dds_fourcc_to_d3dformat(DWORD fourcc)
Definition: surface.c:153
#define DDS_PF_BUMPLUMINANCE
Definition: surface.c:119
#define DDS_PF_LUMINANCE
Definition: surface.c:118
static D3DFORMAT dds_luminance_to_d3dformat(const struct dds_pixel_format *pixel_format)
Definition: surface.c:326
#define DDS_PF_RGB
Definition: surface.c:116
static D3DFORMAT dds_indexed_to_d3dformat(const struct dds_pixel_format *pixel_format)
Definition: surface.c:357
static D3DFORMAT dds_bump_to_d3dformat(const struct dds_pixel_format *pixel_format)
Definition: surface.c:366
#define DDS_PF_ALPHA_ONLY
Definition: surface.c:113
#define DDS_PF_INDEXED
Definition: surface.c:115

Referenced by get_image_info_from_dds().

◆ dds_rgb_to_d3dformat()

static D3DFORMAT dds_rgb_to_d3dformat ( const struct dds_pixel_format pixel_format)
static

Definition at line 303 of file surface.c.

304 {
305  unsigned int i;
306 
307  for (i = 0; i < ARRAY_SIZE(rgb_pixel_formats); i++)
308  {
309  if (rgb_pixel_formats[i].bpp == pixel_format->bpp
310  && rgb_pixel_formats[i].rmask == pixel_format->rmask
311  && rgb_pixel_formats[i].gmask == pixel_format->gmask
312  && rgb_pixel_formats[i].bmask == pixel_format->bmask)
313  {
314  if ((pixel_format->flags & DDS_PF_ALPHA) && rgb_pixel_formats[i].amask == pixel_format->amask)
315  return rgb_pixel_formats[i].format;
316  if (rgb_pixel_formats[i].amask == 0)
317  return rgb_pixel_formats[i].format;
318  }
319  }
320 
321  WARN("Unknown RGB pixel format (%#x, %#x, %#x, %#x)\n",
322  pixel_format->rmask, pixel_format->gmask, pixel_format->bmask, pixel_format->amask);
323  return D3DFMT_UNKNOWN;
324 }
DWORD amask
Definition: surface.c:189
#define WARN(fmt,...)
Definition: debug.h:112
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
static const struct @237 rgb_pixel_formats[]
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 DDS_PF_ALPHA
Definition: surface.c:112
DWORD bpp
Definition: surface.c:185

Referenced by dds_pixel_format_to_d3dformat().

◆ DEFINE_GUID()

DEFINE_GUID ( GUID_WineContainerFormatTga  ,
0x0c44fda1  ,
0xa5c5  ,
0x4298  ,
0x96  ,
0x85  ,
0x47  ,
0x3f  ,
0xc1  ,
0x7c  ,
0xd3  ,
0x22   
)

◆ format_from_vec4()

static void format_from_vec4 ( const struct pixel_format_desc format,
const struct vec4 src,
BYTE dst 
)
static

Definition at line 1650 of file surface.c.

1651 {
1652  DWORD v, mask32;
1653  unsigned int c, i;
1654 
1655  memset(dst, 0, format->bytes_per_pixel);
1656 
1657  for (c = 0; c < 4; ++c)
1658  {
1659  static const unsigned int component_offsets[4] = {3, 0, 1, 2};
1660  const float src_component = *((const float *)src + component_offsets[c]);
1661 
1662  if (!format->bits[c])
1663  continue;
1664 
1665  mask32 = ~0u >> (32 - format->bits[c]);
1666 
1667  if (format->type == FORMAT_ARGBF16)
1668  v = float_32_to_16(src_component);
1669  else if (format->type == FORMAT_ARGBF)
1670  v = *(DWORD *)&src_component;
1671  else
1672  v = (DWORD)(src_component * ((1 << format->bits[c]) - 1) + 0.5f);
1673 
1674  for (i = format->shift[c] / 8 * 8; i < format->shift[c] + format->bits[c]; i += 8)
1675  {
1676  BYTE mask, byte;
1677 
1678  if (format->shift[c] > i)
1679  {
1680  mask = mask32 << (format->shift[c] - i);
1681  byte = (v << (format->shift[c] - i)) & mask;
1682  }
1683  else
1684  {
1685  mask = mask32 >> (i - format->shift[c]);
1686  byte = (v >> (i - format->shift[c])) & mask;
1687  }
1688  dst[i / 8] |= byte;
1689  }
1690  }
1691 }
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 * u
Definition: glfuncs.h:240
#define shift
Definition: input.c:1756
#define DWORD
Definition: nt_native.h:44
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLenum GLint GLuint mask
Definition: glext.h:6028
GLfloat f
Definition: glext.h:7540
const GLubyte * c
Definition: glext.h:8905
unsigned long DWORD
Definition: ntddk_ex.h:95
GLenum src
Definition: glext.h:6340
unsigned char BYTE
Definition: xxhash.c:193
const GLdouble * v
Definition: gl.h:2040
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 byte(x, n)
Definition: tomcrypt.h:118
GLenum GLenum dst
Definition: glext.h:6340
static unsigned short float_32_to_16(const float *in)
Definition: surface.c:1062
#define c
Definition: ke_i.h:80
#define memset(x, y, z)
Definition: compat.h:39

Referenced by convert_argb_pixels(), and point_filter_argb_pixels().

◆ format_to_vec4()

static void format_to_vec4 ( const struct pixel_format_desc format,
const BYTE src,
struct vec4 dst 
)
static

Definition at line 1620 of file surface.c.

1621 {
1622  DWORD mask, tmp;
1623  unsigned int c;
1624 
1625  for (c = 0; c < 4; ++c)
1626  {
1627  static const unsigned int component_offsets[4] = {3, 0, 1, 2};
1628  float *dst_component = (float *)dst + component_offsets[c];
1629 
1630  if (format->bits[c])
1631  {
1632  mask = ~0u >> (32 - format->bits[c]);
1633 
1634  memcpy(&tmp, src + format->shift[c] / 8,
1635  min(sizeof(DWORD), (format->shift[c] % 8 + format->bits[c] + 7) / 8));
1636 
1637  if (format->type == FORMAT_ARGBF16)
1638  *dst_component = float_16_to_32(tmp);
1639  else if (format->type == FORMAT_ARGBF)
1640  *dst_component = *(float *)&tmp;
1641  else
1642  *dst_component = (float)((tmp >> format->shift[c] % 8) & mask) / mask;
1643  }
1644  else
1645  *dst_component = 1.0f;
1646  }
1647 }
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 * u
Definition: glfuncs.h:240
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLenum GLint GLuint mask
Definition: glext.h:6028
float float_16_to_32(const unsigned short in) DECLSPEC_HIDDEN
Definition: math.c:2203
const GLubyte * c
Definition: glext.h:8905
unsigned long DWORD
Definition: ntddk_ex.h:95
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum src
Definition: glext.h:6340
static float(__cdecl *square_half_float)(float x
GLenum GLenum dst
Definition: glext.h:6340
#define min(a, b)
Definition: monoChain.cc:55
#define c
Definition: ke_i.h:80

Referenced by convert_argb_pixels(), and point_filter_argb_pixels().

◆ get_image_info_from_dds()

static HRESULT get_image_info_from_dds ( const void buffer,
UINT  length,
D3DXIMAGE_INFO info 
)
static

Definition at line 512 of file surface.c.

513 {
514  UINT faces = 1;
515  UINT expected_length;
516  const struct dds_header *header = buffer;
517 
518  if (length < sizeof(*header) || !info)
519  return D3DXERR_INVALIDDATA;
520 
521  if (header->pixel_format.size != sizeof(header->pixel_format))
522  return D3DXERR_INVALIDDATA;
523 
524  info->Width = header->width;
525  info->Height = header->height;
526  info->Depth = 1;
527  info->MipLevels = header->miplevels ? header->miplevels : 1;
528 
529  info->Format = dds_pixel_format_to_d3dformat(&header->pixel_format);
530  if (info->Format == D3DFMT_UNKNOWN)
531  return D3DXERR_INVALIDDATA;
532 
533  TRACE("Pixel format is %#x\n", info->Format);
534 
535  if (header->caps2 & DDS_CAPS2_VOLUME)
536  {
537  info->Depth = header->depth;
538  info->ResourceType = D3DRTYPE_VOLUMETEXTURE;
539  }
540  else if (header->caps2 & DDS_CAPS2_CUBEMAP)
541  {
542  DWORD face;
543  faces = 0;
545  {
546  if (header->caps2 & face)
547  faces++;
548  }
549  info->ResourceType = D3DRTYPE_CUBETEXTURE;
550  }
551  else
552  {
553  info->ResourceType = D3DRTYPE_TEXTURE;
554  }
555 
556  expected_length = calculate_dds_file_size(info->Format, info->Width, info->Height, info->Depth,
557  info->MipLevels, faces);
558  if (length < expected_length)
559  {
560  WARN("File is too short %u, expected at least %u bytes\n", length, expected_length);
561  return D3DXERR_INVALIDDATA;
562  }
563 
564  info->ImageFileFormat = D3DXIFF_DDS;
565  return D3D_OK;
566 }
#define WARN(fmt,...)
Definition: debug.h:112
#define DDS_CAPS2_VOLUME
Definition: surface.c:109
GLuint buffer
Definition: glext.h:5915
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
WORD face[3]
Definition: mesh.c:4747
static UINT calculate_dds_file_size(D3DFORMAT format, UINT width, UINT height, UINT depth, UINT miplevels, UINT faces)
Definition: surface.c:475
#define D3D_OK
Definition: d3d.h:106
unsigned int UINT
Definition: ndis.h:50
static D3DFORMAT dds_pixel_format_to_d3dformat(const struct dds_pixel_format *pixel_format)
Definition: surface.c:389
#define DDS_CAPS2_CUBEMAP_NEGATIVEZ
Definition: surface.c:105
#define DDS_CAPS2_CUBEMAP
Definition: surface.c:99
#define DDS_CAPS2_CUBEMAP_POSITIVEX
Definition: surface.c:100
GLenum GLuint GLint GLenum face
Definition: glext.h:7025

Referenced by D3DXGetImageInfoFromFileInMemory().

◆ get_relevant_argb_components()

static void get_relevant_argb_components ( const struct argb_conversion_info info,
const BYTE col,
DWORD out 
)
static

Definition at line 1572 of file surface.c.

1573 {
1574  unsigned int i, j;
1575  unsigned int component, mask;
1576 
1577  for (i = 0; i < 4; ++i)
1578  {
1579  if (!info->process_channel[i])
1580  continue;
1581 
1582  component = 0;
1583  mask = info->srcmask[i];
1584  for (j = 0; j < 4 && mask; ++j)
1585  {
1586  if (info->srcshift[i] < j * 8)
1587  component |= (col[j] & mask) << (j * 8 - info->srcshift[i]);
1588  else
1589  component |= (col[j] & mask) >> (info->srcshift[i] - j * 8);
1590  mask >>= 8;
1591  }
1592  out[i] = component;
1593  }
1594 }
GLenum GLint GLuint mask
Definition: glext.h:6028
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
static FILE * out
Definition: regtests2xml.c:44
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

Referenced by convert_argb_pixels(), and point_filter_argb_pixels().

◆ get_surface()

static HRESULT get_surface ( D3DRESOURCETYPE  type,
struct IDirect3DBaseTexture9 *  tex,
int  face,
UINT  level,
struct IDirect3DSurface9 **  surf 
)
static

Definition at line 657 of file surface.c.

659 {
660  switch (type)
661  {
662  case D3DRTYPE_TEXTURE:
663  return IDirect3DTexture9_GetSurfaceLevel((IDirect3DTexture9*) tex, level, surf);
665  return IDirect3DCubeTexture9_GetCubeMapSurface((IDirect3DCubeTexture9*) tex, face, level, surf);
666  default:
667  ERR("Unexpected texture type\n");
668  return E_NOTIMPL;
669  }
670 }
GLint level
Definition: gl.h:1546
#define IDirect3DTexture9_GetSurfaceLevel(p, a, b)
Definition: d3d9.h:1033
#define IDirect3DCubeTexture9_GetCubeMapSurface(p, a, b, c)
Definition: d3d9.h:938
#define ERR(fmt,...)
Definition: debug.h:110
#define E_NOTIMPL
Definition: ddrawi.h:99
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLenum GLuint GLint GLenum face
Definition: glext.h:7025

Referenced by save_dds_texture_to_memory().

◆ init_argb_conversion_info()

static void init_argb_conversion_info ( const struct pixel_format_desc srcformat,
const struct pixel_format_desc destformat,
struct argb_conversion_info info 
)
static

Definition at line 1539 of file surface.c.

1540 {
1541  UINT i;
1542  ZeroMemory(info->process_channel, 4 * sizeof(BOOL));
1543  info->channelmask = 0;
1544 
1545  info->srcformat = srcformat;
1546  info->destformat = destformat;
1547 
1548  for(i = 0;i < 4;i++) {
1549  /* srcshift is used to extract the _relevant_ components */
1550  info->srcshift[i] = srcformat->shift[i] + max( srcformat->bits[i] - destformat->bits[i], 0);
1551 
1552  /* destshift is used to move the components to the correct position */
1553  info->destshift[i] = destformat->shift[i] + max(destformat->bits[i] - srcformat->bits[i], 0);
1554 
1555  info->srcmask[i] = ((1 << srcformat->bits[i]) - 1) << srcformat->shift[i];
1556  info->destmask[i] = ((1 << destformat->bits[i]) - 1) << destformat->shift[i];
1557 
1558  /* channelmask specifies bits which aren't used in the source format but in the destination one */
1559  if(destformat->bits[i]) {
1560  if(srcformat->bits[i]) info->process_channel[i] = TRUE;
1561  else info->channelmask |= info->destmask[i];
1562  }
1563  }
1564 }
#define max(a, b)
Definition: svc.c:63
#define TRUE
Definition: types.h:120
#define ZeroMemory
Definition: winbase.h:1664
unsigned int BOOL
Definition: ntddk_ex.h:94
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
unsigned int UINT
Definition: ndis.h:50

Referenced by convert_argb_pixels(), and point_filter_argb_pixels().

◆ load_cube_texture_from_dds()

HRESULT load_cube_texture_from_dds ( IDirect3DCubeTexture9 *  cube_texture,
const void src_data,
const PALETTEENTRY palette,
DWORD  filter,
DWORD  color_key,
const D3DXIMAGE_INFO src_info 
)

Definition at line 794 of file surface.c.

796 {
797  HRESULT hr;
798  int face;
799  UINT mip_level;
800  UINT size;
801  RECT src_rect;
802  UINT src_pitch;
803  UINT mip_levels;
804  UINT mip_level_size;
805  IDirect3DSurface9 *surface;
806  const struct dds_header *header = src_data;
807  const BYTE *pixels = (BYTE *)(header + 1);
808 
809  if (src_info->ResourceType != D3DRTYPE_CUBETEXTURE)
810  return D3DXERR_INVALIDDATA;
811 
813  {
814  WARN("Only full cubemaps are supported\n");
815  return D3DXERR_INVALIDDATA;
816  }
817 
818  mip_levels = min(src_info->MipLevels, IDirect3DCubeTexture9_GetLevelCount(cube_texture));
820  {
821  size = src_info->Width;
822  for (mip_level = 0; mip_level < src_info->MipLevels; mip_level++)
823  {
824  hr = calculate_dds_surface_size(src_info->Format, size, size, &src_pitch, &mip_level_size);
825  if (FAILED(hr)) return hr;
826 
827  /* if texture has fewer mip levels than DDS file, skip excessive mip levels */
828  if (mip_level < mip_levels)
829  {
830  SetRect(&src_rect, 0, 0, size, size);
831 
832  IDirect3DCubeTexture9_GetCubeMapSurface(cube_texture, face, mip_level, &surface);
833  hr = D3DXLoadSurfaceFromMemory(surface, palette, NULL, pixels, src_info->Format, src_pitch,
834  NULL, &src_rect, filter, color_key);
835  IDirect3DSurface9_Release(surface);
836  if (FAILED(hr)) return hr;
837  }
838 
839  pixels += mip_level_size;
840  size = max(1, size / 2);
841  }
842  }
843 
844  return D3D_OK;
845 }
#define IDirect3DSurface9_Release(p)
Definition: d3d9.h:622
#define max(a, b)
Definition: svc.c:63
HRESULT hr
Definition: shlfolder.c:183
#define IDirect3DCubeTexture9_GetLevelCount(p)
Definition: d3d9.h:932
#define WARN(fmt,...)
Definition: debug.h:112
D3DRESOURCETYPE ResourceType
Definition: d3dx9tex.h:83
UINT MipLevels
Definition: d3dx9tex.h:81
GLsizeiptr size
Definition: glext.h:5919
D3DFORMAT Format
Definition: d3dx9tex.h:82
#define DDS_CAPS2_CUBEMAP_ALL_FACES
Definition: surface.c:106
LONG HRESULT
Definition: typedefs.h:79
static HRESULT calculate_dds_surface_size(D3DFORMAT format, UINT width, UINT height, UINT *pitch, UINT *size)
Definition: surface.c:452
WORD face[3]
Definition: mesh.c:4747
#define IDirect3DCubeTexture9_GetCubeMapSurface(p, a, b, c)
Definition: d3d9.h:938
unsigned char BYTE
Definition: xxhash.c:193
static HPALETTE palette
Definition: clipboard.c:1345
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
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
GLenum GLuint GLint GLenum face
Definition: glext.h:7025

◆ load_surface_from_dds()

static HRESULT load_surface_from_dds ( IDirect3DSurface9 *  dst_surface,
const PALETTEENTRY dst_palette,
const RECT dst_rect,
const void src_data,
const RECT src_rect,
DWORD  filter,
D3DCOLOR  color_key,
const D3DXIMAGE_INFO src_info 
)
static

Definition at line 568 of file surface.c.

571 {
572  UINT size;
573  UINT src_pitch;
574  const struct dds_header *header = src_data;
575  const BYTE *pixels = (BYTE *)(header + 1);
576 
577  if (src_info->ResourceType != D3DRTYPE_TEXTURE)
578  return D3DXERR_INVALIDDATA;
579 
580  if (FAILED(calculate_dds_surface_size(src_info->Format, src_info->Width, src_info->Height, &src_pitch, &size)))
581  return E_NOTIMPL;
582 
583  return D3DXLoadSurfaceFromMemory(dst_surface, dst_palette, dst_rect, pixels, src_info->Format,
584  src_pitch, NULL, src_rect, filter, color_key);
585 }
D3DRESOURCETYPE ResourceType
Definition: d3dx9tex.h:83
GLsizeiptr size
Definition: glext.h:5919
D3DFORMAT Format
Definition: d3dx9tex.h:82
static HRESULT calculate_dds_surface_size(D3DFORMAT format, UINT width, UINT height, UINT *pitch, UINT *size)
Definition: surface.c:452
unsigned char BYTE
Definition: xxhash.c:193
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 E_NOTIMPL
Definition: ddrawi.h:99
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005

Referenced by D3DXLoadSurfaceFromFileInMemory().

◆ load_texture_from_dds()

HRESULT load_texture_from_dds ( IDirect3DTexture9 *  texture,
const void src_data,
const PALETTEENTRY palette,
DWORD  filter,
D3DCOLOR  color_key,
const D3DXIMAGE_INFO src_info,
unsigned int  skip_levels,
unsigned int loaded_miplevels 
)

Definition at line 737 of file surface.c.

740 {
741  HRESULT hr;
742  RECT src_rect;
743  UINT src_pitch;
744  UINT mip_level;
745  UINT mip_levels;
746  UINT mip_level_size;
747  UINT width, height;
748  IDirect3DSurface9 *surface;
749  const struct dds_header *header = src_data;
750  const BYTE *pixels = (BYTE *)(header + 1);
751 
752  /* Loading a cube texture as a simple texture is also supported
753  * (only first face texture is taken). Same with volume textures. */
754  if ((src_info->ResourceType != D3DRTYPE_TEXTURE)
755  && (src_info->ResourceType != D3DRTYPE_CUBETEXTURE)
756  && (src_info->ResourceType != D3DRTYPE_VOLUMETEXTURE))
757  {
758  WARN("Trying to load a %u resource as a 2D texture, returning failure.\n", src_info->ResourceType);
759  return D3DXERR_INVALIDDATA;
760  }
761 
762  width = src_info->Width;
763  height = src_info->Height;
764  mip_levels = min(src_info->MipLevels, IDirect3DTexture9_GetLevelCount(texture));
765  if (src_info->ResourceType == D3DRTYPE_VOLUMETEXTURE)
766  mip_levels = 1;
767  for (mip_level = 0; mip_level < mip_levels + skip_levels; ++mip_level)
768  {
769  hr = calculate_dds_surface_size(src_info->Format, width, height, &src_pitch, &mip_level_size);
770  if (FAILED(hr)) return hr;
771 
772  if (mip_level >= skip_levels)
773  {
774  SetRect(&src_rect, 0, 0, width, height);
775 
776  IDirect3DTexture9_GetSurfaceLevel(texture, mip_level - skip_levels, &surface);
777  hr = D3DXLoadSurfaceFromMemory(surface, palette, NULL, pixels, src_info->Format, src_pitch,
778  NULL, &src_rect, filter, color_key);
779  IDirect3DSurface9_Release(surface);
780  if (FAILED(hr))
781  return hr;
782  }
783 
784  pixels += mip_level_size;
785  width = max(1, width / 2);
786  height = max(1, height / 2);
787  }
788 
789  *loaded_miplevels = mip_levels - skip_levels;
790 
791  return D3D_OK;
792 }
#define IDirect3DSurface9_Release(p)
Definition: d3d9.h:622
GLint GLint GLsizei width
Definition: gl.h:1546
#define max(a, b)
Definition: svc.c:63
HRESULT hr
Definition: shlfolder.c:183
#define IDirect3DTexture9_GetSurfaceLevel(p, a, b)
Definition: d3d9.h:1033
#define WARN(fmt,...)
Definition: debug.h:112
#define IDirect3DTexture9_GetLevelCount(p)
Definition: d3d9.h:1027
D3DRESOURCETYPE ResourceType
Definition: d3dx9tex.h:83
UINT MipLevels
Definition: d3dx9tex.h:81
D3DFORMAT Format
Definition: d3dx9tex.h:82
GLenum GLuint texture
Definition: glext.h:6295
LONG HRESULT
Definition: typedefs.h:79
static HRESULT calculate_dds_surface_size(D3DFORMAT format, UINT width, UINT height, UINT *pitch, UINT *size)
Definition: surface.c:452
unsigned char BYTE
Definition: xxhash.c:193
static HPALETTE palette
Definition: clipboard.c:1345
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
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
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005

Referenced by D3DXCreateTextureFromFileInMemoryEx().

◆ load_volume_from_dds()

HRESULT load_volume_from_dds ( IDirect3DVolume9 *  dst_volume,
const PALETTEENTRY dst_palette,
const D3DBOX dst_box,
const void src_data,
const D3DBOX src_box,
DWORD  filter,
D3DCOLOR  color_key,
const D3DXIMAGE_INFO src_info 
)

Definition at line 719 of file surface.c.

722 {
723  UINT row_pitch, slice_pitch;
724  const struct dds_header *header = src_data;
725  const BYTE *pixels = (BYTE *)(header + 1);
726 
727  if (src_info->ResourceType != D3DRTYPE_VOLUMETEXTURE)
728  return D3DXERR_INVALIDDATA;
729 
730  if (FAILED(calculate_dds_surface_size(src_info->Format, src_info->Width, src_info->Height, &row_pitch, &slice_pitch)))
731  return E_NOTIMPL;
732 
733  return D3DXLoadVolumeFromMemory(dst_volume, dst_palette, dst_box, pixels, src_info->Format,
734  row_pitch, slice_pitch, NULL, src_box, filter, color_key);
735 }
D3DRESOURCETYPE ResourceType
Definition: d3dx9tex.h:83
D3DFORMAT Format
Definition: d3dx9tex.h:82
static HRESULT calculate_dds_surface_size(D3DFORMAT format, UINT width, UINT height, UINT *pitch, UINT *size)
Definition: surface.c:452
unsigned char BYTE
Definition: xxhash.c:193
HRESULT WINAPI D3DXLoadVolumeFromMemory(IDirect3DVolume9 *dst_volume, const PALETTEENTRY *dst_palette, const D3DBOX *dst_box, const void *src_memory, D3DFORMAT src_format, UINT src_row_pitch, UINT src_slice_pitch, const PALETTEENTRY *src_palette, const D3DBOX *src_box, DWORD filter, D3DCOLOR color_key)
Definition: volume.c:87
#define E_NOTIMPL
Definition: ddrawi.h:99
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005

Referenced by D3DXLoadVolumeFromFileInMemory().

◆ load_volume_texture_from_dds()

HRESULT load_volume_texture_from_dds ( IDirect3DVolumeTexture9 *  volume_texture,
const void src_data,
const PALETTEENTRY palette,
DWORD  filter,
DWORD  color_key,
const D3DXIMAGE_INFO src_info&#