?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dx9: Rename point_filter_simple_data to point_filter_argb_pixels.
[wine.git] / dlls / d3dx9_36 / surface.c
blob14df4ff5ff4503806f497a689f26e3e4686f4553
1 /*
2 * Copyright (C) 2009-2010 Tony Wasserka
3 * Copyright (C) 2012 Józef Kucia
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 *
19 */
20
21 #include "wine/debug.h"
22 #include "wine/unicode.h"
23 #include "d3dx9_36_private.h"
24
25 #include "initguid.h"
26 #include "ole2.h"
27 #include "wincodec.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
30
31
32 /* Wine-specific WIC GUIDs */
33 DEFINE_GUID(GUID_WineContainerFormatTga, 0x0c44fda1,0xa5c5,0x4298,0x96,0x85,0x47,0x3f,0xc1,0x7c,0xd3,0x22);
34
35 static const struct
36 {
37 const GUID *wic_guid;
38 D3DFORMAT d3dformat;
39 } wic_pixel_formats[] = {
40 { &GUID_WICPixelFormat8bppIndexed, D3DFMT_L8 },
41 { &GUID_WICPixelFormat1bppIndexed, D3DFMT_L8 },
42 { &GUID_WICPixelFormat4bppIndexed, D3DFMT_L8 },
43 { &GUID_WICPixelFormat16bppBGR555, D3DFMT_X1R5G5B5 },
44 { &GUID_WICPixelFormat16bppBGR565, D3DFMT_R5G6B5 },
45 { &GUID_WICPixelFormat24bppBGR, D3DFMT_R8G8B8 },
46 { &GUID_WICPixelFormat32bppBGR, D3DFMT_X8R8G8B8 },
47 { &GUID_WICPixelFormat32bppBGRA, D3DFMT_A8R8G8B8 }
48 };
49
50 static D3DFORMAT wic_guid_to_d3dformat(const GUID *guid)
51 {
52 int i;
53
54 for (i = 0; i < sizeof(wic_pixel_formats) / sizeof(wic_pixel_formats[0]); i++)
55 {
56 if (IsEqualGUID(wic_pixel_formats[i].wic_guid, guid))
57 return wic_pixel_formats[i].d3dformat;
58 }
59
60 return D3DFMT_UNKNOWN;
61 }
62
63 static const GUID *d3dformat_to_wic_guid(D3DFORMAT format)
64 {
65 int i;
66
67 for (i = 0; i < sizeof(wic_pixel_formats) / sizeof(wic_pixel_formats[0]); i++)
68 {
69 if (wic_pixel_formats[i].d3dformat == format)
70 return wic_pixel_formats[i].wic_guid;
71 }
72
73 return NULL;
74 }
75
76 /* dds_header.flags */
77 #define DDS_CAPS 0x1
78 #define DDS_HEIGHT 0x2
79 #define DDS_WIDTH 0x2
80 #define DDS_PITCH 0x8
81 #define DDS_PIXELFORMAT 0x1000
82 #define DDS_MIPMAPCOUNT 0x20000
83 #define DDS_LINEARSIZE 0x80000
84 #define DDS_DEPTH 0x800000
85
86 /* dds_header.caps */
87 #define DDS_CAPS_COMPLEX 0x8
88 #define DDS_CAPS_TEXTURE 0x1000
89 #define DDS_CAPS_MIPMAP 0x400000
90
91 /* dds_header.caps2 */
92 #define DDS_CAPS2_CUBEMAP 0x200
93 #define DDS_CAPS2_CUBEMAP_POSITIVEX 0x400
94 #define DDS_CAPS2_CUBEMAP_NEGATIVEX 0x800
95 #define DDS_CAPS2_CUBEMAP_POSITIVEY 0x1000
96 #define DDS_CAPS2_CUBEMAP_NEGATIVEY 0x2000
97 #define DDS_CAPS2_CUBEMAP_POSITIVEZ 0x4000
98 #define DDS_CAPS2_CUBEMAP_NEGATIVEZ 0x8000
99 #define DDS_CAPS2_CUBEMAP_ALL_FACES ( DDS_CAPS2_CUBEMAP_POSITIVEX | DDS_CAPS2_CUBEMAP_NEGATIVEX \
100 | DDS_CAPS2_CUBEMAP_POSITIVEY | DDS_CAPS2_CUBEMAP_NEGATIVEY \
101 | DDS_CAPS2_CUBEMAP_POSITIVEZ | DDS_CAPS2_CUBEMAP_NEGATIVEZ )
102 #define DDS_CAPS2_VOLUME 0x200000
103
104 /* dds_pixel_format.flags */
105 #define DDS_PF_ALPHA 0x1
106 #define DDS_PF_ALPHA_ONLY 0x2
107 #define DDS_PF_FOURCC 0x4
108 #define DDS_PF_RGB 0x40
109 #define DDS_PF_YUV 0x200
110 #define DDS_PF_LUMINANCE 0x20000
111 #define DDS_PF_BUMPDUDV 0x80000
112
113 struct dds_pixel_format
114 {
115 DWORD size;
116 DWORD flags;
117 DWORD fourcc;
118 DWORD bpp;
119 DWORD rmask;
120 DWORD gmask;
121 DWORD bmask;
122 DWORD amask;
123 };
124
125 struct dds_header
126 {
127 DWORD signature;
128 DWORD size;
129 DWORD flags;
130 DWORD height;
131 DWORD width;
132 DWORD pitch_or_linear_size;
133 DWORD depth;
134 DWORD miplevels;
135 DWORD reserved[11];
136 struct dds_pixel_format pixel_format;
137 DWORD caps;
138 DWORD caps2;
139 DWORD caps3;
140 DWORD caps4;
141 DWORD reserved2;
142 };
143
144 static D3DFORMAT dds_fourcc_to_d3dformat(DWORD fourcc)
145 {
146 int i;
147 static const DWORD known_fourcc[] = {
148 MAKEFOURCC('U','Y','V','Y'),
149 MAKEFOURCC('Y','U','Y','2'),
150 MAKEFOURCC('R','G','B','G'),
151 MAKEFOURCC('G','R','G','B'),
152 MAKEFOURCC('D','X','T','1'),
153 MAKEFOURCC('D','X','T','2'),
154 MAKEFOURCC('D','X','T','3'),
155 MAKEFOURCC('D','X','T','4'),
156 MAKEFOURCC('D','X','T','5')
157 };
158
159 for (i = 0; i < sizeof(known_fourcc) / sizeof(known_fourcc[0]); i++)
160 {
161 if (known_fourcc[i] == fourcc)
162 return fourcc;
163 }
164
165 WARN("Unknown FourCC %#x\n", fourcc);
166 return D3DFMT_UNKNOWN;
167 }
168
169 static const struct {
170 DWORD bpp;
171 DWORD rmask;
172 DWORD gmask;
173 DWORD bmask;
174 DWORD amask;
175 D3DFORMAT format;
176 } rgb_pixel_formats[] = {
177 { 8, 0xe0, 0x1c, 0x03, 0, D3DFMT_R3G3B2 },
178 { 16, 0xf800, 0x07e0, 0x001f, 0x0000, D3DFMT_R5G6B5 },
179 { 16, 0x7c00, 0x03e0, 0x001f, 0x8000, D3DFMT_A1R5G5B5 },
180 { 16, 0x7c00, 0x03e0, 0x001f, 0x0000, D3DFMT_X1R5G5B5 },
181 { 16, 0x0f00, 0x00f0, 0x000f, 0xf000, D3DFMT_A4R4G4B4 },
182 { 16, 0x0f00, 0x00f0, 0x000f, 0x0000, D3DFMT_X4R4G4B4 },
183 { 16, 0x00e0, 0x001c, 0x0003, 0xff00, D3DFMT_A8R3G3B2 },
184 { 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000, D3DFMT_R8G8B8 },
185 { 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000, D3DFMT_A8R8G8B8 },
186 { 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000, D3DFMT_X8R8G8B8 },
187 { 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000, D3DFMT_A2B10G10R10 },
188 { 32, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000, D3DFMT_A2R10G10B10 },
189 { 32, 0x0000ffff, 0xffff0000, 0x00000000, 0x00000000, D3DFMT_G16R16 },
190 { 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000, D3DFMT_A8B8G8R8 },
191 { 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000, D3DFMT_X8B8G8R8 },
192 };
193
194 static D3DFORMAT dds_rgb_to_d3dformat(const struct dds_pixel_format *pixel_format)
195 {
196 int i;
197
198 for (i = 0; i < sizeof(rgb_pixel_formats) / sizeof(rgb_pixel_formats[0]); i++)
199 {
200 if (rgb_pixel_formats[i].bpp == pixel_format->bpp
201 && rgb_pixel_formats[i].rmask == pixel_format->rmask
202 && rgb_pixel_formats[i].gmask == pixel_format->gmask
203 && rgb_pixel_formats[i].bmask == pixel_format->bmask)
204 {
205 if ((pixel_format->flags & DDS_PF_ALPHA) && rgb_pixel_formats[i].amask == pixel_format->amask)
206 return rgb_pixel_formats[i].format;
207 if (rgb_pixel_formats[i].amask == 0)
208 return rgb_pixel_formats[i].format;
209 }
210 }
211
212 WARN("Unknown RGB pixel format (%#x, %#x, %#x, %#x)\n",
213 pixel_format->rmask, pixel_format->gmask, pixel_format->bmask, pixel_format->amask);
214 return D3DFMT_UNKNOWN;
215 }
216
217 static D3DFORMAT dds_luminance_to_d3dformat(const struct dds_pixel_format *pixel_format)
218 {
219 if (pixel_format->bpp == 8)
220 {
221 if (pixel_format->rmask == 0xff)
222 return D3DFMT_L8;
223 if ((pixel_format->flags & DDS_PF_ALPHA) && pixel_format->rmask == 0x0f && pixel_format->amask == 0xf0)
224 return D3DFMT_A4L4;
225 }
226 if (pixel_format->bpp == 16)
227 {
228 if (pixel_format->rmask == 0xffff)
229 return D3DFMT_L16;
230 if ((pixel_format->flags & DDS_PF_ALPHA) && pixel_format->rmask == 0x00ff && pixel_format->amask == 0xff00)
231 return D3DFMT_A8L8;
232 }
233
234 WARN("Unknown luminance pixel format (bpp %#x, l %#x, a %#x)\n",
235 pixel_format->bpp, pixel_format->rmask, pixel_format->amask);
236 return D3DFMT_UNKNOWN;
237 }
238
239 static D3DFORMAT dds_alpha_to_d3dformat(const struct dds_pixel_format *pixel_format)
240 {
241 if (pixel_format->bpp == 8 && pixel_format->amask == 0xff)
242 return D3DFMT_A8;
243
244 WARN("Unknown Alpha pixel format (%#x, %#x)\n", pixel_format->bpp, pixel_format->rmask);
245 return D3DFMT_UNKNOWN;
246 }
247
248 static D3DFORMAT dds_bump_to_d3dformat(const struct dds_pixel_format *pixel_format)
249 {
250 if (pixel_format->bpp == 16 && pixel_format->rmask == 0x00ff && pixel_format->gmask == 0xff00)
251 return D3DFMT_V8U8;
252 if (pixel_format->bpp == 32 && pixel_format->rmask == 0x0000ffff && pixel_format->gmask == 0xffff0000)
253 return D3DFMT_V16U16;
254
255 WARN("Unknown bump pixel format (%#x, %#x, %#x, %#x, %#x)\n", pixel_format->bpp,
256 pixel_format->rmask, pixel_format->gmask, pixel_format->bmask, pixel_format->amask);
257 return D3DFMT_UNKNOWN;
258 }
259
260 static D3DFORMAT dds_pixel_format_to_d3dformat(const struct dds_pixel_format *pixel_format)
261 {
262 if (pixel_format->flags & DDS_PF_FOURCC)
263 return dds_fourcc_to_d3dformat(pixel_format->fourcc);
264 if (pixel_format->flags & DDS_PF_RGB)
265 return dds_rgb_to_d3dformat(pixel_format);
266 if (pixel_format->flags & DDS_PF_LUMINANCE)
267 return dds_luminance_to_d3dformat(pixel_format);
268 if (pixel_format->flags & DDS_PF_ALPHA_ONLY)
269 return dds_alpha_to_d3dformat(pixel_format);
270 if (pixel_format->flags & DDS_PF_BUMPDUDV)
271 return dds_bump_to_d3dformat(pixel_format);
272
273 WARN("Unknown pixel format (flags %#x, fourcc %#x, bpp %#x, r %#x, g %#x, b %#x, a %#x)\n",
274 pixel_format->flags, pixel_format->fourcc, pixel_format->bpp,
275 pixel_format->rmask, pixel_format->gmask, pixel_format->bmask, pixel_format->amask);
276 return D3DFMT_UNKNOWN;
277 }
278
279 static HRESULT d3dformat_to_dds_pixel_format(struct dds_pixel_format *pixel_format, D3DFORMAT d3dformat)
280 {
281 int i;
282
283 memset(pixel_format, 0, sizeof(*pixel_format));
284
285 pixel_format->size = sizeof(*pixel_format);
286
287 for (i = 0; i < sizeof(rgb_pixel_formats) / sizeof(rgb_pixel_formats[0]); i++)
288 {
289 if (rgb_pixel_formats[i].format == d3dformat)
290 {
291 pixel_format->flags |= DDS_PF_RGB;
292 pixel_format->bpp = rgb_pixel_formats[i].bpp;
293 pixel_format->rmask = rgb_pixel_formats[i].rmask;
294 pixel_format->gmask = rgb_pixel_formats[i].gmask;
295 pixel_format->bmask = rgb_pixel_formats[i].bmask;
296 pixel_format->amask = rgb_pixel_formats[i].amask;
297 if (pixel_format->amask) pixel_format->flags |= DDS_PF_ALPHA;
298 return D3D_OK;
299 }
300 }
301
302 WARN("Unknown pixel format %#x\n", d3dformat);
303 return E_NOTIMPL;
304 }
305
306 static HRESULT calculate_dds_surface_size(D3DFORMAT format, UINT width, UINT height,
307 UINT *pitch, UINT *size)
308 {
309 const struct pixel_format_desc *format_desc = get_format_info(format);
310 if (format_desc->type == FORMAT_UNKNOWN)
311 return E_NOTIMPL;
312
313 if (format_desc->block_width != 1 || format_desc->block_height != 1)
314 {
315 *pitch = format_desc->block_byte_count
316 * max(1, (width + format_desc->block_width - 1) / format_desc->block_width);
317 *size = *pitch
318 * max(1, (height + format_desc->block_height - 1) / format_desc->block_height);
319 }
320 else
321 {
322 *pitch = width * format_desc->bytes_per_pixel;
323 *size = *pitch * height;
324 }
325
326 return D3D_OK;
327 }
328
329 static UINT calculate_dds_file_size(D3DFORMAT format, UINT width, UINT height, UINT depth,
330 UINT miplevels, UINT faces)
331 {
332 UINT i, file_size = 0;
333
334 for (i = 0; i < miplevels; i++)
335 {
336 UINT pitch, size = 0;
337 calculate_dds_surface_size(format, width, height, &pitch, &size);
338 size *= depth;
339 file_size += size;
340 width = max(1, width / 2);
341 height = max(1, height / 2);
342 depth = max(1, depth / 2);
343 }
344
345 file_size *= faces;
346 file_size += sizeof(struct dds_header);
347 return file_size;
348 }
349
350 /************************************************************
351 * get_image_info_from_dds
352 *
353 * Fills a D3DXIMAGE_INFO structure with information
354 * about a DDS file stored in the memory.
355 *
356 * PARAMS
357 * buffer [I] pointer to DDS data
358 * length [I] size of DDS data
359 * info [O] pointer to D3DXIMAGE_INFO structure
360 *
361 * RETURNS
362 * Success: D3D_OK
363 * Failure: D3DXERR_INVALIDDATA
364 *
365 */
366 static HRESULT get_image_info_from_dds(const void *buffer, UINT length, D3DXIMAGE_INFO *info)
367 {
368 UINT faces = 1;
369 UINT expected_length;
370 const struct dds_header *header = buffer;
371
372 if (length < sizeof(*header) || !info)
373 return D3DXERR_INVALIDDATA;
374
375 if (header->pixel_format.size != sizeof(header->pixel_format))
376 return D3DXERR_INVALIDDATA;
377
378 info->Width = header->width;
379 info->Height = header->height;
380 info->Depth = 1;
381 info->MipLevels = (header->flags & DDS_MIPMAPCOUNT) ? header->miplevels : 1;
382
383 info->Format = dds_pixel_format_to_d3dformat(&header->pixel_format);
384 if (info->Format == D3DFMT_UNKNOWN)
385 return D3DXERR_INVALIDDATA;
386
387 TRACE("Pixel format is %#x\n", info->Format);
388
389 if (header->caps2 & DDS_CAPS2_VOLUME)
390 {
391 info->Depth = header->depth;
392 info->ResourceType = D3DRTYPE_VOLUMETEXTURE;
393 }
394 else if (header->caps2 & DDS_CAPS2_CUBEMAP)
395 {
396 DWORD face;
397 faces = 0;
398 for (face = DDS_CAPS2_CUBEMAP_POSITIVEX; face <= DDS_CAPS2_CUBEMAP_NEGATIVEZ; face <<= 1)
399 {
400 if (header->caps2 & face)
401 faces++;
402 }
403 info->ResourceType = D3DRTYPE_CUBETEXTURE;
404 }
405 else
406 {
407 info->ResourceType = D3DRTYPE_TEXTURE;
408 }
409
410 expected_length = calculate_dds_file_size(info->Format, info->Width, info->Height, info->Depth,
411 info->MipLevels, faces);
412 if (length < expected_length)
413 {
414 WARN("File is too short %u, expected at least %u bytes\n", length, expected_length);
415 return D3DXERR_INVALIDDATA;
416 }
417
418 info->ImageFileFormat = D3DXIFF_DDS;
419 return D3D_OK;
420 }
421
422 static HRESULT load_surface_from_dds(IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette,
423 const RECT *dst_rect, const void *src_data, const RECT *src_rect, DWORD filter, D3DCOLOR color_key,
424 const D3DXIMAGE_INFO *src_info)
425 {
426 UINT size;
427 UINT src_pitch;
428 const struct dds_header *header = src_data;
429 const BYTE *pixels = (BYTE *)(header + 1);
430
431 if (src_info->ResourceType != D3DRTYPE_TEXTURE)
432 return D3DXERR_INVALIDDATA;
433
434 if (FAILED(calculate_dds_surface_size(src_info->Format, src_info->Width, src_info->Height, &src_pitch, &size)))
435 return E_NOTIMPL;
436
437 return D3DXLoadSurfaceFromMemory(dst_surface, dst_palette, dst_rect, pixels, src_info->Format,
438 src_pitch, NULL, src_rect, filter, color_key);
439 }
440
441 static HRESULT save_dds_surface_to_memory(ID3DXBuffer **dst_buffer, IDirect3DSurface9 *src_surface, const RECT *src_rect)
442 {
443 HRESULT hr;
444 UINT dst_pitch, surface_size, file_size;
445 D3DSURFACE_DESC src_desc;
446 D3DLOCKED_RECT locked_rect;
447 ID3DXBuffer *buffer;
448 struct dds_header *header;
449 BYTE *pixels;
450 struct volume volume;
451 const struct pixel_format_desc *pixel_format;
452
453 if (src_rect)
454 {
455 FIXME("Saving a part of a surface to a DDS file is not implemented yet\n");
456 return E_NOTIMPL;
457 }
458
459 hr = IDirect3DSurface9_GetDesc(src_surface, &src_desc);
460 if (FAILED(hr)) return hr;
461
462 pixel_format = get_format_info(src_desc.Format);
463 if (pixel_format->type != FORMAT_ARGB)
464 {
465 FIXME("Unsupported pixel format %#x\n", src_desc.Format);
466 return E_NOTIMPL;
467 }
468
469 file_size = calculate_dds_file_size(src_desc.Format, src_desc.Width, src_desc.Height, 1, 1, 1);
470
471 hr = calculate_dds_surface_size(src_desc.Format, src_desc.Width, src_desc.Height, &dst_pitch, &surface_size);
472 if (FAILED(hr)) return hr;
473
474 hr = D3DXCreateBuffer(file_size, &buffer);
475 if (FAILED(hr)) return hr;
476
477 header = ID3DXBuffer_GetBufferPointer(buffer);
478 pixels = (BYTE *)(header + 1);
479
480 memset(header, 0, sizeof(*header));
481 header->signature = MAKEFOURCC('D','D','S',' ');
482 header->size = sizeof(*header);
483 header->flags = DDS_CAPS | DDS_HEIGHT | DDS_WIDTH | DDS_PITCH | DDS_PIXELFORMAT | DDS_MIPMAPCOUNT;
484 header->height = src_desc.Height;
485 header->width = src_desc.Width;
486 header->pitch_or_linear_size = dst_pitch;
487 header->depth = 1;
488 header->miplevels = 1;
489 header->caps = DDS_CAPS_TEXTURE;
490 hr = d3dformat_to_dds_pixel_format(&header->pixel_format, src_desc.Format);
491 if (FAILED(hr))
492 {
493 ID3DXBuffer_Release(buffer);
494 return hr;
495 }
496
497 hr = IDirect3DSurface9_LockRect(src_surface, &locked_rect, NULL, D3DLOCK_READONLY);
498 if (FAILED(hr))
499 {
500 ID3DXBuffer_Release(buffer);
501 return hr;
502 }
503
504 volume.width = src_desc.Width;
505 volume.height = src_desc.Height;
506 volume.depth = 1;
507 convert_argb_pixels(locked_rect.pBits, locked_rect.Pitch, 0, &volume, pixel_format,
508 pixels, dst_pitch, 0, &volume, pixel_format, 0);
509
510 IDirect3DSurface9_UnlockRect(src_surface);
511
512 *dst_buffer = buffer;
513 return D3D_OK;
514 }
515
516 HRESULT load_volume_from_dds(IDirect3DVolume9 *dst_volume, const PALETTEENTRY *dst_palette,
517 const D3DBOX *dst_box, const void *src_data, const D3DBOX *src_box, DWORD filter, D3DCOLOR color_key,
518 const D3DXIMAGE_INFO *src_info)
519 {
520 UINT row_pitch, slice_pitch;
521 const struct dds_header *header = src_data;
522 const BYTE *pixels = (BYTE *)(header + 1);
523
524 if (src_info->ResourceType != D3DRTYPE_VOLUMETEXTURE)
525 return D3DXERR_INVALIDDATA;
526
527 if (FAILED(calculate_dds_surface_size(src_info->Format, src_info->Width, src_info->Height, &row_pitch, &slice_pitch)))
528 return E_NOTIMPL;
529
530 return D3DXLoadVolumeFromMemory(dst_volume, dst_palette, dst_box, pixels, src_info->Format,
531 row_pitch, slice_pitch, NULL, src_box, filter, color_key);
532 }
533
534 HRESULT load_texture_from_dds(IDirect3DTexture9 *texture, const void *src_data, const PALETTEENTRY *palette,
535 DWORD filter, D3DCOLOR color_key, const D3DXIMAGE_INFO *src_info)
536
537 {
538 HRESULT hr;
539 RECT src_rect;
540 UINT src_pitch;
541 UINT mip_level;
542 UINT mip_levels;
543 UINT mip_level_size;
544 UINT width, height;
545 IDirect3DSurface9 *surface;
546 const struct dds_header *header = src_data;
547 const BYTE *pixels = (BYTE *)(header + 1);
548
549 /* Loading a cube texture as a simple texture is also supported (only first face texture is taken) */
550 if ((src_info->ResourceType != D3DRTYPE_TEXTURE) && (src_info->ResourceType != D3DRTYPE_CUBETEXTURE))
551 return D3DXERR_INVALIDDATA;
552
553 width = src_info->Width;
554 height = src_info->Height;
555 mip_levels = min(src_info->MipLevels, IDirect3DTexture9_GetLevelCount(texture));
556 for (mip_level = 0; mip_level < mip_levels; mip_level++)
557 {
558 hr = calculate_dds_surface_size(src_info->Format, width, height, &src_pitch, &mip_level_size);
559 if (FAILED(hr)) return hr;
560
561 SetRect(&src_rect, 0, 0, width, height);
562
563 IDirect3DTexture9_GetSurfaceLevel(texture, mip_level, &surface);
564 hr = D3DXLoadSurfaceFromMemory(surface, palette, NULL, pixels, src_info->Format, src_pitch,
565 NULL, &src_rect, filter, color_key);
566 IDirect3DSurface9_Release(surface);
567 if (FAILED(hr)) return hr;
568
569 pixels += mip_level_size;
570 width = max(1, width / 2);
571 height = max(1, height / 2);
572 }
573
574 return D3D_OK;
575 }
576
577 HRESULT load_cube_texture_from_dds(IDirect3DCubeTexture9 *cube_texture, const void *src_data,
578 const PALETTEENTRY *palette, DWORD filter, DWORD color_key, const D3DXIMAGE_INFO *src_info)
579 {
580 HRESULT hr;
581 int face;
582 int mip_level;
583 UINT size;
584 RECT src_rect;
585 UINT src_pitch;
586 UINT mip_levels;
587 UINT mip_level_size;
588 IDirect3DSurface9 *surface;
589 const struct dds_header *header = src_data;
590 const BYTE *pixels = (BYTE *)(header + 1);
591
592 if (src_info->ResourceType != D3DRTYPE_CUBETEXTURE)
593 return D3DXERR_INVALIDDATA;
594
595 if ((header->caps2 & DDS_CAPS2_CUBEMAP_ALL_FACES) != DDS_CAPS2_CUBEMAP_ALL_FACES)
596 {
597 WARN("Only full cubemaps are supported\n");
598 return D3DXERR_INVALIDDATA;
599 }
600
601 mip_levels = min(src_info->MipLevels, IDirect3DCubeTexture9_GetLevelCount(cube_texture));
602 for (face = D3DCUBEMAP_FACE_POSITIVE_X; face <= D3DCUBEMAP_FACE_NEGATIVE_Z; face++)
603 {
604 size = src_info->Width;
605 for (mip_level = 0; mip_level < src_info->MipLevels; mip_level++)
606 {
607 hr = calculate_dds_surface_size(src_info->Format, size, size, &src_pitch, &mip_level_size);
608 if (FAILED(hr)) return hr;
609
610 /* if texture has fewer mip levels than DDS file, skip excessive mip levels */
611 if (mip_level < mip_levels)
612 {
613 SetRect(&src_rect, 0, 0, size, size);
614
615 IDirect3DCubeTexture9_GetCubeMapSurface(cube_texture, face, mip_level, &surface);
616 hr = D3DXLoadSurfaceFromMemory(surface, palette, NULL, pixels, src_info->Format, src_pitch,
617 NULL, &src_rect, filter, color_key);
618 IDirect3DSurface9_Release(surface);
619 if (FAILED(hr)) return hr;
620 }
621
622 pixels += mip_level_size;
623 size = max(1, size / 2);
624 }
625 }
626
627 return D3D_OK;
628 }
629
630 HRESULT load_volume_texture_from_dds(IDirect3DVolumeTexture9 *volume_texture, const void *src_data,
631 const PALETTEENTRY *palette, DWORD filter, DWORD color_key, const D3DXIMAGE_INFO *src_info)
632 {
633 HRESULT hr;
634 UINT mip_level;
635 UINT mip_levels;
636 UINT src_slice_pitch;
637 UINT src_row_pitch;
638 D3DBOX src_box;
639 UINT width, height, depth;
640 IDirect3DVolume9 *volume;
641 const struct dds_header *header = src_data;
642 const BYTE *pixels = (BYTE *)(header + 1);
643
644 if (src_info->ResourceType != D3DRTYPE_VOLUMETEXTURE)
645 return D3DXERR_INVALIDDATA;
646
647 width = src_info->Width;
648 height = src_info->Height;
649 depth = src_info->Depth;
650 mip_levels = min(src_info->MipLevels, IDirect3DVolumeTexture9_GetLevelCount(volume_texture));
651
652 for (mip_level = 0; mip_level < mip_levels; mip_level++)
653 {
654 hr = calculate_dds_surface_size(src_info->Format, width, height, &src_row_pitch, &src_slice_pitch);
655 if (FAILED(hr)) return hr;
656
657 hr = IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, mip_level, &volume);
658 if (FAILED(hr)) return hr;
659
660 src_box.Left = 0;
661 src_box.Top = 0;
662 src_box.Right = width;
663 src_box.Bottom = height;
664 src_box.Front = 0;
665 src_box.Back = depth;
666
667 hr = D3DXLoadVolumeFromMemory(volume, palette, NULL, pixels, src_info->Format,
668 src_row_pitch, src_slice_pitch, NULL, &src_box, filter, color_key);
669
670 IDirect3DVolume9_Release(volume);
671 if (FAILED(hr)) return hr;
672
673 pixels += depth * src_slice_pitch;
674 width = max(1, width / 2);
675 height = max(1, height / 2);
676 depth = max(1, depth / 2);
677 }
678
679 return D3D_OK;
680 }
681
682 /************************************************************
683 * D3DXGetImageInfoFromFileInMemory
684 *
685 * Fills a D3DXIMAGE_INFO structure with info about an image
686 *
687 * PARAMS
688 * data [I] pointer to the image file data
689 * datasize [I] size of the passed data
690 * info [O] pointer to the destination structure
691 *
692 * RETURNS
693 * Success: D3D_OK, if info is not NULL and data and datasize make up a valid image file or
694 * if info is NULL and data and datasize are not NULL
695 * Failure: D3DXERR_INVALIDDATA, if data is no valid image file and datasize and info are not NULL
696 * D3DERR_INVALIDCALL, if data is NULL or
697 * if datasize is 0
698 *
699 * NOTES
700 * datasize may be bigger than the actual file size
701 *
702 */
703 HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(LPCVOID data, UINT datasize, D3DXIMAGE_INFO *info)
704 {
705 IWICImagingFactory *factory;
706 IWICBitmapDecoder *decoder = NULL;
707 IWICStream *stream;
708 HRESULT hr;
709 HRESULT initresult;
710
711 TRACE("(%p, %d, %p)\n", data, datasize, info);
712
713 if (!data || !datasize)
714 return D3DERR_INVALIDCALL;
715
716 if (!info)
717 return D3D_OK;
718
719 if ((datasize >= 4) && !strncmp(data, "DDS ", 4)) {
720 TRACE("File type is DDS\n");
721 return get_image_info_from_dds(data, datasize, info);
722 }
723
724 initresult = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
725
726 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, (void**)&factory);
727
728 if (SUCCEEDED(hr)) {
729 IWICImagingFactory_CreateStream(factory, &stream);
730 IWICStream_InitializeFromMemory(stream, (BYTE*)data, datasize);
731 hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream*)stream, NULL, 0, &decoder);
732 IWICStream_Release(stream);
733 IWICImagingFactory_Release(factory);
734 }
735
736 if (FAILED(hr)) {
737 if ((datasize >= 2) && (!strncmp(data, "P3", 2) || !strncmp(data, "P6", 2)))
738 FIXME("File type PPM is not supported yet\n");
739 else if ((datasize >= 2) && !strncmp(data, "BM", 2))
740 FIXME("File type DIB is not supported yet\n");
741 else if ((datasize >= 10) && !strncmp(data, "#?RADIANCE", 10))
742 FIXME("File type HDR is not supported yet\n");
743 else if ((datasize >= 2) && (!strncmp(data, "PF", 2) || !strncmp(data, "Pf", 2)))
744 FIXME("File type PFM is not supported yet\n");
745 }
746
747 if (SUCCEEDED(hr)) {
748 GUID container_format;
749 UINT frame_count;
750
751 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &container_format);
752 if (SUCCEEDED(hr)) {
753 if (IsEqualGUID(&container_format, &GUID_ContainerFormatBmp)) {
754 TRACE("File type is BMP\n");
755 info->ImageFileFormat = D3DXIFF_BMP;
756 } else if (IsEqualGUID(&container_format, &GUID_ContainerFormatPng)) {
757 TRACE("File type is PNG\n");
758 info->ImageFileFormat = D3DXIFF_PNG;
759 } else if(IsEqualGUID(&container_format, &GUID_ContainerFormatJpeg)) {
760 TRACE("File type is JPG\n");
761 info->ImageFileFormat = D3DXIFF_JPG;
762 } else if(IsEqualGUID(&container_format, &GUID_WineContainerFormatTga)) {
763 TRACE("File type is TGA\n");
764 info->ImageFileFormat = D3DXIFF_TGA;
765 } else {
766 WARN("Unsupported image file format %s\n", debugstr_guid(&container_format));
767 hr = D3DXERR_INVALIDDATA;
768 }
769 }
770
771 if (SUCCEEDED(hr))
772 hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
773 if (SUCCEEDED(hr) && !frame_count)
774 hr = D3DXERR_INVALIDDATA;
775
776 if (SUCCEEDED(hr)) {
777 IWICBitmapFrameDecode *frame = NULL;
778
779 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
780
781 if (SUCCEEDED(hr))
782 hr = IWICBitmapFrameDecode_GetSize(frame, &info->Width, &info->Height);
783
784 if (SUCCEEDED(hr)) {
785 WICPixelFormatGUID pixel_format;
786
787 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &pixel_format);
788 if (SUCCEEDED(hr)) {
789 info->Format = wic_guid_to_d3dformat(&pixel_format);
790 if (info->Format == D3DFMT_UNKNOWN) {
791 WARN("Unsupported pixel format %s\n", debugstr_guid(&pixel_format));
792 hr = D3DXERR_INVALIDDATA;
793 }
794 }
795 }
796
797 if (frame)
798 IWICBitmapFrameDecode_Release(frame);
799
800 info->Depth = 1;
801 info->MipLevels = 1;
802 info->ResourceType = D3DRTYPE_TEXTURE;
803 }
804 }
805
806 if (decoder)
807 IWICBitmapDecoder_Release(decoder);
808
809 if (SUCCEEDED(initresult))
810 CoUninitialize();
811
812 if (FAILED(hr)) {
813 TRACE("Invalid or unsupported image file\n");
814 return D3DXERR_INVALIDDATA;
815 }
816
817 return D3D_OK;
818 }
819
820 /************************************************************
821 * D3DXGetImageInfoFromFile
822 *
823 * RETURNS
824 * Success: D3D_OK, if we successfully load a valid image file or
825 * if we successfully load a file which is no valid image and info is NULL
826 * Failure: D3DXERR_INVALIDDATA, if we fail to load file or
827 * if file is not a valid image file and info is not NULL
828 * D3DERR_INVALIDCALL, if file is NULL
829 *
830 */
831 HRESULT WINAPI D3DXGetImageInfoFromFileA(LPCSTR file, D3DXIMAGE_INFO *info)
832 {
833 LPWSTR widename;
834 HRESULT hr;
835 int strlength;
836
837 TRACE("(%s, %p): relay\n", debugstr_a(file), info);
838
839 if( !file ) return D3DERR_INVALIDCALL;
840
841 strlength = MultiByteToWideChar(CP_ACP, 0, file, -1, NULL, 0);
842 widename = HeapAlloc(GetProcessHeap(), 0, strlength * sizeof(*widename));
843 MultiByteToWideChar(CP_ACP, 0, file, -1, widename, strlength);
844
845 hr = D3DXGetImageInfoFromFileW(widename, info);
846 HeapFree(GetProcessHeap(), 0, widename);
847
848 return hr;
849 }
850
851 HRESULT WINAPI D3DXGetImageInfoFromFileW(LPCWSTR file, D3DXIMAGE_INFO *info)
852 {
853 HRESULT hr;
854 DWORD size;
855 LPVOID buffer;
856
857 TRACE("(%s, %p): relay\n", debugstr_w(file), info);
858
859 if( !file ) return D3DERR_INVALIDCALL;
860
861 hr = map_view_of_file(file, &buffer, &size);
862 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
863
864 hr = D3DXGetImageInfoFromFileInMemory(buffer, size, info);
865 UnmapViewOfFile(buffer);
866
867 return hr;
868 }
869
870 /************************************************************
871 * D3DXGetImageInfoFromResource
872 *
873 * RETURNS
874 * Success: D3D_OK, if resource is a valid image file
875 * Failure: D3DXERR_INVALIDDATA, if resource is no valid image file or NULL or
876 * if we fail to load resource
877 *
878 */
879 HRESULT WINAPI D3DXGetImageInfoFromResourceA(HMODULE module, LPCSTR resource, D3DXIMAGE_INFO *info)
880 {
881 HRSRC resinfo;
882
883 TRACE("(%p, %s, %p)\n", module, debugstr_a(resource), info);
884
885 resinfo = FindResourceA(module, resource, (LPCSTR)RT_RCDATA);
886 if(resinfo) {
887 LPVOID buffer;
888 HRESULT hr;
889 DWORD size;
890
891 hr = load_resource_into_memory(module, resinfo, &buffer, &size);
892 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
893 return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
894 }
895
896 resinfo = FindResourceA(module, resource, (LPCSTR)RT_BITMAP);
897 if(resinfo) {
898 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
899 return E_NOTIMPL;
900 }
901 return D3DXERR_INVALIDDATA;
902 }
903
904 HRESULT WINAPI D3DXGetImageInfoFromResourceW(HMODULE module, LPCWSTR resource, D3DXIMAGE_INFO *info)
905 {
906 HRSRC resinfo;
907
908 TRACE("(%p, %s, %p)\n", module, debugstr_w(resource), info);
909
910 resinfo = FindResourceW(module, resource, (LPCWSTR)RT_RCDATA);
911 if(resinfo) {
912 LPVOID buffer;
913 HRESULT hr;
914 DWORD size;
915
916 hr = load_resource_into_memory(module, resinfo, &buffer, &size);
917 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
918 return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
919 }
920
921 resinfo = FindResourceW(module, resource, (LPCWSTR)RT_BITMAP);
922 if(resinfo) {
923 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
924 return E_NOTIMPL;
925 }
926 return D3DXERR_INVALIDDATA;
927 }
928
929 /************************************************************
930 * D3DXLoadSurfaceFromFileInMemory
931 *
932 * Loads data from a given buffer into a surface and fills a given
933 * D3DXIMAGE_INFO structure with info about the source data.
934 *
935 * PARAMS
936 * pDestSurface [I] pointer to the surface
937 * pDestPalette [I] palette to use
938 * pDestRect [I] to be filled area of the surface
939 * pSrcData [I] pointer to the source data
940 * SrcDataSize [I] size of the source data in bytes
941 * pSrcRect [I] area of the source data to load
942 * dwFilter [I] filter to apply on stretching
943 * Colorkey [I] colorkey
944 * pSrcInfo [O] pointer to a D3DXIMAGE_INFO structure
945 *
946 * RETURNS
947 * Success: D3D_OK
948 * Failure: D3DERR_INVALIDCALL, if pDestSurface or pSrcData or SrcDataSize are NULL
949 * D3DXERR_INVALIDDATA, if pSrcData is no valid image file
950 *
951 */
952 HRESULT WINAPI D3DXLoadSurfaceFromFileInMemory(IDirect3DSurface9 *pDestSurface,
953 const PALETTEENTRY *pDestPalette, const RECT *pDestRect, const void *pSrcData, UINT SrcDataSize,
954 const RECT *pSrcRect, DWORD dwFilter, D3DCOLOR Colorkey, D3DXIMAGE_INFO *pSrcInfo)
955 {
956 D3DXIMAGE_INFO imginfo;
957 HRESULT hr;
958
959 IWICImagingFactory *factory;
960 IWICBitmapDecoder *decoder;
961 IWICBitmapFrameDecode *bitmapframe;
962 IWICStream *stream;
963
964 const struct pixel_format_desc *formatdesc;
965 WICRect wicrect;
966 RECT rect;
967
968 TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_data %p, src_data_size %u, "
969 "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
970 pDestSurface, pDestPalette, wine_dbgstr_rect(pDestRect), pSrcData, SrcDataSize,
971 wine_dbgstr_rect(pSrcRect), dwFilter, Colorkey, pSrcInfo);
972
973 if (!pDestSurface || !pSrcData || !SrcDataSize)
974 return D3DERR_INVALIDCALL;
975
976 hr = D3DXGetImageInfoFromFileInMemory(pSrcData, SrcDataSize, &imginfo);
977
978 if (FAILED(hr))
979 return hr;
980
981 if (pSrcRect)
982 {
983 wicrect.X = pSrcRect->left;
984 wicrect.Y = pSrcRect->top;
985 wicrect.Width = pSrcRect->right - pSrcRect->left;
986 wicrect.Height = pSrcRect->bottom - pSrcRect->top;
987 }
988 else
989 {
990 wicrect.X = 0;
991 wicrect.Y = 0;
992 wicrect.Width = imginfo.Width;
993 wicrect.Height = imginfo.Height;
994 }
995
996 SetRect(&rect, 0, 0, wicrect.Width, wicrect.Height);
997
998 if (imginfo.ImageFileFormat == D3DXIFF_DDS)
999 {
1000 hr = load_surface_from_dds(pDestSurface, pDestPalette, pDestRect, pSrcData, &rect,
1001 dwFilter, Colorkey, &imginfo);
1002 if (SUCCEEDED(hr) && pSrcInfo)
1003 *pSrcInfo = imginfo;
1004 return hr;
1005 }
1006
1007 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1008
1009 if (FAILED(CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, (void**)&factory)))
1010 goto cleanup_err;
1011
1012 if (FAILED(IWICImagingFactory_CreateStream(factory, &stream)))
1013 {
1014 IWICImagingFactory_Release(factory);
1015 goto cleanup_err;
1016 }
1017
1018 IWICStream_InitializeFromMemory(stream, (BYTE*)pSrcData, SrcDataSize);
1019
1020 hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream*)stream, NULL, 0, &decoder);
1021
1022 IWICStream_Release(stream);
1023 IWICImagingFactory_Release(factory);
1024
1025 if (FAILED(hr))
1026 goto cleanup_err;
1027
1028 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &bitmapframe);
1029
1030 if (FAILED(hr))
1031 goto cleanup_bmp;
1032
1033 formatdesc = get_format_info(imginfo.Format);
1034
1035 if (formatdesc->type == FORMAT_UNKNOWN)
1036 {
1037 FIXME("Unsupported pixel format\n");
1038 hr = D3DXERR_INVALIDDATA;
1039 }
1040 else
1041 {
1042 BYTE *buffer;
1043 DWORD pitch;
1044
1045 pitch = formatdesc->bytes_per_pixel * wicrect.Width;
1046 buffer = HeapAlloc(GetProcessHeap(), 0, pitch * wicrect.Height);
1047
1048 hr = IWICBitmapFrameDecode_CopyPixels(bitmapframe, &wicrect, pitch,
1049 pitch * wicrect.Height, buffer);
1050
1051 if (SUCCEEDED(hr))
1052 {
1053 hr = D3DXLoadSurfaceFromMemory(pDestSurface, pDestPalette, pDestRect,
1054 buffer, imginfo.Format, pitch,
1055 NULL, &rect, dwFilter, Colorkey);
1056 }
1057
1058 HeapFree(GetProcessHeap(), 0, buffer);
1059 }
1060
1061 IWICBitmapFrameDecode_Release(bitmapframe);
1062
1063 cleanup_bmp:
1064 IWICBitmapDecoder_Release(decoder);
1065
1066 cleanup_err:
1067 CoUninitialize();
1068
1069 if (FAILED(hr))
1070 return D3DXERR_INVALIDDATA;
1071
1072 if (pSrcInfo)
1073 *pSrcInfo = imginfo;
1074
1075 return D3D_OK;
1076 }
1077
1078 HRESULT WINAPI D3DXLoadSurfaceFromFileA(IDirect3DSurface9 *dst_surface,
1079 const PALETTEENTRY *dst_palette, const RECT *dst_rect, const char *src_file,
1080 const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
1081 {
1082 LPWSTR pWidename;
1083 HRESULT hr;
1084 int strlength;
1085
1086 TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_file %s, "
1087 "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
1088 dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), debugstr_a(src_file),
1089 wine_dbgstr_rect(src_rect), filter, color_key, src_info);
1090
1091 if (!src_file || !dst_surface)
1092 return D3DERR_INVALIDCALL;
1093
1094 strlength = MultiByteToWideChar(CP_ACP, 0, src_file, -1, NULL, 0);
1095 pWidename = HeapAlloc(GetProcessHeap(), 0, strlength * sizeof(*pWidename));
1096 MultiByteToWideChar(CP_ACP, 0, src_file, -1, pWidename, strlength);
1097
1098 hr = D3DXLoadSurfaceFromFileW(dst_surface, dst_palette, dst_rect,
1099 pWidename, src_rect, filter, color_key, src_info);
1100 HeapFree(GetProcessHeap(), 0, pWidename);
1101
1102 return hr;
1103 }
1104
1105 HRESULT WINAPI D3DXLoadSurfaceFromFileW(IDirect3DSurface9 *dst_surface,
1106 const PALETTEENTRY *dst_palette, const RECT *dst_rect, const WCHAR *src_file,
1107 const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
1108 {
1109 UINT data_size;
1110 void *data;
1111 HRESULT hr;
1112
1113 TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_file %s, "
1114 "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
1115 dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), debugstr_w(src_file),
1116 wine_dbgstr_rect(src_rect), filter, color_key, src_info);
1117
1118 if (!src_file || !dst_surface)
1119 return D3DERR_INVALIDCALL;
1120
1121 if (FAILED(map_view_of_file(src_file, &data, &data_size)))
1122 return D3DXERR_INVALIDDATA;
1123
1124 hr = D3DXLoadSurfaceFromFileInMemory(dst_surface, dst_palette, dst_rect,
1125 data, data_size, src_rect, filter, color_key, src_info);
1126 UnmapViewOfFile(data);
1127
1128 return hr;
1129 }
1130
1131 HRESULT WINAPI D3DXLoadSurfaceFromResourceA(IDirect3DSurface9 *dst_surface,
1132 const PALETTEENTRY *dst_palette, const RECT *dst_rect, HMODULE src_module, const char *resource,
1133 const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
1134 {
1135 HRSRC hResInfo;
1136
1137 TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_module %p, resource %s, "
1138 "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
1139 dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_module, debugstr_a(resource),
1140 wine_dbgstr_rect(src_rect), filter, color_key, src_info);
1141
1142 if (!dst_surface)
1143 return D3DERR_INVALIDCALL;
1144
1145 if ((hResInfo = FindResourceA(src_module, resource, (const char *)RT_RCDATA)))
1146 {
1147 UINT data_size;
1148 void *data;
1149
1150 if (FAILED(load_resource_into_memory(src_module, hResInfo, &data, &data_size)))
1151 return D3DXERR_INVALIDDATA;
1152
1153 return D3DXLoadSurfaceFromFileInMemory(dst_surface, dst_palette, dst_rect,
1154 data, data_size, src_rect, filter, color_key, src_info);
1155 }
1156
1157 if ((hResInfo = FindResourceA(src_module, resource, (const char *)RT_BITMAP)))
1158 {
1159 FIXME("Implement loading bitmaps from resource type RT_BITMAP.\n");
1160 return E_NOTIMPL;
1161 }
1162
1163 return D3DXERR_INVALIDDATA;
1164 }
1165
1166 HRESULT WINAPI D3DXLoadSurfaceFromResourceW(IDirect3DSurface9 *dst_surface,
1167 const PALETTEENTRY *dst_palette, const RECT *dst_rect, HMODULE src_module, const WCHAR *resource,
1168 const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
1169 {
1170 HRSRC hResInfo;
1171
1172 TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_module %p, resource %s, "
1173 "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
1174 dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_module, debugstr_w(resource),
1175 wine_dbgstr_rect(src_rect), filter, color_key, src_info);
1176
1177 if (!dst_surface)
1178 return D3DERR_INVALIDCALL;
1179
1180 if ((hResInfo = FindResourceW(src_module, resource, (const WCHAR *)RT_RCDATA)))
1181 {
1182 UINT data_size;
1183 void *data;
1184
1185 if (FAILED(load_resource_into_memory(src_module, hResInfo, &data, &data_size)))
1186 return D3DXERR_INVALIDDATA;
1187
1188 return D3DXLoadSurfaceFromFileInMemory(dst_surface, dst_palette, dst_rect,
1189 data, data_size, src_rect, filter, color_key, src_info);
1190 }
1191
1192 if ((hResInfo = FindResourceW(src_module, resource, (const WCHAR *)RT_BITMAP)))
1193 {
1194 FIXME("Implement loading bitmaps from resource type RT_BITMAP.\n");
1195 return E_NOTIMPL;
1196 }
1197
1198 return D3DXERR_INVALIDDATA;
1199 }
1200
1201
1202 /************************************************************
1203 * helper functions for D3DXLoadSurfaceFromMemory
1204 */
1205 struct argb_conversion_info
1206 {
1207 const struct pixel_format_desc *srcformat;
1208 const struct pixel_format_desc *destformat;
1209 DWORD srcshift[4], destshift[4];
1210 DWORD srcmask[4], destmask[4];
1211 BOOL process_channel[4];
1212 DWORD channelmask;
1213 };
1214
1215 static void init_argb_conversion_info(const struct pixel_format_desc *srcformat, const struct pixel_format_desc *destformat, struct argb_conversion_info *info)
1216 {
1217 UINT i;
1218 ZeroMemory(info->process_channel, 4 * sizeof(BOOL));
1219 info->channelmask = 0;
1220
1221 info->srcformat = srcformat;
1222 info->destformat = destformat;
1223
1224 for(i = 0;i < 4;i++) {
1225 /* srcshift is used to extract the _relevant_ components */
1226 info->srcshift[i] = srcformat->shift[i] + max( srcformat->bits[i] - destformat->bits[i], 0);
1227
1228 /* destshift is used to move the components to the correct position */
1229 info->destshift[i] = destformat->shift[i] + max(destformat->bits[i] - srcformat->bits[i], 0);
1230
1231 info->srcmask[i] = ((1 << srcformat->bits[i]) - 1) << srcformat->shift[i];
1232 info->destmask[i] = ((1 << destformat->bits[i]) - 1) << destformat->shift[i];
1233
1234 /* channelmask specifies bits which aren't used in the source format but in the destination one */
1235 if(destformat->bits[i]) {
1236 if(srcformat->bits[i]) info->process_channel[i] = TRUE;
1237 else info->channelmask |= info->destmask[i];
1238 }
1239 }
1240 }
1241
1242 static DWORD dword_from_bytes(CONST BYTE *src, UINT bytes_per_pixel)
1243 {
1244 DWORD ret = 0;
1245 static BOOL fixme_once;
1246
1247 if(bytes_per_pixel > sizeof(DWORD)) {
1248 if(!fixme_once++) FIXME("Unsupported image: %u bytes per pixel\n", bytes_per_pixel);
1249 bytes_per_pixel = sizeof(DWORD);
1250 }
1251
1252 memcpy(&ret, src, bytes_per_pixel);
1253 return ret;
1254 }
1255
1256 static void dword_to_bytes(BYTE *dst, DWORD dword, UINT bytes_per_pixel)
1257 {
1258 static BOOL fixme_once;
1259
1260 if(bytes_per_pixel > sizeof(DWORD)) {
1261 if(!fixme_once++) FIXME("Unsupported image: %u bytes per pixel\n", bytes_per_pixel);
1262 ZeroMemory(dst, bytes_per_pixel);
1263 bytes_per_pixel = sizeof(DWORD);
1264 }
1265
1266 memcpy(dst, &dword, bytes_per_pixel);
1267 }
1268
1269 /************************************************************
1270 * get_relevant_argb_components
1271 *
1272 * Extracts the relevant components from the source color and
1273 * drops the less significant bits if they aren't used by the destination format.
1274 */
1275 static void get_relevant_argb_components(CONST struct argb_conversion_info *info, CONST DWORD col, DWORD *out)
1276 {
1277 UINT i = 0;
1278 for(;i < 4;i++)
1279 if(info->process_channel[i])
1280 out[i] = (col & info->srcmask[i]) >> info->srcshift[i];
1281 }
1282
1283 /************************************************************
1284 * make_argb_color
1285 *
1286 * Recombines the output of get_relevant_argb_components and converts
1287 * it to the destination format.
1288 */
1289 static DWORD make_argb_color(CONST struct argb_conversion_info *info, CONST DWORD *in)
1290 {
1291 UINT i;
1292 DWORD val = 0;
1293
1294 for(i = 0;i < 4;i++) {
1295 if(info->process_channel[i]) {
1296 /* necessary to make sure that e.g. an X4R4G4B4 white maps to an R8G8B8 white instead of 0xf0f0f0 */
1297 signed int shift;
1298 for(shift = info->destshift[i]; shift > info->destformat->shift[i]; shift -= info->srcformat->bits[i]) val |= in[i] << shift;
1299 val |= (in[i] >> (info->destformat->shift[i] - shift)) << info->destformat->shift[i];
1300 }
1301 }
1302 val |= info->channelmask; /* new channels are set to their maximal value */
1303 return val;
1304 }
1305
1306 static void format_to_vec4(const struct pixel_format_desc *format, const DWORD *src, struct vec4 *dst)
1307 {
1308 DWORD mask;
1309
1310 if (format->bits[1])
1311 {
1312 mask = (1 << format->bits[1]) - 1;
1313 dst->x = (float)((*src >> format->shift[1]) & mask) / mask;
1314 }
1315 else
1316 dst->x = 1.0f;
1317
1318 if (format->bits[2])
1319 {
1320 mask = (1 << format->bits[2]) - 1;
1321 dst->y = (float)((*src >> format->shift[2]) & mask) / mask;
1322 }
1323 else
1324 dst->y = 1.0f;
1325
1326 if (format->bits[3])
1327 {
1328 mask = (1 << format->bits[3]) - 1;
1329 dst->z = (float)((*src >> format->shift[3]) & mask) / mask;
1330 }
1331 else
1332 dst->z = 1.0f;
1333
1334 if (format->bits[0])
1335 {
1336 mask = (1 << format->bits[0]) - 1;
1337 dst->w = (float)((*src >> format->shift[0]) & mask) / mask;
1338 }
1339 else
1340 dst->w = 1.0f;
1341 }
1342
1343 static void format_from_vec4(const struct pixel_format_desc *format, const struct vec4 *src, DWORD *dst)
1344 {
1345 *dst = 0;
1346
1347 if (format->bits[1])
1348 *dst |= (DWORD)(src->x * ((1 << format->bits[1]) - 1) + 0.5f) << format->shift[1];
1349 if (format->bits[2])
1350 *dst |= (DWORD)(src->y * ((1 << format->bits[2]) - 1) + 0.5f) << format->shift[2];
1351 if (format->bits[3])
1352 *dst |= (DWORD)(src->z * ((1 << format->bits[3]) - 1) + 0.5f) << format->shift[3];
1353 if (format->bits[0])
1354 *dst |= (DWORD)(src->w * ((1 << format->bits[0]) - 1) + 0.5f) << format->shift[0];
1355 }
1356
1357 /************************************************************
1358 * convert_argb_pixels
1359 *
1360 * Copies the source buffer to the destination buffer, performing
1361 * any necessary format conversion and color keying.
1362 * Pixels outsize the source rect are blacked out.
1363 * Works only for ARGB formats with 1 - 4 bytes per pixel.
1364 */
1365 void convert_argb_pixels(const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, const struct volume *src_size,
1366 const struct pixel_format_desc *src_format, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch,
1367 const struct volume *dst_size, const struct pixel_format_desc *dst_format, D3DCOLOR color_key)
1368 {
1369 struct argb_conversion_info conv_info, ck_conv_info;
1370 const struct pixel_format_desc *ck_format = NULL;
1371 DWORD channels[4], pixel;
1372 UINT min_width, min_height, min_depth;
1373 UINT x, y, z;
1374
1375 ZeroMemory(channels, sizeof(channels));
1376 init_argb_conversion_info(src_format, dst_format, &conv_info);
1377
1378 min_width = min(src_size->width, dst_size->width);
1379 min_height = min(src_size->height, dst_size->height);
1380 min_depth = min(src_size->depth, dst_size->depth);
1381
1382 if (color_key)
1383 {
1384 /* Color keys are always represented in D3DFMT_A8R8G8B8 format. */
1385 ck_format = get_format_info(D3DFMT_A8R8G8B8);
1386 init_argb_conversion_info(src_format, ck_format, &ck_conv_info);
1387 }
1388
1389 for (z = 0; z < min_depth; z++) {
1390 const BYTE *src_slice_ptr = src + z * src_slice_pitch;
1391 BYTE *dst_slice_ptr = dst + z * dst_slice_pitch;
1392
1393 for (y = 0; y < min_height; y++) {
1394 const BYTE *src_ptr = src_slice_ptr + y * src_row_pitch;
1395 BYTE *dst_ptr = dst_slice_ptr + y * dst_row_pitch;
1396 DWORD val;
1397
1398 for (x = 0; x < min_width; x++) {
1399 /* extract source color components */
1400 pixel = dword_from_bytes(src_ptr, src_format->bytes_per_pixel);
1401
1402 if (!src_format->to_rgba && !dst_format->from_rgba)
1403 {
1404 get_relevant_argb_components(&conv_info, pixel, channels);
1405 val = make_argb_color(&conv_info, channels);
1406
1407 if (color_key)
1408 {
1409 get_relevant_argb_components(&ck_conv_info, pixel, channels);
1410 pixel = make_argb_color(&ck_conv_info, channels);
1411 if (pixel == color_key)
1412 val &= ~conv_info.destmask[0];
1413 }
1414 }
1415 else
1416 {
1417 struct vec4 color, tmp;
1418
1419 format_to_vec4(src_format, &pixel, &color);
1420 if (src_format->to_rgba)
1421 src_format->to_rgba(&color, &tmp);
1422 else
1423 tmp = color;
1424
1425 if (ck_format)
1426 {
1427 format_from_vec4(ck_format, &tmp, &pixel);
1428 if (pixel == color_key)
1429 tmp.w = 0.0f;
1430 }
1431
1432 if (dst_format->from_rgba)
1433 dst_format->from_rgba(&tmp, &color);
1434 else
1435 color = tmp;
1436
1437 format_from_vec4(dst_format, &color, &val);
1438 }
1439
1440 dword_to_bytes(dst_ptr, val, dst_format->bytes_per_pixel);
1441 src_ptr += src_format->bytes_per_pixel;
1442 dst_ptr += dst_format->bytes_per_pixel;
1443 }
1444
1445 if (src_size->width < dst_size->width) /* black out remaining pixels */
1446 memset(dst_ptr, 0, dst_format->bytes_per_pixel * (dst_size->width - src_size->width));
1447 }
1448
1449 if (src_size->height < dst_size->height) /* black out remaining pixels */
1450 memset(dst + src_size->height * dst_row_pitch, 0, dst_row_pitch * (dst_size->height - src_size->height));
1451 }
1452 if (src_size->depth < dst_size->depth) /* black out remaining pixels */
1453 memset(dst + src_size->depth * dst_slice_pitch, 0, dst_slice_pitch * (dst_size->depth - src_size->depth));
1454 }
1455
1456 /************************************************************
1457 * point_filter_argb_pixels
1458 *
1459 * Copies the source buffer to the destination buffer, performing
1460 * any necessary format conversion, color keying and stretching
1461 * using a point filter.
1462 * Works only for ARGB formats with 1 - 4 bytes per pixel.
1463 */
1464 void point_filter_argb_pixels(const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, const struct volume *src_size,
1465 const struct pixel_format_desc *src_format, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch,
1466 const struct volume *dst_size, const struct pixel_format_desc *dst_format, D3DCOLOR color_key)
1467 {
1468 struct argb_conversion_info conv_info, ck_conv_info;
1469 const struct pixel_format_desc *ck_format = NULL;
1470 DWORD channels[4], pixel;
1471 UINT x, y, z;
1472
1473 ZeroMemory(channels, sizeof(channels));
1474 init_argb_conversion_info(src_format, dst_format, &conv_info);
1475
1476 if (color_key)
1477 {
1478 /* Color keys are always represented in D3DFMT_A8R8G8B8 format. */
1479 ck_format = get_format_info(D3DFMT_A8R8G8B8);
1480 init_argb_conversion_info(src_format, ck_format, &ck_conv_info);
1481 }
1482
1483 for (z = 0; z < dst_size->depth; z++)
1484 {
1485 BYTE *dst_slice_ptr = dst + z * dst_slice_pitch;
1486 const BYTE *src_slice_ptr = src + src_slice_pitch * (z * src_size->depth / dst_size->depth);
1487
1488 for (y = 0; y < dst_size->height; y++)
1489 {
1490 BYTE *dst_ptr = dst_slice_ptr + y * dst_row_pitch;
1491 const BYTE *src_row_ptr = src_slice_ptr + src_row_pitch * (y * src_size->height / dst_size->height);
1492
1493 for (x = 0; x < dst_size->width; x++)
1494 {
1495 const BYTE *src_ptr = src_row_ptr + (x * src_size->width / dst_size->width) * src_format->bytes_per_pixel;
1496 DWORD val;
1497
1498 /* extract source color components */
1499 pixel = dword_from_bytes(src_ptr, src_format->bytes_per_pixel);
1500
1501 if (!src_format->to_rgba && !dst_format->from_rgba)
1502 {
1503 get_relevant_argb_components(&conv_info, pixel, channels);
1504 val = make_argb_color(&conv_info, channels);
1505
1506 if (color_key)
1507 {
1508 get_relevant_argb_components(&ck_conv_info, pixel, channels);
1509 pixel = make_argb_color(&ck_conv_info, channels);
1510 if (pixel == color_key)
1511 val &= ~conv_info.destmask[0];
1512 }
1513 }
1514 else
1515 {
1516 struct vec4 color, tmp;
1517
1518 format_to_vec4(src_format, &pixel, &color);
1519 if (src_format->to_rgba)
1520 src_format->to_rgba(&color, &tmp);
1521 else
1522 tmp = color;
1523
1524 if (ck_format)
1525 {
1526 format_from_vec4(ck_format, &tmp, &pixel);
1527 if (pixel == color_key)
1528 tmp.w = 0.0f;
1529 }
1530
1531 if (dst_format->from_rgba)
1532 dst_format->from_rgba(&tmp, &color);
1533 else
1534 color = tmp;
1535
1536 format_from_vec4(dst_format, &color, &val);
1537 }
1538
1539 dword_to_bytes(dst_ptr, val, dst_format->bytes_per_pixel);
1540 dst_ptr += dst_format->bytes_per_pixel;
1541 }
1542 }
1543 }
1544 }
1545
1546 /************************************************************
1547 * D3DXLoadSurfaceFromMemory
1548 *
1549 * Loads data from a given memory chunk into a surface,
1550 * applying any of the specified filters.
1551 *
1552 * PARAMS
1553 * pDestSurface [I] pointer to the surface
1554 * pDestPalette [I] palette to use
1555 * pDestRect [I] to be filled area of the surface
1556 * pSrcMemory [I] pointer to the source data
1557 * SrcFormat [I] format of the source pixel data
1558 * SrcPitch [I] number of bytes in a row
1559 * pSrcPalette [I] palette used in the source image
1560 * pSrcRect [I] area of the source data to load
1561 * dwFilter [I] filter to apply on stretching
1562 * Colorkey [I] colorkey
1563 *
1564 * RETURNS
1565 * Success: D3D_OK, if we successfully load the pixel data into our surface or
1566 * if pSrcMemory is NULL but the other parameters are valid
1567 * Failure: D3DERR_INVALIDCALL, if pDestSurface, SrcPitch or pSrcRect are NULL or
1568 * if SrcFormat is an invalid format (other than D3DFMT_UNKNOWN) or
1569 * if DestRect is invalid
1570 * D3DXERR_INVALIDDATA, if we fail to lock pDestSurface
1571 * E_FAIL, if SrcFormat is D3DFMT_UNKNOWN or the dimensions of pSrcRect are invalid
1572 *
1573 * NOTES
1574 * pSrcRect specifies the dimensions of the source data;
1575 * negative values for pSrcRect are allowed as we're only looking at the width and height anyway.
1576 *
1577 */
1578 HRESULT WINAPI D3DXLoadSurfaceFromMemory(IDirect3DSurface9 *dst_surface,
1579 const PALETTEENTRY *dst_palette, const RECT *dst_rect, const void *src_memory,
1580 D3DFORMAT src_format, UINT src_pitch, const PALETTEENTRY *src_palette, const RECT *src_rect,
1581 DWORD filter, D3DCOLOR color_key)
1582 {
1583 const struct pixel_format_desc *srcformatdesc, *destformatdesc;
1584 D3DSURFACE_DESC surfdesc;
1585 D3DLOCKED_RECT lockrect;
1586 struct volume src_size, dst_size;
1587 HRESULT hr;
1588
1589 TRACE("(%p, %p, %s, %p, %#x, %u, %p, %s %#x, 0x%08x)\n",
1590 dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_memory, src_format,
1591 src_pitch, src_palette, wine_dbgstr_rect(src_rect), filter, color_key);
1592
1593 if (!dst_surface || !src_memory || !src_rect)
1594 {
1595 WARN("Invalid argument specified.\n");
1596 return D3DERR_INVALIDCALL;
1597 }
1598 if (src_format == D3DFMT_UNKNOWN
1599 || src_rect->left >= src_rect->right
1600 || src_rect->top >= src_rect->bottom)
1601 {
1602 WARN("Invalid src_format or src_rect.\n");
1603 return E_FAIL;
1604 }
1605
1606 if (filter == D3DX_DEFAULT)
1607 filter = D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER;
1608
1609 IDirect3DSurface9_GetDesc(dst_surface, &surfdesc);
1610
1611 src_size.width = src_rect->right - src_rect->left;
1612 src_size.height = src_rect->bottom - src_rect->top;
1613 src_size.depth = 1;
1614 if (!dst_rect)
1615 {
1616 dst_size.width = surfdesc.Width;
1617 dst_size.height = surfdesc.Height;
1618 }
1619 else
1620 {
1621 if (dst_rect->left > dst_rect->right || dst_rect->right > surfdesc.Width
1622 || dst_rect->top > dst_rect->bottom || dst_rect->bottom > surfdesc.Height
1623 || dst_rect->left < 0 || dst_rect->top < 0)
1624 {
1625 WARN("Invalid dst_rect specified.\n");
1626 return D3DERR_INVALIDCALL;
1627 }
1628 dst_size.width = dst_rect->right - dst_rect->left;
1629 dst_size.height = dst_rect->bottom - dst_rect->top;
1630 if (!dst_size.width || !dst_size.height)
1631 return D3D_OK;
1632 }
1633 dst_size.depth = 1;
1634
1635 srcformatdesc = get_format_info(src_format);
1636 destformatdesc = get_format_info(surfdesc.Format);
1637 if (srcformatdesc->type == FORMAT_UNKNOWN || destformatdesc->type == FORMAT_UNKNOWN)
1638 {
1639 FIXME("Unsupported pixel format conversion %#x -> %#x\n", src_format, surfdesc.Format);
1640 return E_NOTIMPL;
1641 }
1642
1643 if (src_format == surfdesc.Format
1644 && dst_size.width == src_size.width
1645 && dst_size.height == src_size.height) /* Simple copy. */
1646 {
1647 UINT row_block_count = ((src_size.width + srcformatdesc->block_width - 1) / srcformatdesc->block_width);
1648 UINT row_count = (src_size.height + srcformatdesc->block_height - 1) / srcformatdesc->block_height;
1649 const BYTE *src_addr;
1650 BYTE *dst_addr;
1651 UINT row;
1652
1653 if (src_rect->left & (srcformatdesc->block_width - 1)
1654 || src_rect->top & (srcformatdesc->block_height - 1)
1655 || (src_rect->right & (srcformatdesc->block_width - 1)
1656 && src_size.width != surfdesc.Width)
1657 || (src_rect->bottom & (srcformatdesc->block_height - 1)
1658 && src_size.height != surfdesc.Height))
1659 {
1660 WARN("Source rect %s is misaligned.\n", wine_dbgstr_rect(src_rect));
1661 return D3DXERR_INVALIDDATA;
1662 }
1663
1664 if (FAILED(hr = IDirect3DSurface9_LockRect(dst_surface, &lockrect, dst_rect, 0)))
1665 return D3DXERR_INVALIDDATA;
1666
1667 src_addr = src_memory;
1668 src_addr += (src_rect->top / srcformatdesc->block_height) * src_pitch;
1669 src_addr += (src_rect->left / srcformatdesc->block_width) * srcformatdesc->block_byte_count;
1670 dst_addr = lockrect.pBits;
1671
1672 for (row = 0; row < row_count; ++row)
1673 {
1674 memcpy(dst_addr, src_addr, row_block_count * srcformatdesc->block_byte_count);
1675 src_addr += src_pitch;
1676 dst_addr += lockrect.Pitch;
1677 }
1678
1679 IDirect3DSurface9_UnlockRect(dst_surface);
1680 }
1681 else /* Stretching or format conversion. */
1682 {
1683 if (srcformatdesc->type != FORMAT_ARGB || destformatdesc->type != FORMAT_ARGB)
1684 {
1685 FIXME("Format conversion missing %#x -> %#x\n", src_format, surfdesc.Format);
1686 return E_NOTIMPL;
1687 }
1688
1689 if (FAILED(IDirect3DSurface9_LockRect(dst_surface, &lockrect, dst_rect, 0)))
1690 return D3DXERR_INVALIDDATA;
1691
1692 if ((filter & 0xf) == D3DX_FILTER_NONE)
1693 {
1694 convert_argb_pixels(src_memory, src_pitch, 0, &src_size, srcformatdesc,
1695 lockrect.pBits, lockrect.Pitch, 0, &dst_size, destformatdesc, color_key);
1696 }
1697 else /* if ((filter & 0xf) == D3DX_FILTER_POINT) */
1698 {
1699 if ((filter & 0xf) != D3DX_FILTER_POINT)
1700 FIXME("Unhandled filter %#x.\n", filter);
1701
1702 /* Always apply a point filter until D3DX_FILTER_LINEAR,
1703 * D3DX_FILTER_TRIANGLE and D3DX_FILTER_BOX are implemented. */
1704 point_filter_argb_pixels(src_memory, src_pitch, 0, &src_size, srcformatdesc,
1705 lockrect.pBits, lockrect.Pitch, 0, &dst_size, destformatdesc, color_key);
1706 }
1707
1708 IDirect3DSurface9_UnlockRect(dst_surface);
1709 }
1710
1711 return D3D_OK;
1712 }
1713
1714 /************************************************************
1715 * D3DXLoadSurfaceFromSurface
1716 *
1717 * Copies the contents from one surface to another, performing any required
1718 * format conversion, resizing or filtering.
1719 *
1720 * PARAMS
1721 * pDestSurface [I] pointer to the destination surface
1722 * pDestPalette [I] palette to use
1723 * pDestRect [I] to be filled area of the surface
1724 * pSrcSurface [I] pointer to the source surface
1725 * pSrcPalette [I] palette used for the source surface
1726 * pSrcRect [I] area of the source data to load
1727 * dwFilter [I] filter to apply on resizing
1728 * Colorkey [I] any ARGB value or 0 to disable color-keying
1729 *
1730 * RETURNS
1731 * Success: D3D_OK
1732 * Failure: D3DERR_INVALIDCALL, if pDestSurface or pSrcSurface are NULL
1733 * D3DXERR_INVALIDDATA, if one of the surfaces is not lockable
1734 *
1735 */
1736 HRESULT WINAPI D3DXLoadSurfaceFromSurface(IDirect3DSurface9 *dst_surface,
1737 const PALETTEENTRY *dst_palette, const RECT *dst_rect, IDirect3DSurface9 *src_surface,
1738 const PALETTEENTRY *src_palette, const RECT *src_rect, DWORD filter, D3DCOLOR color_key)
1739 {
1740 RECT rect;
1741 D3DLOCKED_RECT lock;
1742 D3DSURFACE_DESC SrcDesc;
1743 HRESULT hr;
1744
1745 TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_surface %p, "
1746 "src_palette %p, src_rect %s, filter %#x, color_key 0x%08x.\n",
1747 dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_surface,
1748 src_palette, wine_dbgstr_rect(src_rect), filter, color_key);
1749
1750 if (!dst_surface || !src_surface)
1751 return D3DERR_INVALIDCALL;
1752
1753 IDirect3DSurface9_GetDesc(src_surface, &SrcDesc);
1754
1755 if (!src_rect)
1756 SetRect(&rect, 0, 0, SrcDesc.Width, SrcDesc.Height);
1757 else
1758 rect = *src_rect;
1759
1760 if (FAILED(IDirect3DSurface9_LockRect(src_surface, &lock, NULL, D3DLOCK_READONLY)))
1761 return D3DXERR_INVALIDDATA;
1762
1763 hr = D3DXLoadSurfaceFromMemory(dst_surface, dst_palette, dst_rect,
1764 lock.pBits, SrcDesc.Format, lock.Pitch, src_palette, &rect, filter, color_key);
1765
1766 IDirect3DSurface9_UnlockRect(src_surface);
1767
1768 return hr;
1769 }
1770
1771
1772 HRESULT WINAPI D3DXSaveSurfaceToFileA(const char *dst_filename, D3DXIMAGE_FILEFORMAT file_format,
1773 IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect)
1774 {
1775 int len;
1776 WCHAR *filename;
1777 HRESULT hr;
1778 ID3DXBuffer *buffer;
1779
1780 TRACE("(%s, %#x, %p, %p, %s): relay\n",
1781 wine_dbgstr_a(dst_filename), file_format, src_surface, src_palette, wine_dbgstr_rect(src_rect));
1782
1783 if (!dst_filename) return D3DERR_INVALIDCALL;
1784
1785 len = MultiByteToWideChar(CP_ACP, 0, dst_filename, -1, NULL, 0);
1786 filename = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1787 if (!filename) return E_OUTOFMEMORY;
1788 MultiByteToWideChar(CP_ACP, 0, dst_filename, -1, filename, len);
1789
1790 hr = D3DXSaveSurfaceToFileInMemory(&buffer, file_format, src_surface, src_palette, src_rect);
1791 if (SUCCEEDED(hr))
1792 {
1793 hr = write_buffer_to_file(filename, buffer);
1794 ID3DXBuffer_Release(buffer);
1795 }
1796
1797 HeapFree(GetProcessHeap(), 0, filename);
1798 return hr;
1799 }
1800
1801 HRESULT WINAPI D3DXSaveSurfaceToFileW(const WCHAR *dst_filename, D3DXIMAGE_FILEFORMAT file_format,
1802 IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect)
1803 {
1804 HRESULT hr;
1805 ID3DXBuffer *buffer;
1806
1807 TRACE("(%s, %#x, %p, %p, %s): relay\n",
1808 wine_dbgstr_w(dst_filename), file_format, src_surface, src_palette, wine_dbgstr_rect(src_rect));
1809
1810 if (!dst_filename) return D3DERR_INVALIDCALL;
1811
1812 hr = D3DXSaveSurfaceToFileInMemory(&buffer, file_format, src_surface, src_palette, src_rect);
1813 if (SUCCEEDED(hr))
1814 {
1815 hr = write_buffer_to_file(dst_filename, buffer);
1816 ID3DXBuffer_Release(buffer);
1817 }
1818
1819 return hr;
1820 }
1821
1822 HRESULT WINAPI D3DXSaveSurfaceToFileInMemory(ID3DXBuffer **dst_buffer, D3DXIMAGE_FILEFORMAT file_format,
1823 IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect)
1824 {
1825 IWICBitmapEncoder *encoder = NULL;
1826 IWICBitmapFrameEncode *frame = NULL;
1827 IPropertyBag2 *encoder_options = NULL;
1828 IStream *stream = NULL;
1829 HRESULT hr;
1830 HRESULT initresult;
1831 const CLSID *encoder_clsid;
1832 const GUID *pixel_format_guid;
1833 WICPixelFormatGUID wic_pixel_format;
1834 D3DFORMAT d3d_pixel_format;
1835 D3DSURFACE_DESC src_surface_desc;
1836 D3DLOCKED_RECT locked_rect;
1837 int width, height;
1838 STATSTG stream_stats;
1839 HGLOBAL stream_hglobal;
1840 ID3DXBuffer *buffer;
1841 DWORD size;
1842
1843 TRACE("(%p, %#x, %p, %p, %s)\n",
1844 dst_buffer, file_format, src_surface, src_palette, wine_dbgstr_rect(src_rect));
1845
1846 if (!dst_buffer || !src_surface) return D3DERR_INVALIDCALL;
1847
1848 if (src_palette)
1849 {
1850 FIXME("Saving surfaces with palettized pixel formats not implemented yet\n");
1851 return D3DERR_INVALIDCALL;
1852 }
1853
1854 switch (file_format)
1855 {
1856 case D3DXIFF_BMP:
1857 encoder_clsid = &CLSID_WICBmpEncoder;
1858 break;
1859 case D3DXIFF_PNG:
1860 encoder_clsid = &CLSID_WICPngEncoder;
1861 break;
1862 case D3DXIFF_JPG:
1863 encoder_clsid = &CLSID_WICJpegEncoder;
1864 break;
1865 case D3DXIFF_DDS:
1866 return save_dds_surface_to_memory(dst_buffer, src_surface, src_rect);
1867 case D3DXIFF_DIB:
1868 case D3DXIFF_HDR:
1869 case D3DXIFF_PFM:
1870 case D3DXIFF_TGA:
1871 case D3DXIFF_PPM:
1872 FIXME("File format %#x is not supported yet\n", file_format);
1873 return E_NOTIMPL;
1874 default:
1875 return D3DERR_INVALIDCALL;
1876 }
1877
1878 IDirect3DSurface9_GetDesc(src_surface, &src_surface_desc);
1879 if (src_rect)
1880 {
1881 if (src_rect->left == src_rect->right || src_rect->top == src_rect->bottom)
1882 {
1883 WARN("Invalid rectangle with 0 area\n");
1884 return D3DXCreateBuffer(64, dst_buffer);
1885 }
1886 if (src_rect->left < 0 || src_rect->top < 0)
1887 return D3DERR_INVALIDCALL;
1888 if (src_rect->left > src_rect->right || src_rect->top > src_rect->bottom)
1889 return D3DERR_INVALIDCALL;
1890 if (src_rect->right > src_surface_desc.Width || src_rect->bottom > src_surface_desc.Height)
1891 return D3DERR_INVALIDCALL;
1892
1893 width = src_rect->right - src_rect->left;
1894 height = src_rect->bottom - src_rect->top;
1895 }
1896 else
1897 {
1898 width = src_surface_desc.Width;
1899 height = src_surface_desc.Height;
1900 }
1901
1902 initresult = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1903
1904 hr = CoCreateInstance(encoder_clsid, NULL, CLSCTX_INPROC_SERVER,
1905 &IID_IWICBitmapEncoder, (void **)&encoder);
1906 if (FAILED(hr)) goto cleanup_err;
1907
1908 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1909 if (FAILED(hr)) goto cleanup_err;
1910
1911 hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
1912 if (FAILED(hr)) goto cleanup_err;
1913
1914 hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frame, &encoder_options);
1915 if (FAILED(hr)) goto cleanup_err;
1916
1917 hr = IWICBitmapFrameEncode_Initialize(frame, encoder_options);
1918 if (FAILED(hr)) goto cleanup_err;
1919
1920 hr = IWICBitmapFrameEncode_SetSize(frame, width, height);
1921 if (FAILED(hr)) goto cleanup_err;
1922
1923 pixel_format_guid = d3dformat_to_wic_guid(src_surface_desc.Format);
1924 if (!pixel_format_guid)
1925 {
1926 FIXME("Pixel format %#x is not supported yet\n", src_surface_desc.Format);
1927 hr = E_NOTIMPL;
1928 goto cleanup;
1929 }
1930
1931 memcpy(&wic_pixel_format, pixel_format_guid, sizeof(GUID));
1932 hr = IWICBitmapFrameEncode_SetPixelFormat(frame, &wic_pixel_format);
1933 d3d_pixel_format = wic_guid_to_d3dformat(&wic_pixel_format);
1934 if (SUCCEEDED(hr) && d3d_pixel_format != D3DFMT_UNKNOWN)
1935 {
1936 TRACE("Using pixel format %s %#x\n", debugstr_guid(&wic_pixel_format), d3d_pixel_format);
1937
1938 if (src_surface_desc.Format == d3d_pixel_format) /* Simple copy */
1939 {
1940 hr = IDirect3DSurface9_LockRect(src_surface, &locked_rect, src_rect, D3DLOCK_READONLY);
1941 if (SUCCEEDED(hr))
1942 {
1943 IWICBitmapFrameEncode_WritePixels(frame, height,
1944 locked_rect.Pitch, height * locked_rect.Pitch, locked_rect.pBits);
1945 IDirect3DSurface9_UnlockRect(src_surface);
1946 }
1947 }
1948 else /* Pixel format conversion */
1949 {
1950 const struct pixel_format_desc *src_format_desc, *dst_format_desc;
1951 struct volume size;
1952 DWORD dst_pitch;
1953 void *dst_data;
1954
1955 src_format_desc = get_format_info(src_surface_desc.Format);
1956 dst_format_desc = get_format_info(d3d_pixel_format);
1957 if (src_format_desc->type != FORMAT_ARGB || dst_format_desc->type != FORMAT_ARGB)
1958 {
1959 FIXME("Unsupported pixel format conversion %#x -> %#x\n",
1960 src_surface_desc.Format, d3d_pixel_format);
1961 hr = E_NOTIMPL;
1962 goto cleanup;
1963 }
1964
1965 size.width = width;
1966 size.height = height;
1967 size.depth = 1;
1968 dst_pitch = width * dst_format_desc->bytes_per_pixel;
1969 dst_data = HeapAlloc(GetProcessHeap(), 0, dst_pitch * height);
1970 if (!dst_data)
1971 {
1972 hr = E_OUTOFMEMORY;
1973 goto cleanup;
1974 }
1975
1976 hr = IDirect3DSurface9_LockRect(src_surface, &locked_rect, src_rect, D3DLOCK_READONLY);
1977 if (SUCCEEDED(hr))
1978 {
1979 convert_argb_pixels(locked_rect.pBits, locked_rect.Pitch, 0, &size, src_format_desc,
1980 dst_data, dst_pitch, 0, &size, dst_format_desc, 0);
1981 IDirect3DSurface9_UnlockRect(src_surface);
1982 }
1983
1984 IWICBitmapFrameEncode_WritePixels(frame, height, dst_pitch, dst_pitch * height, dst_data);
1985 HeapFree(GetProcessHeap(), 0, dst_data);
1986 }
1987
1988 hr = IWICBitmapFrameEncode_Commit(frame);
1989 if (SUCCEEDED(hr)) hr = IWICBitmapEncoder_Commit(encoder);
1990 }
1991 else WARN("Unsupported pixel format %#x\n", src_surface_desc.Format);
1992
1993 /* copy data from stream to ID3DXBuffer */
1994 hr = IStream_Stat(stream, &stream_stats, STATFLAG_NONAME);
1995 if (FAILED(hr)) goto cleanup_err;
1996
1997 if (stream_stats.cbSize.u.HighPart != 0)
1998 {
1999 hr = D3DXERR_INVALIDDATA;
2000 goto cleanup;
2001 }
2002 size = stream_stats.cbSize.u.LowPart;
2003
2004 hr = D3DXCreateBuffer(size, &buffer);
2005 if (FAILED(hr)) goto cleanup;
2006
2007 hr = GetHGlobalFromStream(stream, &stream_hglobal);
2008 if (SUCCEEDED(hr))
2009 {
2010 void *buffer_pointer = ID3DXBuffer_GetBufferPointer(buffer);
2011 void *stream_data = GlobalLock(stream_hglobal);
2012 memcpy(buffer_pointer, stream_data, size);
2013 GlobalUnlock(stream_hglobal);
2014 *dst_buffer = buffer;
2015 }
2016 else ID3DXBuffer_Release(buffer);
2017
2018 cleanup_err:
2019 if (FAILED(hr) && hr != E_OUTOFMEMORY)
2020 hr = D3DERR_INVALIDCALL;
2021
2022 cleanup:
2023 if (stream) IStream_Release(stream);
2024
2025 if (frame) IWICBitmapFrameEncode_Release(frame);
2026 if (encoder_options) IPropertyBag2_Release(encoder_options);
2027
2028 if (encoder) IWICBitmapEncoder_Release(encoder);
2029
2030 if (SUCCEEDED(initresult)) CoUninitialize();
2031
2032 return hr;
2033 }
Windows API implementation