strmbase: Remove break after return (Smatch).
[wine/multimedia.git] / dlls / d3dx9_36 / surface.c
blobf436c533a0e7fdf40873532a4121105a3841e78a
1 /*
2 * Copyright (C) 2009-2010 Tony Wasserka
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.
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.
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
20 #include "wine/debug.h"
21 #include "wine/unicode.h"
22 #include "d3dx9_36_private.h"
24 #include "initguid.h"
25 #include "wincodec.h"
27 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
30 /* Wine-specific WIC GUIDs */
32 DEFINE_GUID(GUID_WineContainerFormatTga, 0x0c44fda1,0xa5c5,0x4298,0x96,0x85,0x47,0x3f,0xc1,0x7c,0xd3,0x22);
34 /************************************************************
35 * D3DXGetImageInfoFromFileInMemory
37 * Fills a D3DXIMAGE_INFO structure with info about an image
39 * PARAMS
40 * data [I] pointer to the image file data
41 * datasize [I] size of the passed data
42 * info [O] pointer to the destination structure
44 * RETURNS
45 * Success: D3D_OK, if info is not NULL and data and datasize make up a valid image file or
46 * if info is NULL and data and datasize are not NULL
47 * Failure: D3DXERR_INVALIDDATA, if data is no valid image file and datasize and info are not NULL
48 * D3DERR_INVALIDCALL, if data is NULL or
49 * if datasize is 0
51 * NOTES
52 * datasize may be bigger than the actual file size
55 HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(LPCVOID data, UINT datasize, D3DXIMAGE_INFO *info)
57 IWICImagingFactory *factory;
58 IWICBitmapDecoder *decoder = NULL;
59 IWICStream *stream;
60 HRESULT hr;
61 HRESULT initresult;
63 TRACE("(%p, %d, %p)\n", data, datasize, info);
65 if (!data || !datasize)
66 return D3DERR_INVALIDCALL;
68 if (!info)
69 return D3D_OK;
71 initresult = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
73 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, (void**)&factory);
75 if (SUCCEEDED(hr)) {
76 IWICImagingFactory_CreateStream(factory, &stream);
77 IWICStream_InitializeFromMemory(stream, (BYTE*)data, datasize);
78 hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream*)stream, NULL, 0, &decoder);
79 IStream_Release(stream);
80 IWICImagingFactory_Release(factory);
83 if (FAILED(hr)) {
84 if ((datasize >= 4) && !strncmp(data, "DDS ", 4))
85 FIXME("File type DDS is not supported yet\n");
86 else if ((datasize >= 2) && (!strncmp(data, "P3", 2) || !strncmp(data, "P6", 2)))
87 FIXME("File type PPM is not supported yet\n");
88 else if ((datasize >= 2) && !strncmp(data, "BM", 2))
89 FIXME("File type DIB is not supported yet\n");
90 else if ((datasize >= 10) && !strncmp(data, "#?RADIANCE", 10))
91 FIXME("File type HDR is not supported yet\n");
92 else if ((datasize >= 2) && (!strncmp(data, "PF", 2) || !strncmp(data, "Pf", 2)))
93 FIXME("File type PFM is not supported yet\n");
96 if (SUCCEEDED(hr)) {
97 GUID container_format;
98 UINT frame_count;
100 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &container_format);
101 if (SUCCEEDED(hr)) {
102 if (IsEqualGUID(&container_format, &GUID_ContainerFormatBmp)) {
103 TRACE("File type is BMP\n");
104 info->ImageFileFormat = D3DXIFF_BMP;
105 } else if (IsEqualGUID(&container_format, &GUID_ContainerFormatPng)) {
106 TRACE("File type is PNG\n");
107 info->ImageFileFormat = D3DXIFF_PNG;
108 } else if(IsEqualGUID(&container_format, &GUID_ContainerFormatJpeg)) {
109 TRACE("File type is JPG\n");
110 info->ImageFileFormat = D3DXIFF_JPG;
111 } else if(IsEqualGUID(&container_format, &GUID_WineContainerFormatTga)) {
112 TRACE("File type is TGA\n");
113 info->ImageFileFormat = D3DXIFF_TGA;
114 } else {
115 WARN("Unsupported image file format %s\n", debugstr_guid(&container_format));
116 hr = D3DXERR_INVALIDDATA;
120 if (SUCCEEDED(hr))
121 hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
122 if (SUCCEEDED(hr) && !frame_count)
123 hr = D3DXERR_INVALIDDATA;
125 if (SUCCEEDED(hr)) {
126 IWICBitmapFrameDecode *frame = NULL;
128 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
130 if (SUCCEEDED(hr))
131 hr = IWICBitmapFrameDecode_GetSize(frame, &info->Width, &info->Height);
133 if (SUCCEEDED(hr)) {
134 WICPixelFormatGUID pixel_format;
136 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &pixel_format);
137 if (SUCCEEDED(hr)) {
138 if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat1bppIndexed))
139 info->Format = D3DFMT_L8;
140 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat4bppIndexed))
141 info->Format = D3DFMT_L8;
142 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat8bppIndexed))
143 info->Format = D3DFMT_L8;
144 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat16bppBGR555))
145 info->Format = D3DFMT_X1R5G5B5;
146 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat24bppBGR))
147 info->Format = D3DFMT_R8G8B8;
148 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat32bppBGR))
149 info->Format = D3DFMT_X8R8G8B8;
150 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat32bppBGRA))
151 info->Format = D3DFMT_A8R8G8B8;
152 else {
153 WARN("Unsupported pixel format %s\n", debugstr_guid(&pixel_format));
154 hr = D3DXERR_INVALIDDATA;
159 if (frame)
160 IWICBitmapFrameDecode_Release(frame);
162 info->Depth = 1;
163 info->MipLevels = 1;
164 info->ResourceType = D3DRTYPE_TEXTURE;
168 if (decoder)
169 IWICBitmapDecoder_Release(decoder);
171 if (SUCCEEDED(initresult))
172 CoUninitialize();
174 if (FAILED(hr)) {
175 TRACE("Invalid or unsupported image file\n");
176 return D3DXERR_INVALIDDATA;
179 return D3D_OK;
182 /************************************************************
183 * D3DXGetImageInfoFromFile
185 * RETURNS
186 * Success: D3D_OK, if we successfully load a valid image file or
187 * if we successfully load a file which is no valid image and info is NULL
188 * Failure: D3DXERR_INVALIDDATA, if we fail to load file or
189 * if file is not a valid image file and info is not NULL
190 * D3DERR_INVALIDCALL, if file is NULL
193 HRESULT WINAPI D3DXGetImageInfoFromFileA(LPCSTR file, D3DXIMAGE_INFO *info)
195 LPWSTR widename;
196 HRESULT hr;
197 int strlength;
199 TRACE("(%s, %p): relay\n", debugstr_a(file), info);
201 if( !file ) return D3DERR_INVALIDCALL;
203 strlength = MultiByteToWideChar(CP_ACP, 0, file, -1, NULL, 0);
204 widename = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, strlength * sizeof(WCHAR));
205 MultiByteToWideChar(CP_ACP, 0, file, -1, widename, strlength);
207 hr = D3DXGetImageInfoFromFileW(widename, info);
208 HeapFree(GetProcessHeap(), 0, widename);
210 return hr;
213 HRESULT WINAPI D3DXGetImageInfoFromFileW(LPCWSTR file, D3DXIMAGE_INFO *info)
215 HRESULT hr;
216 DWORD size;
217 LPVOID buffer;
219 TRACE("(%s, %p): relay\n", debugstr_w(file), info);
221 if( !file ) return D3DERR_INVALIDCALL;
223 hr = map_view_of_file(file, &buffer, &size);
224 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
226 hr = D3DXGetImageInfoFromFileInMemory(buffer, size, info);
227 UnmapViewOfFile(buffer);
229 return hr;
232 /************************************************************
233 * D3DXGetImageInfoFromResource
235 * RETURNS
236 * Success: D3D_OK, if resource is a valid image file
237 * Failure: D3DXERR_INVALIDDATA, if resource is no valid image file or NULL or
238 * if we fail to load resource
241 HRESULT WINAPI D3DXGetImageInfoFromResourceA(HMODULE module, LPCSTR resource, D3DXIMAGE_INFO *info)
243 HRSRC resinfo;
245 TRACE("(%p, %s, %p)\n", module, debugstr_a(resource), info);
247 resinfo = FindResourceA(module, resource, (LPCSTR)RT_RCDATA);
248 if(resinfo) {
249 LPVOID buffer;
250 HRESULT hr;
251 DWORD size;
253 hr = load_resource_into_memory(module, resinfo, &buffer, &size);
254 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
255 return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
258 resinfo = FindResourceA(module, resource, (LPCSTR)RT_BITMAP);
259 if(resinfo) {
260 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
261 return E_NOTIMPL;
263 return D3DXERR_INVALIDDATA;
266 HRESULT WINAPI D3DXGetImageInfoFromResourceW(HMODULE module, LPCWSTR resource, D3DXIMAGE_INFO *info)
268 HRSRC resinfo;
270 TRACE("(%p, %s, %p)\n", module, debugstr_w(resource), info);
272 resinfo = FindResourceW(module, resource, (LPCWSTR)RT_RCDATA);
273 if(resinfo) {
274 LPVOID buffer;
275 HRESULT hr;
276 DWORD size;
278 hr = load_resource_into_memory(module, resinfo, &buffer, &size);
279 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
280 return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
283 resinfo = FindResourceW(module, resource, (LPCWSTR)RT_BITMAP);
284 if(resinfo) {
285 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
286 return E_NOTIMPL;
288 return D3DXERR_INVALIDDATA;
291 /************************************************************
292 * D3DXLoadSurfaceFromFileInMemory
294 * Loads data from a given buffer into a surface and fills a given
295 * D3DXIMAGE_INFO structure with info about the source data.
297 * PARAMS
298 * pDestSurface [I] pointer to the surface
299 * pDestPalette [I] palette to use
300 * pDestRect [I] to be filled area of the surface
301 * pSrcData [I] pointer to the source data
302 * SrcDataSize [I] size of the source data in bytes
303 * pSrcRect [I] area of the source data to load
304 * dwFilter [I] filter to apply on stretching
305 * Colorkey [I] colorkey
306 * pSrcInfo [O] pointer to a D3DXIMAGE_INFO structure
308 * RETURNS
309 * Success: D3D_OK
310 * Failure: D3DERR_INVALIDCALL, if pDestSurface or pSrcData or SrcDataSize are NULL
311 * D3DXERR_INVALIDDATA, if pSrcData is no valid image file
314 HRESULT WINAPI D3DXLoadSurfaceFromFileInMemory(LPDIRECT3DSURFACE9 pDestSurface,
315 CONST PALETTEENTRY *pDestPalette,
316 CONST RECT *pDestRect,
317 LPCVOID pSrcData,
318 UINT SrcDataSize,
319 CONST RECT *pSrcRect,
320 DWORD dwFilter,
321 D3DCOLOR Colorkey,
322 D3DXIMAGE_INFO *pSrcInfo)
324 D3DXIMAGE_INFO imginfo;
325 HRESULT hr;
327 IWICImagingFactory *factory;
328 IWICBitmapDecoder *decoder;
329 IWICBitmapFrameDecode *bitmapframe;
330 IWICStream *stream;
332 const PixelFormatDesc *formatdesc;
333 WICRect wicrect;
334 RECT rect;
336 TRACE("(%p, %p, %p, %p, %d, %p, %d, %x, %p)\n", pDestSurface, pDestPalette, pDestRect, pSrcData,
337 SrcDataSize, pSrcRect, dwFilter, Colorkey, pSrcInfo);
339 if (!pDestSurface || !pSrcData || !SrcDataSize)
340 return D3DERR_INVALIDCALL;
342 hr = D3DXGetImageInfoFromFileInMemory(pSrcData, SrcDataSize, &imginfo);
344 if (FAILED(hr))
345 return hr;
347 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
349 if (FAILED(CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, (void**)&factory)))
350 goto cleanup_err;
352 if (FAILED(IWICImagingFactory_CreateStream(factory, &stream)))
354 IWICImagingFactory_Release(factory);
355 goto cleanup_err;
358 IWICStream_InitializeFromMemory(stream, (BYTE*)pSrcData, SrcDataSize);
360 hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream*)stream, NULL, 0, &decoder);
362 IStream_Release(stream);
363 IWICImagingFactory_Release(factory);
365 if (FAILED(hr))
366 goto cleanup_err;
368 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &bitmapframe);
370 if (FAILED(hr))
371 goto cleanup_bmp;
373 if (pSrcRect)
375 wicrect.X = pSrcRect->left;
376 wicrect.Y = pSrcRect->top;
377 wicrect.Width = pSrcRect->right - pSrcRect->left;
378 wicrect.Height = pSrcRect->bottom - pSrcRect->top;
380 else
382 wicrect.X = 0;
383 wicrect.Y = 0;
384 wicrect.Width = imginfo.Width;
385 wicrect.Height = imginfo.Height;
388 SetRect(&rect, 0, 0, wicrect.Width, wicrect.Height);
390 formatdesc = get_format_info(imginfo.Format);
392 if (formatdesc->format == D3DFMT_UNKNOWN)
394 FIXME("Unsupported pixel format\n");
395 hr = D3DXERR_INVALIDDATA;
397 else
399 BYTE *buffer;
400 DWORD pitch;
402 pitch = formatdesc->bytes_per_pixel * wicrect.Width;
403 buffer = HeapAlloc(GetProcessHeap(), 0, pitch * wicrect.Height);
405 hr = IWICBitmapFrameDecode_CopyPixels(bitmapframe, &wicrect, pitch,
406 pitch * wicrect.Height, buffer);
408 if (SUCCEEDED(hr))
410 hr = D3DXLoadSurfaceFromMemory(pDestSurface, pDestPalette, pDestRect,
411 buffer, imginfo.Format, pitch,
412 NULL, &rect, dwFilter, Colorkey);
415 HeapFree(GetProcessHeap(), 0, buffer);
418 IWICBitmapFrameDecode_Release(bitmapframe);
420 cleanup_bmp:
421 IWICBitmapDecoder_Release(decoder);
423 cleanup_err:
424 CoUninitialize();
426 if (FAILED(hr))
427 return D3DXERR_INVALIDDATA;
429 if (pSrcInfo)
430 *pSrcInfo = imginfo;
432 return D3D_OK;
435 /************************************************************
436 * D3DXLoadSurfaceFromFile
438 HRESULT WINAPI D3DXLoadSurfaceFromFileA(LPDIRECT3DSURFACE9 pDestSurface,
439 CONST PALETTEENTRY *pDestPalette,
440 CONST RECT *pDestRect,
441 LPCSTR pSrcFile,
442 CONST RECT *pSrcRect,
443 DWORD dwFilter,
444 D3DCOLOR Colorkey,
445 D3DXIMAGE_INFO *pSrcInfo)
447 LPWSTR pWidename;
448 HRESULT hr;
449 int strlength;
451 TRACE("(%p, %p, %p, %s, %p, %u, %#x, %p): relay\n", pDestSurface, pDestPalette, pDestRect, debugstr_a(pSrcFile),
452 pSrcRect, dwFilter, Colorkey, pSrcInfo);
454 if( !pSrcFile || !pDestSurface ) return D3DERR_INVALIDCALL;
456 strlength = MultiByteToWideChar(CP_ACP, 0, pSrcFile, -1, NULL, 0);
457 pWidename = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, strlength * sizeof(WCHAR));
458 MultiByteToWideChar(CP_ACP, 0, pSrcFile, -1, pWidename, strlength);
460 hr = D3DXLoadSurfaceFromFileW(pDestSurface, pDestPalette, pDestRect, pWidename, pSrcRect, dwFilter, Colorkey, pSrcInfo);
461 HeapFree(GetProcessHeap(), 0, pWidename);
463 return hr;
466 HRESULT WINAPI D3DXLoadSurfaceFromFileW(LPDIRECT3DSURFACE9 pDestSurface,
467 CONST PALETTEENTRY *pDestPalette,
468 CONST RECT *pDestRect,
469 LPCWSTR pSrcFile,
470 CONST RECT *pSrcRect,
471 DWORD Filter,
472 D3DCOLOR Colorkey,
473 D3DXIMAGE_INFO *pSrcInfo)
475 HRESULT hr;
476 DWORD dwSize;
477 LPVOID pBuffer;
479 TRACE("(%p, %p, %p, %s, %p, %u, %#x, %p): relay\n", pDestSurface, pDestPalette, pDestRect, debugstr_w(pSrcFile),
480 pSrcRect, Filter, Colorkey, pSrcInfo);
482 if( !pSrcFile || !pDestSurface ) return D3DERR_INVALIDCALL;
484 hr = map_view_of_file(pSrcFile, &pBuffer, &dwSize);
485 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
487 hr = D3DXLoadSurfaceFromFileInMemory(pDestSurface, pDestPalette, pDestRect, pBuffer, dwSize, pSrcRect, Filter, Colorkey, pSrcInfo);
488 UnmapViewOfFile(pBuffer);
490 return hr;
493 /************************************************************
494 * D3DXLoadSurfaceFromResource
496 HRESULT WINAPI D3DXLoadSurfaceFromResourceA(LPDIRECT3DSURFACE9 pDestSurface,
497 CONST PALETTEENTRY *pDestPalette,
498 CONST RECT *pDestRect,
499 HMODULE hSrcModule,
500 LPCSTR pResource,
501 CONST RECT *pSrcRect,
502 DWORD dwFilter,
503 D3DCOLOR Colorkey,
504 D3DXIMAGE_INFO *pSrcInfo)
506 HRSRC hResInfo;
508 TRACE("(%p, %p, %p, %p, %s, %p, %u, %#x, %p): relay\n", pDestSurface, pDestPalette, pDestRect, hSrcModule,
509 debugstr_a(pResource), pSrcRect, dwFilter, Colorkey, pSrcInfo);
511 if( !pDestSurface ) return D3DERR_INVALIDCALL;
513 hResInfo = FindResourceA(hSrcModule, pResource, (LPCSTR)RT_RCDATA);
514 if(hResInfo) {
515 LPVOID pBuffer;
516 HRESULT hr;
517 DWORD dwSize;
519 hr = load_resource_into_memory(hSrcModule, hResInfo, &pBuffer, &dwSize);
520 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
521 return D3DXLoadSurfaceFromFileInMemory(pDestSurface, pDestPalette, pDestRect, pBuffer, dwSize, pSrcRect, dwFilter, Colorkey, pSrcInfo);
524 hResInfo = FindResourceA(hSrcModule, pResource, (LPCSTR)RT_BITMAP);
525 if(hResInfo) {
526 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
527 return E_NOTIMPL;
529 return D3DXERR_INVALIDDATA;
532 HRESULT WINAPI D3DXLoadSurfaceFromResourceW(LPDIRECT3DSURFACE9 pDestSurface,
533 CONST PALETTEENTRY *pDestPalette,
534 CONST RECT *pDestRect,
535 HMODULE hSrcModule,
536 LPCWSTR pResource,
537 CONST RECT *pSrcRect,
538 DWORD dwFilter,
539 D3DCOLOR Colorkey,
540 D3DXIMAGE_INFO *pSrcInfo)
542 HRSRC hResInfo;
544 TRACE("(%p, %p, %p, %p, %s, %p, %u, %#x, %p): relay\n", pDestSurface, pDestPalette, pDestRect, hSrcModule,
545 debugstr_w(pResource), pSrcRect, dwFilter, Colorkey, pSrcInfo);
547 if( !pDestSurface ) return D3DERR_INVALIDCALL;
549 hResInfo = FindResourceW(hSrcModule, pResource, (LPCWSTR)RT_RCDATA);
550 if(hResInfo) {
551 LPVOID pBuffer;
552 HRESULT hr;
553 DWORD dwSize;
555 hr = load_resource_into_memory(hSrcModule, hResInfo, &pBuffer, &dwSize);
556 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
557 return D3DXLoadSurfaceFromFileInMemory(pDestSurface, pDestPalette, pDestRect, pBuffer, dwSize, pSrcRect, dwFilter, Colorkey, pSrcInfo);
560 hResInfo = FindResourceW(hSrcModule, pResource, (LPCWSTR)RT_BITMAP);
561 if(hResInfo) {
562 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
563 return E_NOTIMPL;
565 return D3DXERR_INVALIDDATA;
569 /************************************************************
570 * helper functions for D3DXLoadSurfaceFromMemory
572 struct argb_conversion_info
574 CONST PixelFormatDesc *srcformat;
575 CONST PixelFormatDesc *destformat;
576 DWORD srcshift[4], destshift[4];
577 DWORD srcmask[4], destmask[4];
578 BOOL process_channel[4];
579 DWORD channelmask;
582 static void init_argb_conversion_info(CONST PixelFormatDesc *srcformat, CONST PixelFormatDesc *destformat, struct argb_conversion_info *info)
584 UINT i;
585 ZeroMemory(info->process_channel, 4 * sizeof(BOOL));
586 info->channelmask = 0;
588 info->srcformat = srcformat;
589 info->destformat = destformat;
591 for(i = 0;i < 4;i++) {
592 /* srcshift is used to extract the _relevant_ components */
593 info->srcshift[i] = srcformat->shift[i] + max( srcformat->bits[i] - destformat->bits[i], 0);
595 /* destshift is used to move the components to the correct position */
596 info->destshift[i] = destformat->shift[i] + max(destformat->bits[i] - srcformat->bits[i], 0);
598 info->srcmask[i] = ((1 << srcformat->bits[i]) - 1) << srcformat->shift[i];
599 info->destmask[i] = ((1 << destformat->bits[i]) - 1) << destformat->shift[i];
601 /* channelmask specifies bits which aren't used in the source format but in the destination one */
602 if(destformat->bits[i]) {
603 if(srcformat->bits[i]) info->process_channel[i] = TRUE;
604 else info->channelmask |= info->destmask[i];
609 static DWORD dword_from_bytes(CONST BYTE *src, UINT bytes_per_pixel)
611 DWORD ret = 0;
612 static BOOL fixme_once;
614 if(bytes_per_pixel > sizeof(DWORD)) {
615 if(!fixme_once++) FIXME("Unsupported image: %u bytes per pixel\n", bytes_per_pixel);
616 bytes_per_pixel = sizeof(DWORD);
619 memcpy(&ret, src, bytes_per_pixel);
620 return ret;
623 static void dword_to_bytes(BYTE *dst, DWORD dword, UINT bytes_per_pixel)
625 static BOOL fixme_once;
627 if(bytes_per_pixel > sizeof(DWORD)) {
628 if(!fixme_once++) FIXME("Unsupported image: %u bytes per pixel\n", bytes_per_pixel);
629 ZeroMemory(dst, bytes_per_pixel);
630 bytes_per_pixel = sizeof(DWORD);
633 memcpy(dst, &dword, bytes_per_pixel);
636 /************************************************************
637 * get_relevant_argb_components
639 * Extracts the relevant components from the source color and
640 * drops the less significant bits if they aren't used by the destination format.
642 static void get_relevant_argb_components(CONST struct argb_conversion_info *info, CONST DWORD col, DWORD *out)
644 UINT i = 0;
645 for(;i < 4;i++)
646 if(info->process_channel[i])
647 out[i] = (col & info->srcmask[i]) >> info->srcshift[i];
650 /************************************************************
651 * make_argb_color
653 * Recombines the output of get_relevant_argb_components and converts
654 * it to the destination format.
656 static DWORD make_argb_color(CONST struct argb_conversion_info *info, CONST DWORD *in)
658 UINT i;
659 DWORD val = 0;
661 for(i = 0;i < 4;i++) {
662 if(info->process_channel[i]) {
663 /* necessary to make sure that e.g. an X4R4G4B4 white maps to an R8G8B8 white instead of 0xf0f0f0 */
664 signed int shift;
665 for(shift = info->destshift[i]; shift > info->destformat->shift[i]; shift -= info->srcformat->bits[i]) val |= in[i] << shift;
666 val |= (in[i] >> (info->destformat->shift[i] - shift)) << info->destformat->shift[i];
669 val |= info->channelmask; /* new channels are set to their maximal value */
670 return val;
673 static void format_to_vec4(const PixelFormatDesc *format, const DWORD *src, struct vec4 *dst)
675 DWORD mask;
677 if (format->bits[1])
679 mask = (1 << format->bits[1]) - 1;
680 dst->x = (float)((*src >> format->shift[1]) & mask) / mask;
682 else
683 dst->x = 1.0f;
685 if (format->bits[2])
687 mask = (1 << format->bits[2]) - 1;
688 dst->y = (float)((*src >> format->shift[2]) & mask) / mask;
690 else
691 dst->y = 1.0f;
693 if (format->bits[3])
695 mask = (1 << format->bits[3]) - 1;
696 dst->z = (float)((*src >> format->shift[3]) & mask) / mask;
698 else
699 dst->z = 1.0f;
701 if (format->bits[0])
703 mask = (1 << format->bits[0]) - 1;
704 dst->w = (float)((*src >> format->shift[0]) & mask) / mask;
706 else
707 dst->w = 1.0f;
710 static void format_from_vec4(const PixelFormatDesc *format, const struct vec4 *src, DWORD *dst)
712 *dst = 0;
714 if (format->bits[1])
715 *dst |= (DWORD)(src->x * ((1 << format->bits[1]) - 1) + 0.5f) << format->shift[1];
716 if (format->bits[2])
717 *dst |= (DWORD)(src->y * ((1 << format->bits[2]) - 1) + 0.5f) << format->shift[2];
718 if (format->bits[3])
719 *dst |= (DWORD)(src->z * ((1 << format->bits[3]) - 1) + 0.5f) << format->shift[3];
720 if (format->bits[0])
721 *dst |= (DWORD)(src->w * ((1 << format->bits[0]) - 1) + 0.5f) << format->shift[0];
724 /************************************************************
725 * copy_simple_data
727 * Copies the source buffer to the destination buffer, performing
728 * any necessary format conversion and color keying.
729 * Pixels outsize the source rect are blacked out.
730 * Works only for ARGB formats with 1 - 4 bytes per pixel.
732 static void copy_simple_data(CONST BYTE *src, UINT srcpitch, POINT srcsize,
733 CONST PixelFormatDesc *srcformat,
734 BYTE *dest, UINT destpitch, POINT destsize,
735 CONST PixelFormatDesc *destformat,
736 D3DCOLOR colorkey)
738 struct argb_conversion_info conv_info, ck_conv_info;
739 const PixelFormatDesc *ck_format = NULL;
740 DWORD channels[4], pixel;
741 UINT minwidth, minheight;
742 UINT x, y;
744 ZeroMemory(channels, sizeof(channels));
745 init_argb_conversion_info(srcformat, destformat, &conv_info);
747 minwidth = (srcsize.x < destsize.x) ? srcsize.x : destsize.x;
748 minheight = (srcsize.y < destsize.y) ? srcsize.y : destsize.y;
750 if (colorkey)
752 /* Color keys are always represented in D3DFMT_A8R8G8B8 format. */
753 ck_format = get_format_info(D3DFMT_A8R8G8B8);
754 init_argb_conversion_info(srcformat, ck_format, &ck_conv_info);
757 for(y = 0;y < minheight;y++) {
758 const BYTE *srcptr = src + y * srcpitch;
759 BYTE *destptr = dest + y * destpitch;
760 DWORD val;
762 for(x = 0;x < minwidth;x++) {
763 /* extract source color components */
764 pixel = dword_from_bytes(srcptr, srcformat->bytes_per_pixel);
766 if (!srcformat->to_rgba && !destformat->from_rgba)
768 get_relevant_argb_components(&conv_info, pixel, channels);
769 val = make_argb_color(&conv_info, channels);
771 if (colorkey)
773 get_relevant_argb_components(&ck_conv_info, pixel, channels);
774 pixel = make_argb_color(&ck_conv_info, channels);
775 if (pixel == colorkey)
776 val &= ~conv_info.destmask[0];
779 else
781 struct vec4 color, tmp;
783 format_to_vec4(srcformat, &pixel, &color);
784 if (srcformat->to_rgba)
785 srcformat->to_rgba(&color, &tmp);
786 else
787 tmp = color;
789 if (ck_format)
791 format_from_vec4(ck_format, &tmp, &pixel);
792 if (pixel == colorkey)
793 tmp.w = 0.0f;
796 if (destformat->from_rgba)
797 destformat->from_rgba(&tmp, &color);
798 else
799 color = tmp;
801 format_from_vec4(destformat, &color, &val);
804 dword_to_bytes(destptr, val, destformat->bytes_per_pixel);
805 srcptr += srcformat->bytes_per_pixel;
806 destptr += destformat->bytes_per_pixel;
809 if(srcsize.x < destsize.x) /* black out remaining pixels */
810 ZeroMemory(destptr, destformat->bytes_per_pixel * (destsize.x - srcsize.x));
812 if(srcsize.y < destsize.y) /* black out remaining pixels */
813 ZeroMemory(dest + srcsize.y * destpitch, destpitch * (destsize.y - srcsize.y));
816 /************************************************************
817 * point_filter_simple_data
819 * Copies the source buffer to the destination buffer, performing
820 * any necessary format conversion, color keying and stretching
821 * using a point filter.
822 * Works only for ARGB formats with 1 - 4 bytes per pixel.
824 static void point_filter_simple_data(CONST BYTE *src, UINT srcpitch, POINT srcsize,
825 CONST PixelFormatDesc *srcformat,
826 BYTE *dest, UINT destpitch, POINT destsize,
827 CONST PixelFormatDesc *destformat,
828 D3DCOLOR colorkey)
830 struct argb_conversion_info conv_info, ck_conv_info;
831 const PixelFormatDesc *ck_format = NULL;
832 DWORD channels[4], pixel;
834 UINT x, y;
836 ZeroMemory(channels, sizeof(channels));
837 init_argb_conversion_info(srcformat, destformat, &conv_info);
839 if (colorkey)
841 /* Color keys are always represented in D3DFMT_A8R8G8B8 format. */
842 ck_format = get_format_info(D3DFMT_A8R8G8B8);
843 init_argb_conversion_info(srcformat, ck_format, &ck_conv_info);
846 for(y = 0;y < destsize.y;y++) {
847 BYTE *destptr = dest + y * destpitch;
848 const BYTE *bufptr = src + srcpitch * (y * srcsize.y / destsize.y);
850 for(x = 0;x < destsize.x;x++) {
851 const BYTE *srcptr = bufptr + (x * srcsize.x / destsize.x) * srcformat->bytes_per_pixel;
852 DWORD val;
854 /* extract source color components */
855 pixel = dword_from_bytes(srcptr, srcformat->bytes_per_pixel);
857 if (!srcformat->to_rgba && !destformat->from_rgba)
859 get_relevant_argb_components(&conv_info, pixel, channels);
860 val = make_argb_color(&conv_info, channels);
862 if (colorkey)
864 get_relevant_argb_components(&ck_conv_info, pixel, channels);
865 pixel = make_argb_color(&ck_conv_info, channels);
866 if (pixel == colorkey)
867 val &= ~conv_info.destmask[0];
870 else
872 struct vec4 color, tmp;
874 format_to_vec4(srcformat, &pixel, &color);
875 if (srcformat->to_rgba)
876 srcformat->to_rgba(&color, &tmp);
877 else
878 tmp = color;
880 if (ck_format)
882 format_from_vec4(ck_format, &tmp, &pixel);
883 if (pixel == colorkey)
884 tmp.w = 0.0f;
887 if (destformat->from_rgba)
888 destformat->from_rgba(&tmp, &color);
889 else
890 color = tmp;
892 format_from_vec4(destformat, &color, &val);
895 dword_to_bytes(destptr, val, destformat->bytes_per_pixel);
896 destptr += destformat->bytes_per_pixel;
901 /************************************************************
902 * D3DXLoadSurfaceFromMemory
904 * Loads data from a given memory chunk into a surface,
905 * applying any of the specified filters.
907 * PARAMS
908 * pDestSurface [I] pointer to the surface
909 * pDestPalette [I] palette to use
910 * pDestRect [I] to be filled area of the surface
911 * pSrcMemory [I] pointer to the source data
912 * SrcFormat [I] format of the source pixel data
913 * SrcPitch [I] number of bytes in a row
914 * pSrcPalette [I] palette used in the source image
915 * pSrcRect [I] area of the source data to load
916 * dwFilter [I] filter to apply on stretching
917 * Colorkey [I] colorkey
919 * RETURNS
920 * Success: D3D_OK, if we successfully load the pixel data into our surface or
921 * if pSrcMemory is NULL but the other parameters are valid
922 * Failure: D3DERR_INVALIDCALL, if pDestSurface, SrcPitch or pSrcRect are NULL or
923 * if SrcFormat is an invalid format (other than D3DFMT_UNKNOWN) or
924 * if DestRect is invalid
925 * D3DXERR_INVALIDDATA, if we fail to lock pDestSurface
926 * E_FAIL, if SrcFormat is D3DFMT_UNKNOWN or the dimensions of pSrcRect are invalid
928 * NOTES
929 * pSrcRect specifies the dimensions of the source data;
930 * negative values for pSrcRect are allowed as we're only looking at the width and height anyway.
933 HRESULT WINAPI D3DXLoadSurfaceFromMemory(LPDIRECT3DSURFACE9 pDestSurface,
934 CONST PALETTEENTRY *pDestPalette,
935 CONST RECT *pDestRect,
936 LPCVOID pSrcMemory,
937 D3DFORMAT SrcFormat,
938 UINT SrcPitch,
939 CONST PALETTEENTRY *pSrcPalette,
940 CONST RECT *pSrcRect,
941 DWORD dwFilter,
942 D3DCOLOR Colorkey)
944 CONST PixelFormatDesc *srcformatdesc, *destformatdesc;
945 D3DSURFACE_DESC surfdesc;
946 D3DLOCKED_RECT lockrect;
947 POINT srcsize, destsize;
948 HRESULT hr;
950 TRACE("(%p, %p, %p, %p, %x, %u, %p, %p %u, %#x)\n", pDestSurface, pDestPalette, pDestRect, pSrcMemory,
951 SrcFormat, SrcPitch, pSrcPalette, pSrcRect, dwFilter, Colorkey);
953 if( !pDestSurface || !pSrcMemory || !pSrcRect ) return D3DERR_INVALIDCALL;
954 if(SrcFormat == D3DFMT_UNKNOWN || pSrcRect->left >= pSrcRect->right || pSrcRect->top >= pSrcRect->bottom) return E_FAIL;
956 if(dwFilter == D3DX_DEFAULT) dwFilter = D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER;
958 IDirect3DSurface9_GetDesc(pDestSurface, &surfdesc);
960 srcformatdesc = get_format_info(SrcFormat);
961 destformatdesc = get_format_info(surfdesc.Format);
962 if( srcformatdesc->type == FORMAT_UNKNOWN || srcformatdesc->bytes_per_pixel > 4) return E_NOTIMPL;
963 if(destformatdesc->type == FORMAT_UNKNOWN || destformatdesc->bytes_per_pixel > 4) return E_NOTIMPL;
965 srcsize.x = pSrcRect->right - pSrcRect->left;
966 srcsize.y = pSrcRect->bottom - pSrcRect->top;
967 if( !pDestRect ) {
968 destsize.x = surfdesc.Width;
969 destsize.y = surfdesc.Height;
970 } else {
971 if(pDestRect->left > pDestRect->right || pDestRect->right > surfdesc.Width) return D3DERR_INVALIDCALL;
972 if(pDestRect->top > pDestRect->bottom || pDestRect->bottom > surfdesc.Height) return D3DERR_INVALIDCALL;
973 if(pDestRect->left < 0 || pDestRect->top < 0) return D3DERR_INVALIDCALL;
974 destsize.x = pDestRect->right - pDestRect->left;
975 destsize.y = pDestRect->bottom - pDestRect->top;
976 if(destsize.x == 0 || destsize.y == 0) return D3D_OK;
979 hr = IDirect3DSurface9_LockRect(pDestSurface, &lockrect, pDestRect, 0);
980 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
982 if((dwFilter & 0xF) == D3DX_FILTER_NONE) {
983 copy_simple_data(pSrcMemory, SrcPitch, srcsize, srcformatdesc,
984 lockrect.pBits, lockrect.Pitch, destsize, destformatdesc,
985 Colorkey);
986 } else /*if((dwFilter & 0xF) == D3DX_FILTER_POINT) */ {
987 /* always apply a point filter until D3DX_FILTER_LINEAR, D3DX_FILTER_TRIANGLE and D3DX_FILTER_BOX are implemented */
988 point_filter_simple_data(pSrcMemory, SrcPitch, srcsize, srcformatdesc,
989 lockrect.pBits, lockrect.Pitch, destsize, destformatdesc,
990 Colorkey);
993 IDirect3DSurface9_UnlockRect(pDestSurface);
994 return D3D_OK;
997 /************************************************************
998 * D3DXLoadSurfaceFromSurface
1000 * Copies the contents from one surface to another, performing any required
1001 * format conversion, resizing or filtering.
1003 * PARAMS
1004 * pDestSurface [I] pointer to the destination surface
1005 * pDestPalette [I] palette to use
1006 * pDestRect [I] to be filled area of the surface
1007 * pSrcSurface [I] pointer to the source surface
1008 * pSrcPalette [I] palette used for the source surface
1009 * pSrcRect [I] area of the source data to load
1010 * dwFilter [I] filter to apply on resizing
1011 * Colorkey [I] any ARGB value or 0 to disable color-keying
1013 * RETURNS
1014 * Success: D3D_OK
1015 * Failure: D3DERR_INVALIDCALL, if pDestSurface or pSrcSurface are NULL
1016 * D3DXERR_INVALIDDATA, if one of the surfaces is not lockable
1019 HRESULT WINAPI D3DXLoadSurfaceFromSurface(LPDIRECT3DSURFACE9 pDestSurface,
1020 CONST PALETTEENTRY *pDestPalette,
1021 CONST RECT *pDestRect,
1022 LPDIRECT3DSURFACE9 pSrcSurface,
1023 CONST PALETTEENTRY *pSrcPalette,
1024 CONST RECT *pSrcRect,
1025 DWORD dwFilter,
1026 D3DCOLOR Colorkey)
1028 RECT rect;
1029 D3DLOCKED_RECT lock;
1030 D3DSURFACE_DESC SrcDesc;
1031 HRESULT hr;
1033 TRACE("(%p, %p, %p, %p, %p, %p, %u, %#x): relay\n", pDestSurface, pDestPalette, pDestRect,
1034 pSrcSurface, pSrcPalette, pSrcRect, dwFilter, Colorkey);
1036 if( !pDestSurface || !pSrcSurface ) return D3DERR_INVALIDCALL;
1038 IDirect3DSurface9_GetDesc(pSrcSurface, &SrcDesc);
1040 if( !pSrcRect ) SetRect(&rect, 0, 0, SrcDesc.Width, SrcDesc.Height);
1041 else rect = *pSrcRect;
1043 hr = IDirect3DSurface9_LockRect(pSrcSurface, &lock, NULL, D3DLOCK_READONLY);
1044 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
1046 hr = D3DXLoadSurfaceFromMemory(pDestSurface, pDestPalette, pDestRect,
1047 lock.pBits, SrcDesc.Format, lock.Pitch,
1048 pSrcPalette, &rect, dwFilter, Colorkey);
1050 IDirect3DSurface9_UnlockRect(pSrcSurface);
1051 return hr;
1055 HRESULT WINAPI D3DXSaveSurfaceToFileA(LPCSTR pDestFile, D3DXIMAGE_FILEFORMAT DestFormat,
1056 LPDIRECT3DSURFACE9 pSrcSurface, const PALETTEENTRY* pSrcPalette, const RECT* pSrcRect)
1058 FIXME("(%p, %d, %p, %p, %p): stub\n", pDestFile, DestFormat, pSrcSurface, pSrcPalette, pSrcRect);
1059 return D3DERR_INVALIDCALL;
1062 HRESULT WINAPI D3DXSaveSurfaceToFileW(LPCWSTR pDestFile, D3DXIMAGE_FILEFORMAT DestFormat,
1063 LPDIRECT3DSURFACE9 pSrcSurface, const PALETTEENTRY* pSrcPalette, const RECT* pSrcRect)
1065 FIXME("(%p, %d, %p, %p, %p): stub\n", pDestFile, DestFormat, pSrcSurface, pSrcPalette, pSrcRect);
1066 return D3DERR_INVALIDCALL;