wininet: Support the Cache-Control max-age directive for setting url cache entry...
[wine/testsucceed.git] / dlls / d3dx9_36 / surface.c
blob1bc2d54be6bb7cc529784c135223b7af7fa18a90
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;
62 static int warn_once;
64 if (!warn_once++)
65 FIXME("(%p, %d, %p): partially implemented\n", data, datasize, info);
67 /* TODO: Add support for (or at least detect) TGA, DDS, PPM and DIB */
69 if (!data || !datasize)
70 return D3DERR_INVALIDCALL;
72 if (!info)
73 return D3D_OK;
75 initresult = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
77 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, (void**)&factory);
79 if (SUCCEEDED(hr)) {
80 IWICImagingFactory_CreateStream(factory, &stream);
81 IWICStream_InitializeFromMemory(stream, (BYTE*)data, datasize);
82 hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream*)stream, NULL, 0, &decoder);
83 IStream_Release(stream);
84 IWICImagingFactory_Release(factory);
87 if (SUCCEEDED(hr)) {
88 GUID container_format;
89 UINT frame_count;
91 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &container_format);
92 if (SUCCEEDED(hr)) {
93 if (IsEqualGUID(&container_format, &GUID_ContainerFormatBmp)) {
94 TRACE("File type is BMP\n");
95 info->ImageFileFormat = D3DXIFF_BMP;
96 } else if (IsEqualGUID(&container_format, &GUID_ContainerFormatPng)) {
97 TRACE("File type is PNG\n");
98 info->ImageFileFormat = D3DXIFF_PNG;
99 } else if(IsEqualGUID(&container_format, &GUID_ContainerFormatJpeg)) {
100 TRACE("File type is JPG\n");
101 info->ImageFileFormat = D3DXIFF_JPG;
102 } else if(IsEqualGUID(&container_format, &GUID_WineContainerFormatTga)) {
103 TRACE("File type is TGA\n");
104 info->ImageFileFormat = D3DXIFF_TGA;
105 } else {
106 WARN("Unsupported image file format %s\n", debugstr_guid(&container_format));
107 hr = D3DXERR_INVALIDDATA;
111 if (SUCCEEDED(hr))
112 hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
113 if (SUCCEEDED(hr) && !frame_count)
114 hr = D3DXERR_INVALIDDATA;
116 if (SUCCEEDED(hr)) {
117 IWICBitmapFrameDecode *frame = NULL;
119 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
121 if (SUCCEEDED(hr))
122 hr = IWICBitmapFrameDecode_GetSize(frame, &info->Width, &info->Height);
124 if (SUCCEEDED(hr)) {
125 WICPixelFormatGUID pixel_format;
127 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &pixel_format);
128 if (SUCCEEDED(hr)) {
129 if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat1bppIndexed))
130 info->Format = D3DFMT_L8;
131 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat4bppIndexed))
132 info->Format = D3DFMT_L8;
133 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat8bppIndexed))
134 info->Format = D3DFMT_L8;
135 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat16bppBGR555))
136 info->Format = D3DFMT_X1R5G5B5;
137 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat24bppBGR))
138 info->Format = D3DFMT_R8G8B8;
139 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat32bppBGR))
140 info->Format = D3DFMT_X8R8G8B8;
141 else if (IsEqualGUID(&pixel_format, &GUID_WICPixelFormat32bppBGRA))
142 info->Format = D3DFMT_A8R8G8B8;
143 else {
144 WARN("Unsupported pixel format %s\n", debugstr_guid(&pixel_format));
145 hr = D3DXERR_INVALIDDATA;
150 if (frame)
151 IWICBitmapFrameDecode_Release(frame);
153 info->Depth = 1;
154 info->MipLevels = 1;
155 info->ResourceType = D3DRTYPE_TEXTURE;
159 if (decoder)
160 IWICBitmapDecoder_Release(decoder);
162 if (SUCCEEDED(initresult))
163 CoUninitialize();
165 if (FAILED(hr)) {
166 /* Missing formats are not detected yet and will fail silently without the FIXME */
167 FIXME("Invalid or unsupported image file\n");
168 return D3DXERR_INVALIDDATA;
171 return D3D_OK;
174 /************************************************************
175 * D3DXGetImageInfoFromFile
177 * RETURNS
178 * Success: D3D_OK, if we successfully load a valid image file or
179 * if we successfully load a file which is no valid image and info is NULL
180 * Failure: D3DXERR_INVALIDDATA, if we fail to load file or
181 * if file is not a valid image file and info is not NULL
182 * D3DERR_INVALIDCALL, if file is NULL
185 HRESULT WINAPI D3DXGetImageInfoFromFileA(LPCSTR file, D3DXIMAGE_INFO *info)
187 LPWSTR widename;
188 HRESULT hr;
189 int strlength;
191 TRACE("(%s, %p): relay\n", debugstr_a(file), info);
193 if( !file ) return D3DERR_INVALIDCALL;
195 strlength = MultiByteToWideChar(CP_ACP, 0, file, -1, NULL, 0);
196 widename = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, strlength * sizeof(WCHAR));
197 MultiByteToWideChar(CP_ACP, 0, file, -1, widename, strlength);
199 hr = D3DXGetImageInfoFromFileW(widename, info);
200 HeapFree(GetProcessHeap(), 0, widename);
202 return hr;
205 HRESULT WINAPI D3DXGetImageInfoFromFileW(LPCWSTR file, D3DXIMAGE_INFO *info)
207 HRESULT hr;
208 DWORD size;
209 LPVOID buffer;
211 TRACE("(%s, %p): relay\n", debugstr_w(file), info);
213 if( !file ) return D3DERR_INVALIDCALL;
215 hr = map_view_of_file(file, &buffer, &size);
216 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
218 hr = D3DXGetImageInfoFromFileInMemory(buffer, size, info);
219 UnmapViewOfFile(buffer);
221 return hr;
224 /************************************************************
225 * D3DXGetImageInfoFromResource
227 * RETURNS
228 * Success: D3D_OK, if resource is a valid image file
229 * Failure: D3DXERR_INVALIDDATA, if resource is no valid image file or NULL or
230 * if we fail to load resource
233 HRESULT WINAPI D3DXGetImageInfoFromResourceA(HMODULE module, LPCSTR resource, D3DXIMAGE_INFO *info)
235 HRSRC resinfo;
237 TRACE("(%p, %s, %p)\n", module, debugstr_a(resource), info);
239 resinfo = FindResourceA(module, resource, (LPCSTR)RT_RCDATA);
240 if(resinfo) {
241 LPVOID buffer;
242 HRESULT hr;
243 DWORD size;
245 hr = load_resource_into_memory(module, resinfo, &buffer, &size);
246 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
247 return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
250 resinfo = FindResourceA(module, resource, (LPCSTR)RT_BITMAP);
251 if(resinfo) {
252 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
253 return E_NOTIMPL;
255 return D3DXERR_INVALIDDATA;
258 HRESULT WINAPI D3DXGetImageInfoFromResourceW(HMODULE module, LPCWSTR resource, D3DXIMAGE_INFO *info)
260 HRSRC resinfo;
262 TRACE("(%p, %s, %p)\n", module, debugstr_w(resource), info);
264 resinfo = FindResourceW(module, resource, (LPCWSTR)RT_RCDATA);
265 if(resinfo) {
266 LPVOID buffer;
267 HRESULT hr;
268 DWORD size;
270 hr = load_resource_into_memory(module, resinfo, &buffer, &size);
271 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
272 return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
275 resinfo = FindResourceW(module, resource, (LPCWSTR)RT_BITMAP);
276 if(resinfo) {
277 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
278 return E_NOTIMPL;
280 return D3DXERR_INVALIDDATA;
283 /************************************************************
284 * D3DXLoadSurfaceFromFileInMemory
286 * Loads data from a given buffer into a surface and fills a given
287 * D3DXIMAGE_INFO structure with info about the source data.
289 * PARAMS
290 * pDestSurface [I] pointer to the surface
291 * pDestPalette [I] palette to use
292 * pDestRect [I] to be filled area of the surface
293 * pSrcData [I] pointer to the source data
294 * SrcDataSize [I] size of the source data in bytes
295 * pSrcRect [I] area of the source data to load
296 * dwFilter [I] filter to apply on stretching
297 * Colorkey [I] colorkey
298 * pSrcInfo [O] pointer to a D3DXIMAGE_INFO structure
300 * RETURNS
301 * Success: D3D_OK
302 * Failure: D3DERR_INVALIDCALL, if pDestSurface or pSrcData or SrcDataSize are NULL
303 * D3DXERR_INVALIDDATA, if pSrcData is no valid image file
306 HRESULT WINAPI D3DXLoadSurfaceFromFileInMemory(LPDIRECT3DSURFACE9 pDestSurface,
307 CONST PALETTEENTRY *pDestPalette,
308 CONST RECT *pDestRect,
309 LPCVOID pSrcData,
310 UINT SrcDataSize,
311 CONST RECT *pSrcRect,
312 DWORD dwFilter,
313 D3DCOLOR Colorkey,
314 D3DXIMAGE_INFO *pSrcInfo)
316 D3DXIMAGE_INFO imginfo;
317 HRESULT hr;
319 IWICImagingFactory *factory;
320 IWICBitmapDecoder *decoder;
321 IWICBitmapFrameDecode *bitmapframe;
322 IWICStream *stream;
324 const PixelFormatDesc *formatdesc;
325 WICRect wicrect;
326 RECT rect;
328 TRACE("(%p, %p, %p, %p, %d, %p, %d, %x, %p)\n", pDestSurface, pDestPalette, pDestRect, pSrcData,
329 SrcDataSize, pSrcRect, dwFilter, Colorkey, pSrcInfo);
331 if (!pDestSurface || !pSrcData | !SrcDataSize)
332 return D3DERR_INVALIDCALL;
334 hr = D3DXGetImageInfoFromFileInMemory(pSrcData, SrcDataSize, &imginfo);
336 if (FAILED(hr))
337 return hr;
339 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
341 if (FAILED(CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, (void**)&factory)))
342 goto cleanup_err;
344 if (FAILED(IWICImagingFactory_CreateStream(factory, &stream)))
346 IWICImagingFactory_Release(factory);
347 goto cleanup_err;
350 IWICStream_InitializeFromMemory(stream, (BYTE*)pSrcData, SrcDataSize);
352 hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream*)stream, NULL, 0, &decoder);
354 IStream_Release(stream);
355 IWICImagingFactory_Release(factory);
357 if (FAILED(hr))
358 goto cleanup_err;
360 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &bitmapframe);
362 if (FAILED(hr))
363 goto cleanup_bmp;
365 if (pSrcRect)
367 wicrect.X = pSrcRect->left;
368 wicrect.Y = pSrcRect->top;
369 wicrect.Width = pSrcRect->right - pSrcRect->left;
370 wicrect.Height = pSrcRect->bottom - pSrcRect->top;
372 else
374 wicrect.X = 0;
375 wicrect.Y = 0;
376 wicrect.Width = imginfo.Width;
377 wicrect.Height = imginfo.Height;
380 SetRect(&rect, 0, 0, wicrect.Width, wicrect.Height);
382 formatdesc = get_format_info(imginfo.Format);
384 if (formatdesc->format == D3DFMT_UNKNOWN)
386 FIXME("Unsupported pixel format\n");
387 hr = D3DXERR_INVALIDDATA;
389 else
391 BYTE *buffer;
392 DWORD pitch;
394 pitch = formatdesc->bytes_per_pixel * wicrect.Width;
395 buffer = HeapAlloc(GetProcessHeap(), 0, pitch * wicrect.Height);
397 hr = IWICBitmapFrameDecode_CopyPixels(bitmapframe, &wicrect, pitch,
398 pitch * wicrect.Height, buffer);
400 if (SUCCEEDED(hr))
402 hr = D3DXLoadSurfaceFromMemory(pDestSurface, pDestPalette, pDestRect,
403 buffer, imginfo.Format, pitch,
404 NULL, &rect, dwFilter, Colorkey);
407 HeapFree(GetProcessHeap(), 0, buffer);
410 IWICBitmapFrameDecode_Release(bitmapframe);
412 cleanup_bmp:
413 IWICBitmapDecoder_Release(decoder);
415 cleanup_err:
416 CoUninitialize();
418 if (FAILED(hr))
419 return D3DXERR_INVALIDDATA;
421 if (pSrcInfo)
422 *pSrcInfo = imginfo;
424 return D3D_OK;
427 /************************************************************
428 * D3DXLoadSurfaceFromFile
430 HRESULT WINAPI D3DXLoadSurfaceFromFileA(LPDIRECT3DSURFACE9 pDestSurface,
431 CONST PALETTEENTRY *pDestPalette,
432 CONST RECT *pDestRect,
433 LPCSTR pSrcFile,
434 CONST RECT *pSrcRect,
435 DWORD dwFilter,
436 D3DCOLOR Colorkey,
437 D3DXIMAGE_INFO *pSrcInfo)
439 LPWSTR pWidename;
440 HRESULT hr;
441 int strlength;
443 TRACE("(%p, %p, %p, %s, %p, %u, %#x, %p): relay\n", pDestSurface, pDestPalette, pDestRect, debugstr_a(pSrcFile),
444 pSrcRect, dwFilter, Colorkey, pSrcInfo);
446 if( !pSrcFile || !pDestSurface ) return D3DERR_INVALIDCALL;
448 strlength = MultiByteToWideChar(CP_ACP, 0, pSrcFile, -1, NULL, 0);
449 pWidename = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, strlength * sizeof(WCHAR));
450 MultiByteToWideChar(CP_ACP, 0, pSrcFile, -1, pWidename, strlength);
452 hr = D3DXLoadSurfaceFromFileW(pDestSurface, pDestPalette, pDestRect, pWidename, pSrcRect, dwFilter, Colorkey, pSrcInfo);
453 HeapFree(GetProcessHeap(), 0, pWidename);
455 return hr;
458 HRESULT WINAPI D3DXLoadSurfaceFromFileW(LPDIRECT3DSURFACE9 pDestSurface,
459 CONST PALETTEENTRY *pDestPalette,
460 CONST RECT *pDestRect,
461 LPCWSTR pSrcFile,
462 CONST RECT *pSrcRect,
463 DWORD Filter,
464 D3DCOLOR Colorkey,
465 D3DXIMAGE_INFO *pSrcInfo)
467 HRESULT hr;
468 DWORD dwSize;
469 LPVOID pBuffer;
471 TRACE("(%p, %p, %p, %s, %p, %u, %#x, %p): relay\n", pDestSurface, pDestPalette, pDestRect, debugstr_w(pSrcFile),
472 pSrcRect, Filter, Colorkey, pSrcInfo);
474 if( !pSrcFile || !pDestSurface ) return D3DERR_INVALIDCALL;
476 hr = map_view_of_file(pSrcFile, &pBuffer, &dwSize);
477 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
479 hr = D3DXLoadSurfaceFromFileInMemory(pDestSurface, pDestPalette, pDestRect, pBuffer, dwSize, pSrcRect, Filter, Colorkey, pSrcInfo);
480 UnmapViewOfFile(pBuffer);
482 return hr;
485 /************************************************************
486 * D3DXLoadSurfaceFromResource
488 HRESULT WINAPI D3DXLoadSurfaceFromResourceA(LPDIRECT3DSURFACE9 pDestSurface,
489 CONST PALETTEENTRY *pDestPalette,
490 CONST RECT *pDestRect,
491 HMODULE hSrcModule,
492 LPCSTR pResource,
493 CONST RECT *pSrcRect,
494 DWORD dwFilter,
495 D3DCOLOR Colorkey,
496 D3DXIMAGE_INFO *pSrcInfo)
498 HRSRC hResInfo;
500 TRACE("(%p, %p, %p, %p, %s, %p, %u, %#x, %p): relay\n", pDestSurface, pDestPalette, pDestRect, hSrcModule,
501 debugstr_a(pResource), pSrcRect, dwFilter, Colorkey, pSrcInfo);
503 if( !pDestSurface ) return D3DERR_INVALIDCALL;
505 hResInfo = FindResourceA(hSrcModule, pResource, (LPCSTR)RT_RCDATA);
506 if(hResInfo) {
507 LPVOID pBuffer;
508 HRESULT hr;
509 DWORD dwSize;
511 hr = load_resource_into_memory(hSrcModule, hResInfo, &pBuffer, &dwSize);
512 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
513 return D3DXLoadSurfaceFromFileInMemory(pDestSurface, pDestPalette, pDestRect, pBuffer, dwSize, pSrcRect, dwFilter, Colorkey, pSrcInfo);
516 hResInfo = FindResourceA(hSrcModule, pResource, (LPCSTR)RT_BITMAP);
517 if(hResInfo) {
518 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
519 return E_NOTIMPL;
521 return D3DXERR_INVALIDDATA;
524 HRESULT WINAPI D3DXLoadSurfaceFromResourceW(LPDIRECT3DSURFACE9 pDestSurface,
525 CONST PALETTEENTRY *pDestPalette,
526 CONST RECT *pDestRect,
527 HMODULE hSrcModule,
528 LPCWSTR pResource,
529 CONST RECT *pSrcRect,
530 DWORD dwFilter,
531 D3DCOLOR Colorkey,
532 D3DXIMAGE_INFO *pSrcInfo)
534 HRSRC hResInfo;
536 TRACE("(%p, %p, %p, %p, %s, %p, %u, %#x, %p): relay\n", pDestSurface, pDestPalette, pDestRect, hSrcModule,
537 debugstr_w(pResource), pSrcRect, dwFilter, Colorkey, pSrcInfo);
539 if( !pDestSurface ) return D3DERR_INVALIDCALL;
541 hResInfo = FindResourceW(hSrcModule, pResource, (LPCWSTR)RT_RCDATA);
542 if(hResInfo) {
543 LPVOID pBuffer;
544 HRESULT hr;
545 DWORD dwSize;
547 hr = load_resource_into_memory(hSrcModule, hResInfo, &pBuffer, &dwSize);
548 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
549 return D3DXLoadSurfaceFromFileInMemory(pDestSurface, pDestPalette, pDestRect, pBuffer, dwSize, pSrcRect, dwFilter, Colorkey, pSrcInfo);
552 hResInfo = FindResourceW(hSrcModule, pResource, (LPCWSTR)RT_BITMAP);
553 if(hResInfo) {
554 FIXME("Implement loading bitmaps from resource type RT_BITMAP\n");
555 return E_NOTIMPL;
557 return D3DXERR_INVALIDDATA;
561 /************************************************************
562 * helper functions for D3DXLoadSurfaceFromMemory
564 struct argb_conversion_info
566 CONST PixelFormatDesc *srcformat;
567 CONST PixelFormatDesc *destformat;
568 DWORD srcshift[4], destshift[4];
569 DWORD srcmask[4], destmask[4];
570 BOOL process_channel[4];
571 DWORD channelmask;
574 static void init_argb_conversion_info(CONST PixelFormatDesc *srcformat, CONST PixelFormatDesc *destformat, struct argb_conversion_info *info)
576 UINT i;
577 ZeroMemory(info->process_channel, 4 * sizeof(BOOL));
578 info->channelmask = 0;
580 info->srcformat = srcformat;
581 info->destformat = destformat;
583 for(i = 0;i < 4;i++) {
584 /* srcshift is used to extract the _relevant_ components */
585 info->srcshift[i] = srcformat->shift[i] + max( srcformat->bits[i] - destformat->bits[i], 0);
587 /* destshift is used to move the components to the correct position */
588 info->destshift[i] = destformat->shift[i] + max(destformat->bits[i] - srcformat->bits[i], 0);
590 info->srcmask[i] = ((1 << srcformat->bits[i]) - 1) << srcformat->shift[i];
591 info->destmask[i] = ((1 << destformat->bits[i]) - 1) << destformat->shift[i];
593 /* channelmask specifies bits which aren't used in the source format but in the destination one */
594 if(destformat->bits[i]) {
595 if(srcformat->bits[i]) info->process_channel[i] = TRUE;
596 else info->channelmask |= info->destmask[i];
601 static DWORD dword_from_bytes(CONST BYTE *src, UINT bytes_per_pixel)
603 DWORD ret = 0;
604 static BOOL fixme_once;
606 if(bytes_per_pixel > sizeof(DWORD)) {
607 if(!fixme_once++) FIXME("Unsupported image: %u bytes per pixel\n", bytes_per_pixel);
608 bytes_per_pixel = sizeof(DWORD);
611 memcpy(&ret, src, bytes_per_pixel);
612 return ret;
615 static void dword_to_bytes(BYTE *dst, DWORD dword, UINT bytes_per_pixel)
617 static BOOL fixme_once;
619 if(bytes_per_pixel > sizeof(DWORD)) {
620 if(!fixme_once++) FIXME("Unsupported image: %u bytes per pixel\n", bytes_per_pixel);
621 ZeroMemory(dst, bytes_per_pixel);
622 bytes_per_pixel = sizeof(DWORD);
625 memcpy(dst, &dword, bytes_per_pixel);
628 /************************************************************
629 * get_relevant_argb_components
631 * Extracts the relevant components from the source color and
632 * drops the less significant bits if they aren't used by the destination format.
634 static void get_relevant_argb_components(CONST struct argb_conversion_info *info, CONST DWORD col, DWORD *out)
636 UINT i = 0;
637 for(;i < 4;i++)
638 if(info->process_channel[i])
639 out[i] = (col & info->srcmask[i]) >> info->srcshift[i];
642 /************************************************************
643 * make_argb_color
645 * Recombines the output of get_relevant_argb_components and converts
646 * it to the destination format.
648 static DWORD make_argb_color(CONST struct argb_conversion_info *info, CONST DWORD *in)
650 UINT i;
651 DWORD val = 0;
653 for(i = 0;i < 4;i++) {
654 if(info->process_channel[i]) {
655 /* necessary to make sure that e.g. an X4R4G4B4 white maps to an R8G8B8 white instead of 0xf0f0f0 */
656 signed int shift;
657 for(shift = info->destshift[i]; shift > info->destformat->shift[i]; shift -= info->srcformat->bits[i]) val |= in[i] << shift;
658 val |= (in[i] >> (info->destformat->shift[i] - shift)) << info->destformat->shift[i];
661 val |= info->channelmask; /* new channels are set to their maximal value */
662 return val;
665 /************************************************************
666 * copy_simple_data
668 * Copies the source buffer to the destination buffer, performing
669 * any necessary format conversion and color keying.
670 * Pixels outsize the source rect are blacked out.
671 * Works only for ARGB formats with 1 - 4 bytes per pixel.
673 static void copy_simple_data(CONST BYTE *src, UINT srcpitch, POINT srcsize,
674 CONST PixelFormatDesc *srcformat,
675 BYTE *dest, UINT destpitch, POINT destsize,
676 CONST PixelFormatDesc *destformat,
677 D3DCOLOR colorkey)
679 struct argb_conversion_info conv_info, ck_conv_info;
680 DWORD channels[4], pixel;
681 UINT minwidth, minheight;
682 UINT x, y;
684 ZeroMemory(channels, sizeof(channels));
685 init_argb_conversion_info(srcformat, destformat, &conv_info);
687 minwidth = (srcsize.x < destsize.x) ? srcsize.x : destsize.x;
688 minheight = (srcsize.y < destsize.y) ? srcsize.y : destsize.y;
690 if(colorkey) {
691 /* color keys are always represented in D3DFMT_A8R8G8B8 format */
692 const PixelFormatDesc *ckformatdesc;
694 ckformatdesc = get_format_info(D3DFMT_A8R8G8B8);
695 init_argb_conversion_info(srcformat, ckformatdesc, &ck_conv_info);
698 for(y = 0;y < minheight;y++) {
699 const BYTE *srcptr = src + y * srcpitch;
700 BYTE *destptr = dest + y * destpitch;
701 DWORD val = 0;
703 for(x = 0;x < minwidth;x++) {
704 /* extract source color components */
705 if(srcformat->type == FORMAT_ARGB) {
706 pixel = dword_from_bytes(srcptr, srcformat->bytes_per_pixel);
707 get_relevant_argb_components(&conv_info, pixel, channels);
710 /* recombine the components */
711 if(destformat->type == FORMAT_ARGB) val = make_argb_color(&conv_info, channels);
713 if(colorkey) {
714 get_relevant_argb_components(&ck_conv_info, pixel, channels);
715 pixel = make_argb_color(&ck_conv_info, channels);
716 if(pixel == colorkey)
717 /* make this pixel transparent */
718 val &= ~conv_info.destmask[0];
721 dword_to_bytes(destptr, val, destformat->bytes_per_pixel);
722 srcptr += srcformat->bytes_per_pixel;
723 destptr += destformat->bytes_per_pixel;
726 if(srcsize.x < destsize.x) /* black out remaining pixels */
727 ZeroMemory(destptr, destformat->bytes_per_pixel * (destsize.x - srcsize.x));
729 if(srcsize.y < destsize.y) /* black out remaining pixels */
730 ZeroMemory(dest + srcsize.y * destpitch, destpitch * (destsize.y - srcsize.y));
733 /************************************************************
734 * point_filter_simple_data
736 * Copies the source buffer to the destination buffer, performing
737 * any necessary format conversion, color keying and stretching
738 * using a point filter.
739 * Works only for ARGB formats with 1 - 4 bytes per pixel.
741 static void point_filter_simple_data(CONST BYTE *src, UINT srcpitch, POINT srcsize,
742 CONST PixelFormatDesc *srcformat,
743 BYTE *dest, UINT destpitch, POINT destsize,
744 CONST PixelFormatDesc *destformat,
745 D3DCOLOR colorkey)
747 struct argb_conversion_info conv_info, ck_conv_info;
748 DWORD channels[4], pixel;
750 UINT x, y;
752 ZeroMemory(channels, sizeof(channels));
753 init_argb_conversion_info(srcformat, destformat, &conv_info);
755 if(colorkey) {
756 /* color keys are always represented in D3DFMT_A8R8G8B8 format */
757 const PixelFormatDesc *ckformatdesc;
759 ckformatdesc = get_format_info(D3DFMT_A8R8G8B8);
760 init_argb_conversion_info(srcformat, ckformatdesc, &ck_conv_info);
763 for(y = 0;y < destsize.y;y++) {
764 BYTE *destptr = dest + y * destpitch;
765 const BYTE *bufptr = src + srcpitch * (y * srcsize.y / destsize.y);
767 for(x = 0;x < destsize.x;x++) {
768 const BYTE *srcptr = bufptr + (x * srcsize.x / destsize.x) * srcformat->bytes_per_pixel;
769 DWORD val = 0;
771 /* extract source color components */
772 if(srcformat->type == FORMAT_ARGB) {
773 pixel = dword_from_bytes(srcptr, srcformat->bytes_per_pixel);
774 get_relevant_argb_components(&conv_info, pixel, channels);
777 /* recombine the components */
778 if(destformat->type == FORMAT_ARGB) val = make_argb_color(&conv_info, channels);
780 if(colorkey) {
781 get_relevant_argb_components(&ck_conv_info, pixel, channels);
782 pixel = make_argb_color(&ck_conv_info, channels);
783 if(pixel == colorkey)
784 /* make this pixel transparent */
785 val &= ~conv_info.destmask[0];
788 dword_to_bytes(destptr, val, destformat->bytes_per_pixel);
789 destptr += destformat->bytes_per_pixel;
794 /************************************************************
795 * D3DXLoadSurfaceFromMemory
797 * Loads data from a given memory chunk into a surface,
798 * applying any of the specified filters.
800 * PARAMS
801 * pDestSurface [I] pointer to the surface
802 * pDestPalette [I] palette to use
803 * pDestRect [I] to be filled area of the surface
804 * pSrcMemory [I] pointer to the source data
805 * SrcFormat [I] format of the source pixel data
806 * SrcPitch [I] number of bytes in a row
807 * pSrcPalette [I] palette used in the source image
808 * pSrcRect [I] area of the source data to load
809 * dwFilter [I] filter to apply on stretching
810 * Colorkey [I] colorkey
812 * RETURNS
813 * Success: D3D_OK, if we successfully load the pixel data into our surface or
814 * if pSrcMemory is NULL but the other parameters are valid
815 * Failure: D3DERR_INVALIDCALL, if pDestSurface, SrcPitch or pSrcRect are NULL or
816 * if SrcFormat is an invalid format (other than D3DFMT_UNKNOWN) or
817 * if DestRect is invalid
818 * D3DXERR_INVALIDDATA, if we fail to lock pDestSurface
819 * E_FAIL, if SrcFormat is D3DFMT_UNKNOWN or the dimensions of pSrcRect are invalid
821 * NOTES
822 * pSrcRect specifies the dimensions of the source data;
823 * negative values for pSrcRect are allowed as we're only looking at the width and height anyway.
826 HRESULT WINAPI D3DXLoadSurfaceFromMemory(LPDIRECT3DSURFACE9 pDestSurface,
827 CONST PALETTEENTRY *pDestPalette,
828 CONST RECT *pDestRect,
829 LPCVOID pSrcMemory,
830 D3DFORMAT SrcFormat,
831 UINT SrcPitch,
832 CONST PALETTEENTRY *pSrcPalette,
833 CONST RECT *pSrcRect,
834 DWORD dwFilter,
835 D3DCOLOR Colorkey)
837 CONST PixelFormatDesc *srcformatdesc, *destformatdesc;
838 D3DSURFACE_DESC surfdesc;
839 D3DLOCKED_RECT lockrect;
840 POINT srcsize, destsize;
841 HRESULT hr;
843 TRACE("(%p, %p, %p, %p, %x, %u, %p, %p %u, %#x)\n", pDestSurface, pDestPalette, pDestRect, pSrcMemory,
844 SrcFormat, SrcPitch, pSrcPalette, pSrcRect, dwFilter, Colorkey);
846 if( !pDestSurface || !pSrcMemory || !pSrcRect ) return D3DERR_INVALIDCALL;
847 if(SrcFormat == D3DFMT_UNKNOWN || pSrcRect->left >= pSrcRect->right || pSrcRect->top >= pSrcRect->bottom) return E_FAIL;
849 if(dwFilter == D3DX_DEFAULT) dwFilter = D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER;
851 IDirect3DSurface9_GetDesc(pDestSurface, &surfdesc);
853 srcformatdesc = get_format_info(SrcFormat);
854 destformatdesc = get_format_info(surfdesc.Format);
855 if( srcformatdesc->type == FORMAT_UNKNOWN || srcformatdesc->bytes_per_pixel > 4) return E_NOTIMPL;
856 if(destformatdesc->type == FORMAT_UNKNOWN || destformatdesc->bytes_per_pixel > 4) return E_NOTIMPL;
858 srcsize.x = pSrcRect->right - pSrcRect->left;
859 srcsize.y = pSrcRect->bottom - pSrcRect->top;
860 if( !pDestRect ) {
861 destsize.x = surfdesc.Width;
862 destsize.y = surfdesc.Height;
863 } else {
864 if(pDestRect->left > pDestRect->right || pDestRect->right > surfdesc.Width) return D3DERR_INVALIDCALL;
865 if(pDestRect->top > pDestRect->bottom || pDestRect->bottom > surfdesc.Height) return D3DERR_INVALIDCALL;
866 if(pDestRect->left < 0 || pDestRect->top < 0) return D3DERR_INVALIDCALL;
867 destsize.x = pDestRect->right - pDestRect->left;
868 destsize.y = pDestRect->bottom - pDestRect->top;
869 if(destsize.x == 0 || destsize.y == 0) return D3D_OK;
872 hr = IDirect3DSurface9_LockRect(pDestSurface, &lockrect, pDestRect, 0);
873 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
875 if((dwFilter & 0xF) == D3DX_FILTER_NONE) {
876 copy_simple_data(pSrcMemory, SrcPitch, srcsize, srcformatdesc,
877 lockrect.pBits, lockrect.Pitch, destsize, destformatdesc,
878 Colorkey);
879 } else /*if((dwFilter & 0xF) == D3DX_FILTER_POINT) */ {
880 /* always apply a point filter until D3DX_FILTER_LINEAR, D3DX_FILTER_TRIANGLE and D3DX_FILTER_BOX are implemented */
881 point_filter_simple_data(pSrcMemory, SrcPitch, srcsize, srcformatdesc,
882 lockrect.pBits, lockrect.Pitch, destsize, destformatdesc,
883 Colorkey);
886 IDirect3DSurface9_UnlockRect(pDestSurface);
887 return D3D_OK;
890 /************************************************************
891 * D3DXLoadSurfaceFromSurface
893 * Copies the contents from one surface to another, performing any required
894 * format conversion, resizing or filtering.
896 * PARAMS
897 * pDestSurface [I] pointer to the destination surface
898 * pDestPalette [I] palette to use
899 * pDestRect [I] to be filled area of the surface
900 * pSrcSurface [I] pointer to the source surface
901 * pSrcPalette [I] palette used for the source surface
902 * pSrcRect [I] area of the source data to load
903 * dwFilter [I] filter to apply on resizing
904 * Colorkey [I] any ARGB value or 0 to disable color-keying
906 * RETURNS
907 * Success: D3D_OK
908 * Failure: D3DERR_INVALIDCALL, if pDestSurface or pSrcSurface are NULL
909 * D3DXERR_INVALIDDATA, if one of the surfaces is not lockable
912 HRESULT WINAPI D3DXLoadSurfaceFromSurface(LPDIRECT3DSURFACE9 pDestSurface,
913 CONST PALETTEENTRY *pDestPalette,
914 CONST RECT *pDestRect,
915 LPDIRECT3DSURFACE9 pSrcSurface,
916 CONST PALETTEENTRY *pSrcPalette,
917 CONST RECT *pSrcRect,
918 DWORD dwFilter,
919 D3DCOLOR Colorkey)
921 RECT rect;
922 D3DLOCKED_RECT lock;
923 D3DSURFACE_DESC SrcDesc;
924 HRESULT hr;
926 TRACE("(%p, %p, %p, %p, %p, %p, %u, %#x): relay\n", pDestSurface, pDestPalette, pDestRect,
927 pSrcSurface, pSrcPalette, pSrcRect, dwFilter, Colorkey);
929 if( !pDestSurface || !pSrcSurface ) return D3DERR_INVALIDCALL;
931 IDirect3DSurface9_GetDesc(pSrcSurface, &SrcDesc);
933 if( !pSrcRect ) SetRect(&rect, 0, 0, SrcDesc.Width, SrcDesc.Height);
934 else rect = *pSrcRect;
936 hr = IDirect3DSurface9_LockRect(pSrcSurface, &lock, NULL, D3DLOCK_READONLY);
937 if(FAILED(hr)) return D3DXERR_INVALIDDATA;
939 hr = D3DXLoadSurfaceFromMemory(pDestSurface, pDestPalette, pDestRect,
940 lock.pBits, SrcDesc.Format, lock.Pitch,
941 pSrcPalette, &rect, dwFilter, Colorkey);
943 IDirect3DSurface9_UnlockRect(pSrcSurface);
944 return hr;