projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[CRT] Massively improve performance of rand_s
[reactos.git] / dll / directx / wine / d3dx9_36 / surface.c
1 #ifdef __REACTOS__
2 #include "precomp.h"
3 #else
4 /*
5 * Copyright (C) 2009-2010 Tony Wasserka
6 * Copyright (C) 2012 Józef Kucia
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 *
22 */
23
24
25 #include "d3dx9_private.h"
26
27 #include "initguid.h"
28 #include "ole2.h"
29 #include "wincodec.h"
30
31 #include "txc_dxtn.h"
32 #endif /* __REACTOS__ */
33
34 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
35
36 HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT, IWICImagingFactory**);
37
38 /* Wine-specific WIC GUIDs */
39 DEFINE_GUID(GUID_WineContainerFormatTga, 0x0c44fda1,0xa5c5,0x4298,0x96,0x85,0x47,0x3f,0xc1,0x7c,0xd3,0x22);
40
41 static const struct
42 {
43 const GUID *wic_guid;
44 D3DFORMAT d3dformat;
45 } wic_pixel_formats[] = {
46 { &GUID_WICPixelFormat8bppIndexed, D3DFMT_P8 },
47 { &GUID_WICPixelFormat1bppIndexed, D3DFMT_P8 },
48 { &GUID_WICPixelFormat4bppIndexed, D3DFMT_P8 },
49 { &GUID_WICPixelFormat8bppGray, D3DFMT_L8 },
50 { &GUID_WICPixelFormat16bppBGR555, D3DFMT_X1R5G5B5 },
51 { &GUID_WICPixelFormat16bppBGR565, D3DFMT_R5G6B5 },
52 { &GUID_WICPixelFormat24bppBGR, D3DFMT_R8G8B8 },
53 { &GUID_WICPixelFormat32bppBGR, D3DFMT_X8R8G8B8 },
54 { &GUID_WICPixelFormat32bppBGRA, D3DFMT_A8R8G8B8 }
55 };
56
57 static D3DFORMAT wic_guid_to_d3dformat(const GUID *guid)
58 {
59 unsigned int i;
60
61 for (i = 0; i < ARRAY_SIZE(wic_pixel_formats); i++)
62 {
63 if (IsEqualGUID(wic_pixel_formats[i].wic_guid, guid))
64 return wic_pixel_formats[i].d3dformat;
65 }
66
67 return D3DFMT_UNKNOWN;
68 }
69
70 static const GUID *d3dformat_to_wic_guid(D3DFORMAT format)
71 {
72 unsigned int i;
73
74 for (i = 0; i < ARRAY_SIZE(wic_pixel_formats); i++)
75 {
76 if (wic_pixel_formats[i].d3dformat == format)
77 return wic_pixel_formats[i].wic_guid;
78 }
79
80 return NULL;
81 }
82
83 /* dds_header.flags */
84 #define DDS_CAPS 0x1
85 #define DDS_HEIGHT 0x2
86 #define DDS_WIDTH 0x4
87 #define DDS_PITCH 0x8
88 #define DDS_PIXELFORMAT 0x1000
89 #define DDS_MIPMAPCOUNT 0x20000
90 #define DDS_LINEARSIZE 0x80000
91 #define DDS_DEPTH 0x800000
92
93 /* dds_header.caps */
94 #define DDS_CAPS_COMPLEX 0x8
95 #define DDS_CAPS_TEXTURE 0x1000
96 #define DDS_CAPS_MIPMAP 0x400000
97
98 /* dds_header.caps2 */
99 #define DDS_CAPS2_CUBEMAP 0x200
100 #define DDS_CAPS2_CUBEMAP_POSITIVEX 0x400
101 #define DDS_CAPS2_CUBEMAP_NEGATIVEX 0x800
102 #define DDS_CAPS2_CUBEMAP_POSITIVEY 0x1000
103 #define DDS_CAPS2_CUBEMAP_NEGATIVEY 0x2000
104 #define DDS_CAPS2_CUBEMAP_POSITIVEZ 0x4000
105 #define DDS_CAPS2_CUBEMAP_NEGATIVEZ 0x8000
106 #define DDS_CAPS2_CUBEMAP_ALL_FACES ( DDS_CAPS2_CUBEMAP_POSITIVEX | DDS_CAPS2_CUBEMAP_NEGATIVEX \
107 | DDS_CAPS2_CUBEMAP_POSITIVEY | DDS_CAPS2_CUBEMAP_NEGATIVEY \
108 | DDS_CAPS2_CUBEMAP_POSITIVEZ | DDS_CAPS2_CUBEMAP_NEGATIVEZ )
109 #define DDS_CAPS2_VOLUME 0x200000
110
111 /* dds_pixel_format.flags */
112 #define DDS_PF_ALPHA 0x1
113 #define DDS_PF_ALPHA_ONLY 0x2
114 #define DDS_PF_FOURCC 0x4
115 #define DDS_PF_INDEXED 0x20
116 #define DDS_PF_RGB 0x40
117 #define DDS_PF_YUV 0x200
118 #define DDS_PF_LUMINANCE 0x20000
119 #define DDS_PF_BUMPLUMINANCE 0x40000
120 #define DDS_PF_BUMPDUDV 0x80000
121
122 struct dds_pixel_format
123 {
124 DWORD size;
125 DWORD flags;
126 DWORD fourcc;
127 DWORD bpp;
128 DWORD rmask;
129 DWORD gmask;
130 DWORD bmask;
131 DWORD amask;
132 };
133
134 struct dds_header
135 {
136 DWORD signature;
137 DWORD size;
138 DWORD flags;
139 DWORD height;
140 DWORD width;
141 DWORD pitch_or_linear_size;
142 DWORD depth;
143 DWORD miplevels;
144 DWORD reserved[11];
145 struct dds_pixel_format pixel_format;
146 DWORD caps;
147 DWORD caps2;
148 DWORD caps3;
149 DWORD caps4;
150 DWORD reserved2;
151 };
152
153 static D3DFORMAT dds_fourcc_to_d3dformat(DWORD fourcc)
154 {
155 unsigned int i;
156 static const DWORD known_fourcc[] = {
157 D3DFMT_UYVY,
158 D3DFMT_YUY2,
159 D3DFMT_R8G8_B8G8,
160 D3DFMT_G8R8_G8B8,
161 D3DFMT_DXT1,
162 D3DFMT_DXT2,
163 D3DFMT_DXT3,
164 D3DFMT_DXT4,
165 D3DFMT_DXT5,
166 D3DFMT_R16F,
167 D3DFMT_G16R16F,
168 D3DFMT_A16B16G16R16F,
169 D3DFMT_R32F,
170 D3DFMT_G32R32F,
171 D3DFMT_A32B32G32R32F,
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 }
183
184 static const struct {
185 DWORD bpp;
186 DWORD rmask;
187 DWORD gmask;
188 DWORD bmask;
189 DWORD amask;
190 D3DFORMAT format;
191 } rgb_pixel_formats[] = {
192 { 8, 0xe0, 0x1c, 0x03, 0, D3DFMT_R3G3B2 },
193 { 16, 0xf800, 0x07e0, 0x001f, 0x0000, D3DFMT_R5G6B5 },
194 { 16, 0x7c00, 0x03e0, 0x001f, 0x8000, D3DFMT_A1R5G5B5 },
195 { 16, 0x7c00, 0x03e0, 0x001f, 0x0000, D3DFMT_X1R5G5B5 },
196 { 16, 0x0f00, 0x00f0, 0x000f, 0xf000, D3DFMT_A4R4G4B4 },
197 { 16, 0x0f00, 0x00f0, 0x000f, 0x0000, D3DFMT_X4R4G4B4 },
198 { 16, 0x00e0, 0x001c, 0x0003, 0xff00, D3DFMT_A8R3G3B2 },
199 { 24, 0xff0000, 0x00ff00, 0x0000ff, 0x000000, D3DFMT_R8G8B8 },
200 { 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000, D3DFMT_A8R8G8B8 },
201 { 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000, D3DFMT_X8R8G8B8 },
202 { 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000, D3DFMT_A2B10G10R10 },
203 { 32, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000, D3DFMT_A2R10G10B10 },
204 { 32, 0x0000ffff, 0xffff0000, 0x00000000, 0x00000000, D3DFMT_G16R16 },
205 { 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000, D3DFMT_A8B8G8R8 },
206 { 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000, D3DFMT_X8B8G8R8 },
207 };
208
209 HRESULT lock_surface(IDirect3DSurface9 *surface, const RECT *surface_rect, D3DLOCKED_RECT *lock,
210 IDirect3DSurface9 **temp_surface, BOOL write)
211 {
212 unsigned int width, height;
213 IDirect3DDevice9 *device;
214 D3DSURFACE_DESC desc;
215 DWORD lock_flag;
216 HRESULT hr;
217
218 lock_flag = write ? 0 : D3DLOCK_READONLY;
219 *temp_surface = NULL;
220 if (FAILED(hr = IDirect3DSurface9_LockRect(surface, lock, surface_rect, lock_flag)))
221 {
222 IDirect3DSurface9_GetDevice(surface, &device);
223 IDirect3DSurface9_GetDesc(surface, &desc);
224
225 if (surface_rect)
226 {
227 width = surface_rect->right - surface_rect->left;
228 height = surface_rect->bottom - surface_rect->top;
229 }
230 else
231 {
232 width = desc.Width;
233 height = desc.Height;
234 }
235
236 hr = write ? IDirect3DDevice9_CreateOffscreenPlainSurface(device, width, height,
237 desc.Format, D3DPOOL_SYSTEMMEM, temp_surface, NULL)
238 : IDirect3DDevice9_CreateRenderTarget(device, width, height,
239 desc.Format, D3DMULTISAMPLE_NONE, 0, TRUE, temp_surface, NULL);
240 if (FAILED(hr))
241 {
242 WARN("Failed to create temporary surface, surface %p, format %#x,"
243 " usage %#x, pool %#x, write %#x, width %u, height %u.\n",
244 surface, desc.Format, desc.Usage, desc.Pool, write, width, height);
245 IDirect3DDevice9_Release(device);
246 return hr;
247 }
248
249 if (write || SUCCEEDED(hr = IDirect3DDevice9_StretchRect(device, surface, surface_rect,
250 *temp_surface, NULL, D3DTEXF_NONE)))
251 hr = IDirect3DSurface9_LockRect(*temp_surface, lock, NULL, lock_flag);
252
253 IDirect3DDevice9_Release(device);
254 if (FAILED(hr))
255 {
256 WARN("Failed to lock surface %p, write %#x, usage %#x, pool %#x.\n",
257 surface, write, desc.Usage, desc.Pool);
258 IDirect3DSurface9_Release(*temp_surface);
259 *temp_surface = NULL;
260 return hr;
261 }
262 TRACE("Created temporary surface %p.\n", surface);
263 }
264 return hr;
265 }
266
267 HRESULT unlock_surface(IDirect3DSurface9 *surface, const RECT *surface_rect,
268 IDirect3DSurface9 *temp_surface, BOOL update)
269 {
270 IDirect3DDevice9 *device;
271 POINT surface_point;
272 HRESULT hr;
273
274 if (!temp_surface)
275 {
276 hr = IDirect3DSurface9_UnlockRect(surface);
277 return hr;
278 }
279
280 hr = IDirect3DSurface9_UnlockRect(temp_surface);
281 if (update)
282 {
283 if (surface_rect)
284 {
285 surface_point.x = surface_rect->left;
286 surface_point.y = surface_rect->top;
287 }
288 else
289 {
290 surface_point.x = 0;
291 surface_point.y = 0;
292 }
293 IDirect3DSurface9_GetDevice(surface, &device);
294 if (FAILED(hr = IDirect3DDevice9_UpdateSurface(device, temp_surface, NULL, surface, &surface_point)))
295 WARN("Updating surface failed, hr %#x, surface %p, temp_surface %p.\n",
296 hr, surface, temp_surface);
297 IDirect3DDevice9_Release(device);
298 }
299 IDirect3DSurface9_Release(temp_surface);
300 return hr;
301 }
302
303 static D3DFORMAT dds_rgb_to_d3dformat(const struct dds_pixel_format *pixel_format)
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 }
325
326 static D3DFORMAT dds_luminance_to_d3dformat(const struct dds_pixel_format *pixel_format)
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 }
347
348 static D3DFORMAT dds_alpha_to_d3dformat(const struct dds_pixel_format *pixel_format)
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 }
356
357 static D3DFORMAT dds_indexed_to_d3dformat(const struct dds_pixel_format *pixel_format)
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 }
365
366 static D3DFORMAT dds_bump_to_d3dformat(const struct dds_pixel_format *pixel_format)
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 }
377
378 static D3DFORMAT dds_bump_luminance_to_d3dformat(const struct dds_pixel_format *pixel_format)
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 }
388
389 static D3DFORMAT dds_pixel_format_to_d3dformat(const struct dds_pixel_format *pixel_format)
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)
399 return dds_indexed_to_d3dformat(pixel_format);
400 if (pixel_format->flags & DDS_PF_RGB)
401 return dds_rgb_to_d3dformat(pixel_format);
402 if (pixel_format->flags & DDS_PF_LUMINANCE)
403 return dds_luminance_to_d3dformat(pixel_format);
404 if (pixel_format->flags & DDS_PF_ALPHA_ONLY)
405 return dds_alpha_to_d3dformat(pixel_format);
406 if (pixel_format->flags & DDS_PF_BUMPDUDV)
407 return dds_bump_to_d3dformat(pixel_format);
408 if (pixel_format->flags & DDS_PF_BUMPLUMINANCE)
409 return dds_bump_luminance_to_d3dformat(pixel_format);
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 }
416
417 static HRESULT d3dformat_to_dds_pixel_format(struct dds_pixel_format *pixel_format, D3DFORMAT d3dformat)
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 {
427 if (rgb_pixel_formats[i].format == d3dformat)
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 */
441 if (dds_fourcc_to_d3dformat(d3dformat) != D3DFMT_UNKNOWN)
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 }
451
452 static HRESULT calculate_dds_surface_size(D3DFORMAT format, UINT width, UINT height,
453 UINT *pitch, UINT *size)
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 }
474
475 static UINT calculate_dds_file_size(D3DFORMAT format, UINT width, UINT height, UINT depth,
476 UINT miplevels, UINT faces)
477 {
478 UINT i, file_size = 0;
479
480 for (i = 0; i < miplevels; i++)
481 {
482 UINT pitch, size = 0;
483 calculate_dds_surface_size(format, width, height, &pitch, &size);
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 }
495
496 /************************************************************
497 * get_image_info_from_dds
498 *
499 * Fills a D3DXIMAGE_INFO structure with information
500 * about a DDS file stored in the memory.
501 *
502 * PARAMS
503 * buffer [I] pointer to DDS data
504 * length [I] size of DDS data
505 * info [O] pointer to D3DXIMAGE_INFO structure
506 *
507 * RETURNS
508 * Success: D3D_OK
509 * Failure: D3DXERR_INVALIDDATA
510 *
511 */
512 static HRESULT get_image_info_from_dds(const void *buffer, UINT length, D3DXIMAGE_INFO *info)
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;
544 for (face = DDS_CAPS2_CUBEMAP_POSITIVEX; face <= DDS_CAPS2_CUBEMAP_NEGATIVEZ; face <<= 1)
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 }
567
568 static HRESULT load_surface_from_dds(IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette,
569 const RECT *dst_rect, const void *src_data, const RECT *src_rect, DWORD filter, D3DCOLOR color_key,
570 const D3DXIMAGE_INFO *src_info)
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 }
586
587 static HRESULT save_dds_surface_to_memory(ID3DXBuffer **dst_buffer, IDirect3DSurface9 *src_surface, const RECT *src_rect)
588 {
589 HRESULT hr;
590 UINT dst_pitch, surface_size, file_size;
591 D3DSURFACE_DESC src_desc;
592 D3DLOCKED_RECT locked_rect;
593 ID3DXBuffer *buffer;
594 struct dds_header *header;
595 BYTE *pixels;
596 struct volume volume;
597 const struct pixel_format_desc *pixel_format;
598 IDirect3DSurface9 *temp_surface;
599
600 if (src_rect)
601 {
602 FIXME("Saving a part of a surface to a DDS file is not implemented yet\n");
603 return E_NOTIMPL;
604 }
605
606 hr = IDirect3DSurface9_GetDesc(src_surface, &src_desc);
607 if (FAILED(hr)) return hr;
608
609 pixel_format = get_format_info(src_desc.Format);
610 if (pixel_format->type == FORMAT_UNKNOWN) return E_NOTIMPL;
611
612 file_size = calculate_dds_file_size(src_desc.Format, src_desc.Width, src_desc.Height, 1, 1, 1);
613
614 hr = calculate_dds_surface_size(src_desc.Format, src_desc.Width, src_desc.Height, &dst_pitch, &surface_size);
615 if (FAILED(hr)) return hr;
616
617 hr = D3DXCreateBuffer(file_size, &buffer);
618 if (FAILED(hr)) return hr;
619
620 header = ID3DXBuffer_GetBufferPointer(buffer);
621 pixels = (BYTE *)(header + 1);
622
623 memset(header, 0, sizeof(*header));
624 header->signature = MAKEFOURCC('D','D','S',' ');
625 /* The signature is not really part of the DDS header */
626 header->size = sizeof(*header) - FIELD_OFFSET(struct dds_header, size);
627 header->flags = DDS_CAPS | DDS_HEIGHT | DDS_WIDTH | DDS_PIXELFORMAT;
628 header->height = src_desc.Height;
629 header->width = src_desc.Width;
630 header->caps = DDS_CAPS_TEXTURE;
631 hr = d3dformat_to_dds_pixel_format(&header->pixel_format, src_desc.Format);
632 if (FAILED(hr))
633 {
634 ID3DXBuffer_Release(buffer);
635 return hr;
636 }
637
638 hr = lock_surface(src_surface, NULL, &locked_rect, &temp_surface, FALSE);
639 if (FAILED(hr))
640 {
641 ID3DXBuffer_Release(buffer);
642 return hr;
643 }
644
645 volume.width = src_desc.Width;
646 volume.height = src_desc.Height;
647 volume.depth = 1;
648 copy_pixels(locked_rect.pBits, locked_rect.Pitch, 0, pixels, dst_pitch, 0,
649 &volume, pixel_format);
650
651 unlock_surface(src_surface, NULL, temp_surface, FALSE);
652
653 *dst_buffer = buffer;
654 return D3D_OK;
655 }
656
657 static HRESULT get_surface(D3DRESOURCETYPE type, struct IDirect3DBaseTexture9 *tex,
658 int face, UINT level, struct IDirect3DSurface9 **surf)
659 {
660 switch (type)
661 {
662 case D3DRTYPE_TEXTURE:
663 return IDirect3DTexture9_GetSurfaceLevel((IDirect3DTexture9*) tex, level, surf);
664 case D3DRTYPE_CUBETEXTURE:
665 return IDirect3DCubeTexture9_GetCubeMapSurface((IDirect3DCubeTexture9*) tex, face, level, surf);
666 default:
667 ERR("Unexpected texture type\n");
668 return E_NOTIMPL;
669 }
670 }
671
672 HRESULT save_dds_texture_to_memory(ID3DXBuffer **dst_buffer, IDirect3DBaseTexture9 *src_texture, const PALETTEENTRY *src_palette)
673 {
674 HRESULT hr;
675 D3DRESOURCETYPE type;
676 UINT mip_levels;
677 IDirect3DSurface9 *surface;
678
679 type = IDirect3DBaseTexture9_GetType(src_texture);
680
681 if ((type != D3DRTYPE_TEXTURE) && (type != D3DRTYPE_CUBETEXTURE) && (type != D3DRTYPE_VOLUMETEXTURE))
682 return D3DERR_INVALIDCALL;
683
684 if (type == D3DRTYPE_CUBETEXTURE)
685 {
686 FIXME("Cube texture not supported yet\n");
687 return E_NOTIMPL;
688 }
689 else if (type == D3DRTYPE_VOLUMETEXTURE)
690 {
691 FIXME("Volume texture not supported yet\n");
692 return E_NOTIMPL;
693 }
694
695 mip_levels = IDirect3DTexture9_GetLevelCount(src_texture);
696
697 if (mip_levels > 1)
698 {
699 FIXME("Mipmap not supported yet\n");
700 return E_NOTIMPL;
701 }
702
703 if (src_palette)
704 {
705 FIXME("Saving surfaces with palettized pixel formats not implemented yet\n");
706 return E_NOTIMPL;
707 }
708
709 hr = get_surface(type, src_texture, D3DCUBEMAP_FACE_POSITIVE_X, 0, &surface);
710
711 if (SUCCEEDED(hr))
712 {
713 hr = save_dds_surface_to_memory(dst_buffer, surface, NULL);
714 IDirect3DSurface9_Release(surface);
715 }
716
717 return hr;
718 }
719 HRESULT load_volume_from_dds(IDirect3DVolume9 *dst_volume, const PALETTEENTRY *dst_palette,
720 const D3DBOX *dst_box, const void *src_data, const D3DBOX *src_box, DWORD filter, D3DCOLOR color_key,
721 const D3DXIMAGE_INFO *src_info)
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 }
736
737 HRESULT load_texture_from_dds(IDirect3DTexture9 *texture, const void *src_data, const PALETTEENTRY *palette,
738 DWORD filter, D3DCOLOR color_key, const D3DXIMAGE_INFO *src_info, unsigned int skip_levels,
739 unsigned int *loaded_miplevels)
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 }
793
794 HRESULT load_cube_texture_from_dds(IDirect3DCubeTexture9 *cube_texture, const void *src_data,
795 const PALETTEENTRY *palette, DWORD filter, DWORD color_key, const D3DXIMAGE_INFO *src_info)
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
812 if ((header->caps2 & DDS_CAPS2_CUBEMAP_ALL_FACES) != DDS_CAPS2_CUBEMAP_ALL_FACES)
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));
819 for (face = D3DCUBEMAP_FACE_POSITIVE_X; face <= D3DCUBEMAP_FACE_NEGATIVE_Z; face++)
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 }
846
847 HRESULT load_volume_texture_from_dds(IDirect3DVolumeTexture9 *volume_texture, const void *src_data,
848 const PALETTEENTRY *palette, DWORD filter, DWORD color_key, const D3DXIMAGE_INFO *src_info)
849 {
850 HRESULT hr;
851 UINT mip_level;
852 UINT mip_levels;
853 UINT src_slice_pitch;
854 UINT src_row_pitch;
855 D3DBOX src_box;
856 UINT width, height, depth;
857 IDirect3DVolume9 *volume;
858 const struct dds_header *header = src_data;
859 const BYTE *pixels = (BYTE *)(header + 1);
860
861 if (src_info->ResourceType != D3DRTYPE_VOLUMETEXTURE)
862 return D3DXERR_INVALIDDATA;
863
864 width = src_info->Width;
865 height = src_info->Height;
866 depth = src_info->Depth;
867 mip_levels = min(src_info->MipLevels, IDirect3DVolumeTexture9_GetLevelCount(volume_texture));
868
869 for (mip_level = 0; mip_level < mip_levels; mip_level++)
870 {
871 hr = calculate_dds_surface_size(src_info->Format, width, height, &src_row_pitch, &src_slice_pitch);
872 if (FAILED(hr)) return hr;
873
874 hr = IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, mip_level, &volume);
875 if (FAILED(hr)) return hr;
876
877 src_box.Left = 0;
878 src_box.Top = 0;
879 src_box.Right = width;
880 src_box.Bottom = height;
881 src_box.Front = 0;
882 src_box.Back = depth;
883
884 hr = D3DXLoadVolumeFromMemory(volume, palette, NULL, pixels, src_info->Format,
885 src_row_pitch, src_slice_pitch, NULL, &src_box, filter, color_key);
886
887 IDirect3DVolume9_Release(volume);
888 if (FAILED(hr)) return hr;
889
890 pixels += depth * src_slice_pitch;
891 width = max(1, width / 2);
892 height = max(1, height / 2);
893 depth = max(1, depth / 2);
894 }
895
896 return D3D_OK;
897 }
898
899 static BOOL convert_dib_to_bmp(const void **data, unsigned int *size)
900 {
901 ULONG header_size;
902 ULONG count = 0;
903 ULONG offset;
904 BITMAPFILEHEADER *header;
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 }
963
964 /************************************************************
965 * D3DXGetImageInfoFromFileInMemory
966 *
967 * Fills a D3DXIMAGE_INFO structure with info about an image
968 *
969 * PARAMS
970 * data [I] pointer to the image file data
971 * datasize [I] size of the passed data
972 * info [O] pointer to the destination structure
973 *
974 * RETURNS
975 * Success: D3D_OK, if info is not NULL and data and datasize make up a valid image file or
976 * if info is NULL and data and datasize are not NULL
977 * Failure: D3DXERR_INVALIDDATA, if data is no valid image file and datasize and info are not NULL
978 * D3DERR_INVALIDCALL, if data is NULL or
979 * if datasize is 0
980 *
981 * NOTES
982 * datasize may be bigger than the actual file size
983 *
984 */
985 HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(const void *data, UINT datasize, D3DXIMAGE_INFO *info)
986 {
987 IWICImagingFactory *factory;
988 IWICBitmapDecoder *decoder = NULL;
989 IWICStream *stream;
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");
1003 return get_image_info_from_dds(data, datasize, info);
1004 }
1005
1006 /* In case of DIB file, convert it to BMP */
1007 dib = convert_dib_to_bmp(&data, &datasize);
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));
1053 hr = D3DXERR_INVALIDDATA;
1054 }
1055 }
1056
1057 if (SUCCEEDED(hr))
1058 hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
1059 if (SUCCEEDED(hr) && !frame_count)
1060 hr = D3DXERR_INVALIDDATA;
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)) {
1071 WICPixelFormatGUID pixel_format;
1072
1073 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &pixel_format);
1074 if (SUCCEEDED(hr)) {
1075 info->Format = wic_guid_to_d3dformat(&pixel_format);
1076 if (info->Format == D3DFMT_UNKNOWN) {
1077 WARN("Unsupported pixel format %s\n", debugstr_guid(&pixel_format));
1078 hr = D3DXERR_INVALIDDATA;
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;
1087 BYTE *buffer = HeapAlloc(GetProcessHeap(), 0, size);
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 }
1098 HeapFree(GetProcessHeap(), 0, buffer);
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 }
1123
1124 /************************************************************
1125 * D3DXGetImageInfoFromFile
1126 *
1127 * RETURNS
1128 * Success: D3D_OK, if we successfully load a valid image file or
1129 * if we successfully load a file which is no valid image and info is NULL
1130 * Failure: D3DXERR_INVALIDDATA, if we fail to load file or
1131 * if file is not a valid image file and info is not NULL
1132 * D3DERR_INVALIDCALL, if file is NULL
1133 *
1134 */
1135 HRESULT WINAPI D3DXGetImageInfoFromFileA(const char *file, D3DXIMAGE_INFO *info)
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 }
1154
1155 HRESULT WINAPI D3DXGetImageInfoFromFileW(const WCHAR *file, D3DXIMAGE_INFO *info)
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
1166 if (FAILED(map_view_of_file(file, &buffer, &size)))
1167 return D3DXERR_INVALIDDATA;
1168
1169 hr = D3DXGetImageInfoFromFileInMemory(buffer, size, info);
1170 UnmapViewOfFile(buffer);
1171
1172 return hr;
1173 }
1174
1175 /************************************************************
1176 * D3DXGetImageInfoFromResource
1177 *
1178 * RETURNS
1179 * Success: D3D_OK, if resource is a valid image file
1180 * Failure: D3DXERR_INVALIDDATA, if resource is no valid image file or NULL or
1181 * if we fail to load resource
1182 *
1183 */
1184 HRESULT WINAPI D3DXGetImageInfoFromResourceA(HMODULE module, const char *resource, D3DXIMAGE_INFO *info)
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
1200 return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
1201 }
1202
1203 HRESULT WINAPI D3DXGetImageInfoFromResourceW(HMODULE module, const WCHAR *resource, D3DXIMAGE_INFO *info)
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
1219 return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
1220 }
1221
1222 /************************************************************
1223 * D3DXLoadSurfaceFromFileInMemory
1224 *
1225 * Loads data from a given buffer into a surface and fills a given
1226 * D3DXIMAGE_INFO structure with info about the source data.
1227 *
1228 * PARAMS
1229 * pDestSurface [I] pointer to the surface
1230 * pDestPalette [I] palette to use
1231 * pDestRect [I] to be filled area of the surface
1232 * pSrcData [I] pointer to the source data
1233 * SrcDataSize [I] size of the source data in bytes
1234 * pSrcRect [I] area of the source data to load
1235 * dwFilter [I] filter to apply on stretching
1236 * Colorkey [I] colorkey
1237 * pSrcInfo [O] pointer to a D3DXIMAGE_INFO structure
1238 *
1239 * RETURNS
1240 * Success: D3D_OK
1241 * Failure: D3DERR_INVALIDCALL, if pDestSurface, pSrcData or SrcDataSize is NULL
1242 * D3DXERR_INVALIDDATA, if pSrcData is no valid image file
1243 *
1244 */
1245 HRESULT WINAPI D3DXLoadSurfaceFromFileInMemory(IDirect3DSurface9 *pDestSurface,
1246 const PALETTEENTRY *pDestPalette, const RECT *pDestRect, const void *pSrcData, UINT SrcDataSize,
1247 const RECT *pSrcRect, DWORD dwFilter, D3DCOLOR Colorkey, D3DXIMAGE_INFO *pSrcInfo)
1248 {
1249 D3DXIMAGE_INFO imginfo;
1250 HRESULT hr;
1251
1252 IWICImagingFactory *factory = NULL;
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");
1332 hr = D3DXERR_INVALIDDATA;
1333 }
1334 else
1335 {
1336 BYTE *buffer;
1337 DWORD pitch;
1338 PALETTEENTRY *palette = NULL;
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);
1391 HeapFree(GetProcessHeap(), 0, palette);
1392 HeapFree(GetProcessHeap(), 0, buffer);
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 }
1415
1416 HRESULT WINAPI D3DXLoadSurfaceFromFileA(IDirect3DSurface9 *dst_surface,
1417 const PALETTEENTRY *dst_palette, const RECT *dst_rect, const char *src_file,
1418 const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
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 }
1442
1443 HRESULT WINAPI D3DXLoadSurfaceFromFileW(IDirect3DSurface9 *dst_surface,
1444 const PALETTEENTRY *dst_palette, const RECT *dst_rect, const WCHAR *src_file,
1445 const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
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);
1464 UnmapViewOfFile(data);
1465
1466 return hr;
1467 }
1468
1469 HRESULT WINAPI D3DXLoadSurfaceFromResourceA(IDirect3DSurface9 *dst_surface,
1470 const PALETTEENTRY *dst_palette, const RECT *dst_rect, HMODULE src_module, const char *resource,
1471 const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
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 }
1496
1497 HRESULT WINAPI D3DXLoadSurfaceFromResourceW(IDirect3DSurface9 *dst_surface,
1498 const PALETTEENTRY *dst_palette, const RECT *dst_rect, HMODULE src_module, const WCHAR *resource,
1499 const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
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 }
1524
1525
1526 /************************************************************
1527 * helper functions for D3DXLoadSurfaceFromMemory
1528 */
1529 struct argb_conversion_info
1530 {
1531 const struct pixel_format_desc *srcformat;
1532 const struct pixel_format_desc *destformat;
1533 DWORD srcshift[4], destshift[4];
1534 DWORD srcmask[4], destmask[4];
1535 BOOL process_channel[4];
1536 DWORD channelmask;
1537 };
1538
1539 static void init_argb_conversion_info(const struct pixel_format_desc *srcformat, const struct pixel_format_desc *destformat, struct argb_conversion_info *info)
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 }
1565
1566 /************************************************************
1567 * get_relevant_argb_components
1568 *
1569 * Extracts the relevant components from the source color and
1570 * drops the less significant bits if they aren't used by the destination format.
1571 */
1572 static void get_relevant_argb_components(const struct argb_conversion_info *info, const BYTE *col, DWORD *out)
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 }
1595
1596 /************************************************************
1597 * make_argb_color
1598 *
1599 * Recombines the output of get_relevant_argb_components and converts
1600 * it to the destination format.
1601 */
1602 static DWORD make_argb_color(const struct argb_conversion_info *info, const DWORD *in)
1603 {
1604 UINT i;
1605 DWORD val = 0;
1606
1607 for(i = 0;i < 4;i++) {
1608 if(info->process_channel[i]) {
1609 /* necessary to make sure that e.g. an X4R4G4B4 white maps to an R8G8B8 white instead of 0xf0f0f0 */
1610 signed int shift;
1611 for(shift = info->destshift[i]; shift > info->destformat->shift[i]; shift -= info->srcformat->bits[i]) val |= in[i] << shift;
1612 val |= (in[i] >> (info->destformat->shift[i] - shift)) << info->destformat->shift[i];
1613 }
1614 }
1615 val |= info->channelmask; /* new channels are set to their maximal value */
1616 return val;
1617 }
1618
1619 /* It doesn't work for components bigger than 32 bits (or somewhat smaller but unaligned). */
1620 static void format_to_vec4(const struct pixel_format_desc *format, const BYTE *src, struct vec4 *dst)
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 }
1648
1649 /* It doesn't work for components bigger than 32 bits. */
1650 static void format_from_vec4(const struct pixel_format_desc *format, const struct vec4 *src, BYTE *dst)
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 }
1692
1693 /************************************************************
1694 * copy_pixels
1695 *
1696 * Copies the source buffer to the destination buffer.
1697 * Works for any pixel format.
1698 * The source and the destination must be block-aligned.
1699 */
1700 void copy_pixels(const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch,
1701 BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *size,
1702 const struct pixel_format_desc *format)
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 }
1723
1724 /************************************************************
1725 * convert_argb_pixels
1726 *
1727 * Copies the source buffer to the destination buffer, performing
1728 * any necessary format conversion and color keying.
1729 * Pixels outsize the source rect are blacked out.
1730 */
1731 void convert_argb_pixels(const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, const struct volume *src_size,
1732 const struct pixel_format_desc *src_format, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch,
1733 const struct volume *dst_size, const struct pixel_format_desc *dst_format, D3DCOLOR color_key,
1734 const PALETTEENTRY *palette)
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,
1745 dst_format, color_key, palette);
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 }
1831
1832 /************************************************************
1833 * point_filter_argb_pixels
1834 *
1835 * Copies the source buffer to the destination buffer, performing
1836 * any necessary format conversion, color keying and stretching
1837 * using a point filter.
1838 */
1839 void point_filter_argb_pixels(const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, const struct volume *src_size,
1840 const struct pixel_format_desc *src_format, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch,
1841 const struct volume *dst_size, const struct pixel_format_desc *dst_format, D3DCOLOR color_key,
1842 const PALETTEENTRY *palette)
1843 {
1844 struct argb_conversion_info conv_info, ck_conv_info;
1845 const struct pixel_format_desc *ck_format = NULL;
1846 DWORD channels[4];
1847 UINT x, y, z;
1848
1849 TRACE("src %p, src_row_pitch %u, src_slice_pitch %u, src_size %p, src_format %p, dst %p, "
1850 "dst_row_pitch %u, dst_slice_pitch %u, dst_size %p, dst_format %p, color_key 0x%08x, palette %p.\n",
1851 src, src_row_pitch, src_slice_pitch, src_size, src_format, dst, dst_row_pitch, dst_slice_pitch, dst_size,
1852 dst_format, color_key, palette);
1853
1854 ZeroMemory(channels, sizeof(channels));
1855 init_argb_conversion_info(src_format, dst_format, &conv_info);
1856
1857 if (color_key)
1858 {
1859 /* Color keys are always represented in D3DFMT_A8R8G8B8 format. */
1860 ck_format = get_format_info(D3DFMT_A8R8G8B8);
1861 init_argb_conversion_info(src_format, ck_format, &ck_conv_info);
1862 }
1863
1864 for (z = 0; z < dst_size->depth; z++)
1865 {
1866 BYTE *dst_slice_ptr = dst + z * dst_slice_pitch;
1867 const BYTE *src_slice_ptr = src + src_slice_pitch * (z * src_size->depth / dst_size->depth);
1868
1869 for (y = 0; y < dst_size->height; y++)
1870 {
1871 BYTE *dst_ptr = dst_slice_ptr + y * dst_row_pitch;
1872 const BYTE *src_row_ptr = src_slice_ptr + src_row_pitch * (y * src_size->height / dst_size->height);
1873
1874 for (x = 0; x < dst_size->width; x++)
1875 {
1876 const BYTE *src_ptr = src_row_ptr + (x * src_size->width / dst_size->width) * src_format->bytes_per_pixel;
1877
1878 if (!src_format->to_rgba && !dst_format->from_rgba
1879 && src_format->type == dst_format->type
1880 && src_format->bytes_per_pixel <= 4 && dst_format->bytes_per_pixel <= 4)
1881 {
1882 DWORD val;
1883
1884 get_relevant_argb_components(&conv_info, src_ptr, channels);
1885 val = make_argb_color(&conv_info, channels);
1886
1887 if (color_key)
1888 {
1889 DWORD ck_pixel;
1890
1891 get_relevant_argb_components(&ck_conv_info, src_ptr, channels);
1892 ck_pixel = make_argb_color(&ck_conv_info, channels);
1893 if (ck_pixel == color_key)
1894 val &= ~conv_info.destmask[0];
1895 }
1896 memcpy(dst_ptr, &val, dst_format->bytes_per_pixel);
1897 }
1898 else
1899 {
1900 struct vec4 color, tmp;
1901
1902 format_to_vec4(src_format, src_ptr, &color);
1903 if (src_format->to_rgba)
1904 src_format->to_rgba(&color, &tmp, palette);
1905 else
1906 tmp = color;
1907
1908 if (ck_format)
1909 {
1910 DWORD ck_pixel;
1911
1912 format_from_vec4(ck_format, &tmp, (BYTE *)&ck_pixel);
1913 if (ck_pixel == color_key)
1914 tmp.w = 0.0f;
1915 }
1916
1917 if (dst_format->from_rgba)
1918 dst_format->from_rgba(&tmp, &color);
1919 else
1920 color = tmp;
1921
1922 format_from_vec4(dst_format, &color, dst_ptr);
1923 }
1924
1925 dst_ptr += dst_format->bytes_per_pixel;
1926 }
1927 }
1928 }
1929 }
1930
1931 /************************************************************
1932 * D3DXLoadSurfaceFromMemory
1933 *
1934 * Loads data from a given memory chunk into a surface,
1935 * applying any of the specified filters.
1936 *
1937 * PARAMS
1938 * pDestSurface [I] pointer to the surface
1939 * pDestPalette [I] palette to use
1940 * pDestRect [I] to be filled area of the surface
1941 * pSrcMemory [I] pointer to the source data
1942 * SrcFormat [I] format of the source pixel data
1943 * SrcPitch [I] number of bytes in a row
1944 * pSrcPalette [I] palette used in the source image
1945 * pSrcRect [I] area of the source data to load
1946 * dwFilter [I] filter to apply on stretching
1947 * Colorkey [I] colorkey
1948 *
1949 * RETURNS
1950 * Success: D3D_OK, if we successfully load the pixel data into our surface or
1951 * if pSrcMemory is NULL but the other parameters are valid
1952 * Failure: D3DERR_INVALIDCALL, if pDestSurface, SrcPitch or pSrcRect is NULL or
1953 * if SrcFormat is an invalid format (other than D3DFMT_UNKNOWN) or
1954 * if DestRect is invalid
1955 * D3DXERR_INVALIDDATA, if we fail to lock pDestSurface
1956 * E_FAIL, if SrcFormat is D3DFMT_UNKNOWN or the dimensions of pSrcRect are invalid
1957 *
1958 * NOTES
1959 * pSrcRect specifies the dimensions of the source data;
1960 * negative values for pSrcRect are allowed as we're only looking at the width and height anyway.
1961 *
1962 */
1963 HRESULT WINAPI D3DXLoadSurfaceFromMemory(IDirect3DSurface9 *dst_surface,
1964 const PALETTEENTRY *dst_palette, const RECT *dst_rect, const void *src_memory,
1965 D3DFORMAT src_format, UINT src_pitch, const PALETTEENTRY *src_palette, const RECT *src_rect,
1966 DWORD filter, D3DCOLOR color_key)
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)
2050 filter = D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER;
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);
2151 dst_format = get_format_info(D3DFMT_A8B8G8R8);
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:
2188 gl_format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
2189 break;
2190 case D3DFMT_DXT2:
2191 case D3DFMT_DXT3:
2192 gl_format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
2193 break;
2194 case D3DFMT_DXT4:
2195 case D3DFMT_DXT5:
2196 gl_format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
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 }
2210
2211 /************************************************************
2212 * D3DXLoadSurfaceFromSurface
2213 *
2214 * Copies the contents from one surface to another, performing any required
2215 * format conversion, resizing or filtering.
2216 *
2217 * PARAMS
2218 * pDestSurface [I] pointer to the destination surface
2219 * pDestPalette [I] palette to use
2220 * pDestRect [I] to be filled area of the surface
2221 * pSrcSurface [I] pointer to the source surface
2222 * pSrcPalette [I] palette used for the source surface
2223 * pSrcRect [I] area of the source data to load
2224 * dwFilter [I] filter to apply on resizing
2225 * Colorkey [I] any ARGB value or 0 to disable color-keying
2226 *
2227 * RETURNS
2228 * Success: D3D_OK
2229 * Failure: D3DERR_INVALIDCALL, if pDestSurface or pSrcSurface is NULL
2230 * D3DXERR_INVALIDDATA, if one of the surfaces is not lockable
2231 *
2232 */
2233 HRESULT WINAPI D3DXLoadSurfaceFromSurface(IDirect3DSurface9 *dst_surface,
2234 const PALETTEENTRY *dst_palette, const RECT *dst_rect, IDirect3DSurface9 *src_surface,
2235 const PALETTEENTRY *src_palette, const RECT *src_rect, DWORD filter, D3DCOLOR color_key)
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;
2243 D3DLOCKED_RECT lock;
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);
2345 IDirect3DDevice9_Release(device);
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 }
2362
2363
2364 HRESULT WINAPI D3DXSaveSurfaceToFileA(const char *dst_filename, D3DXIMAGE_FILEFORMAT file_format,
2365 IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect)
2366 {
2367 int len;
2368 WCHAR *filename;
2369 HRESULT hr;
2370 ID3DXBuffer *buffer;
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 {
2385 hr = write_buffer_to_file(filename, buffer);
2386 ID3DXBuffer_Release(buffer);
2387 }
2388
2389 HeapFree(GetProcessHeap(), 0, filename);
2390 return hr;
2391 }
2392
2393 HRESULT WINAPI D3DXSaveSurfaceToFileW(const WCHAR *dst_filename, D3DXIMAGE_FILEFORMAT file_format,
2394 IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect)
2395 {
2396 HRESULT hr;
2397 ID3DXBuffer *buffer;
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);
2408 ID3DXBuffer_Release(buffer);
2409 }
2410
2411 return hr;
2412 }
2413
2414 HRESULT WINAPI D3DXSaveSurfaceToFileInMemory(ID3DXBuffer **dst_buffer, D3DXIMAGE_FILEFORMAT file_format,
2415 IDirect3DSurface9 *src_surface, const PALETTEENTRY *src_palette, const RECT *src_rect)
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;
2425 IWICImagingFactory *factory;
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;
2433 ID3DXBuffer *buffer;
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
2502 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
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 {
2592 hr = D3DXERR_INVALIDDATA;
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
2601 hr = D3DXCreateBuffer(size, &buffer);
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 }
2616 else ID3DXBuffer_Release(buffer);
2617
2618 cleanup_err:
2619 if (FAILED(hr) && hr != E_OUTOFMEMORY)
2620 hr = D3DERR_INVALIDCALL;
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 }
A free Windows-compatible Operating System