/*
* Copyright (C) 2009-2010 Tony Wasserka
- * Copyright (C) 2012 Jأ³zef Kucia
+ * Copyright (C) 2012 Józef Kucia
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
MAKEFOURCC('D','X','T','2'),
MAKEFOURCC('D','X','T','3'),
MAKEFOURCC('D','X','T','4'),
- MAKEFOURCC('D','X','T','5')
+ MAKEFOURCC('D','X','T','5'),
+ D3DFMT_R16F,
+ D3DFMT_G16R16F,
+ D3DFMT_A16B16G16R16F,
+ D3DFMT_R32F,
+ D3DFMT_G32R32F,
+ D3DFMT_A32B32G32R32F,
};
for (i = 0; i < sizeof(known_fourcc) / sizeof(known_fourcc[0]); i++)
static D3DFORMAT dds_pixel_format_to_d3dformat(const struct dds_pixel_format *pixel_format)
{
+ TRACE("pixel_format: size %u, flags %#x, fourcc %#x, bpp %u.\n", pixel_format->size,
+ pixel_format->flags, pixel_format->fourcc, pixel_format->bpp);
+ TRACE("rmask %#x, gmask %#x, bmask %#x, amask %#x.\n", pixel_format->rmask, pixel_format->gmask,
+ pixel_format->bmask, pixel_format->amask);
+
if (pixel_format->flags & DDS_PF_FOURCC)
return dds_fourcc_to_d3dformat(pixel_format->fourcc);
if (pixel_format->flags & DDS_PF_RGB)
}
HRESULT load_texture_from_dds(IDirect3DTexture9 *texture, const void *src_data, const PALETTEENTRY *palette,
- DWORD filter, D3DCOLOR color_key, const D3DXIMAGE_INFO *src_info)
-
+ DWORD filter, D3DCOLOR color_key, const D3DXIMAGE_INFO *src_info, unsigned int skip_levels,
+ unsigned int *loaded_miplevels)
{
HRESULT hr;
RECT src_rect;
const struct dds_header *header = src_data;
const BYTE *pixels = (BYTE *)(header + 1);
- /* Loading a cube texture as a simple texture is also supported (only first face texture is taken) */
- if ((src_info->ResourceType != D3DRTYPE_TEXTURE) && (src_info->ResourceType != D3DRTYPE_CUBETEXTURE))
+ /* Loading a cube texture as a simple texture is also supported
+ * (only first face texture is taken). Same with volume textures. */
+ if ((src_info->ResourceType != D3DRTYPE_TEXTURE)
+ && (src_info->ResourceType != D3DRTYPE_CUBETEXTURE)
+ && (src_info->ResourceType != D3DRTYPE_VOLUMETEXTURE))
+ {
+ WARN("Trying to load a %u resource as a 2D texture, returning failure.\n", src_info->ResourceType);
return D3DXERR_INVALIDDATA;
+ }
width = src_info->Width;
height = src_info->Height;
mip_levels = min(src_info->MipLevels, IDirect3DTexture9_GetLevelCount(texture));
- for (mip_level = 0; mip_level < mip_levels; mip_level++)
+ if (src_info->ResourceType == D3DRTYPE_VOLUMETEXTURE)
+ mip_levels = 1;
+ for (mip_level = 0; mip_level < mip_levels + skip_levels; ++mip_level)
{
hr = calculate_dds_surface_size(src_info->Format, width, height, &src_pitch, &mip_level_size);
if (FAILED(hr)) return hr;
- SetRect(&src_rect, 0, 0, width, height);
+ if (mip_level >= skip_levels)
+ {
+ SetRect(&src_rect, 0, 0, width, height);
- IDirect3DTexture9_GetSurfaceLevel(texture, mip_level, &surface);
- hr = D3DXLoadSurfaceFromMemory(surface, palette, NULL, pixels, src_info->Format, src_pitch,
- NULL, &src_rect, filter, color_key);
- IDirect3DSurface9_Release(surface);
- if (FAILED(hr)) return hr;
+ IDirect3DTexture9_GetSurfaceLevel(texture, mip_level - skip_levels, &surface);
+ hr = D3DXLoadSurfaceFromMemory(surface, palette, NULL, pixels, src_info->Format, src_pitch,
+ NULL, &src_rect, filter, color_key);
+ IDirect3DSurface9_Release(surface);
+ if (FAILED(hr))
+ return hr;
+ }
pixels += mip_level_size;
width = max(1, width / 2);
height = max(1, height / 2);
}
+ *loaded_miplevels = mip_levels - skip_levels;
+
return D3D_OK;
}
* D3DERR_INVALIDCALL, if file is NULL
*
*/
-HRESULT WINAPI D3DXGetImageInfoFromFileA(LPCSTR file, D3DXIMAGE_INFO *info)
+HRESULT WINAPI D3DXGetImageInfoFromFileA(const char *file, D3DXIMAGE_INFO *info)
{
- LPWSTR widename;
+ WCHAR *widename;
HRESULT hr;
int strlength;
- TRACE("(%s, %p): relay\n", debugstr_a(file), info);
+ TRACE("file %s, info %p.\n", debugstr_a(file), info);
if( !file ) return D3DERR_INVALIDCALL;
const RECT *pSrcRect, DWORD dwFilter, D3DCOLOR Colorkey, D3DXIMAGE_INFO *pSrcInfo)
{
D3DXIMAGE_INFO imginfo;
- HRESULT hr;
+ HRESULT hr, com_init;
IWICImagingFactory *factory = NULL;
IWICBitmapDecoder *decoder;
if (imginfo.ImageFileFormat == D3DXIFF_DIB)
convert_dib_to_bmp((void**)&pSrcData, &SrcDataSize);
- CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
+ com_init = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
if (FAILED(CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, (void**)&factory)))
goto cleanup_err;
if (factory)
IWICImagingFactory_Release(factory);
- CoUninitialize();
+ if (SUCCEEDED(com_init))
+ CoUninitialize();
if (imginfo.ImageFileFormat == D3DXIFF_DIB)
HeapFree(GetProcessHeap(), 0, (void*)pSrcData);
const PALETTEENTRY *dst_palette, const RECT *dst_rect, const char *src_file,
const RECT *src_rect, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
{
- LPWSTR pWidename;
+ WCHAR *src_file_w;
HRESULT hr;
int strlength;
return D3DERR_INVALIDCALL;
strlength = MultiByteToWideChar(CP_ACP, 0, src_file, -1, NULL, 0);
- pWidename = HeapAlloc(GetProcessHeap(), 0, strlength * sizeof(*pWidename));
- MultiByteToWideChar(CP_ACP, 0, src_file, -1, pWidename, strlength);
+ src_file_w = HeapAlloc(GetProcessHeap(), 0, strlength * sizeof(*src_file_w));
+ MultiByteToWideChar(CP_ACP, 0, src_file, -1, src_file_w, strlength);
hr = D3DXLoadSurfaceFromFileW(dst_surface, dst_palette, dst_rect,
- pWidename, src_rect, filter, color_key, src_info);
- HeapFree(GetProcessHeap(), 0, pWidename);
+ src_file_w, src_rect, filter, color_key, src_info);
+ HeapFree(GetProcessHeap(), 0, src_file_w);
return hr;
}
}
}
-static DWORD dword_from_bytes(CONST BYTE *src, UINT bytes_per_pixel)
-{
- DWORD ret = 0;
- static BOOL fixme_once;
-
- if(bytes_per_pixel > sizeof(DWORD)) {
- if(!fixme_once++) FIXME("Unsupported image: %u bytes per pixel\n", bytes_per_pixel);
- bytes_per_pixel = sizeof(DWORD);
- }
-
- memcpy(&ret, src, bytes_per_pixel);
- return ret;
-}
-
-static void dword_to_bytes(BYTE *dst, DWORD dword, UINT bytes_per_pixel)
-{
- static BOOL fixme_once;
-
- if(bytes_per_pixel > sizeof(DWORD)) {
- if(!fixme_once++) FIXME("Unsupported image: %u bytes per pixel\n", bytes_per_pixel);
- ZeroMemory(dst, bytes_per_pixel);
- bytes_per_pixel = sizeof(DWORD);
- }
-
- memcpy(dst, &dword, bytes_per_pixel);
-}
-
/************************************************************
* get_relevant_argb_components
*
* Extracts the relevant components from the source color and
* drops the less significant bits if they aren't used by the destination format.
*/
-static void get_relevant_argb_components(CONST struct argb_conversion_info *info, CONST DWORD col, DWORD *out)
+static void get_relevant_argb_components(const struct argb_conversion_info *info, DWORD col, DWORD *out)
{
UINT i = 0;
for(;i < 4;i++)
* Recombines the output of get_relevant_argb_components and converts
* it to the destination format.
*/
-static DWORD make_argb_color(CONST struct argb_conversion_info *info, CONST DWORD *in)
+static DWORD make_argb_color(const struct argb_conversion_info *info, const DWORD *in)
{
UINT i;
DWORD val = 0;
return val;
}
-static void format_to_vec4(const struct pixel_format_desc *format, const DWORD *src, struct vec4 *dst)
+/* It doesn't work for components bigger than 32 bits (or somewhat smaller but unaligned). */
+static void format_to_vec4(const struct pixel_format_desc *format, const BYTE *src, struct vec4 *dst)
{
- DWORD mask;
+ DWORD mask, tmp;
+ unsigned int c;
- if (format->bits[1])
+ for (c = 0; c < 4; ++c)
{
- mask = (1 << format->bits[1]) - 1;
- dst->x = (float)((*src >> format->shift[1]) & mask) / mask;
- }
- else
- dst->x = 1.0f;
+ static const unsigned int component_offsets[4] = {3, 0, 1, 2};
+ float *dst_component = (float *)dst + component_offsets[c];
- if (format->bits[2])
- {
- mask = (1 << format->bits[2]) - 1;
- dst->y = (float)((*src >> format->shift[2]) & mask) / mask;
- }
- else
- dst->y = 1.0f;
+ if (format->bits[c])
+ {
+ mask = ~0u >> (32 - format->bits[c]);
- if (format->bits[3])
- {
- mask = (1 << format->bits[3]) - 1;
- dst->z = (float)((*src >> format->shift[3]) & mask) / mask;
- }
- else
- dst->z = 1.0f;
+ memcpy(&tmp, src + format->shift[c] / 8,
+ min(sizeof(DWORD), (format->shift[c] % 8 + format->bits[c] + 7) / 8));
- if (format->bits[0])
- {
- mask = (1 << format->bits[0]) - 1;
- dst->w = (float)((*src >> format->shift[0]) & mask) / mask;
+ if (format->type == FORMAT_ARGBF16)
+ *dst_component = float_16_to_32(tmp);
+ else if (format->type == FORMAT_ARGBF)
+ *dst_component = *(float *)&tmp;
+ else
+ *dst_component = (float)((tmp >> format->shift[c] % 8) & mask) / mask;
+ }
+ else
+ *dst_component = 1.0f;
}
- else
- dst->w = 1.0f;
}
-static void format_from_vec4(const struct pixel_format_desc *format, const struct vec4 *src, DWORD *dst)
+/* It doesn't work for components bigger than 32 bits. */
+static void format_from_vec4(const struct pixel_format_desc *format, const struct vec4 *src, BYTE *dst)
{
- *dst = 0;
-
- if (format->bits[1])
- *dst |= (DWORD)(src->x * ((1 << format->bits[1]) - 1) + 0.5f) << format->shift[1];
- if (format->bits[2])
- *dst |= (DWORD)(src->y * ((1 << format->bits[2]) - 1) + 0.5f) << format->shift[2];
- if (format->bits[3])
- *dst |= (DWORD)(src->z * ((1 << format->bits[3]) - 1) + 0.5f) << format->shift[3];
- if (format->bits[0])
- *dst |= (DWORD)(src->w * ((1 << format->bits[0]) - 1) + 0.5f) << format->shift[0];
+ DWORD v, mask32;
+ unsigned int c, i;
+
+ memset(dst, 0, format->bytes_per_pixel);
+
+ for (c = 0; c < 4; ++c)
+ {
+ static const unsigned int component_offsets[4] = {3, 0, 1, 2};
+ const float src_component = *((const float *)src + component_offsets[c]);
+
+ if (!format->bits[c])
+ continue;
+
+ mask32 = ~0u >> (32 - format->bits[c]);
+
+ if (format->type == FORMAT_ARGBF16)
+ v = float_32_to_16(src_component);
+ else if (format->type == FORMAT_ARGBF)
+ v = *(DWORD *)&src_component;
+ else
+ v = (DWORD)(src_component * ((1 << format->bits[c]) - 1) + 0.5f);
+
+ for (i = format->shift[c] / 8 * 8; i < format->shift[c] + format->bits[c]; i += 8)
+ {
+ BYTE mask, byte;
+
+ if (format->shift[c] > i)
+ {
+ mask = mask32 << (format->shift[c] - i);
+ byte = (v << (format->shift[c] - i)) & mask;
+ }
+ else
+ {
+ mask = mask32 >> (i - format->shift[c]);
+ byte = (v >> (i - format->shift[c])) & mask;
+ }
+ dst[i / 8] |= byte;
+ }
+ }
}
/************************************************************
{
struct argb_conversion_info conv_info, ck_conv_info;
const struct pixel_format_desc *ck_format = NULL;
- DWORD channels[4], pixel;
+ DWORD channels[4];
UINT min_width, min_height, min_depth;
UINT x, y, z;
for (y = 0; y < min_height; y++) {
const BYTE *src_ptr = src_slice_ptr + y * src_row_pitch;
BYTE *dst_ptr = dst_slice_ptr + y * dst_row_pitch;
- DWORD val;
for (x = 0; x < min_width; x++) {
- /* extract source color components */
- pixel = dword_from_bytes(src_ptr, src_format->bytes_per_pixel);
-
- if (!src_format->to_rgba && !dst_format->from_rgba)
+ if (!src_format->to_rgba && !dst_format->from_rgba
+ && src_format->bytes_per_pixel <= 4 && dst_format->bytes_per_pixel <= 4)
{
- get_relevant_argb_components(&conv_info, pixel, channels);
+ DWORD val;
+
+ get_relevant_argb_components(&conv_info, *(DWORD *)src_ptr, channels);
val = make_argb_color(&conv_info, channels);
if (color_key)
{
- get_relevant_argb_components(&ck_conv_info, pixel, channels);
- pixel = make_argb_color(&ck_conv_info, channels);
- if (pixel == color_key)
+ DWORD ck_pixel;
+
+ get_relevant_argb_components(&ck_conv_info, *(DWORD *)src_ptr, channels);
+ ck_pixel = make_argb_color(&ck_conv_info, channels);
+ if (ck_pixel == color_key)
val &= ~conv_info.destmask[0];
}
+ memcpy(dst_ptr, &val, dst_format->bytes_per_pixel);
}
else
{
struct vec4 color, tmp;
- format_to_vec4(src_format, &pixel, &color);
+ format_to_vec4(src_format, src_ptr, &color);
if (src_format->to_rgba)
src_format->to_rgba(&color, &tmp, palette);
else
if (ck_format)
{
- format_from_vec4(ck_format, &tmp, &pixel);
- if (pixel == color_key)
+ DWORD ck_pixel;
+
+ format_from_vec4(ck_format, &tmp, (BYTE *)&ck_pixel);
+ if (ck_pixel == color_key)
tmp.w = 0.0f;
}
else
color = tmp;
- format_from_vec4(dst_format, &color, &val);
+ format_from_vec4(dst_format, &color, dst_ptr);
}
- dword_to_bytes(dst_ptr, val, dst_format->bytes_per_pixel);
- src_ptr += src_format->bytes_per_pixel;
+ src_ptr += src_format->bytes_per_pixel;
dst_ptr += dst_format->bytes_per_pixel;
}
{
struct argb_conversion_info conv_info, ck_conv_info;
const struct pixel_format_desc *ck_format = NULL;
- DWORD channels[4], pixel;
+ DWORD channels[4];
UINT x, y, z;
ZeroMemory(channels, sizeof(channels));
for (x = 0; x < dst_size->width; x++)
{
const BYTE *src_ptr = src_row_ptr + (x * src_size->width / dst_size->width) * src_format->bytes_per_pixel;
- DWORD val;
-
- /* extract source color components */
- pixel = dword_from_bytes(src_ptr, src_format->bytes_per_pixel);
- if (!src_format->to_rgba && !dst_format->from_rgba)
+ if (!src_format->to_rgba && !dst_format->from_rgba
+ && src_format->bytes_per_pixel <= 4 && dst_format->bytes_per_pixel <= 4)
{
- get_relevant_argb_components(&conv_info, pixel, channels);
+ DWORD val;
+
+ get_relevant_argb_components(&conv_info, *(DWORD *)src_ptr, channels);
val = make_argb_color(&conv_info, channels);
if (color_key)
{
- get_relevant_argb_components(&ck_conv_info, pixel, channels);
- pixel = make_argb_color(&ck_conv_info, channels);
- if (pixel == color_key)
+ DWORD ck_pixel;
+
+ get_relevant_argb_components(&ck_conv_info, *(DWORD *)src_ptr, channels);
+ ck_pixel = make_argb_color(&ck_conv_info, channels);
+ if (ck_pixel == color_key)
val &= ~conv_info.destmask[0];
}
+ memcpy(dst_ptr, &val, dst_format->bytes_per_pixel);
}
else
{
struct vec4 color, tmp;
- format_to_vec4(src_format, &pixel, &color);
+ format_to_vec4(src_format, src_ptr, &color);
if (src_format->to_rgba)
src_format->to_rgba(&color, &tmp, palette);
else
if (ck_format)
{
- format_from_vec4(ck_format, &tmp, &pixel);
- if (pixel == color_key)
+ DWORD ck_pixel;
+
+ format_from_vec4(ck_format, &tmp, (BYTE *)&ck_pixel);
+ if (ck_pixel == color_key)
tmp.w = 0.0f;
}
else
color = tmp;
- format_from_vec4(dst_format, &color, &val);
+ format_from_vec4(dst_format, &color, dst_ptr);
}
- dword_to_bytes(dst_ptr, val, dst_format->bytes_per_pixel);
dst_ptr += dst_format->bytes_per_pixel;
}
}
projects / reactos.git / blobdiff