- Merge from trunk up to r45543
[reactos.git] / dll / directx / wine / d3dx9_36 / surface.c
1 /*
2 * Copyright (C) 2009 Tony Wasserka
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 *
18 */
19
20 #include "wine/debug.h"
21 #include "wine/unicode.h"
22 #include "d3dx9_36_private.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
25
26
27 /************************************************************
28 * D3DXGetImageInfoFromFileInMemory
29 *
30 * Fills a D3DXIMAGE_INFO structure with info about an image
31 *
32 * PARAMS
33 * data [I] pointer to the image file data
34 * datasize [I] size of the passed data
35 * info [O] pointer to the destination structure
36 *
37 * RETURNS
38 * Success: D3D_OK, if info is not NULL and data and datasize make up a valid image file or
39 * if info is NULL and data and datasize are not NULL
40 * Failure: D3DXERR_INVALIDDATA, if data is no valid image file and datasize and info are not NULL
41 * D3DERR_INVALIDCALL, if data is NULL or
42 * if datasize is 0
43 *
44 * NOTES
45 * datasize may be bigger than the actual file size
46 *
47 */
48 HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(LPCVOID data, UINT datasize, D3DXIMAGE_INFO *info)
49 {
50 FIXME("stub\n");
51
52 if(data && datasize && !info) return D3D_OK;
53 if( !data || !datasize ) return D3DERR_INVALIDCALL;
54
55 return E_NOTIMPL;
56 }
57
58 /************************************************************
59 * D3DXGetImageInfoFromFile
60 *
61 * RETURNS
62 * Success: D3D_OK, if we successfully load a valid image file or
63 * if we successfully load a file which is no valid image and info is NULL
64 * Failure: D3DXERR_INVALIDDATA, if we fail to load file or
65 * if file is not a valid image file and info is not NULL
66 * D3DERR_INVALIDCALL, if file is NULL
67 *
68 */
69 HRESULT WINAPI D3DXGetImageInfoFromFileA(LPCSTR file, D3DXIMAGE_INFO *info)
70 {
71 LPWSTR widename;
72 HRESULT hr;
73 int strlength;
74 TRACE("(void): relay\n");
75
76 if( !file ) return D3DERR_INVALIDCALL;
77
78 strlength = MultiByteToWideChar(CP_ACP, 0, file, -1, NULL, 0);
79 widename = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, strlength * sizeof(WCHAR));
80 MultiByteToWideChar(CP_ACP, 0, file, -1, widename, strlength);
81
82 hr = D3DXGetImageInfoFromFileW(widename, info);
83 HeapFree(GetProcessHeap(), 0, widename);
84
85 return hr;
86 }
87
88 HRESULT WINAPI D3DXGetImageInfoFromFileW(LPCWSTR file, D3DXIMAGE_INFO *info)
89 {
90 HRESULT hr;
91 DWORD size;
92 LPVOID buffer;
93 TRACE("(void): relay\n");
94
95 if( !file ) return D3DERR_INVALIDCALL;
96
97 hr = map_view_of_file(file, &buffer, &size);
98 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
99
100 hr = D3DXGetImageInfoFromFileInMemory(buffer, size, info);
101 UnmapViewOfFile(buffer);
102
103 return hr;
104 }
105
106 /************************************************************
107 * D3DXGetImageInfoFromResource
108 *
109 * RETURNS
110 * Success: D3D_OK, if resource is a valid image file
111 * Failure: D3DXERR_INVALIDDATA, if resource is no valid image file or NULL or
112 * if we fail to load resource
113 *
114 */
115 HRESULT WINAPI D3DXGetImageInfoFromResourceA(HMODULE module, LPCSTR resource, D3DXIMAGE_INFO *info)
116 {
117 HRSRC resinfo;
118 TRACE("(void)\n");
119
120 resinfo = FindResourceA(module, resource, (LPCSTR)RT_RCDATA);
121 if(resinfo) {
122 LPVOID buffer;
123 HRESULT hr;
124 DWORD size;
125
126 hr = load_resource_into_memory(module, resinfo, &buffer, &size);
127 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
128 return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
129 }
130
131 resinfo = FindResourceA(module, resource, (LPCSTR)RT_BITMAP);
132 if(resinfo) {
133 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
134 return E_NOTIMPL;
135 }
136 return D3DXERR_INVALIDDATA;
137 }
138
139 HRESULT WINAPI D3DXGetImageInfoFromResourceW(HMODULE module, LPCWSTR resource, D3DXIMAGE_INFO *info)
140 {
141 HRSRC resinfo;
142 TRACE("(void)\n");
143
144 resinfo = FindResourceW(module, resource, (LPCWSTR)RT_RCDATA);
145 if(resinfo) {
146 LPVOID buffer;
147 HRESULT hr;
148 DWORD size;
149
150 hr = load_resource_into_memory(module, resinfo, &buffer, &size);
151 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
152 return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
153 }
154
155 resinfo = FindResourceW(module, resource, (LPCWSTR)RT_BITMAP);
156 if(resinfo) {
157 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
158 return E_NOTIMPL;
159 }
160 return D3DXERR_INVALIDDATA;
161 }
162
163 /************************************************************
164 * D3DXLoadSurfaceFromFileInMemory
165 *
166 * Loads data from a given buffer into a surface and fills a given
167 * D3DXIMAGE_INFO structure with info about the source data.
168 *
169 * PARAMS
170 * pDestSurface [I] pointer to the surface
171 * pDestPalette [I] palette to use
172 * pDestRect [I] to be filled area of the surface
173 * pSrcData [I] pointer to the source data
174 * SrcDataSize [I] size of the source data in bytes
175 * pSrcRect [I] area of the source data to load
176 * dwFilter [I] filter to apply on stretching
177 * Colorkey [I] colorkey
178 * pSrcInfo [O] pointer to a D3DXIMAGE_INFO structure
179 *
180 * RETURNS
181 * Success: D3D_OK
182 * Failure: D3DERR_INVALIDCALL, if pDestSurface or pSrcData or SrcDataSize are NULL
183 * D3DXERR_INVALIDDATA, if pSrcData is no valid image file
184 *
185 */
186 HRESULT WINAPI D3DXLoadSurfaceFromFileInMemory(LPDIRECT3DSURFACE9 pDestSurface,
187 CONST PALETTEENTRY *pDestPalette,
188 CONST RECT *pDestRect,
189 LPCVOID pSrcData,
190 UINT SrcDataSize,
191 CONST RECT *pSrcRect,
192 DWORD dwFilter,
193 D3DCOLOR Colorkey,
194 D3DXIMAGE_INFO *pSrcInfo)
195 {
196 FIXME("stub\n");
197 if( !pDestSurface || !pSrcData | !SrcDataSize ) return D3DERR_INVALIDCALL;
198 return E_NOTIMPL;
199 }
200
201 /************************************************************
202 * D3DXLoadSurfaceFromFile
203 */
204 HRESULT WINAPI D3DXLoadSurfaceFromFileA(LPDIRECT3DSURFACE9 pDestSurface,
205 CONST PALETTEENTRY *pDestPalette,
206 CONST RECT *pDestRect,
207 LPCSTR pSrcFile,
208 CONST RECT *pSrcRect,
209 DWORD dwFilter,
210 D3DCOLOR Colorkey,
211 D3DXIMAGE_INFO *pSrcInfo)
212 {
213 LPWSTR pWidename;
214 HRESULT hr;
215 int strlength;
216 TRACE("(void): relay\n");
217
218 if( !pSrcFile || !pDestSurface ) return D3DERR_INVALIDCALL;
219
220 strlength = MultiByteToWideChar(CP_ACP, 0, pSrcFile, -1, NULL, 0);
221 pWidename = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, strlength * sizeof(WCHAR));
222 MultiByteToWideChar(CP_ACP, 0, pSrcFile, -1, pWidename, strlength);
223
224 hr = D3DXLoadSurfaceFromFileW(pDestSurface, pDestPalette, pDestRect, pWidename, pSrcRect, dwFilter, Colorkey, pSrcInfo);
225 HeapFree(GetProcessHeap(), 0, pWidename);
226
227 return hr;
228 }
229
230 HRESULT WINAPI D3DXLoadSurfaceFromFileW(LPDIRECT3DSURFACE9 pDestSurface,
231 CONST PALETTEENTRY *pDestPalette,
232 CONST RECT *pDestRect,
233 LPCWSTR pSrcFile,
234 CONST RECT *pSrcRect,
235 DWORD Filter,
236 D3DCOLOR Colorkey,
237 D3DXIMAGE_INFO *pSrcInfo)
238 {
239 HRESULT hr;
240 DWORD dwSize;
241 LPVOID pBuffer;
242 TRACE("(void): relay\n");
243
244 if( !pSrcFile || !pDestSurface ) return D3DERR_INVALIDCALL;
245
246 hr = map_view_of_file(pSrcFile, &pBuffer, &dwSize);
247 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
248
249 hr = D3DXLoadSurfaceFromFileInMemory(pDestSurface, pDestPalette, pDestRect, pBuffer, dwSize, pSrcRect, Filter, Colorkey, pSrcInfo);
250 UnmapViewOfFile(pBuffer);
251
252 return hr;
253 }
254
255 /************************************************************
256 * D3DXLoadSurfaceFromResource
257 */
258 HRESULT WINAPI D3DXLoadSurfaceFromResourceA(LPDIRECT3DSURFACE9 pDestSurface,
259 CONST PALETTEENTRY *pDestPalette,
260 CONST RECT *pDestRect,
261 HMODULE hSrcModule,
262 LPCSTR pResource,
263 CONST RECT *pSrcRect,
264 DWORD dwFilter,
265 D3DCOLOR Colorkey,
266 D3DXIMAGE_INFO *pSrcInfo)
267 {
268 HRSRC hResInfo;
269 TRACE("(void): relay\n");
270
271 if( !pDestSurface ) return D3DERR_INVALIDCALL;
272
273 hResInfo = FindResourceA(hSrcModule, pResource, (LPCSTR)RT_RCDATA);
274 if(hResInfo) {
275 LPVOID pBuffer;
276 HRESULT hr;
277 DWORD dwSize;
278
279 hr = load_resource_into_memory(hSrcModule, hResInfo, &pBuffer, &dwSize);
280 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
281 return D3DXLoadSurfaceFromFileInMemory(pDestSurface, pDestPalette, pDestRect, pBuffer, dwSize, pSrcRect, dwFilter, Colorkey, pSrcInfo);
282 }
283
284 hResInfo = FindResourceA(hSrcModule, pResource, (LPCSTR)RT_BITMAP);
285 if(hResInfo) {
286 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
287 return E_NOTIMPL;
288 }
289 return D3DXERR_INVALIDDATA;
290 }
291
292 HRESULT WINAPI D3DXLoadSurfaceFromResourceW(LPDIRECT3DSURFACE9 pDestSurface,
293 CONST PALETTEENTRY *pDestPalette,
294 CONST RECT *pDestRect,
295 HMODULE hSrcModule,
296 LPCWSTR pResource,
297 CONST RECT *pSrcRect,
298 DWORD dwFilter,
299 D3DCOLOR Colorkey,
300 D3DXIMAGE_INFO *pSrcInfo)
301 {
302 HRSRC hResInfo;
303 TRACE("(void): relay\n");
304
305 if( !pDestSurface ) return D3DERR_INVALIDCALL;
306
307 hResInfo = FindResourceW(hSrcModule, pResource, (LPCWSTR)RT_RCDATA);
308 if(hResInfo) {
309 LPVOID pBuffer;
310 HRESULT hr;
311 DWORD dwSize;
312
313 hr = load_resource_into_memory(hSrcModule, hResInfo, &pBuffer, &dwSize);
314 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
315 return D3DXLoadSurfaceFromFileInMemory(pDestSurface, pDestPalette, pDestRect, pBuffer, dwSize, pSrcRect, dwFilter, Colorkey, pSrcInfo);
316 }
317
318 hResInfo = FindResourceW(hSrcModule, pResource, (LPCWSTR)RT_BITMAP);
319 if(hResInfo) {
320 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
321 return E_NOTIMPL;
322 }
323 return D3DXERR_INVALIDDATA;
324 }
325
326
327 /************************************************************
328 * copy_simple_data
329 *
330 * Copies the source buffer to the destination buffer, performing
331 * any necessary format conversion and color keying.
332 * Works only for ARGB formats with 1 - 4 bytes per pixel.
333 */
334 static void copy_simple_data(CONST BYTE *src, UINT srcpitch, POINT srcsize, CONST PixelFormatDesc *srcformat,
335 CONST BYTE *dest, UINT destpitch, POINT destsize, CONST PixelFormatDesc *destformat,
336 DWORD dwFilter)
337 {
338 DWORD srcshift[4], destshift[4];
339 DWORD srcmask[4], destmask[4];
340 BOOL process_channel[4];
341 DWORD channels[4];
342 DWORD channelmask = 0;
343
344 UINT minwidth, minheight;
345 BYTE *srcptr, *destptr;
346 UINT i, x, y;
347
348 ZeroMemory(channels, sizeof(channels));
349 ZeroMemory(process_channel, sizeof(process_channel));
350
351 for(i = 0;i < 4;i++) {
352 /* srcshift is used to extract the _relevant_ components */
353 srcshift[i] = srcformat->shift[i] + max( srcformat->bits[i] - destformat->bits[i], 0);
354
355 /* destshift is used to move the components to the correct position */
356 destshift[i] = destformat->shift[i] + max(destformat->bits[i] - srcformat->bits[i], 0);
357
358 srcmask[i] = ((1 << srcformat->bits[i]) - 1) << srcformat->shift[i];
359 destmask[i] = ((1 << destformat->bits[i]) - 1) << destformat->shift[i];
360
361 /* channelmask specifies bits which aren't used in the source format but in the destination one */
362 if(destformat->bits[i]) {
363 if(srcformat->bits[i]) process_channel[i] = TRUE;
364 else channelmask |= destmask[i];
365 }
366 }
367
368 minwidth = (srcsize.x < destsize.x) ? srcsize.x : destsize.x;
369 minheight = (srcsize.y < destsize.y) ? srcsize.y : destsize.y;
370
371 for(y = 0;y < minheight;y++) {
372 srcptr = (BYTE*)( src + y * srcpitch);
373 destptr = (BYTE*)(dest + y * destpitch);
374 for(x = 0;x < minwidth;x++) {
375 /* extract source color components */
376 if(srcformat->type == FORMAT_ARGB) {
377 const DWORD col = *(DWORD*)srcptr;
378 for(i = 0;i < 4;i++)
379 if(process_channel[i])
380 channels[i] = (col & srcmask[i]) >> srcshift[i];
381 }
382
383 /* recombine the components */
384 if(destformat->type == FORMAT_ARGB) {
385 DWORD* const pixel = (DWORD*)destptr;
386 *pixel = 0;
387
388 for(i = 0;i < 4;i++) {
389 if(process_channel[i]) {
390 /* necessary to make sure that e.g. an X4R4G4B4 white maps to an R8G8B8 white instead of 0xf0f0f0 */
391 signed int shift;
392 for(shift = destshift[i]; shift > destformat->shift[i]; shift -= srcformat->bits[i]) *pixel |= channels[i] << shift;
393 *pixel |= (channels[i] >> (destformat->shift[i] - shift)) << destformat->shift[i];
394 }
395 }
396 *pixel |= channelmask; /* new channels are set to their maximal value */
397 }
398 srcptr += srcformat->bytes_per_pixel;
399 destptr += destformat->bytes_per_pixel;
400 }
401 }
402 }
403
404 /************************************************************
405 * D3DXLoadSurfaceFromMemory
406 *
407 * Loads data from a given memory chunk into a surface,
408 * applying any of the specified filters.
409 *
410 * PARAMS
411 * pDestSurface [I] pointer to the surface
412 * pDestPalette [I] palette to use
413 * pDestRect [I] to be filled area of the surface
414 * pSrcMemory [I] pointer to the source data
415 * SrcFormat [I] format of the source pixel data
416 * SrcPitch [I] number of bytes in a row
417 * pSrcPalette [I] palette used in the source image
418 * pSrcRect [I] area of the source data to load
419 * dwFilter [I] filter to apply on stretching
420 * Colorkey [I] colorkey
421 *
422 * RETURNS
423 * Success: D3D_OK, if we successfully load the pixel data into our surface or
424 * if pSrcMemory is NULL but the other parameters are valid
425 * Failure: D3DERR_INVALIDCALL, if pDestSurface, SrcPitch or pSrcRect are NULL or
426 * if SrcFormat is an invalid format (other than D3DFMT_UNKNOWN)
427 * D3DXERR_INVALIDDATA, if we fail to lock pDestSurface
428 * E_FAIL, if SrcFormat is D3DFMT_UNKNOWN or the dimensions of pSrcRect are invalid
429 *
430 * NOTES
431 * pSrcRect specifies the dimensions of the source data;
432 * negative values for pSrcRect are allowed as we're only looking at the width and height anyway.
433 *
434 */
435 HRESULT WINAPI D3DXLoadSurfaceFromMemory(LPDIRECT3DSURFACE9 pDestSurface,
436 CONST PALETTEENTRY *pDestPalette,
437 CONST RECT *pDestRect,
438 LPCVOID pSrcMemory,
439 D3DFORMAT SrcFormat,
440 UINT SrcPitch,
441 CONST PALETTEENTRY *pSrcPalette,
442 CONST RECT *pSrcRect,
443 DWORD dwFilter,
444 D3DCOLOR Colorkey)
445 {
446 CONST PixelFormatDesc *srcformatdesc, *destformatdesc;
447 D3DSURFACE_DESC surfdesc;
448 D3DLOCKED_RECT lockrect;
449 POINT srcsize, destsize;
450 HRESULT hr;
451 TRACE("(void)\n");
452
453 if( !pDestSurface || !pSrcMemory || !pSrcRect ) return D3DERR_INVALIDCALL;
454 if(SrcFormat == D3DFMT_UNKNOWN || pSrcRect->left >= pSrcRect->right || pSrcRect->top >= pSrcRect->bottom) return E_FAIL;
455
456 if(dwFilter != D3DX_FILTER_NONE) return E_NOTIMPL;
457
458 IDirect3DSurface9_GetDesc(pDestSurface, &surfdesc);
459
460 srcformatdesc = get_format_info(SrcFormat);
461 destformatdesc = get_format_info(surfdesc.Format);
462 if( srcformatdesc->type == FORMAT_UNKNOWN || srcformatdesc->bytes_per_pixel > 4) return E_NOTIMPL;
463 if(destformatdesc->type == FORMAT_UNKNOWN || destformatdesc->bytes_per_pixel > 4) return E_NOTIMPL;
464
465 srcsize.x = pSrcRect->right - pSrcRect->left;
466 srcsize.y = pSrcRect->bottom - pSrcRect->top;
467 if( !pDestRect ) {
468 destsize.x = surfdesc.Width;
469 destsize.y = surfdesc.Height;
470 } else {
471 destsize.x = pDestRect->right - pDestRect->left;
472 destsize.y = pDestRect->bottom - pDestRect->top;
473 }
474
475 hr = IDirect3DSurface9_LockRect(pDestSurface, &lockrect, pDestRect, 0);
476 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
477
478 copy_simple_data((CONST BYTE*)pSrcMemory, SrcPitch, srcsize, srcformatdesc,
479 (CONST BYTE*)lockrect.pBits, lockrect.Pitch, destsize, destformatdesc,
480 dwFilter);
481
482 IDirect3DSurface9_UnlockRect(pDestSurface);
483 return D3D_OK;
484 }
485
486 /************************************************************
487 * D3DXLoadSurfaceFromSurface
488 *
489 * Copies the contents from one surface to another, performing any required
490 * format conversion, resizing or filtering.
491 *
492 * PARAMS
493 * pDestSurface [I] pointer to the destination surface
494 * pDestPalette [I] palette to use
495 * pDestRect [I] to be filled area of the surface
496 * pSrcSurface [I] pointer to the source surface
497 * pSrcPalette [I] palette used for the source surface
498 * pSrcRect [I] area of the source data to load
499 * dwFilter [I] filter to apply on resizing
500 * Colorkey [I] any ARGB value or 0 to disable color-keying
501 *
502 * RETURNS
503 * Success: D3D_OK
504 * Failure: D3DERR_INVALIDCALL, if pDestSurface or pSrcSurface are NULL
505 * D3DXERR_INVALIDDATA, if one of the surfaces is not lockable
506 *
507 */
508 HRESULT WINAPI D3DXLoadSurfaceFromSurface(LPDIRECT3DSURFACE9 pDestSurface,
509 CONST PALETTEENTRY *pDestPalette,
510 CONST RECT *pDestRect,
511 LPDIRECT3DSURFACE9 pSrcSurface,
512 CONST PALETTEENTRY *pSrcPalette,
513 CONST RECT *pSrcRect,
514 DWORD dwFilter,
515 D3DCOLOR Colorkey)
516 {
517 RECT rect;
518 D3DLOCKED_RECT lock;
519 D3DSURFACE_DESC SrcDesc;
520 HRESULT hr;
521 TRACE("(void): relay\n");
522
523 if( !pDestSurface || !pSrcSurface ) return D3DERR_INVALIDCALL;
524
525 IDirect3DSurface9_GetDesc(pSrcSurface, &SrcDesc);
526
527 if( !pSrcRect ) SetRect(&rect, 0, 0, SrcDesc.Width, SrcDesc.Height);
528 else rect = *pSrcRect;
529
530 hr = IDirect3DSurface9_LockRect(pSrcSurface, &lock, NULL, D3DLOCK_READONLY);
531 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
532
533 hr = D3DXLoadSurfaceFromMemory(pDestSurface, pDestPalette, pDestRect,
534 lock.pBits, SrcDesc.Format, lock.Pitch,
535 pSrcPalette, &rect, dwFilter, Colorkey);
536
537 IDirect3DSurface9_UnlockRect(pSrcSurface);
538 return hr;
539 }