Yidhra/DirectXTex
2
0
Fork 0
mirror of https://github.com/microsoft/DirectXTex.git synced 2025-07-09 11:40:14 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Convert internal functions to use Internal namespace instead of leading underscore (#266)

Browse Source 
Fixes clang v13 -Wreserved-identifier warning
This commit is contained in:
Chuck Walbourn 2022-02-20 14:47:07 -08:00 committed by GitHub
parent 192e674537
commit 469c65406a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
24 changed files with 1132 additions and 1074 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
DirectXTex/DirectXTex.h
View File

@ -827,6 +827,13 @@ namespace DirectX
void __cdecl SetWICFactory(_In_opt_ IWICImagingFactory* pWIC) noexcept; void __cdecl SetWICFactory(_In_opt_ IWICImagingFactory* pWIC) noexcept;
#endif #endif
//---------------------------------------------------------------------------------
// DDS helper functions
HRESULT __cdecl EncodeDDSHeader(
_In_ const TexMetadata& metadata, DDS_FLAGS flags,
_Out_writes_bytes_to_opt_(maxsize, required) void* pDestination, _In_ size_t maxsize,
_Out_ size_t& required) noexcept;
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// Direct3D 11 functions // Direct3D 11 functions
#if defined(__d3d11_h__) || defined(__d3d11_x_h__) #if defined(__d3d11_h__) || defined(__d3d11_x_h__)

165
DirectXTex/DirectXTexCompress.cpp
View File

@ -19,6 +19,7 @@
#include "BC.h" #include "BC.h"
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
namespace namespace
{ {
@ -122,25 +123,25 @@ namespace
ptrdiff_t bytesLeft = pEnd - sptr; ptrdiff_t bytesLeft = pEnd - sptr;
assert(bytesLeft > 0); assert(bytesLeft > 0);
size_t bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft)); size_t bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft));
if (!_LoadScanline(&temp[0], pw, sptr, bytesToRead, format)) if (!LoadScanline(&temp[0], pw, sptr, bytesToRead, format))
return E_FAIL; return E_FAIL;
if (ph > 1) if (ph > 1)
{ {
bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch); bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch);
if (!_LoadScanline(&temp[4], pw, sptr + rowPitch, bytesToRead, format)) if (!LoadScanline(&temp[4], pw, sptr + rowPitch, bytesToRead, format))
return E_FAIL; return E_FAIL;
if (ph > 2) if (ph > 2)
{ {
bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch * 2); bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch * 2);
if (!_LoadScanline(&temp[8], pw, sptr + rowPitch * 2, bytesToRead, format)) if (!LoadScanline(&temp[8], pw, sptr + rowPitch * 2, bytesToRead, format))
return E_FAIL; return E_FAIL;
if (ph > 3) if (ph > 3)
{ {
bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch * 3); bytesToRead = std::min<size_t>(rowPitch, static_cast<size_t>(bytesLeft) - rowPitch * 3);
if (!_LoadScanline(&temp[12], pw, sptr + rowPitch * 3, bytesToRead, format)) if (!LoadScanline(&temp[12], pw, sptr + rowPitch * 3, bytesToRead, format))
return E_FAIL; return E_FAIL;
} }
} }
@ -176,7 +177,7 @@ namespace
} }
} }
_ConvertScanline(temp, 16, result.format, format, cflags | srgb); ConvertScanline(temp, 16, result.format, format, cflags | srgb);
if (pfEncode) if (pfEncode)
pfEncode(dptr, temp, bcflags); pfEncode(dptr, temp, bcflags);
@ -264,25 +265,25 @@ namespace
size_t bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft)); size_t bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft));
XM_ALIGNED_DATA(16) XMVECTOR temp[16]; XM_ALIGNED_DATA(16) XMVECTOR temp[16];
if (!_LoadScanline(&temp[0], pw, pSrc, bytesToRead, format)) if (!LoadScanline(&temp[0], pw, pSrc, bytesToRead, format))
fail = true; fail = true;
if (ph > 1) if (ph > 1)
{ {
bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch); bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch);
if (!_LoadScanline(&temp[4], pw, pSrc + rowPitch, bytesToRead, format)) if (!LoadScanline(&temp[4], pw, pSrc + rowPitch, bytesToRead, format))
fail = true; fail = true;
if (ph > 2) if (ph > 2)
{ {
bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch * 2); bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch * 2);
if (!_LoadScanline(&temp[8], pw, pSrc + rowPitch * 2, bytesToRead, format)) if (!LoadScanline(&temp[8], pw, pSrc + rowPitch * 2, bytesToRead, format))
fail = true; fail = true;
if (ph > 3) if (ph > 3)
{ {
bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch * 3); bytesToRead = std::min<size_t>(rowPitch, size_t(bytesLeft) - rowPitch * 3);
if (!_LoadScanline(&temp[12], pw, pSrc + rowPitch * 3, bytesToRead, format)) if (!LoadScanline(&temp[12], pw, pSrc + rowPitch * 3, bytesToRead, format))
fail = true; fail = true;
} }
} }
@ -316,7 +317,7 @@ namespace
} }
} }
_ConvertScanline(temp, 16, result.format, format, cflags | srgb); ConvertScanline(temp, 16, result.format, format, cflags | srgb);
if (pfEncode) if (pfEncode)
pfEncode(pDest, temp, bcflags); pfEncode(pDest, temp, bcflags);
@ -453,27 +454,27 @@ namespace
for (size_t count = 0; (count < cImage.rowPitch) && (w < cImage.width); count += sbpp, w += 4) for (size_t count = 0; (count < cImage.rowPitch) && (w < cImage.width); count += sbpp, w += 4)
{ {
pfDecode(temp, sptr); pfDecode(temp, sptr);
_ConvertScanline(temp, 16, format, cformat, TEX_FILTER_DEFAULT); ConvertScanline(temp, 16, format, cformat, TEX_FILTER_DEFAULT);
size_t pw = std::min<size_t>(4, cImage.width - w); size_t pw = std::min<size_t>(4, cImage.width - w);
assert(pw > 0 && ph > 0); assert(pw > 0 && ph > 0);
if (!_StoreScanline(dptr, rowPitch, format, &temp[0], pw)) if (!StoreScanline(dptr, rowPitch, format, &temp[0], pw))
return E_FAIL; return E_FAIL;
if (ph > 1) if (ph > 1)
{ {
if (!_StoreScanline(dptr + rowPitch, rowPitch, format, &temp[4], pw)) if (!StoreScanline(dptr + rowPitch, rowPitch, format, &temp[4], pw))
return E_FAIL; return E_FAIL;
if (ph > 2) if (ph > 2)
{ {
if (!_StoreScanline(dptr + rowPitch * 2, rowPitch, format, &temp[8], pw)) if (!StoreScanline(dptr + rowPitch * 2, rowPitch, format, &temp[8], pw))
return E_FAIL; return E_FAIL;
if (ph > 3) if (ph > 3)
{ {
if (!_StoreScanline(dptr + rowPitch * 3, rowPitch, format, &temp[12], pw)) if (!StoreScanline(dptr + rowPitch * 3, rowPitch, format, &temp[12], pw))
return E_FAIL; return E_FAIL;
} }
} }
@ -492,95 +493,89 @@ namespace
} }
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
namespace DirectX bool DirectX::Internal::IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept
{ {
bool _IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept; if (!cImage.pixels)
// Also used by Image return false;
bool _IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept // Promote "typeless" BC formats
DXGI_FORMAT cformat;
switch (cImage.format)
{ {
if (!cImage.pixels) case DXGI_FORMAT_BC1_TYPELESS: cformat = DXGI_FORMAT_BC1_UNORM; break;
return false; case DXGI_FORMAT_BC2_TYPELESS: cformat = DXGI_FORMAT_BC2_UNORM; break;
case DXGI_FORMAT_BC3_TYPELESS: cformat = DXGI_FORMAT_BC3_UNORM; break;
case DXGI_FORMAT_BC7_TYPELESS: cformat = DXGI_FORMAT_BC7_UNORM; break;
default: cformat = cImage.format; break;
}
// Promote "typeless" BC formats // Determine BC format decoder
DXGI_FORMAT cformat; BC_DECODE pfDecode;
switch (cImage.format) size_t sbpp;
switch (cformat)
{
case DXGI_FORMAT_BC1_UNORM:
case DXGI_FORMAT_BC1_UNORM_SRGB: pfDecode = D3DXDecodeBC1; sbpp = 8; break;
case DXGI_FORMAT_BC2_UNORM:
case DXGI_FORMAT_BC2_UNORM_SRGB: pfDecode = D3DXDecodeBC2; sbpp = 16; break;
case DXGI_FORMAT_BC3_UNORM:
case DXGI_FORMAT_BC3_UNORM_SRGB: pfDecode = D3DXDecodeBC3; sbpp = 16; break;
case DXGI_FORMAT_BC7_UNORM:
case DXGI_FORMAT_BC7_UNORM_SRGB: pfDecode = D3DXDecodeBC7; sbpp = 16; break;
default:
// BC4, BC5, and BC6 don't have alpha channels
return false;
}
// Scan blocks for non-opaque alpha
static const XMVECTORF32 threshold = { { { 0.99f, 0.99f, 0.99f, 0.99f } } };
XM_ALIGNED_DATA(16) XMVECTOR temp[16];
const uint8_t* pPixels = cImage.pixels;
for (size_t h = 0; h < cImage.height; h += 4)
{
const uint8_t* ptr = pPixels;
size_t ph = std::min<size_t>(4, cImage.height - h);
size_t w = 0;
for (size_t count = 0; (count < cImage.rowPitch) && (w < cImage.width); count += sbpp, w += 4)
{ {
case DXGI_FORMAT_BC1_TYPELESS: cformat = DXGI_FORMAT_BC1_UNORM; break; pfDecode(temp, ptr);
case DXGI_FORMAT_BC2_TYPELESS: cformat = DXGI_FORMAT_BC2_UNORM; break;
case DXGI_FORMAT_BC3_TYPELESS: cformat = DXGI_FORMAT_BC3_UNORM; break;
case DXGI_FORMAT_BC7_TYPELESS: cformat = DXGI_FORMAT_BC7_UNORM; break;
default: cformat = cImage.format; break;
}
// Determine BC format decoder size_t pw = std::min<size_t>(4, cImage.width - w);
BC_DECODE pfDecode; assert(pw > 0 && ph > 0);
size_t sbpp;
switch (cformat)
{
case DXGI_FORMAT_BC1_UNORM:
case DXGI_FORMAT_BC1_UNORM_SRGB: pfDecode = D3DXDecodeBC1; sbpp = 8; break;
case DXGI_FORMAT_BC2_UNORM:
case DXGI_FORMAT_BC2_UNORM_SRGB: pfDecode = D3DXDecodeBC2; sbpp = 16; break;
case DXGI_FORMAT_BC3_UNORM:
case DXGI_FORMAT_BC3_UNORM_SRGB: pfDecode = D3DXDecodeBC3; sbpp = 16; break;
case DXGI_FORMAT_BC7_UNORM:
case DXGI_FORMAT_BC7_UNORM_SRGB: pfDecode = D3DXDecodeBC7; sbpp = 16; break;
default:
// BC4, BC5, and BC6 don't have alpha channels
return false;
}
// Scan blocks for non-opaque alpha if (pw == 4 && ph == 4)
static const XMVECTORF32 threshold = { { { 0.99f, 0.99f, 0.99f, 0.99f } } };
XM_ALIGNED_DATA(16) XMVECTOR temp[16];
const uint8_t *pPixels = cImage.pixels;
for (size_t h = 0; h < cImage.height; h += 4)
{
const uint8_t *ptr = pPixels;
size_t ph = std::min<size_t>(4, cImage.height - h);
size_t w = 0;
for (size_t count = 0; (count < cImage.rowPitch) && (w < cImage.width); count += sbpp, w += 4)
{ {
pfDecode(temp, ptr); // Full blocks
for (size_t j = 0; j < 16; ++j)
size_t pw = std::min<size_t>(4, cImage.width - w);
assert(pw > 0 && ph > 0);
if (pw == 4 && ph == 4)
{ {
// Full blocks XMVECTOR alpha = XMVectorSplatW(temp[j]);
for (size_t j = 0; j < 16; ++j) if (XMVector4Less(alpha, threshold))
return false;
}
}
else
{
// Handle partial blocks
for (size_t y = 0; y < ph; ++y)
{
for (size_t x = 0; x < pw; ++x)
{ {
XMVECTOR alpha = XMVectorSplatW(temp[j]); XMVECTOR alpha = XMVectorSplatW(temp[y * 4 + x]);
if (XMVector4Less(alpha, threshold)) if (XMVector4Less(alpha, threshold))
return false; return false;
} }
} }
else
{
// Handle partial blocks
for (size_t y = 0; y < ph; ++y)
{
for (size_t x = 0; x < pw; ++x)
{
XMVECTOR alpha = XMVectorSplatW(temp[y * 4 + x]);
if (XMVector4Less(alpha, threshold))
return false;
}
}
}
ptr += sbpp;
} }
pPixels += cImage.rowPitch; ptr += sbpp;
} }
return true; pPixels += cImage.rowPitch;
} }
};
return true;
}
//===================================================================================== //=====================================================================================

11
DirectXTex/DirectXTexCompressGPU.cpp
View File

@ -14,6 +14,7 @@
#include "BCDirectCompute.h" #include "BCDirectCompute.h"
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
namespace namespace
{ {
@ -69,15 +70,15 @@ namespace
const uint8_t *pSrc = srcImage.pixels; const uint8_t *pSrc = srcImage.pixels;
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format)) if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
{ {
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
} }
_ConvertScanline(scanline.get(), srcImage.width, format, srcImage.format, filter); ConvertScanline(scanline.get(), srcImage.width, format, srcImage.format, filter);
if (!_StoreScanline(pDest, img->rowPitch, format, scanline.get(), srcImage.width)) if (!StoreScanline(pDest, img->rowPitch, format, scanline.get(), srcImage.width))
{ {
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
@ -123,13 +124,13 @@ namespace
const uint8_t *pSrc = srcImage.pixels; const uint8_t *pSrc = srcImage.pixels;
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format)) if (!LoadScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
{ {
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
} }
_ConvertScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, DXGI_FORMAT_R32G32B32A32_FLOAT, srcImage.format, filter); ConvertScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, DXGI_FORMAT_R32G32B32A32_FLOAT, srcImage.format, filter);
pSrc += srcImage.rowPitch; pSrc += srcImage.rowPitch;
pDest += img->rowPitch; pDest += img->rowPitch;

91
DirectXTex/DirectXTexConvert.cpp
View File

@ -12,6 +12,7 @@
#include "DirectXTexP.h" #include "DirectXTexP.h"
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
using namespace DirectX::PackedVector; using namespace DirectX::PackedVector;
using Microsoft::WRL::ComPtr; using Microsoft::WRL::ComPtr;
@ -199,7 +200,7 @@ namespace
// (can be used in place as well) otherwise copies the image row unmodified. // (can be used in place as well) otherwise copies the image row unmodified.
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
_Use_decl_annotations_ _Use_decl_annotations_
void DirectX::_CopyScanline( void DirectX::Internal::CopyScanline(
void* pDestination, void* pDestination,
size_t outSize, size_t outSize,
const void* pSource, const void* pSource,
@ -444,7 +445,7 @@ void DirectX::_CopyScanline(
// (can be used in place as well) otherwise copies the image row unmodified. // (can be used in place as well) otherwise copies the image row unmodified.
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
_Use_decl_annotations_ _Use_decl_annotations_
void DirectX::_SwizzleScanline( void DirectX::Internal::SwizzleScanline(
void* pDestination, void* pDestination,
size_t outSize, size_t outSize,
const void* pSource, const void* pSource,
@ -614,7 +615,7 @@ void DirectX::_SwizzleScanline(
// Returns true if supported, false if expansion case not supported // Returns true if supported, false if expansion case not supported
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
_Use_decl_annotations_ _Use_decl_annotations_
bool DirectX::_ExpandScanline( bool DirectX::Internal::ExpandScanline(
void* pDestination, void* pDestination,
size_t outSize, size_t outSize,
DXGI_FORMAT outFormat, DXGI_FORMAT outFormat,
@ -755,7 +756,7 @@ bool DirectX::_ExpandScanline(
return false; return false;
#pragma warning(suppress: 6101) #pragma warning(suppress: 6101)
_Use_decl_annotations_ bool DirectX::_LoadScanline( _Use_decl_annotations_ bool DirectX::Internal::LoadScanline(
XMVECTOR* pDestination, XMVECTOR* pDestination,
size_t count, size_t count,
const void* pSource, const void* pSource,
@ -1603,7 +1604,7 @@ _Use_decl_annotations_ bool DirectX::_LoadScanline(
return false; return false;
_Use_decl_annotations_ _Use_decl_annotations_
bool DirectX::_StoreScanline( bool DirectX::Internal::StoreScanline(
void* pDestination, void* pDestination,
size_t size, size_t size,
DXGI_FORMAT format, DXGI_FORMAT format,
@ -2470,7 +2471,7 @@ bool DirectX::_StoreScanline(
// Convert DXGI image to/from GUID_WICPixelFormat128bppRGBAFloat (no range conversions) // Convert DXGI image to/from GUID_WICPixelFormat128bppRGBAFloat (no range conversions)
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
_Use_decl_annotations_ _Use_decl_annotations_
HRESULT DirectX::_ConvertToR32G32B32A32(const Image& srcImage, ScratchImage& image) noexcept HRESULT DirectX::Internal::ConvertToR32G32B32A32(const Image& srcImage, ScratchImage& image) noexcept
{ {
if (!srcImage.pixels) if (!srcImage.pixels)
return E_POINTER; return E_POINTER;
@ -2496,7 +2497,7 @@ HRESULT DirectX::_ConvertToR32G32B32A32(const Image& srcImage, ScratchImage& ima
const uint8_t *pSrc = srcImage.pixels; const uint8_t *pSrc = srcImage.pixels;
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format)) if (!LoadScanline(reinterpret_cast<XMVECTOR*>(pDest), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
{ {
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
@ -2510,7 +2511,7 @@ HRESULT DirectX::_ConvertToR32G32B32A32(const Image& srcImage, ScratchImage& ima
} }
_Use_decl_annotations_ _Use_decl_annotations_
HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, const Image& destImage) noexcept HRESULT DirectX::Internal::ConvertFromR32G32B32A32(const Image& srcImage, const Image& destImage) noexcept
{ {
assert(srcImage.format == DXGI_FORMAT_R32G32B32A32_FLOAT); assert(srcImage.format == DXGI_FORMAT_R32G32B32A32_FLOAT);
@ -2525,7 +2526,7 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, const Image& de
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, reinterpret_cast<const XMVECTOR*>(pSrc), srcImage.width)) if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, reinterpret_cast<const XMVECTOR*>(pSrc), srcImage.width))
return E_FAIL; return E_FAIL;
pSrc += srcImage.rowPitch; pSrc += srcImage.rowPitch;
@ -2536,7 +2537,10 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, const Image& de
} }
_Use_decl_annotations_ _Use_decl_annotations_
HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, DXGI_FORMAT format, ScratchImage& image) noexcept HRESULT DirectX::Internal::ConvertFromR32G32B32A32(
const Image& srcImage,
DXGI_FORMAT format,
ScratchImage& image) noexcept
{ {
if (!srcImage.pixels) if (!srcImage.pixels)
return E_POINTER; return E_POINTER;
@ -2552,7 +2556,7 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, DXGI_FORMAT for
return E_POINTER; return E_POINTER;
} }
hr = _ConvertFromR32G32B32A32(srcImage, *img); hr = ConvertFromR32G32B32A32(srcImage, *img);
if (FAILED(hr)) if (FAILED(hr))
{ {
image.Release(); image.Release();
@ -2563,7 +2567,7 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(const Image& srcImage, DXGI_FORMAT for
} }
_Use_decl_annotations_ _Use_decl_annotations_
HRESULT DirectX::_ConvertFromR32G32B32A32( HRESULT DirectX::Internal::ConvertFromR32G32B32A32(
const Image* srcImages, const Image* srcImages,
size_t nimages, size_t nimages,
const TexMetadata& metadata, const TexMetadata& metadata,
@ -2620,7 +2624,7 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(
for (size_t h = 0; h < src.height; ++h) for (size_t h = 0; h < src.height; ++h)
{ {
if (!_StoreScanline(pDest, dst.rowPitch, format, reinterpret_cast<const XMVECTOR*>(pSrc), src.width)) if (!StoreScanline(pDest, dst.rowPitch, format, reinterpret_cast<const XMVECTOR*>(pSrc), src.width))
{ {
result.Release(); result.Release();
return E_FAIL; return E_FAIL;
@ -2639,7 +2643,7 @@ HRESULT DirectX::_ConvertFromR32G32B32A32(
// Convert DXGI image to/from GUID_WICPixelFormat64bppRGBAHalf (no range conversions) // Convert DXGI image to/from GUID_WICPixelFormat64bppRGBAHalf (no range conversions)
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
_Use_decl_annotations_ _Use_decl_annotations_
HRESULT DirectX::_ConvertToR16G16B16A16(const Image& srcImage, ScratchImage& image) noexcept HRESULT DirectX::Internal::ConvertToR16G16B16A16(const Image& srcImage, ScratchImage& image) noexcept
{ {
if (!srcImage.pixels) if (!srcImage.pixels)
return E_POINTER; return E_POINTER;
@ -2672,7 +2676,7 @@ HRESULT DirectX::_ConvertToR16G16B16A16(const Image& srcImage, ScratchImage& ima
const uint8_t *pSrc = srcImage.pixels; const uint8_t *pSrc = srcImage.pixels;
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format)) if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
{ {
image.Release(); image.Release();
return E_FAIL; return E_FAIL;
@ -2691,7 +2695,7 @@ HRESULT DirectX::_ConvertToR16G16B16A16(const Image& srcImage, ScratchImage& ima
} }
_Use_decl_annotations_ _Use_decl_annotations_
HRESULT DirectX::_ConvertFromR16G16B16A16(const Image& srcImage, const Image& destImage) noexcept HRESULT DirectX::Internal::ConvertFromR16G16B16A16(const Image& srcImage, const Image& destImage) noexcept
{ {
assert(srcImage.format == DXGI_FORMAT_R16G16B16A16_FLOAT); assert(srcImage.format == DXGI_FORMAT_R16G16B16A16_FLOAT);
@ -2715,7 +2719,7 @@ HRESULT DirectX::_ConvertFromR16G16B16A16(const Image& srcImage, const Image& de
reinterpret_cast<const HALF*>(pSrc), sizeof(HALF), reinterpret_cast<const HALF*>(pSrc), sizeof(HALF),
srcImage.width * 4); srcImage.width * 4);
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width)) if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
return E_FAIL; return E_FAIL;
pSrc += srcImage.rowPitch; pSrc += srcImage.rowPitch;
@ -2734,7 +2738,7 @@ HRESULT DirectX::_ConvertFromR16G16B16A16(const Image& srcImage, const Image& de
// where a = 0.055 // where a = 0.055
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
_Use_decl_annotations_ _Use_decl_annotations_
bool DirectX::_StoreScanlineLinear( bool DirectX::Internal::StoreScanlineLinear(
void* pDestination, void* pDestination,
size_t size, size_t size,
DXGI_FORMAT format, DXGI_FORMAT format,
@ -2799,7 +2803,7 @@ bool DirectX::_StoreScanlineLinear(
} }
} }
return _StoreScanline(pDestination, size, format, pSource, count, threshold); return StoreScanline(pDestination, size, format, pSource, count, threshold);
} }
@ -2811,7 +2815,7 @@ bool DirectX::_StoreScanlineLinear(
// where a = 0.055 // where a = 0.055
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
_Use_decl_annotations_ _Use_decl_annotations_
bool DirectX::_LoadScanlineLinear( bool DirectX::Internal::LoadScanlineLinear(
XMVECTOR* pDestination, XMVECTOR* pDestination,
size_t count, size_t count,
const void* pSource, const void* pSource,
@ -2858,7 +2862,7 @@ bool DirectX::_LoadScanlineLinear(
break; break;
} }
if (_LoadScanline(pDestination, count, pSource, size, format)) if (LoadScanline(pDestination, count, pSource, size, format))
{ {
// sRGB input processing (sRGB -> Linear RGB) // sRGB input processing (sRGB -> Linear RGB)
if (flags & TEX_FILTER_SRGB_IN) if (flags & TEX_FILTER_SRGB_IN)
@ -2988,7 +2992,7 @@ namespace
} }
_Use_decl_annotations_ _Use_decl_annotations_
uint32_t DirectX::_GetConvertFlags(DXGI_FORMAT format) noexcept uint32_t DirectX::Internal::GetConvertFlags(DXGI_FORMAT format) noexcept
{ {
#ifdef _DEBUG #ifdef _DEBUG
// Ensure conversion table is in ascending order // Ensure conversion table is in ascending order
@ -3008,7 +3012,7 @@ uint32_t DirectX::_GetConvertFlags(DXGI_FORMAT format) noexcept
} }
_Use_decl_annotations_ _Use_decl_annotations_
void DirectX::_ConvertScanline( void DirectX::Internal::ConvertScanline(
XMVECTOR* pBuffer, XMVECTOR* pBuffer,
size_t count, size_t count,
DXGI_FORMAT outFormat, DXGI_FORMAT outFormat,
@ -3046,8 +3050,8 @@ void DirectX::_ConvertScanline(
return; return;
} }
assert(_GetConvertFlags(inFormat) == in->flags); assert(GetConvertFlags(inFormat) == in->flags);
assert(_GetConvertFlags(outFormat) == out->flags); assert(GetConvertFlags(outFormat) == out->flags);
// Handle SRGB filtering modes // Handle SRGB filtering modes
switch (inFormat) switch (inFormat)
@ -3903,7 +3907,7 @@ namespace
#pragma warning( disable : 4127 ) #pragma warning( disable : 4127 )
_Use_decl_annotations_ _Use_decl_annotations_
bool DirectX::_StoreScanlineDither( bool DirectX::Internal::StoreScanlineDither(
void* pDestination, void* pDestination,
size_t size, size_t size,
DXGI_FORMAT format, DXGI_FORMAT format,
@ -4363,7 +4367,7 @@ bool DirectX::_StoreScanlineDither(
return false; return false;
default: default:
return _StoreScanline(pDestination, size, format, pSource, count, threshold); return StoreScanline(pDestination, size, format, pSource, count, threshold);
} }
} }
@ -4402,7 +4406,7 @@ namespace
return false; return false;
} }
if (!_DXGIToWIC(sformat, pfGUID) || !_DXGIToWIC(tformat, targetGUID)) if (!DXGIToWIC(sformat, pfGUID) || !DXGIToWIC(tformat, targetGUID))
{ {
// Source or target format are not WIC supported native pixel formats // Source or target format are not WIC supported native pixel formats
return false; return false;
@ -4525,7 +4529,7 @@ namespace
filter &= ~(TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT); filter &= ~(TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT);
} }
auto wicsrgb = _CheckWICColorSpace(pfGUID, targetGUID); auto wicsrgb = CheckWICColorSpace(pfGUID, targetGUID);
if (wicsrgb != (filter & (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT))) if (wicsrgb != (filter & (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT)))
{ {
@ -4592,7 +4596,8 @@ namespace
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
hr = FC->Initialize(source.Get(), targetGUID, _GetWICDither(filter), nullptr, static_cast<double>(threshold) * 100.0, WICBitmapPaletteTypeMedianCut); hr = FC->Initialize(source.Get(), targetGUID, GetWICDither(filter), nullptr,
static_cast<double>(threshold) * 100.0, WICBitmapPaletteTypeMedianCut);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -4636,12 +4641,12 @@ namespace
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format)) if (!LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
return E_FAIL; return E_FAIL;
_ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter); ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
if (!_StoreScanlineDither(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold, h, z, pDiffusionErrors)) if (!StoreScanlineDither(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold, h, z, pDiffusionErrors))
return E_FAIL; return E_FAIL;
pSrc += srcImage.rowPitch; pSrc += srcImage.rowPitch;
@ -4659,12 +4664,12 @@ namespace
// Ordered dithering // Ordered dithering
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format)) if (!LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
return E_FAIL; return E_FAIL;
_ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter); ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
if (!_StoreScanlineDither(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold, h, z, nullptr)) if (!StoreScanlineDither(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold, h, z, nullptr))
return E_FAIL; return E_FAIL;
pSrc += srcImage.rowPitch; pSrc += srcImage.rowPitch;
@ -4676,12 +4681,12 @@ namespace
// No dithering // No dithering
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format)) if (!LoadScanline(scanline.get(), width, pSrc, srcImage.rowPitch, srcImage.format))
return E_FAIL; return E_FAIL;
_ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter); ConvertScanline(scanline.get(), width, destImage.format, srcImage.format, filter);
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold)) if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), width, threshold))
return E_FAIL; return E_FAIL;
pSrc += srcImage.rowPitch; pSrc += srcImage.rowPitch;
@ -4694,7 +4699,7 @@ namespace
} }
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
DXGI_FORMAT _PlanarToSingle(_In_ DXGI_FORMAT format) noexcept DXGI_FORMAT PlanarToSingle(_In_ DXGI_FORMAT format) noexcept
{ {
switch (format) switch (format)
{ {
@ -5077,7 +5082,7 @@ HRESULT DirectX::ConvertToSinglePlane(const Image& srcImage, ScratchImage& image
if (!srcImage.pixels) if (!srcImage.pixels)
return E_POINTER; return E_POINTER;
DXGI_FORMAT format = _PlanarToSingle(srcImage.format); DXGI_FORMAT format = PlanarToSingle(srcImage.format);
if (format == DXGI_FORMAT_UNKNOWN) if (format == DXGI_FORMAT_UNKNOWN)
return HRESULT_E_NOT_SUPPORTED; return HRESULT_E_NOT_SUPPORTED;
@ -5125,7 +5130,7 @@ HRESULT DirectX::ConvertToSinglePlane(
return HRESULT_E_NOT_SUPPORTED; return HRESULT_E_NOT_SUPPORTED;
} }
DXGI_FORMAT format = _PlanarToSingle(metadata.format); DXGI_FORMAT format = PlanarToSingle(metadata.format);
if (format == DXGI_FORMAT_UNKNOWN) if (format == DXGI_FORMAT_UNKNOWN)
return HRESULT_E_NOT_SUPPORTED; return HRESULT_E_NOT_SUPPORTED;
@ -5189,7 +5194,7 @@ HRESULT DirectX::ConvertToSinglePlane(
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
DirectX::FORMAT_TYPE DirectX::FormatDataType(_In_ DXGI_FORMAT fmt) noexcept DirectX::FORMAT_TYPE DirectX::FormatDataType(_In_ DXGI_FORMAT fmt) noexcept
{ {
auto cflags = _GetConvertFlags(fmt); const auto cflags = GetConvertFlags(fmt);
switch (cflags & (CONVF_FLOAT | CONVF_UNORM | CONVF_UINT | CONVF_SNORM | CONVF_SINT)) switch (cflags & (CONVF_FLOAT | CONVF_UNORM | CONVF_UINT | CONVF_SNORM | CONVF_SINT))
{ {

59
DirectXTex/DirectXTexDDS.cpp
View File

@ -14,6 +14,7 @@
#include "DDS.h" #include "DDS.h"
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE1D) == static_cast<int>(DDS_DIMENSION_TEXTURE1D), "header enum mismatch"); static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE1D) == static_cast<int>(DDS_DIMENSION_TEXTURE1D), "header enum mismatch");
static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE2D) == static_cast<int>(DDS_DIMENSION_TEXTURE2D), "header enum mismatch"); static_assert(static_cast<int>(TEX_DIMENSION_TEXTURE2D) == static_cast<int>(DDS_DIMENSION_TEXTURE2D), "header enum mismatch");
@ -558,7 +559,7 @@ namespace
// Encodes DDS file header (magic value, header, optional DX10 extended header) // Encodes DDS file header (magic value, header, optional DX10 extended header)
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
_Use_decl_annotations_ _Use_decl_annotations_
HRESULT DirectX::_EncodeDDSHeader( HRESULT DirectX::EncodeDDSHeader(
const TexMetadata& metadata, const TexMetadata& metadata,
DDS_FLAGS flags, DDS_FLAGS flags,
void* pDestination, void* pDestination,
@ -889,7 +890,7 @@ namespace
TEXP_LEGACY_A8L8 TEXP_LEGACY_A8L8
}; };
inline TEXP_LEGACY_FORMAT _FindLegacyFormat(uint32_t flags) noexcept inline TEXP_LEGACY_FORMAT FindLegacyFormat(uint32_t flags) noexcept
{ {
TEXP_LEGACY_FORMAT lformat = TEXP_LEGACY_UNKNOWN; TEXP_LEGACY_FORMAT lformat = TEXP_LEGACY_UNKNOWN;
@ -1253,7 +1254,7 @@ namespace
} }
size_t pixelSize, nimages; size_t pixelSize, nimages;
if (!_DetermineImageArray(metadata, cpFlags, nimages, pixelSize)) if (!DetermineImageArray(metadata, cpFlags, nimages, pixelSize))
return HRESULT_E_ARITHMETIC_OVERFLOW; return HRESULT_E_ARITHMETIC_OVERFLOW;
if ((nimages == 0) || (nimages != image.GetImageCount())) if ((nimages == 0) || (nimages != image.GetImageCount()))
@ -1272,7 +1273,7 @@ namespace
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
if (!_SetupImageArray( if (!SetupImageArray(
const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(pPixels)), const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(pPixels)),
pixelSize, pixelSize,
metadata, metadata,
@ -1366,7 +1367,7 @@ namespace
{ {
if (convFlags & (CONV_FLAGS_565 | CONV_FLAGS_5551 | CONV_FLAGS_4444)) if (convFlags & (CONV_FLAGS_565 | CONV_FLAGS_5551 | CONV_FLAGS_4444))
{ {
if (!_ExpandScanline(pDest, dpitch, DXGI_FORMAT_R8G8B8A8_UNORM, if (!ExpandScanline(pDest, dpitch, DXGI_FORMAT_R8G8B8A8_UNORM,
pSrc, spitch, pSrc, spitch,
(convFlags & CONV_FLAGS_565) ? DXGI_FORMAT_B5G6R5_UNORM : DXGI_FORMAT_B5G5R5A1_UNORM, (convFlags & CONV_FLAGS_565) ? DXGI_FORMAT_B5G6R5_UNORM : DXGI_FORMAT_B5G5R5A1_UNORM,
tflags)) tflags))
@ -1374,7 +1375,7 @@ namespace
} }
else else
{ {
TEXP_LEGACY_FORMAT lformat = _FindLegacyFormat(convFlags); TEXP_LEGACY_FORMAT lformat = FindLegacyFormat(convFlags);
if (!LegacyExpandScanline(pDest, dpitch, metadata.format, if (!LegacyExpandScanline(pDest, dpitch, metadata.format,
pSrc, spitch, lformat, pal8, pSrc, spitch, lformat, pal8,
tflags)) tflags))
@ -1383,12 +1384,12 @@ namespace
} }
else if (convFlags & CONV_FLAGS_SWIZZLE) else if (convFlags & CONV_FLAGS_SWIZZLE)
{ {
_SwizzleScanline(pDest, dpitch, pSrc, spitch, SwizzleScanline(pDest, dpitch, pSrc, spitch,
metadata.format, tflags); metadata.format, tflags);
} }
else else
{ {
_CopyScanline(pDest, dpitch, pSrc, spitch, CopyScanline(pDest, dpitch, pSrc, spitch,
metadata.format, tflags); metadata.format, tflags);
} }
@ -1459,7 +1460,7 @@ namespace
{ {
if (convFlags & (CONV_FLAGS_565 | CONV_FLAGS_5551 | CONV_FLAGS_4444)) if (convFlags & (CONV_FLAGS_565 | CONV_FLAGS_5551 | CONV_FLAGS_4444))
{ {
if (!_ExpandScanline(pDest, dpitch, DXGI_FORMAT_R8G8B8A8_UNORM, if (!ExpandScanline(pDest, dpitch, DXGI_FORMAT_R8G8B8A8_UNORM,
pSrc, spitch, pSrc, spitch,
(convFlags & CONV_FLAGS_565) ? DXGI_FORMAT_B5G6R5_UNORM : DXGI_FORMAT_B5G5R5A1_UNORM, (convFlags & CONV_FLAGS_565) ? DXGI_FORMAT_B5G6R5_UNORM : DXGI_FORMAT_B5G5R5A1_UNORM,
tflags)) tflags))
@ -1467,7 +1468,7 @@ namespace
} }
else else
{ {
TEXP_LEGACY_FORMAT lformat = _FindLegacyFormat(convFlags); TEXP_LEGACY_FORMAT lformat = FindLegacyFormat(convFlags);
if (!LegacyExpandScanline(pDest, dpitch, metadata.format, if (!LegacyExpandScanline(pDest, dpitch, metadata.format,
pSrc, spitch, lformat, pal8, pSrc, spitch, lformat, pal8,
tflags)) tflags))
@ -1476,11 +1477,11 @@ namespace
} }
else if (convFlags & CONV_FLAGS_SWIZZLE) else if (convFlags & CONV_FLAGS_SWIZZLE)
{ {
_SwizzleScanline(pDest, dpitch, pSrc, spitch, metadata.format, tflags); SwizzleScanline(pDest, dpitch, pSrc, spitch, metadata.format, tflags);
} }
else else
{ {
_CopyScanline(pDest, dpitch, pSrc, spitch, metadata.format, tflags); CopyScanline(pDest, dpitch, pSrc, spitch, metadata.format, tflags);
} }
pSrc += spitch; pSrc += spitch;
@ -1533,11 +1534,11 @@ namespace
{ {
if (convFlags & CONV_FLAGS_SWIZZLE) if (convFlags & CONV_FLAGS_SWIZZLE)
{ {
_SwizzleScanline(pPixels, rowPitch, pPixels, rowPitch, metadata.format, tflags); SwizzleScanline(pPixels, rowPitch, pPixels, rowPitch, metadata.format, tflags);
} }
else else
{ {
_CopyScanline(pPixels, rowPitch, pPixels, rowPitch, metadata.format, tflags); CopyScanline(pPixels, rowPitch, pPixels, rowPitch, metadata.format, tflags);
} }
pPixels += rowPitch; pPixels += rowPitch;
@ -1992,7 +1993,7 @@ HRESULT DirectX::SaveToDDSMemory(
// Determine memory required // Determine memory required
size_t required = 0; size_t required = 0;
HRESULT hr = _EncodeDDSHeader(metadata, flags, nullptr, 0, required); HRESULT hr = EncodeDDSHeader(metadata, flags, nullptr, 0, required);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -2033,7 +2034,7 @@ HRESULT DirectX::SaveToDDSMemory(
auto pDestination = static_cast<uint8_t*>(blob.GetBufferPointer()); auto pDestination = static_cast<uint8_t*>(blob.GetBufferPointer());
assert(pDestination); assert(pDestination);
hr = _EncodeDDSHeader(metadata, flags, pDestination, blob.GetBufferSize(), required); hr = EncodeDDSHeader(metadata, flags, pDestination, blob.GetBufferSize(), required);
if (FAILED(hr)) if (FAILED(hr))
{ {
blob.Release(); blob.Release();
@ -2083,16 +2084,22 @@ HRESULT DirectX::SaveToDDSMemory(
return hr; return hr;
} }
size_t rowPitch = images[index].rowPitch; const size_t rowPitch = images[index].rowPitch;
const uint8_t * __restrict sPtr = images[index].pixels; const uint8_t * __restrict sPtr = images[index].pixels;
uint8_t * __restrict dPtr = pDestination; uint8_t * __restrict dPtr = pDestination;
size_t lines = ComputeScanlines(metadata.format, images[index].height); const size_t lines = ComputeScanlines(metadata.format, images[index].height);
size_t csize = std::min<size_t>(rowPitch, ddsRowPitch); const size_t csize = std::min<size_t>(rowPitch, ddsRowPitch);
size_t tremaining = remaining; size_t tremaining = remaining;
for (size_t j = 0; j < lines; ++j) for (size_t j = 0; j < lines; ++j)
{ {
if (tremaining < csize)
{
blob.Release();
return E_FAIL;
}
memcpy(dPtr, sPtr, csize); memcpy(dPtr, sPtr, csize);
sPtr += rowPitch; sPtr += rowPitch;
@ -2149,16 +2156,22 @@ HRESULT DirectX::SaveToDDSMemory(
return hr; return hr;
} }
size_t rowPitch = images[index].rowPitch; const size_t rowPitch = images[index].rowPitch;
const uint8_t * __restrict sPtr = images[index].pixels; const uint8_t * __restrict sPtr = images[index].pixels;
uint8_t * __restrict dPtr = pDestination; uint8_t * __restrict dPtr = pDestination;
size_t lines = ComputeScanlines(metadata.format, images[index].height); const size_t lines = ComputeScanlines(metadata.format, images[index].height);
size_t csize = std::min<size_t>(rowPitch, ddsRowPitch); const size_t csize = std::min<size_t>(rowPitch, ddsRowPitch);
size_t tremaining = remaining; size_t tremaining = remaining;
for (size_t j = 0; j < lines; ++j) for (size_t j = 0; j < lines; ++j)
{ {
if (tremaining < csize)
{
blob.Release();
return E_FAIL;
}
memcpy(dPtr, sPtr, csize); memcpy(dPtr, sPtr, csize);
sPtr += rowPitch; sPtr += rowPitch;
@ -2206,7 +2219,7 @@ HRESULT DirectX::SaveToDDSFile(
const size_t MAX_HEADER_SIZE = sizeof(uint32_t) + sizeof(DDS_HEADER) + sizeof(DDS_HEADER_DXT10); const size_t MAX_HEADER_SIZE = sizeof(uint32_t) + sizeof(DDS_HEADER) + sizeof(DDS_HEADER_DXT10);
uint8_t header[MAX_HEADER_SIZE]; uint8_t header[MAX_HEADER_SIZE];
size_t required; size_t required;
HRESULT hr = _EncodeDDSHeader(metadata, flags, header, MAX_HEADER_SIZE, required); HRESULT hr = EncodeDDSHeader(metadata, flags, header, MAX_HEADER_SIZE, required);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;

13
DirectXTex/DirectXTexFlipRotate.cpp
View File

@ -12,6 +12,7 @@
#include "DirectXTexP.h" #include "DirectXTexP.h"
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
using Microsoft::WRL::ComPtr; using Microsoft::WRL::ComPtr;
namespace namespace
@ -100,7 +101,7 @@ namespace
assert(srcImage.format == destImage.format); assert(srcImage.format == destImage.format);
ScratchImage temp; ScratchImage temp;
HRESULT hr = _ConvertToR16G16B16A16(srcImage, temp); HRESULT hr = ConvertToR16G16B16A16(srcImage, temp);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -123,7 +124,7 @@ namespace
temp.Release(); temp.Release();
hr = _ConvertFromR16G16B16A16(*tdest, destImage); hr = ConvertFromR16G16B16A16(*tdest, destImage);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -142,7 +143,7 @@ namespace
assert(srcImage.format == destImage.format); assert(srcImage.format == destImage.format);
ScratchImage temp; ScratchImage temp;
HRESULT hr = _ConvertToR32G32B32A32(srcImage, temp); HRESULT hr = ConvertToR32G32B32A32(srcImage, temp);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -165,7 +166,7 @@ namespace
temp.Release(); temp.Release();
hr = _ConvertFromR32G32B32A32(*tdest, destImage); hr = ConvertFromR32G32B32A32(*tdest, destImage);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -245,7 +246,7 @@ HRESULT DirectX::FlipRotate(
} }
WICPixelFormatGUID pfGUID; WICPixelFormatGUID pfGUID;
if (_DXGIToWIC(srcImage.format, pfGUID)) if (DXGIToWIC(srcImage.format, pfGUID))
{ {
// Case 1: Source format is supported by Windows Imaging Component // Case 1: Source format is supported by Windows Imaging Component
hr = PerformFlipRotateUsingWIC(srcImage, flags, pfGUID, *rimage); hr = PerformFlipRotateUsingWIC(srcImage, flags, pfGUID, *rimage);
@ -345,7 +346,7 @@ HRESULT DirectX::FlipRotate(
} }
WICPixelFormatGUID pfGUID; WICPixelFormatGUID pfGUID;
bool wicpf = _DXGIToWIC(metadata.format, pfGUID); bool wicpf = DXGIToWIC(metadata.format, pfGUID);
for (size_t index = 0; index < nimages; ++index) for (size_t index = 0; index < nimages; ++index)
{ {

38
DirectXTex/DirectXTexImage.cpp
View File

@ -11,14 +11,8 @@
#include "DirectXTexP.h" #include "DirectXTexP.h"
namespace DirectX
{
extern bool _CalculateMipLevels(_In_ size_t width, _In_ size_t height, _Inout_ size_t& mipLevels) noexcept;
extern bool _CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth, _Inout_ size_t& mipLevels) noexcept;
extern bool _IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept;
}
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
#ifndef WIN32 #ifndef WIN32
namespace namespace
@ -37,7 +31,7 @@ namespace
// Determines number of image array entries and pixel size // Determines number of image array entries and pixel size
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
_Use_decl_annotations_ _Use_decl_annotations_
bool DirectX::_DetermineImageArray( bool DirectX::Internal::DetermineImageArray(
const TexMetadata& metadata, const TexMetadata& metadata,
CP_FLAGS cpFlags, CP_FLAGS cpFlags,
size_t& nImages, size_t& nImages,
@ -140,7 +134,7 @@ bool DirectX::_DetermineImageArray(
// Fills in the image array entries // Fills in the image array entries
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
_Use_decl_annotations_ _Use_decl_annotations_
bool DirectX::_SetupImageArray( bool DirectX::Internal::SetupImageArray(
uint8_t *pMemory, uint8_t *pMemory,
size_t pixelSize, size_t pixelSize,
const TexMetadata& metadata, const TexMetadata& metadata,
@ -311,7 +305,7 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
if (!mdata.width || mdata.height != 1 || mdata.depth != 1 || !mdata.arraySize) if (!mdata.width || mdata.height != 1 || mdata.depth != 1 || !mdata.arraySize)
return E_INVALIDARG; return E_INVALIDARG;
if (!_CalculateMipLevels(mdata.width, 1, mipLevels)) if (!CalculateMipLevels(mdata.width, 1, mipLevels))
return E_INVALIDARG; return E_INVALIDARG;
break; break;
@ -325,7 +319,7 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
return E_INVALIDARG; return E_INVALIDARG;
} }
if (!_CalculateMipLevels(mdata.width, mdata.height, mipLevels)) if (!CalculateMipLevels(mdata.width, mdata.height, mipLevels))
return E_INVALIDARG; return E_INVALIDARG;
break; break;
@ -333,7 +327,7 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
if (!mdata.width || !mdata.height || !mdata.depth || mdata.arraySize != 1) if (!mdata.width || !mdata.height || !mdata.depth || mdata.arraySize != 1)
return E_INVALIDARG; return E_INVALIDARG;
if (!_CalculateMipLevels3D(mdata.width, mdata.height, mdata.depth, mipLevels)) if (!CalculateMipLevels3D(mdata.width, mdata.height, mdata.depth, mipLevels))
return E_INVALIDARG; return E_INVALIDARG;
break; break;
@ -354,7 +348,7 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
m_metadata.dimension = mdata.dimension; m_metadata.dimension = mdata.dimension;
size_t pixelSize, nimages; size_t pixelSize, nimages;
if (!_DetermineImageArray(m_metadata, flags, nimages, pixelSize)) if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
return HRESULT_E_ARITHMETIC_OVERFLOW; return HRESULT_E_ARITHMETIC_OVERFLOW;
m_image = new (std::nothrow) Image[nimages]; m_image = new (std::nothrow) Image[nimages];
@ -371,7 +365,7 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
m_size = pixelSize; m_size = pixelSize;
if (!_SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages)) if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
{ {
Release(); Release();
return E_FAIL; return E_FAIL;
@ -405,7 +399,7 @@ HRESULT ScratchImage::Initialize2D(DXGI_FORMAT fmt, size_t width, size_t height,
if (IsPalettized(fmt)) if (IsPalettized(fmt))
return HRESULT_E_NOT_SUPPORTED; return HRESULT_E_NOT_SUPPORTED;
if (!_CalculateMipLevels(width, height, mipLevels)) if (!CalculateMipLevels(width, height, mipLevels))
return E_INVALIDARG; return E_INVALIDARG;
Release(); Release();
@ -421,7 +415,7 @@ HRESULT ScratchImage::Initialize2D(DXGI_FORMAT fmt, size_t width, size_t height,
m_metadata.dimension = TEX_DIMENSION_TEXTURE2D; m_metadata.dimension = TEX_DIMENSION_TEXTURE2D;
size_t pixelSize, nimages; size_t pixelSize, nimages;
if (!_DetermineImageArray(m_metadata, flags, nimages, pixelSize)) if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
return HRESULT_E_ARITHMETIC_OVERFLOW; return HRESULT_E_ARITHMETIC_OVERFLOW;
m_image = new (std::nothrow) Image[nimages]; m_image = new (std::nothrow) Image[nimages];
@ -438,7 +432,7 @@ HRESULT ScratchImage::Initialize2D(DXGI_FORMAT fmt, size_t width, size_t height,
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
m_size = pixelSize; m_size = pixelSize;
if (!_SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages)) if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
{ {
Release(); Release();
return E_FAIL; return E_FAIL;
@ -456,7 +450,7 @@ HRESULT ScratchImage::Initialize3D(DXGI_FORMAT fmt, size_t width, size_t height,
if (IsPalettized(fmt)) if (IsPalettized(fmt))
return HRESULT_E_NOT_SUPPORTED; return HRESULT_E_NOT_SUPPORTED;
if (!_CalculateMipLevels3D(width, height, depth, mipLevels)) if (!CalculateMipLevels3D(width, height, depth, mipLevels))
return E_INVALIDARG; return E_INVALIDARG;
Release(); Release();
@ -472,7 +466,7 @@ HRESULT ScratchImage::Initialize3D(DXGI_FORMAT fmt, size_t width, size_t height,
m_metadata.dimension = TEX_DIMENSION_TEXTURE3D; m_metadata.dimension = TEX_DIMENSION_TEXTURE3D;
size_t pixelSize, nimages; size_t pixelSize, nimages;
if (!_DetermineImageArray(m_metadata, flags, nimages, pixelSize)) if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
return HRESULT_E_ARITHMETIC_OVERFLOW; return HRESULT_E_ARITHMETIC_OVERFLOW;
m_image = new (std::nothrow) Image[nimages]; m_image = new (std::nothrow) Image[nimages];
@ -492,7 +486,7 @@ HRESULT ScratchImage::Initialize3D(DXGI_FORMAT fmt, size_t width, size_t height,
} }
m_size = pixelSize; m_size = pixelSize;
if (!_SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages)) if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
{ {
Release(); Release();
return E_FAIL; return E_FAIL;
@ -793,7 +787,7 @@ bool ScratchImage::IsAlphaAllOpaque() const noexcept
{ {
for (size_t index = 0; index < m_nimages; ++index) for (size_t index = 0; index < m_nimages; ++index)
{ {
if (!_IsAlphaAllOpaqueBC(m_image[index])) if (!IsAlphaAllOpaqueBC(m_image[index]))
return false; return false;
} }
} }
@ -815,7 +809,7 @@ bool ScratchImage::IsAlphaAllOpaque() const noexcept
for (size_t h = 0; h < img.height; ++h) for (size_t h = 0; h < img.height; ++h)
{ {
if (!_LoadScanline(scanline.get(), img.width, pPixels, img.rowPitch, img.format)) if (!LoadScanline(scanline.get(), img.width, pPixels, img.rowPitch, img.format))
return false; return false;
const XMVECTOR* ptr = scanline.get(); const XMVECTOR* ptr = scanline.get();

642
DirectXTex/DirectXTexMipmaps.cpp
View File

File diff suppressed because it is too large Load Diff

17
DirectXTex/DirectXTexMisc.cpp
View File

@ -12,6 +12,7 @@
#include "DirectXTexP.h" #include "DirectXTexP.h"
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
#ifdef __GNUC__ #ifdef __GNUC__
#pragma GCC diagnostic push #pragma GCC diagnostic push
@ -101,11 +102,11 @@ namespace
for (size_t h = 0; h < image1.height; ++h) for (size_t h = 0; h < image1.height; ++h)
{ {
XMVECTOR* ptr1 = scanline.get(); XMVECTOR* ptr1 = scanline.get();
if (!_LoadScanline(ptr1, width, pSrc1, rowPitch1, image1.format)) if (!LoadScanline(ptr1, width, pSrc1, rowPitch1, image1.format))
return E_FAIL; return E_FAIL;
XMVECTOR* ptr2 = scanline.get() + width; XMVECTOR* ptr2 = scanline.get() + width;
if (!_LoadScanline(ptr2, width, pSrc2, rowPitch2, image2.format)) if (!LoadScanline(ptr2, width, pSrc2, rowPitch2, image2.format))
return E_FAIL; return E_FAIL;
for (size_t i = 0; i < width; ++i) for (size_t i = 0; i < width; ++i)
@ -198,7 +199,7 @@ namespace
for (size_t h = 0; h < image.height; ++h) for (size_t h = 0; h < image.height; ++h)
{ {
if (!_LoadScanline(scanline.get(), width, pSrc, rowPitch, image.format)) if (!LoadScanline(scanline.get(), width, pSrc, rowPitch, image.format))
return E_FAIL; return E_FAIL;
pixelFunc(scanline.get(), width, h); pixelFunc(scanline.get(), width, h);
@ -242,7 +243,7 @@ namespace
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanline(sScanline, width, pSrc, spitch, srcImage.format)) if (!LoadScanline(sScanline, width, pSrc, spitch, srcImage.format))
return E_FAIL; return E_FAIL;
#ifdef _DEBUG #ifdef _DEBUG
@ -251,7 +252,7 @@ namespace
pixelFunc(dScanline, sScanline, width, h); pixelFunc(dScanline, sScanline, width, h);
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, dScanline, width)) if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, dScanline, width))
return E_FAIL; return E_FAIL;
pSrc += spitch; pSrc += spitch;
@ -364,12 +365,12 @@ HRESULT DirectX::CopyRectangle(
if (((pSrc + copyS) > pEndSrc) || ((pDest + copyD) > pEndDest)) if (((pSrc + copyS) > pEndSrc) || ((pDest + copyD) > pEndDest))
return E_FAIL; return E_FAIL;
if (!_LoadScanline(scanline.get(), srcRect.w, pSrc, copyS, srcImage.format)) if (!LoadScanline(scanline.get(), srcRect.w, pSrc, copyS, srcImage.format))
return E_FAIL; return E_FAIL;
_ConvertScanline(scanline.get(), srcRect.w, dstImage.format, srcImage.format, filter); ConvertScanline(scanline.get(), srcRect.w, dstImage.format, srcImage.format, filter);
if (!_StoreScanline(pDest, copyD, dstImage.format, scanline.get(), srcRect.w)) if (!StoreScanline(pDest, copyD, dstImage.format, scanline.get(), srcRect.w))
return E_FAIL; return E_FAIL;
pSrc += srcImage.rowPitch; pSrc += srcImage.rowPitch;

15
DirectXTex/DirectXTexNormalMaps.cpp
View File

@ -12,6 +12,7 @@
#include "DirectXTexP.h" #include "DirectXTexP.h"
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
namespace namespace
{ {
@ -79,7 +80,7 @@ namespace
if (!srcImage.pixels || !normalMap.pixels) if (!srcImage.pixels || !normalMap.pixels)
return E_INVALIDARG; return E_INVALIDARG;
const uint32_t convFlags = _GetConvertFlags(format); const uint32_t convFlags = GetConvertFlags(format);
if (!convFlags) if (!convFlags)
return E_FAIL; return E_FAIL;
@ -117,7 +118,7 @@ namespace
const uint8_t* pSrc = srcImage.pixels; const uint8_t* pSrc = srcImage.pixels;
// Read first scanline row into 'row1' // Read first scanline row into 'row1'
if (!_LoadScanline(row1, width, pSrc, rowPitch, srcImage.format)) if (!LoadScanline(row1, width, pSrc, rowPitch, srcImage.format))
return E_FAIL; return E_FAIL;
// Setup 'row0' // Setup 'row0'
@ -129,7 +130,7 @@ namespace
else else
{ {
// Read last row (Wrap V) // Read last row (Wrap V)
if (!_LoadScanline(row0, width, pSrc + (rowPitch * (height - 1)), rowPitch, srcImage.format)) if (!LoadScanline(row0, width, pSrc + (rowPitch * (height - 1)), rowPitch, srcImage.format))
return E_FAIL; return E_FAIL;
} }
@ -144,7 +145,7 @@ namespace
// Load next scanline of source image // Load next scanline of source image
if (y < (height - 1)) if (y < (height - 1))
{ {
if (!_LoadScanline(row2, width, pSrc, rowPitch, srcImage.format)) if (!LoadScanline(row2, width, pSrc, rowPitch, srcImage.format))
return E_FAIL; return E_FAIL;
} }
else else
@ -152,13 +153,13 @@ namespace
if (flags & CNMAP_MIRROR_V) if (flags & CNMAP_MIRROR_V)
{ {
// Use last row of source image // Use last row of source image
if (!_LoadScanline(row2, width, srcImage.pixels + (rowPitch * (height - 1)), rowPitch, srcImage.format)) if (!LoadScanline(row2, width, srcImage.pixels + (rowPitch * (height - 1)), rowPitch, srcImage.format))
return E_FAIL; return E_FAIL;
} }
else else
{ {
// Use first row of source image (Wrap V) // Use first row of source image (Wrap V)
if (!_LoadScanline(row2, width, srcImage.pixels, rowPitch, srcImage.format)) if (!LoadScanline(row2, width, srcImage.pixels, rowPitch, srcImage.format))
return E_FAIL; return E_FAIL;
} }
} }
@ -227,7 +228,7 @@ namespace
} }
} }
if (!_StoreScanline(pDest, normalMap.rowPitch, format, target, width)) if (!StoreScanline(pDest, normalMap.rowPitch, format, target, width))
return E_FAIL; return E_FAIL;
// Cycle buffers // Cycle buffers

296
DirectXTex/DirectXTexP.h
View File

@ -203,25 +203,28 @@ using WICPixelFormatGUID = GUID;
#define E_NOT_SUFFICIENT_BUFFER static_cast<HRESULT>(0x8007007AL) #define E_NOT_SUFFICIENT_BUFFER static_cast<HRESULT>(0x8007007AL)
#endif #endif
//-------------------------------------------------------------------------------------
namespace DirectX namespace DirectX
{ {
//--------------------------------------------------------------------------------- namespace Internal
// WIC helper functions
#ifdef WIN32
DXGI_FORMAT __cdecl _WICToDXGI(_In_ const GUID& guid) noexcept;
bool __cdecl _DXGIToWIC(_In_ DXGI_FORMAT format, _Out_ GUID& guid, _In_ bool ignoreRGBvsBGR = false) noexcept;
TEX_FILTER_FLAGS __cdecl _CheckWICColorSpace(_In_ const GUID& sourceGUID, _In_ const GUID& targetGUID) noexcept;
inline WICBitmapDitherType __cdecl _GetWICDither(_In_ TEX_FILTER_FLAGS flags) noexcept
{ {
static_assert(TEX_FILTER_DITHER == 0x10000, "TEX_FILTER_DITHER* flag values don't match mask"); //-----------------------------------------------------------------------------
// WIC helper functions
#ifdef WIN32
DXGI_FORMAT __cdecl WICToDXGI(_In_ const GUID& guid) noexcept;
bool __cdecl DXGIToWIC(_In_ DXGI_FORMAT format, _Out_ GUID& guid, _In_ bool ignoreRGBvsBGR = false) noexcept;
static_assert(static_cast<int>(TEX_FILTER_DITHER) == static_cast<int>(WIC_FLAGS_DITHER), "TEX_FILTER_DITHER* should match WIC_FLAGS_DITHER*"); TEX_FILTER_FLAGS __cdecl CheckWICColorSpace(_In_ const GUID& sourceGUID, _In_ const GUID& targetGUID) noexcept;
static_assert(static_cast<int>(TEX_FILTER_DITHER_DIFFUSION) == static_cast<int>(WIC_FLAGS_DITHER_DIFFUSION), "TEX_FILTER_DITHER* should match WIC_FLAGS_DITHER*");
switch (flags & TEX_FILTER_DITHER_MASK) inline WICBitmapDitherType __cdecl GetWICDither(_In_ TEX_FILTER_FLAGS flags) noexcept
{ {
static_assert(TEX_FILTER_DITHER == 0x10000, "TEX_FILTER_DITHER* flag values don't match mask");
static_assert(static_cast<int>(TEX_FILTER_DITHER) == static_cast<int>(WIC_FLAGS_DITHER), "TEX_FILTER_DITHER* should match WIC_FLAGS_DITHER*");
static_assert(static_cast<int>(TEX_FILTER_DITHER_DIFFUSION) == static_cast<int>(WIC_FLAGS_DITHER_DIFFUSION), "TEX_FILTER_DITHER* should match WIC_FLAGS_DITHER*");
switch (flags & TEX_FILTER_DITHER_MASK)
{
case TEX_FILTER_DITHER: case TEX_FILTER_DITHER:
return WICBitmapDitherTypeOrdered4x4; return WICBitmapDitherTypeOrdered4x4;
@ -230,35 +233,35 @@ namespace DirectX
default: default:
return WICBitmapDitherTypeNone; return WICBitmapDitherTypeNone;
}
} }
}
inline WICBitmapDitherType __cdecl _GetWICDither(_In_ WIC_FLAGS flags) noexcept inline WICBitmapDitherType __cdecl GetWICDither(_In_ WIC_FLAGS flags) noexcept
{
switch (flags & TEX_FILTER_DITHER_MASK)
{ {
case WIC_FLAGS_DITHER: switch (flags & TEX_FILTER_DITHER_MASK)
return WICBitmapDitherTypeOrdered4x4; {
case WIC_FLAGS_DITHER:
return WICBitmapDitherTypeOrdered4x4;
case WIC_FLAGS_DITHER_DIFFUSION: case WIC_FLAGS_DITHER_DIFFUSION:
return WICBitmapDitherTypeErrorDiffusion; return WICBitmapDitherTypeErrorDiffusion;
default: default:
return WICBitmapDitherTypeNone; return WICBitmapDitherTypeNone;
}
} }
}
inline WICBitmapInterpolationMode __cdecl _GetWICInterp(_In_ WIC_FLAGS flags) noexcept inline WICBitmapInterpolationMode __cdecl GetWICInterp(_In_ WIC_FLAGS flags) noexcept
{
static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MASK");
static_assert(static_cast<int>(TEX_FILTER_POINT) == static_cast<int>(WIC_FLAGS_FILTER_POINT), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
static_assert(static_cast<int>(TEX_FILTER_LINEAR) == static_cast<int>(WIC_FLAGS_FILTER_LINEAR), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
static_assert(static_cast<int>(TEX_FILTER_CUBIC) == static_cast<int>(WIC_FLAGS_FILTER_CUBIC), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
static_assert(static_cast<int>(TEX_FILTER_FANT) == static_cast<int>(WIC_FLAGS_FILTER_FANT), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
switch (flags & TEX_FILTER_MODE_MASK)
{ {
static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MASK");
static_assert(static_cast<int>(TEX_FILTER_POINT) == static_cast<int>(WIC_FLAGS_FILTER_POINT), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
static_assert(static_cast<int>(TEX_FILTER_LINEAR) == static_cast<int>(WIC_FLAGS_FILTER_LINEAR), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
static_assert(static_cast<int>(TEX_FILTER_CUBIC) == static_cast<int>(WIC_FLAGS_FILTER_CUBIC), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
static_assert(static_cast<int>(TEX_FILTER_FANT) == static_cast<int>(WIC_FLAGS_FILTER_FANT), "TEX_FILTER_* flags should match WIC_FLAGS_FILTER_*");
switch (flags & TEX_FILTER_MODE_MASK)
{
case TEX_FILTER_POINT: case TEX_FILTER_POINT:
return WICBitmapInterpolationModeNearestNeighbor; return WICBitmapInterpolationModeNearestNeighbor;
@ -271,137 +274,152 @@ namespace DirectX
case TEX_FILTER_FANT: case TEX_FILTER_FANT:
default: default:
return WICBitmapInterpolationModeFant; return WICBitmapInterpolationModeFant;
}
} }
}
inline WICBitmapInterpolationMode __cdecl _GetWICInterp(_In_ TEX_FILTER_FLAGS flags) noexcept inline WICBitmapInterpolationMode __cdecl GetWICInterp(_In_ TEX_FILTER_FLAGS flags) noexcept
{
switch (flags & TEX_FILTER_MODE_MASK)
{ {
case TEX_FILTER_POINT: switch (flags & TEX_FILTER_MODE_MASK)
return WICBitmapInterpolationModeNearestNeighbor; {
case TEX_FILTER_POINT:
return WICBitmapInterpolationModeNearestNeighbor;
case TEX_FILTER_LINEAR: case TEX_FILTER_LINEAR:
return WICBitmapInterpolationModeLinear; return WICBitmapInterpolationModeLinear;
case TEX_FILTER_CUBIC: case TEX_FILTER_CUBIC:
return WICBitmapInterpolationModeCubic; return WICBitmapInterpolationModeCubic;
case TEX_FILTER_FANT: case TEX_FILTER_FANT:
default: default:
return WICBitmapInterpolationModeFant; return WICBitmapInterpolationModeFant;
}
} }
}
#endif // WIN32 #endif // WIN32
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// Image helper functions // Image helper functions
_Success_(return) bool __cdecl _DetermineImageArray( _Success_(return) bool __cdecl DetermineImageArray(
_In_ const TexMetadata& metadata, _In_ CP_FLAGS cpFlags, _In_ const TexMetadata& metadata, _In_ CP_FLAGS cpFlags,
_Out_ size_t& nImages, _Out_ size_t& pixelSize) noexcept; _Out_ size_t& nImages, _Out_ size_t& pixelSize) noexcept;
_Success_(return) bool __cdecl _SetupImageArray( _Success_(return) bool __cdecl SetupImageArray(
_In_reads_bytes_(pixelSize) uint8_t *pMemory, _In_ size_t pixelSize, _In_reads_bytes_(pixelSize) uint8_t* pMemory, _In_ size_t pixelSize,
_In_ const TexMetadata& metadata, _In_ CP_FLAGS cpFlags, _In_ const TexMetadata& metadata, _In_ CP_FLAGS cpFlags,
_Out_writes_(nImages) Image* images, _In_ size_t nImages) noexcept; _Out_writes_(nImages) Image* images, _In_ size_t nImages) noexcept;
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// Conversion helper functions // Conversion helper functions
enum TEXP_SCANLINE_FLAGS : uint32_t enum TEXP_SCANLINE_FLAGS : uint32_t
{ {
TEXP_SCANLINE_NONE = 0, TEXP_SCANLINE_NONE = 0,
TEXP_SCANLINE_SETALPHA = 0x1, // Set alpha channel to known opaque value TEXP_SCANLINE_SETALPHA = 0x1, // Set alpha channel to known opaque value
TEXP_SCANLINE_LEGACY = 0x2, // Enables specific legacy format conversion cases TEXP_SCANLINE_LEGACY = 0x2, // Enables specific legacy format conversion cases
}; };
enum CONVERT_FLAGS : uint32_t enum CONVERT_FLAGS : uint32_t
{ {
CONVF_FLOAT = 0x1, CONVF_FLOAT = 0x1,
CONVF_UNORM = 0x2, CONVF_UNORM = 0x2,
CONVF_UINT = 0x4, CONVF_UINT = 0x4,
CONVF_SNORM = 0x8, CONVF_SNORM = 0x8,
CONVF_SINT = 0x10, CONVF_SINT = 0x10,
CONVF_DEPTH = 0x20, CONVF_DEPTH = 0x20,
CONVF_STENCIL = 0x40, CONVF_STENCIL = 0x40,
CONVF_SHAREDEXP = 0x80, CONVF_SHAREDEXP = 0x80,
CONVF_BGR = 0x100, CONVF_BGR = 0x100,
CONVF_XR = 0x200, CONVF_XR = 0x200,
CONVF_PACKED = 0x400, CONVF_PACKED = 0x400,
CONVF_BC = 0x800, CONVF_BC = 0x800,
CONVF_YUV = 0x1000, CONVF_YUV = 0x1000,
CONVF_POS_ONLY = 0x2000, CONVF_POS_ONLY = 0x2000,
CONVF_R = 0x10000, CONVF_R = 0x10000,
CONVF_G = 0x20000, CONVF_G = 0x20000,
CONVF_B = 0x40000, CONVF_B = 0x40000,
CONVF_A = 0x80000, CONVF_A = 0x80000,
CONVF_RGB_MASK = 0x70000, CONVF_RGB_MASK = 0x70000,
CONVF_RGBA_MASK = 0xF0000, CONVF_RGBA_MASK = 0xF0000,
}; };
uint32_t __cdecl _GetConvertFlags(_In_ DXGI_FORMAT format) noexcept; uint32_t __cdecl GetConvertFlags(_In_ DXGI_FORMAT format) noexcept;
void __cdecl _CopyScanline( void __cdecl CopyScanline(
_When_(pDestination == pSource, _Inout_updates_bytes_(outSize)) _When_(pDestination == pSource, _Inout_updates_bytes_(outSize))
_When_(pDestination != pSource, _Out_writes_bytes_(outSize)) _When_(pDestination != pSource, _Out_writes_bytes_(outSize))
void* pDestination, _In_ size_t outSize, void* pDestination, _In_ size_t outSize,
_In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize, _In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize,
_In_ DXGI_FORMAT format, _In_ uint32_t tflags) noexcept; _In_ DXGI_FORMAT format, _In_ uint32_t tflags) noexcept;
void __cdecl _SwizzleScanline( void __cdecl SwizzleScanline(
_When_(pDestination == pSource, _In_) _When_(pDestination == pSource, _In_)
_When_(pDestination != pSource, _Out_writes_bytes_(outSize)) _When_(pDestination != pSource, _Out_writes_bytes_(outSize))
void* pDestination, _In_ size_t outSize, void* pDestination, _In_ size_t outSize,
_In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize, _In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize,
_In_ DXGI_FORMAT format, _In_ uint32_t tflags) noexcept; _In_ DXGI_FORMAT format, _In_ uint32_t tflags) noexcept;
_Success_(return) bool __cdecl _ExpandScanline( _Success_(return) bool __cdecl ExpandScanline(
_Out_writes_bytes_(outSize) void* pDestination, _In_ size_t outSize, _Out_writes_bytes_(outSize) void* pDestination, _In_ size_t outSize,
_In_ DXGI_FORMAT outFormat, _In_ DXGI_FORMAT outFormat,
_In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize, _In_reads_bytes_(inSize) const void* pSource, _In_ size_t inSize,
_In_ DXGI_FORMAT inFormat, _In_ uint32_t tflags) noexcept; _In_ DXGI_FORMAT inFormat, _In_ uint32_t tflags) noexcept;
_Success_(return) bool __cdecl _LoadScanline( _Success_(return) bool __cdecl LoadScanline(
_Out_writes_(count) XMVECTOR* pDestination, _In_ size_t count, _Out_writes_(count) XMVECTOR* pDestination, _In_ size_t count,
_In_reads_bytes_(size) const void* pSource, _In_ size_t size, _In_ DXGI_FORMAT format) noexcept; _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
_In_ DXGI_FORMAT format) noexcept;
_Success_(return) bool __cdecl _LoadScanlineLinear( _Success_(return) bool __cdecl LoadScanlineLinear(
_Out_writes_(count) XMVECTOR* pDestination, _In_ size_t count, _Out_writes_(count) XMVECTOR* pDestination, _In_ size_t count,
_In_reads_bytes_(size) const void* pSource, _In_ size_t size, _In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS flags) noexcept; _In_reads_bytes_(size) const void* pSource, _In_ size_t size,
_In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS flags) noexcept;
_Success_(return) bool __cdecl _StoreScanline( _Success_(return) bool __cdecl StoreScanline(
_Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format, _Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format,
_In_reads_(count) const XMVECTOR* pSource, _In_ size_t count, _In_ float threshold = 0) noexcept; _In_reads_(count) const XMVECTOR* pSource, _In_ size_t count, _In_ float threshold = 0) noexcept;
_Success_(return) bool __cdecl _StoreScanlineLinear( _Success_(return) bool __cdecl StoreScanlineLinear(
_Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format, _Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format,
_Inout_updates_all_(count) XMVECTOR* pSource, _In_ size_t count, _In_ TEX_FILTER_FLAGS flags, _In_ float threshold = 0) noexcept; _Inout_updates_all_(count) XMVECTOR* pSource, _In_ size_t count,
_In_ TEX_FILTER_FLAGS flags, _In_ float threshold = 0) noexcept;
_Success_(return) bool __cdecl _StoreScanlineDither( _Success_(return) bool __cdecl StoreScanlineDither(
_Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format, _Out_writes_bytes_(size) void* pDestination, _In_ size_t size, _In_ DXGI_FORMAT format,
_Inout_updates_all_(count) XMVECTOR* pSource, _In_ size_t count, _In_ float threshold, size_t y, size_t z, _Inout_updates_all_(count) XMVECTOR* pSource, _In_ size_t count,
_Inout_updates_all_opt_(count + 2) XMVECTOR* pDiffusionErrors) noexcept; _In_ float threshold, size_t y, size_t z,
_Inout_updates_all_opt_(count + 2) XMVECTOR* pDiffusionErrors) noexcept;
HRESULT __cdecl _ConvertToR32G32B32A32(_In_ const Image& srcImage, _Inout_ ScratchImage& image) noexcept; HRESULT __cdecl ConvertToR32G32B32A32(_In_ const Image& srcImage, _Inout_ ScratchImage& image) noexcept;
HRESULT __cdecl _ConvertFromR32G32B32A32(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept; HRESULT __cdecl ConvertFromR32G32B32A32(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept;
HRESULT __cdecl _ConvertFromR32G32B32A32(_In_ const Image& srcImage, _In_ DXGI_FORMAT format, _Inout_ ScratchImage& image) noexcept; HRESULT __cdecl ConvertFromR32G32B32A32(
HRESULT __cdecl _ConvertFromR32G32B32A32( _In_ const Image& srcImage, _In_ DXGI_FORMAT format, _Inout_ ScratchImage& image) noexcept;
_In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata, HRESULT __cdecl ConvertFromR32G32B32A32(
_In_ DXGI_FORMAT format, _Out_ ScratchImage& result) noexcept; _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
_In_ DXGI_FORMAT format, _Out_ ScratchImage& result) noexcept;
HRESULT __cdecl _ConvertToR16G16B16A16(_In_ const Image& srcImage, _Inout_ ScratchImage& image) noexcept; HRESULT __cdecl ConvertToR16G16B16A16(_In_ const Image& srcImage, _Inout_ ScratchImage& image) noexcept;
HRESULT __cdecl _ConvertFromR16G16B16A16(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept; HRESULT __cdecl ConvertFromR16G16B16A16(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept;
void __cdecl _ConvertScanline( void __cdecl ConvertScanline(
_Inout_updates_all_(count) XMVECTOR* pBuffer, _In_ size_t count, _Inout_updates_all_(count) XMVECTOR* pBuffer, _In_ size_t count,
_In_ DXGI_FORMAT outFormat, _In_ DXGI_FORMAT inFormat, _In_ TEX_FILTER_FLAGS flags) noexcept; _In_ DXGI_FORMAT outFormat, _In_ DXGI_FORMAT inFormat, _In_ TEX_FILTER_FLAGS flags) noexcept;
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// DDS helper functions // Misc helper functions
HRESULT __cdecl _EncodeDDSHeader( bool IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept;
_In_ const TexMetadata& metadata, DDS_FLAGS flags, bool CalculateMipLevels(_In_ size_t width, _In_ size_t height, _Inout_ size_t& mipLevels) noexcept;
_Out_writes_bytes_to_opt_(maxsize, required) void* pDestination, _In_ size_t maxsize, _Out_ size_t& required) noexcept; bool CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth,
_Inout_ size_t& mipLevels) noexcept;
} // namespace #ifdef WIN32
HRESULT ResizeSeparateColorAndAlpha(_In_ IWICImagingFactory* pWIC,
_In_ bool iswic2,
_In_ IWICBitmap* original,
_In_ size_t newWidth, _In_ size_t newHeight, _In_ TEX_FILTER_FLAGS filter,
_Inout_ const Image* img) noexcept;
#endif
} // namespace Internal
} // namespace DirectX

17
DirectXTex/DirectXTexPMAlpha.cpp
View File

@ -12,6 +12,7 @@
#include "DirectXTexP.h" #include "DirectXTexP.h"
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
namespace namespace
{ {
@ -42,7 +43,7 @@ namespace
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format)) if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
return E_FAIL; return E_FAIL;
XMVECTOR* ptr = scanline.get(); XMVECTOR* ptr = scanline.get();
@ -54,7 +55,7 @@ namespace
*(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110); *(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
} }
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width)) if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
return E_FAIL; return E_FAIL;
pSrc += srcImage.rowPitch; pSrc += srcImage.rowPitch;
@ -87,7 +88,7 @@ namespace
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanlineLinear(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format, filter)) if (!LoadScanlineLinear(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format, filter))
return E_FAIL; return E_FAIL;
XMVECTOR* ptr = scanline.get(); XMVECTOR* ptr = scanline.get();
@ -99,7 +100,7 @@ namespace
*(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110); *(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
} }
if (!_StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width, filter)) if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width, filter))
return E_FAIL; return E_FAIL;
pSrc += srcImage.rowPitch; pSrc += srcImage.rowPitch;
@ -127,7 +128,7 @@ namespace
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format)) if (!LoadScanline(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format))
return E_FAIL; return E_FAIL;
XMVECTOR* ptr = scanline.get(); XMVECTOR* ptr = scanline.get();
@ -142,7 +143,7 @@ namespace
*(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110); *(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
} }
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width)) if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width))
return E_FAIL; return E_FAIL;
pSrc += srcImage.rowPitch; pSrc += srcImage.rowPitch;
@ -175,7 +176,7 @@ namespace
for (size_t h = 0; h < srcImage.height; ++h) for (size_t h = 0; h < srcImage.height; ++h)
{ {
if (!_LoadScanlineLinear(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format, filter)) if (!LoadScanlineLinear(scanline.get(), srcImage.width, pSrc, srcImage.rowPitch, srcImage.format, filter))
return E_FAIL; return E_FAIL;
XMVECTOR* ptr = scanline.get(); XMVECTOR* ptr = scanline.get();
@ -190,7 +191,7 @@ namespace
*(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110); *(ptr++) = XMVectorSelect(v, alpha, g_XMSelect1110);
} }
if (!_StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width, filter)) if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, scanline.get(), srcImage.width, filter))
return E_FAIL; return E_FAIL;
pSrc += srcImage.rowPitch; pSrc += srcImage.rowPitch;

78
DirectXTex/DirectXTexResize.cpp
View File

@ -14,16 +14,9 @@
#include "filters.h" #include "filters.h"
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
using Microsoft::WRL::ComPtr; using Microsoft::WRL::ComPtr;
#ifdef WIN32
namespace DirectX
{
extern HRESULT _ResizeSeparateColorAndAlpha(_In_ IWICImagingFactory* pWIC, _In_ bool iswic2, _In_ IWICBitmap* original,
_In_ size_t newWidth, _In_ size_t newHeight, _In_ TEX_FILTER_FLAGS filter, _Inout_ const Image* img) noexcept;
}
#endif
namespace namespace
{ {
#ifdef WIN32 #ifdef WIN32
@ -72,7 +65,7 @@ namespace
if ((filter & TEX_FILTER_SEPARATE_ALPHA) && supportsTransparency) if ((filter & TEX_FILTER_SEPARATE_ALPHA) && supportsTransparency)
{ {
hr = _ResizeSeparateColorAndAlpha(pWIC, iswic2, source.Get(), destImage.width, destImage.height, filter, &destImage); hr = ResizeSeparateColorAndAlpha(pWIC, iswic2, source.Get(), destImage.width, destImage.height, filter, &destImage);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
} }
@ -83,7 +76,9 @@ namespace
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
hr = scaler->Initialize(source.Get(), static_cast<UINT>(destImage.width), static_cast<UINT>(destImage.height), _GetWICInterp(filter)); hr = scaler->Initialize(source.Get(),
static_cast<UINT>(destImage.width), static_cast<UINT>(destImage.height),
GetWICInterp(filter));
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -114,7 +109,8 @@ namespace
return E_UNEXPECTED; return E_UNEXPECTED;
} }
hr = FC->Initialize(scaler.Get(), pfGUID, _GetWICDither(filter), nullptr, 0, WICBitmapPaletteTypeMedianCut); hr = FC->Initialize(scaler.Get(), pfGUID, GetWICDither(filter), nullptr,
0, WICBitmapPaletteTypeMedianCut);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -141,7 +137,7 @@ namespace
assert(srcImage.format == destImage.format); assert(srcImage.format == destImage.format);
ScratchImage temp; ScratchImage temp;
HRESULT hr = _ConvertToR32G32B32A32(srcImage, temp); HRESULT hr = ConvertToR32G32B32A32(srcImage, temp);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -164,7 +160,7 @@ namespace
temp.Release(); temp.Release();
hr = _ConvertFromR32G32B32A32(*tdest, destImage); hr = ConvertFromR32G32B32A32(*tdest, destImage);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -281,7 +277,7 @@ namespace
{ {
if ((lasty ^ sy) >> 16) if ((lasty ^ sy) >> 16)
{ {
if (!_LoadScanline(row, srcImage.width, pSrc + (rowPitch * (sy >> 16)), rowPitch, srcImage.format)) if (!LoadScanline(row, srcImage.width, pSrc + (rowPitch * (sy >> 16)), rowPitch, srcImage.format))
return E_FAIL; return E_FAIL;
lasty = sy; lasty = sy;
} }
@ -293,7 +289,7 @@ namespace
sx += xinc; sx += xinc;
} }
if (!_StoreScanline(pDest, destImage.rowPitch, destImage.format, target, destImage.width)) if (!StoreScanline(pDest, destImage.rowPitch, destImage.format, target, destImage.width))
return E_FAIL; return E_FAIL;
pDest += destImage.rowPitch; pDest += destImage.rowPitch;
@ -307,6 +303,8 @@ namespace
//--- Box Filter --- //--- Box Filter ---
HRESULT ResizeBoxFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept HRESULT ResizeBoxFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
{ {
using namespace DirectX::Filters;
assert(srcImage.pixels && destImage.pixels); assert(srcImage.pixels && destImage.pixels);
assert(srcImage.format == destImage.format); assert(srcImage.format == destImage.format);
@ -338,13 +336,13 @@ namespace
for (size_t y = 0; y < destImage.height; ++y) for (size_t y = 0; y < destImage.height; ++y)
{ {
if (!_LoadScanlineLinear(urow0, srcImage.width, pSrc, rowPitch, srcImage.format, filter)) if (!LoadScanlineLinear(urow0, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
return E_FAIL; return E_FAIL;
pSrc += rowPitch; pSrc += rowPitch;
if (urow0 != urow1) if (urow0 != urow1)
{ {
if (!_LoadScanlineLinear(urow1, srcImage.width, pSrc, rowPitch, srcImage.format, filter)) if (!LoadScanlineLinear(urow1, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
return E_FAIL; return E_FAIL;
pSrc += rowPitch; pSrc += rowPitch;
} }
@ -356,7 +354,7 @@ namespace
AVERAGE4(target[x], urow0[x2], urow1[x2], urow2[x2], urow3[x2]) AVERAGE4(target[x], urow0[x2], urow1[x2], urow2[x2], urow3[x2])
} }
if (!_StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter)) if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
return E_FAIL; return E_FAIL;
pDest += destImage.rowPitch; pDest += destImage.rowPitch;
} }
@ -368,6 +366,8 @@ namespace
//--- Linear Filter --- //--- Linear Filter ---
HRESULT ResizeLinearFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept HRESULT ResizeLinearFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
{ {
using namespace DirectX::Filters;
assert(srcImage.pixels && destImage.pixels); assert(srcImage.pixels && destImage.pixels);
assert(srcImage.format == destImage.format); assert(srcImage.format == destImage.format);
@ -383,8 +383,8 @@ namespace
LinearFilter* lfX = lf.get(); LinearFilter* lfX = lf.get();
LinearFilter* lfY = lf.get() + destImage.width; LinearFilter* lfY = lf.get() + destImage.width;
_CreateLinearFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, lfX); CreateLinearFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
_CreateLinearFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, lfY); CreateLinearFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
XMVECTOR* target = scanline.get(); XMVECTOR* target = scanline.get();
@ -414,7 +414,7 @@ namespace
{ {
u0 = toY.u0; u0 = toY.u0;
if (!_LoadScanlineLinear(row0, srcImage.width, pSrc + (rowPitch * u0), rowPitch, srcImage.format, filter)) if (!LoadScanlineLinear(row0, srcImage.width, pSrc + (rowPitch * u0), rowPitch, srcImage.format, filter))
return E_FAIL; return E_FAIL;
} }
else else
@ -430,7 +430,7 @@ namespace
{ {
u1 = toY.u1; u1 = toY.u1;
if (!_LoadScanlineLinear(row1, srcImage.width, pSrc + (rowPitch * u1), rowPitch, srcImage.format, filter)) if (!LoadScanlineLinear(row1, srcImage.width, pSrc + (rowPitch * u1), rowPitch, srcImage.format, filter))
return E_FAIL; return E_FAIL;
} }
@ -441,7 +441,7 @@ namespace
BILINEAR_INTERPOLATE(target[x], toX, toY, row0, row1) BILINEAR_INTERPOLATE(target[x], toX, toY, row0, row1)
} }
if (!_StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter)) if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
return E_FAIL; return E_FAIL;
pDest += destImage.rowPitch; pDest += destImage.rowPitch;
} }
@ -453,6 +453,8 @@ namespace
//--- Cubic Filter --- //--- Cubic Filter ---
HRESULT ResizeCubicFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept HRESULT ResizeCubicFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
{ {
using namespace DirectX::Filters;
assert(srcImage.pixels && destImage.pixels); assert(srcImage.pixels && destImage.pixels);
assert(srcImage.format == destImage.format); assert(srcImage.format == destImage.format);
@ -468,8 +470,8 @@ namespace
CubicFilter* cfX = cf.get(); CubicFilter* cfX = cf.get();
CubicFilter* cfY = cf.get() + destImage.width; CubicFilter* cfY = cf.get() + destImage.width;
_CreateCubicFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX); CreateCubicFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
_CreateCubicFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY); CreateCubicFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
XMVECTOR* target = scanline.get(); XMVECTOR* target = scanline.get();
@ -506,7 +508,7 @@ namespace
{ {
u0 = toY.u0; u0 = toY.u0;
if (!_LoadScanlineLinear(row0, srcImage.width, pSrc + (rowPitch * u0), rowPitch, srcImage.format, filter)) if (!LoadScanlineLinear(row0, srcImage.width, pSrc + (rowPitch * u0), rowPitch, srcImage.format, filter))
return E_FAIL; return E_FAIL;
} }
else if (toY.u0 == u1) else if (toY.u0 == u1)
@ -539,7 +541,7 @@ namespace
{ {
u1 = toY.u1; u1 = toY.u1;
if (!_LoadScanlineLinear(row1, srcImage.width, pSrc + (rowPitch * u1), rowPitch, srcImage.format, filter)) if (!LoadScanlineLinear(row1, srcImage.width, pSrc + (rowPitch * u1), rowPitch, srcImage.format, filter))
return E_FAIL; return E_FAIL;
} }
else if (toY.u1 == u2) else if (toY.u1 == u2)
@ -565,7 +567,7 @@ namespace
{ {
u2 = toY.u2; u2 = toY.u2;
if (!_LoadScanlineLinear(row2, srcImage.width, pSrc + (rowPitch * u2), rowPitch, srcImage.format, filter)) if (!LoadScanlineLinear(row2, srcImage.width, pSrc + (rowPitch * u2), rowPitch, srcImage.format, filter))
return E_FAIL; return E_FAIL;
} }
else else
@ -582,7 +584,7 @@ namespace
{ {
u3 = toY.u3; u3 = toY.u3;
if (!_LoadScanlineLinear(row3, srcImage.width, pSrc + (rowPitch * u3), rowPitch, srcImage.format, filter)) if (!LoadScanlineLinear(row3, srcImage.width, pSrc + (rowPitch * u3), rowPitch, srcImage.format, filter))
return E_FAIL; return E_FAIL;
} }
@ -600,7 +602,7 @@ namespace
CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3) CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3)
} }
if (!_StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter)) if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
return E_FAIL; return E_FAIL;
pDest += destImage.rowPitch; pDest += destImage.rowPitch;
} }
@ -612,11 +614,11 @@ namespace
//--- Triangle Filter --- //--- Triangle Filter ---
HRESULT ResizeTriangleFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept HRESULT ResizeTriangleFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
{ {
using namespace DirectX::Filters;
assert(srcImage.pixels && destImage.pixels); assert(srcImage.pixels && destImage.pixels);
assert(srcImage.format == destImage.format); assert(srcImage.format == destImage.format);
using namespace TriangleFilter;
// Allocate initial temporary space (1 scanline, accumulation rows, plus X and Y filters) // Allocate initial temporary space (1 scanline, accumulation rows, plus X and Y filters)
auto scanline = make_AlignedArrayXMVECTOR(srcImage.width); auto scanline = make_AlignedArrayXMVECTOR(srcImage.width);
if (!scanline) if (!scanline)
@ -629,12 +631,12 @@ namespace
TriangleRow * rowFree = nullptr; TriangleRow * rowFree = nullptr;
std::unique_ptr<Filter> tfX; std::unique_ptr<Filter> tfX;
HRESULT hr = _Create(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, tfX); HRESULT hr = CreateTriangleFilter(srcImage.width, destImage.width, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
std::unique_ptr<Filter> tfY; std::unique_ptr<Filter> tfY;
hr = _Create(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, tfY); hr = CreateTriangleFilter(srcImage.height, destImage.height, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -701,7 +703,7 @@ namespace
if ((pSrc + rowPitch) > pEndSrc) if ((pSrc + rowPitch) > pEndSrc)
return E_FAIL; return E_FAIL;
if (!_LoadScanlineLinear(row, srcImage.width, pSrc, rowPitch, srcImage.format, filter)) if (!LoadScanlineLinear(row, srcImage.width, pSrc, rowPitch, srcImage.format, filter))
return E_FAIL; return E_FAIL;
pSrc += rowPitch; pSrc += rowPitch;
@ -773,7 +775,7 @@ namespace
} }
// This performs any required clamping // This performs any required clamping
if (!_StoreScanlineLinear(pDest + (destImage.rowPitch * v), destImage.rowPitch, destImage.format, pAccSrc, destImage.width, filter)) if (!StoreScanlineLinear(pDest + (destImage.rowPitch * v), destImage.rowPitch, destImage.format, pAccSrc, destImage.width, filter))
return E_FAIL; return E_FAIL;
// Put row on freelist to reuse it's allocated scanline // Put row on freelist to reuse it's allocated scanline
@ -866,7 +868,7 @@ HRESULT DirectX::Resize(
bool usewic = UseWICFiltering(srcImage.format, filter); bool usewic = UseWICFiltering(srcImage.format, filter);
WICPixelFormatGUID pfGUID = {}; WICPixelFormatGUID pfGUID = {};
bool wicpf = (usewic) ? _DXGIToWIC(srcImage.format, pfGUID, true) : false; bool wicpf = (usewic) ? DXGIToWIC(srcImage.format, pfGUID, true) : false;
if (usewic && !wicpf) if (usewic && !wicpf)
{ {
@ -953,7 +955,7 @@ HRESULT DirectX::Resize(
bool usewic = !metadata.IsPMAlpha() && UseWICFiltering(metadata.format, filter); bool usewic = !metadata.IsPMAlpha() && UseWICFiltering(metadata.format, filter);
WICPixelFormatGUID pfGUID = {}; WICPixelFormatGUID pfGUID = {};
bool wicpf = (usewic) ? _DXGIToWIC(metadata.format, pfGUID, true) : false; bool wicpf = (usewic) ? DXGIToWIC(metadata.format, pfGUID, true) : false;
if (usewic && !wicpf) if (usewic && !wicpf)
{ {

13
DirectXTex/DirectXTexTGA.cpp
View File

@ -20,6 +20,7 @@
// //
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
namespace namespace
{ {
@ -270,7 +271,7 @@ namespace
for (size_t y = 0; y < image->height; ++y) for (size_t y = 0; y < image->height; ++y)
{ {
_CopyScanline(pPixels, image->rowPitch, pPixels, image->rowPitch, image->format, TEXP_SCANLINE_SETALPHA); CopyScanline(pPixels, image->rowPitch, pPixels, image->rowPitch, image->format, TEXP_SCANLINE_SETALPHA);
pPixels += image->rowPitch; pPixels += image->rowPitch;
} }
@ -1792,7 +1793,7 @@ HRESULT DirectX::LoadFromTGAFile(
for (size_t h = 0; h < img->height; ++h) for (size_t h = 0; h < img->height; ++h)
{ {
_SwizzleScanline(pPixels, rowPitch, pPixels, rowPitch, mdata.format, tflags); SwizzleScanline(pPixels, rowPitch, pPixels, rowPitch, mdata.format, tflags);
pPixels += rowPitch; pPixels += rowPitch;
} }
} }
@ -2115,11 +2116,11 @@ HRESULT DirectX::SaveToTGAMemory(
} }
else if (convFlags & CONV_FLAGS_SWIZZLE) else if (convFlags & CONV_FLAGS_SWIZZLE)
{ {
_SwizzleScanline(dPtr, rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE); SwizzleScanline(dPtr, rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
} }
else else
{ {
_CopyScanline(dPtr, rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE); CopyScanline(dPtr, rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
} }
dPtr += rowPitch; dPtr += rowPitch;
@ -2268,11 +2269,11 @@ HRESULT DirectX::SaveToTGAFile(
} }
else if (convFlags & CONV_FLAGS_SWIZZLE) else if (convFlags & CONV_FLAGS_SWIZZLE)
{ {
_SwizzleScanline(temp.get(), rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE); SwizzleScanline(temp.get(), rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
} }
else else
{ {
_CopyScanline(temp.get(), rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE); CopyScanline(temp.get(), rowPitch, pPixels, image.rowPitch, image.format, TEXP_SCANLINE_NONE);
} }
pPixels += image.rowPitch; pPixels += image.rowPitch;

6
DirectXTex/DirectXTexUtil.cpp
View File

@ -133,7 +133,7 @@ namespace
//===================================================================================== //=====================================================================================
_Use_decl_annotations_ _Use_decl_annotations_
DXGI_FORMAT DirectX::_WICToDXGI(const GUID& guid) noexcept DXGI_FORMAT DirectX::Internal::WICToDXGI(const GUID& guid) noexcept
{ {
for (size_t i = 0; i < std::size(g_WICFormats); ++i) for (size_t i = 0; i < std::size(g_WICFormats); ++i)
{ {
@ -153,7 +153,7 @@ DXGI_FORMAT DirectX::_WICToDXGI(const GUID& guid) noexcept
} }
_Use_decl_annotations_ _Use_decl_annotations_
bool DirectX::_DXGIToWIC(DXGI_FORMAT format, GUID& guid, bool ignoreRGBvsBGR) noexcept bool DirectX::Internal::DXGIToWIC(DXGI_FORMAT format, GUID& guid, bool ignoreRGBvsBGR) noexcept
{ {
switch (format) switch (format)
{ {
@ -213,7 +213,7 @@ bool DirectX::_DXGIToWIC(DXGI_FORMAT format, GUID& guid, bool ignoreRGBvsBGR) no
return false; return false;
} }
TEX_FILTER_FLAGS DirectX::_CheckWICColorSpace(_In_ const GUID& sourceGUID, _In_ const GUID& targetGUID) noexcept TEX_FILTER_FLAGS DirectX::Internal::CheckWICColorSpace(_In_ const GUID& sourceGUID, _In_ const GUID& targetGUID) noexcept
{ {
TEX_FILTER_FLAGS srgb = TEX_FILTER_DEFAULT; TEX_FILTER_FLAGS srgb = TEX_FILTER_DEFAULT;

25
DirectXTex/DirectXTexWIC.cpp
View File

@ -12,6 +12,7 @@
#include "DirectXTexP.h" #include "DirectXTexP.h"
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
using Microsoft::WRL::ComPtr; using Microsoft::WRL::ComPtr;
namespace namespace
@ -99,7 +100,7 @@ namespace
*alphaMode = TEX_ALPHA_MODE_UNKNOWN; *alphaMode = TEX_ALPHA_MODE_UNKNOWN;
DXGI_FORMAT format = _WICToDXGI(pixelFormat); DXGI_FORMAT format = WICToDXGI(pixelFormat);
if (format == DXGI_FORMAT_UNKNOWN) if (format == DXGI_FORMAT_UNKNOWN)
{ {
@ -132,7 +133,7 @@ namespace
if (pConvert) if (pConvert)
memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID)); memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID));
format = _WICToDXGI(g_WICConvert[i].target); format = WICToDXGI(g_WICConvert[i].target);
assert(format != DXGI_FORMAT_UNKNOWN); assert(format != DXGI_FORMAT_UNKNOWN);
*alphaMode = g_WICConvert[i].alphaMode; *alphaMode = g_WICConvert[i].alphaMode;
break; break;
@ -712,7 +713,8 @@ namespace
return E_UNEXPECTED; return E_UNEXPECTED;
} }
hr = FC->Initialize(frame, convertGUID, _GetWICDither(flags), nullptr, 0, WICBitmapPaletteTypeMedianCut); hr = FC->Initialize(frame, convertGUID, GetWICDither(flags), nullptr,
0, WICBitmapPaletteTypeMedianCut);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -747,7 +749,7 @@ namespace
return E_NOINTERFACE; return E_NOINTERFACE;
WICPixelFormatGUID sourceGUID; WICPixelFormatGUID sourceGUID;
if (!_DXGIToWIC(metadata.format, sourceGUID)) if (!DXGIToWIC(metadata.format, sourceGUID))
return E_FAIL; return E_FAIL;
for (size_t index = 0; index < metadata.arraySize; ++index) for (size_t index = 0; index < metadata.arraySize; ++index)
@ -797,7 +799,8 @@ namespace
return E_UNEXPECTED; return E_UNEXPECTED;
} }
hr = FC->Initialize(frame.Get(), sourceGUID, _GetWICDither(flags), nullptr, 0, WICBitmapPaletteTypeMedianCut); hr = FC->Initialize(frame.Get(), sourceGUID, GetWICDither(flags), nullptr,
0, WICBitmapPaletteTypeMedianCut);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -814,7 +817,9 @@ namespace
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
hr = scaler->Initialize(frame.Get(), static_cast<UINT>(metadata.width), static_cast<UINT>(metadata.height), _GetWICInterp(flags)); hr = scaler->Initialize(frame.Get(),
static_cast<UINT>(metadata.width), static_cast<UINT>(metadata.height),
GetWICInterp(flags));
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -845,7 +850,8 @@ namespace
return E_UNEXPECTED; return E_UNEXPECTED;
} }
hr = FC->Initialize(scaler.Get(), sourceGUID, _GetWICDither(flags), nullptr, 0, WICBitmapPaletteTypeMedianCut); hr = FC->Initialize(scaler.Get(), sourceGUID, GetWICDither(flags), nullptr,
0, WICBitmapPaletteTypeMedianCut);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -978,7 +984,7 @@ namespace
return E_POINTER; return E_POINTER;
WICPixelFormatGUID pfGuid; WICPixelFormatGUID pfGuid;
if (!_DXGIToWIC(image.format, pfGuid)) if (!DXGIToWIC(image.format, pfGuid))
return HRESULT_E_NOT_SUPPORTED; return HRESULT_E_NOT_SUPPORTED;
HRESULT hr = frame->Initialize(props); HRESULT hr = frame->Initialize(props);
@ -1041,7 +1047,8 @@ namespace
return E_UNEXPECTED; return E_UNEXPECTED;
} }
hr = FC->Initialize(source.Get(), targetGuid, _GetWICDither(flags), nullptr, 0, WICBitmapPaletteTypeMedianCut); hr = FC->Initialize(source.Get(), targetGuid, GetWICDither(flags), nullptr,
0, WICBitmapPaletteTypeMedianCut);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;

18
DirectXTex/d3dx12.h
View File

@ -2463,16 +2463,16 @@ template <typename InnerStructType, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE Type, ty
class alignas(void*) CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT class alignas(void*) CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT
{ {
private: private:
D3D12_PIPELINE_STATE_SUBOBJECT_TYPE _Type; D3D12_PIPELINE_STATE_SUBOBJECT_TYPE pssType;
InnerStructType _Inner; InnerStructType pssInner;
public: public:
CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT() noexcept : _Type(Type), _Inner(DefaultArg()) {} CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT() noexcept : pssType(Type), pssInner(DefaultArg()) {}
CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT(InnerStructType const& i) noexcept : _Type(Type), _Inner(i) {} CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT(InnerStructType const& i) noexcept : pssType(Type), pssInner(i) {}
CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT& operator=(InnerStructType const& i) noexcept { _Type = Type; _Inner = i; return *this; } CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT& operator=(InnerStructType const& i) noexcept { pssType = Type; pssInner = i; return *this; }
operator InnerStructType const&() const noexcept { return _Inner; } operator InnerStructType const&() const noexcept { return pssInner; }
operator InnerStructType&() noexcept { return _Inner; } operator InnerStructType&() noexcept { return pssInner; }
InnerStructType* operator&() noexcept { return &_Inner; } InnerStructType* operator&() noexcept { return &pssInner; }
InnerStructType const* operator&() const noexcept { return &_Inner; } InnerStructType const* operator&() const noexcept { return &pssInner; }
}; };
#pragma warning(pop) #pragma warning(pop)
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PIPELINE_STATE_FLAGS, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS> CD3DX12_PIPELINE_STATE_STREAM_FLAGS; typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PIPELINE_STATE_FLAGS, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS> CD3DX12_PIPELINE_STATE_STREAM_FLAGS;

619
DirectXTex/filters.h
View File

@ -16,15 +16,17 @@
#include "scoped.h" #include "scoped.h"
namespace DirectX namespace DirectX
{ {
namespace Filters
{
//-------------------------------------------------------------------------------------
// Box filtering helpers
//-------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------- XMGLOBALCONST XMVECTORF32 g_boxScale = { { { 0.25f, 0.25f, 0.25f, 0.25f } } };
// Box filtering helpers XMGLOBALCONST XMVECTORF32 g_boxScale3D = { { { 0.125f, 0.125f, 0.125f, 0.125f } } };
//-------------------------------------------------------------------------------------
XMGLOBALCONST XMVECTORF32 g_boxScale = { { { 0.25f, 0.25f, 0.25f, 0.25f } } };
XMGLOBALCONST XMVECTORF32 g_boxScale3D = { { { 0.125f, 0.125f, 0.125f, 0.125f } } };
#define AVERAGE4( res, p0, p1, p2, p3 ) \ #define AVERAGE4( res, p0, p1, p2, p3 ) \
{ \ { \
@ -47,56 +49,56 @@ XMGLOBALCONST XMVECTORF32 g_boxScale3D = { { { 0.125f, 0.125f, 0.125f, 0.125f }
} }
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
// Linear filtering helpers // Linear filtering helpers
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
struct LinearFilter struct LinearFilter
{
size_t u0;
float weight0;
size_t u1;
float weight1;
};
inline void _CreateLinearFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Out_writes_(dest) LinearFilter* lf) noexcept
{
assert(source > 0);
assert(dest > 0);
assert(lf != nullptr);
float scale = float(source) / float(dest);
// Mirror is the same case as clamp for linear
for (size_t u = 0; u < dest; ++u)
{
float srcB = (float(u) + 0.5f) * scale + 0.5f;
ptrdiff_t isrcB = ptrdiff_t(srcB);
ptrdiff_t isrcA = isrcB - 1;
float weight = 1.0f + float(isrcB) - srcB;
if (isrcA < 0)
{ {
isrcA = (wrap) ? (ptrdiff_t(source) - 1) : 0; size_t u0;
} float weight0;
size_t u1;
float weight1;
};
if (size_t(isrcB) >= source) inline void CreateLinearFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Out_writes_(dest) LinearFilter* lf) noexcept
{ {
isrcB = (wrap) ? 0 : (ptrdiff_t(source) - 1); assert(source > 0);
assert(dest > 0);
assert(lf != nullptr);
float scale = float(source) / float(dest);
// Mirror is the same case as clamp for linear
for (size_t u = 0; u < dest; ++u)
{
float srcB = (float(u) + 0.5f) * scale + 0.5f;
ptrdiff_t isrcB = ptrdiff_t(srcB);
ptrdiff_t isrcA = isrcB - 1;
float weight = 1.0f + float(isrcB) - srcB;
if (isrcA < 0)
{
isrcA = (wrap) ? (ptrdiff_t(source) - 1) : 0;
}
if (size_t(isrcB) >= source)
{
isrcB = (wrap) ? 0 : (ptrdiff_t(source) - 1);
}
auto& entry = lf[u];
entry.u0 = size_t(isrcA);
entry.weight0 = weight;
entry.u1 = size_t(isrcB);
entry.weight1 = 1.0f - weight;
}
} }
auto& entry = lf[u];
entry.u0 = size_t(isrcA);
entry.weight0 = weight;
entry.u1 = size_t(isrcB);
entry.weight1 = 1.0f - weight;
}
}
#define BILINEAR_INTERPOLATE( res, x, y, r0, r1 ) \ #define BILINEAR_INTERPOLATE( res, x, y, r0, r1 ) \
res = XMVectorAdd(XMVectorScale(XMVectorAdd(XMVectorScale((r0)[ x.u0 ], x.weight0), XMVectorScale((r0)[ x.u1 ], x.weight1)), y.weight0), \ res = XMVectorAdd(XMVectorScale(XMVectorAdd(XMVectorScale((r0)[ x.u0 ], x.weight0), XMVectorScale((r0)[ x.u1 ], x.weight1)), y.weight0), \
XMVectorScale(XMVectorAdd(XMVectorScale((r1)[ x.u0 ], x.weight0), XMVectorScale((r1)[ x.u1 ], x.weight1)), y.weight1) ); XMVectorScale(XMVectorAdd(XMVectorScale((r1)[ x.u0 ], x.weight0), XMVectorScale((r1)[ x.u1 ], x.weight1)), y.weight1) );
@ -110,82 +112,82 @@ inline void _CreateLinearFilter(_In_ size_t source, _In_ size_t dest, _In_ bool
res = XMVectorAdd(XMVectorScale(XMVectorAdd(a0, a1), z.weight0), XMVectorScale(XMVectorAdd(a2, a3), z.weight1)); \ res = XMVectorAdd(XMVectorScale(XMVectorAdd(a0, a1), z.weight0), XMVectorScale(XMVectorAdd(a2, a3), z.weight1)); \
} }
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
// Cubic filtering helpers // Cubic filtering helpers
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
XMGLOBALCONST XMVECTORF32 g_cubicThird = { { { 1.f / 3.f, 1.f / 3.f, 1.f / 3.f, 1.f / 3.f } } }; XMGLOBALCONST XMVECTORF32 g_cubicThird = { { { 1.f / 3.f, 1.f / 3.f, 1.f / 3.f, 1.f / 3.f } } };
XMGLOBALCONST XMVECTORF32 g_cubicSixth = { { { 1.f / 6.f, 1.f / 6.f, 1.f / 6.f, 1.f / 6.f } } }; XMGLOBALCONST XMVECTORF32 g_cubicSixth = { { { 1.f / 6.f, 1.f / 6.f, 1.f / 6.f, 1.f / 6.f } } };
XMGLOBALCONST XMVECTORF32 g_cubicHalf = { { { 1.f / 2.f, 1.f / 2.f, 1.f / 2.f, 1.f / 2.f } } }; XMGLOBALCONST XMVECTORF32 g_cubicHalf = { { { 1.f / 2.f, 1.f / 2.f, 1.f / 2.f, 1.f / 2.f } } };
inline ptrdiff_t bounduvw(ptrdiff_t u, ptrdiff_t maxu, bool wrap, bool mirror) noexcept inline ptrdiff_t bounduvw(ptrdiff_t u, ptrdiff_t maxu, bool wrap, bool mirror) noexcept
{
if (wrap)
{
if (u < 0)
{ {
u = maxu + u + 1; if (wrap)
{
if (u < 0)
{
u = maxu + u + 1;
}
else if (u > maxu)
{
u = u - maxu - 1;
}
}
else if (mirror)
{
if (u < 0)
{
u = (-u) - 1;
}
else if (u > maxu)
{
u = maxu - (u - maxu - 1);
}
}
// Handles clamp, but also a safety factor for degenerate images for wrap/mirror
u = std::min<ptrdiff_t>(u, maxu);
u = std::max<ptrdiff_t>(u, 0);
return u;
} }
else if (u > maxu)
struct CubicFilter
{ {
u = u - maxu - 1; size_t u0;
} size_t u1;
} size_t u2;
else if (mirror) size_t u3;
{ float x;
if (u < 0) };
inline void CreateCubicFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _In_ bool mirror, _Out_writes_(dest) CubicFilter* cf) noexcept
{ {
u = (-u) - 1; assert(source > 0);
assert(dest > 0);
assert(cf != nullptr);
float scale = float(source) / float(dest);
for (size_t u = 0; u < dest; ++u)
{
float srcB = (float(u) + 0.5f) * scale - 0.5f;
ptrdiff_t isrcB = bounduvw(ptrdiff_t(srcB), ptrdiff_t(source) - 1, wrap, mirror);
ptrdiff_t isrcA = bounduvw(isrcB - 1, ptrdiff_t(source) - 1, wrap, mirror);
ptrdiff_t isrcC = bounduvw(isrcB + 1, ptrdiff_t(source) - 1, wrap, mirror);
ptrdiff_t isrcD = bounduvw(isrcB + 2, ptrdiff_t(source) - 1, wrap, mirror);
auto& entry = cf[u];
entry.u0 = size_t(isrcA);
entry.u1 = size_t(isrcB);
entry.u2 = size_t(isrcC);
entry.u3 = size_t(isrcD);
float x = srcB - float(isrcB);
entry.x = x;
}
} }
else if (u > maxu)
{
u = maxu - (u - maxu - 1);
}
}
// Handles clamp, but also a safety factor for degenerate images for wrap/mirror
u = std::min<ptrdiff_t>(u, maxu);
u = std::max<ptrdiff_t>(u, 0);
return u;
}
struct CubicFilter
{
size_t u0;
size_t u1;
size_t u2;
size_t u3;
float x;
};
inline void _CreateCubicFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _In_ bool mirror, _Out_writes_(dest) CubicFilter* cf) noexcept
{
assert(source > 0);
assert(dest > 0);
assert(cf != nullptr);
float scale = float(source) / float(dest);
for (size_t u = 0; u < dest; ++u)
{
float srcB = (float(u) + 0.5f) * scale - 0.5f;
ptrdiff_t isrcB = bounduvw(ptrdiff_t(srcB), ptrdiff_t(source) - 1, wrap, mirror);
ptrdiff_t isrcA = bounduvw(isrcB - 1, ptrdiff_t(source) - 1, wrap, mirror);
ptrdiff_t isrcC = bounduvw(isrcB + 1, ptrdiff_t(source) - 1, wrap, mirror);
ptrdiff_t isrcD = bounduvw(isrcB + 2, ptrdiff_t(source) - 1, wrap, mirror);
auto& entry = cf[u];
entry.u0 = size_t(isrcA);
entry.u1 = size_t(isrcB);
entry.u2 = size_t(isrcC);
entry.u3 = size_t(isrcD);
float x = srcB - float(isrcB);
entry.x = x;
}
}
#define CUBIC_INTERPOLATE( res, dx, p0, p1, p2, p3 ) \ #define CUBIC_INTERPOLATE( res, dx, p0, p1, p2, p3 ) \
{ \ { \
@ -205,219 +207,216 @@ inline void _CreateCubicFilter(_In_ size_t source, _In_ size_t dest, _In_ bool w
} }
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
// Triangle filtering helpers // Triangle filtering helpers
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
namespace TriangleFilter struct FilterTo
{
struct FilterTo
{
size_t u;
float weight;
};
struct FilterFrom
{
size_t count;
size_t sizeInBytes;
FilterTo to[1]; // variable-sized array
};
struct Filter
{
size_t sizeInBytes;
size_t totalSize;
FilterFrom from[1]; // variable-sized array
};
struct TriangleRow
{
size_t remaining;
TriangleRow* next;
ScopedAlignedArrayXMVECTOR scanline;
TriangleRow() noexcept : remaining(0), next(nullptr) {}
};
constexpr size_t TF_FILTER_SIZE = sizeof(Filter) - sizeof(FilterFrom);
constexpr size_t TF_FROM_SIZE = sizeof(FilterFrom) - sizeof(FilterTo);
constexpr size_t TF_TO_SIZE = sizeof(FilterTo);
constexpr float TF_EPSILON = 0.00001f;
inline HRESULT _Create(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Inout_ std::unique_ptr<Filter>& tf) noexcept
{
assert(source > 0);
assert(dest > 0);
float scale = float(dest) / float(source);
float scaleInv = 0.5f / scale;
// Determine storage required for filter and allocate memory if needed
size_t totalSize = TF_FILTER_SIZE + TF_FROM_SIZE + TF_TO_SIZE;
float repeat = (wrap) ? 1.f : 0.f;
for (size_t u = 0; u < source; ++u)
{ {
float src = float(u) - 0.5f; size_t u;
float destMin = src * scale; float weight;
float destMax = destMin + scale; };
float t = destMax - destMin + repeat + 1.f;
totalSize += TF_FROM_SIZE + TF_TO_SIZE + size_t(t) * TF_TO_SIZE * 2;
}
uint8_t* pFilter = nullptr; struct FilterFrom
if (tf)
{ {
// See if existing filter memory block is large enough to reuse size_t count;
if (tf->totalSize >= totalSize) size_t sizeInBytes;
FilterTo to[1]; // variable-sized array
};
struct Filter
{
size_t sizeInBytes;
size_t totalSize;
FilterFrom from[1]; // variable-sized array
};
struct TriangleRow
{
size_t remaining;
TriangleRow* next;
ScopedAlignedArrayXMVECTOR scanline;
TriangleRow() noexcept : remaining(0), next(nullptr) {}
};
constexpr size_t TF_FILTER_SIZE = sizeof(Filter) - sizeof(FilterFrom);
constexpr size_t TF_FROM_SIZE = sizeof(FilterFrom) - sizeof(FilterTo);
constexpr size_t TF_TO_SIZE = sizeof(FilterTo);
constexpr float TF_EPSILON = 0.00001f;
inline HRESULT CreateTriangleFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Inout_ std::unique_ptr<Filter>& tf) noexcept
{
assert(source > 0);
assert(dest > 0);
float scale = float(dest) / float(source);
float scaleInv = 0.5f / scale;
// Determine storage required for filter and allocate memory if needed
size_t totalSize = TF_FILTER_SIZE + TF_FROM_SIZE + TF_TO_SIZE;
float repeat = (wrap) ? 1.f : 0.f;
for (size_t u = 0; u < source; ++u)
{ {
pFilter = reinterpret_cast<uint8_t*>(tf.get()); float src = float(u) - 0.5f;
}
else
{
// Need to reallocate filter memory block
tf.reset(nullptr);
}
}
if (!tf)
{
// Allocate filter memory block
pFilter = new (std::nothrow) uint8_t[totalSize];
if (!pFilter)
return E_OUTOFMEMORY;
tf.reset(reinterpret_cast<Filter*>(pFilter));
tf->totalSize = totalSize;
}
assert(pFilter != nullptr);
_Analysis_assume_(pFilter != nullptr);
// Filter setup
size_t sizeInBytes = TF_FILTER_SIZE;
size_t accumU = 0;
float accumWeight = 0.f;
for (size_t u = 0; u < source; ++u)
{
// Setup from entry
size_t sizeFrom = sizeInBytes;
auto pFrom = reinterpret_cast<FilterFrom*>(pFilter + sizeInBytes);
sizeInBytes += TF_FROM_SIZE;
if (sizeInBytes > totalSize)
return E_FAIL;
size_t toCount = 0;
// Perform two passes to capture the influences from both sides
for (size_t j = 0; j < 2; ++j)
{
float src = float(u + j) - 0.5f;
float destMin = src * scale; float destMin = src * scale;
float destMax = destMin + scale; float destMax = destMin + scale;
float t = destMax - destMin + repeat + 1.f;
totalSize += TF_FROM_SIZE + TF_TO_SIZE + size_t(t) * TF_TO_SIZE * 2;
}
if (!wrap) uint8_t* pFilter = nullptr;
if (tf)
{
// See if existing filter memory block is large enough to reuse
if (tf->totalSize >= totalSize)
{ {
// Clamp pFilter = reinterpret_cast<uint8_t*>(tf.get());
if (destMin < 0.f)
destMin = 0.f;
if (destMax > float(dest))
destMax = float(dest);
} }
else
for (auto k = static_cast<ptrdiff_t>(floorf(destMin)); float(k) < destMax; ++k)
{ {
float d0 = float(k); // Need to reallocate filter memory block
float d1 = d0 + 1.f; tf.reset(nullptr);
size_t u0;
if (k < 0)
{
// Handle wrap
u0 = size_t(k + ptrdiff_t(dest));
}
else if (k >= ptrdiff_t(dest))
{
// Handle wrap
u0 = size_t(k - ptrdiff_t(dest));
}
else
{
u0 = size_t(k);
}
// Save previous accumulated weight (if any)
if (u0 != accumU)
{
if (accumWeight > TF_EPSILON)
{
auto pTo = reinterpret_cast<FilterTo*>(pFilter + sizeInBytes);
sizeInBytes += TF_TO_SIZE;
++toCount;
if (sizeInBytes > totalSize)
return E_FAIL;
pTo->u = accumU;
pTo->weight = accumWeight;
}
accumWeight = 0.f;
accumU = u0;
}
// Clip destination
if (d0 < destMin)
d0 = destMin;
if (d1 > destMax)
d1 = destMax;
// Calculate average weight over destination pixel
float weight;
if (!wrap && src < 0.f)
weight = 1.f;
else if (!wrap && ((src + 1.f) >= float(source)))
weight = 0.f;
else
weight = (d0 + d1) * scaleInv - src;
accumWeight += (d1 - d0) * (j ? (1.f - weight) : weight);
} }
} }
// Store accumulated weight if (!tf)
if (accumWeight > TF_EPSILON)
{ {
auto pTo = reinterpret_cast<FilterTo*>(pFilter + sizeInBytes); // Allocate filter memory block
sizeInBytes += TF_TO_SIZE; pFilter = new (std::nothrow) uint8_t[totalSize];
++toCount; if (!pFilter)
return E_OUTOFMEMORY;
tf.reset(reinterpret_cast<Filter*>(pFilter));
tf->totalSize = totalSize;
}
assert(pFilter != nullptr);
_Analysis_assume_(pFilter != nullptr);
// Filter setup
size_t sizeInBytes = TF_FILTER_SIZE;
size_t accumU = 0;
float accumWeight = 0.f;
for (size_t u = 0; u < source; ++u)
{
// Setup from entry
size_t sizeFrom = sizeInBytes;
auto pFrom = reinterpret_cast<FilterFrom*>(pFilter + sizeInBytes);
sizeInBytes += TF_FROM_SIZE;
if (sizeInBytes > totalSize) if (sizeInBytes > totalSize)
return E_FAIL; return E_FAIL;
pTo->u = accumU; size_t toCount = 0;
pTo->weight = accumWeight;
// Perform two passes to capture the influences from both sides
for (size_t j = 0; j < 2; ++j)
{
float src = float(u + j) - 0.5f;
float destMin = src * scale;
float destMax = destMin + scale;
if (!wrap)
{
// Clamp
if (destMin < 0.f)
destMin = 0.f;
if (destMax > float(dest))
destMax = float(dest);
}
for (auto k = static_cast<ptrdiff_t>(floorf(destMin)); float(k) < destMax; ++k)
{
float d0 = float(k);
float d1 = d0 + 1.f;
size_t u0;
if (k < 0)
{
// Handle wrap
u0 = size_t(k + ptrdiff_t(dest));
}
else if (k >= ptrdiff_t(dest))
{
// Handle wrap
u0 = size_t(k - ptrdiff_t(dest));
}
else
{
u0 = size_t(k);
}
// Save previous accumulated weight (if any)
if (u0 != accumU)
{
if (accumWeight > TF_EPSILON)
{
auto pTo = reinterpret_cast<FilterTo*>(pFilter + sizeInBytes);
sizeInBytes += TF_TO_SIZE;
++toCount;
if (sizeInBytes > totalSize)
return E_FAIL;
pTo->u = accumU;
pTo->weight = accumWeight;
}
accumWeight = 0.f;
accumU = u0;
}
// Clip destination
if (d0 < destMin)
d0 = destMin;
if (d1 > destMax)
d1 = destMax;
// Calculate average weight over destination pixel
float weight;
if (!wrap && src < 0.f)
weight = 1.f;
else if (!wrap && ((src + 1.f) >= float(source)))
weight = 0.f;
else
weight = (d0 + d1) * scaleInv - src;
accumWeight += (d1 - d0) * (j ? (1.f - weight) : weight);
}
}
// Store accumulated weight
if (accumWeight > TF_EPSILON)
{
auto pTo = reinterpret_cast<FilterTo*>(pFilter + sizeInBytes);
sizeInBytes += TF_TO_SIZE;
++toCount;
if (sizeInBytes > totalSize)
return E_FAIL;
pTo->u = accumU;
pTo->weight = accumWeight;
}
accumWeight = 0.f;
// Finalize from entry
pFrom->count = toCount;
pFrom->sizeInBytes = sizeInBytes - sizeFrom;
} }
accumWeight = 0.f; tf->sizeInBytes = sizeInBytes;
// Finalize from entry return S_OK;
pFrom->count = toCount;
pFrom->sizeInBytes = sizeInBytes - sizeFrom;
} }
tf->sizeInBytes = sizeInBytes; } // namespace Filters
return S_OK;
}
} // namespace TriangleFilter
} // namespace DirectX } // namespace DirectX

4
ScreenGrab/ScreenGrab11.cpp
View File

@ -768,7 +768,7 @@ namespace
#endif #endif
} }
IWICImagingFactory* _GetWIC() noexcept IWICImagingFactory* GetWIC() noexcept
{ {
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT; static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
@ -1022,7 +1022,7 @@ HRESULT DirectX::SaveWICTextureToFile(
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED); return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
} }
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;

4
ScreenGrab/ScreenGrab12.cpp
View File

@ -863,7 +863,7 @@ namespace
ifactory)) ? TRUE : FALSE; ifactory)) ? TRUE : FALSE;
} }
IWICImagingFactory2* _GetWIC() noexcept IWICImagingFactory2* GetWIC() noexcept
{ {
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT; static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
@ -1200,7 +1200,7 @@ HRESULT DirectX::SaveWICTextureToFile(
return HRESULT_E_NOT_SUPPORTED; return HRESULT_E_NOT_SUPPORTED;
} }
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;

4
ScreenGrab/ScreenGrab9.cpp
View File

@ -549,7 +549,7 @@ namespace
#endif #endif
} }
IWICImagingFactory* _GetWIC() IWICImagingFactory* GetWIC()
{ {
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT; static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
@ -770,7 +770,7 @@ HRESULT DirectX::SaveWICTextureToFile(
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED); return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
} }
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;

24
WICTextureLoader/WICTextureLoader11.cpp
View File

@ -216,7 +216,7 @@ namespace
#endif #endif
} }
IWICImagingFactory* _GetWIC() noexcept IWICImagingFactory* GetWIC() noexcept
{ {
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT; static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
@ -234,7 +234,7 @@ namespace
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
DXGI_FORMAT _WICToDXGI(const GUID& guid) noexcept DXGI_FORMAT WICToDXGI(const GUID& guid) noexcept
{ {
for (size_t i = 0; i < std::size(g_WICFormats); ++i) for (size_t i = 0; i < std::size(g_WICFormats); ++i)
{ {
@ -254,9 +254,9 @@ namespace
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
size_t _WICBitsPerPixel(REFGUID targetGuid) noexcept size_t WICBitsPerPixel(REFGUID targetGuid) noexcept
{ {
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return 0; return 0;
@ -449,7 +449,7 @@ namespace
size_t bpp = 0; size_t bpp = 0;
DXGI_FORMAT format = _WICToDXGI(pixelFormat); DXGI_FORMAT format = WICToDXGI(pixelFormat);
if (format == DXGI_FORMAT_UNKNOWN) if (format == DXGI_FORMAT_UNKNOWN)
{ {
if (memcmp(&GUID_WICPixelFormat96bppRGBFixedPoint, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0) if (memcmp(&GUID_WICPixelFormat96bppRGBFixedPoint, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0)
@ -477,9 +477,9 @@ namespace
{ {
memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID)); memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID));
format = _WICToDXGI(g_WICConvert[i].target); format = WICToDXGI(g_WICConvert[i].target);
assert(format != DXGI_FORMAT_UNKNOWN); assert(format != DXGI_FORMAT_UNKNOWN);
bpp = _WICBitsPerPixel(convertGUID); bpp = WICBitsPerPixel(convertGUID);
break; break;
} }
} }
@ -490,7 +490,7 @@ namespace
} }
else else
{ {
bpp = _WICBitsPerPixel(pixelFormat); bpp = WICBitsPerPixel(pixelFormat);
} }
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
@ -609,7 +609,7 @@ namespace
else if (twidth != width || theight != height) else if (twidth != width || theight != height)
{ {
// Resize // Resize
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;
@ -660,7 +660,7 @@ namespace
else else
{ {
// Format conversion but no resize // Format conversion but no resize
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;
@ -921,7 +921,7 @@ HRESULT DirectX::CreateWICTextureFromMemoryEx(
if (wicDataSize > UINT32_MAX) if (wicDataSize > UINT32_MAX)
return HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE); return HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE);
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;
@ -1055,7 +1055,7 @@ HRESULT DirectX::CreateWICTextureFromFileEx(
return E_INVALIDARG; return E_INVALIDARG;
} }
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;

24
WICTextureLoader/WICTextureLoader12.cpp
View File

@ -177,7 +177,7 @@ namespace
ifactory)) ? TRUE : FALSE; ifactory)) ? TRUE : FALSE;
} }
IWICImagingFactory2* _GetWIC() noexcept IWICImagingFactory2* GetWIC() noexcept
{ {
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT; static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
@ -253,7 +253,7 @@ namespace
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
DXGI_FORMAT _WICToDXGI(const GUID& guid) noexcept DXGI_FORMAT WICToDXGI(const GUID& guid) noexcept
{ {
for (size_t i = 0; i < std::size(g_WICFormats); ++i) for (size_t i = 0; i < std::size(g_WICFormats); ++i)
{ {
@ -265,9 +265,9 @@ namespace
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
size_t _WICBitsPerPixel(REFGUID targetGuid) noexcept size_t WICBitsPerPixel(REFGUID targetGuid) noexcept
{ {
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return 0; return 0;
@ -398,7 +398,7 @@ namespace
size_t bpp = 0; size_t bpp = 0;
DXGI_FORMAT format = _WICToDXGI(pixelFormat); DXGI_FORMAT format = WICToDXGI(pixelFormat);
if (format == DXGI_FORMAT_UNKNOWN) if (format == DXGI_FORMAT_UNKNOWN)
{ {
for (size_t i = 0; i < std::size(g_WICConvert); ++i) for (size_t i = 0; i < std::size(g_WICConvert); ++i)
@ -407,9 +407,9 @@ namespace
{ {
memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID)); memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID));
format = _WICToDXGI(g_WICConvert[i].target); format = WICToDXGI(g_WICConvert[i].target);
assert(format != DXGI_FORMAT_UNKNOWN); assert(format != DXGI_FORMAT_UNKNOWN);
bpp = _WICBitsPerPixel(convertGUID); bpp = WICBitsPerPixel(convertGUID);
break; break;
} }
} }
@ -419,7 +419,7 @@ namespace
} }
else else
{ {
bpp = _WICBitsPerPixel(pixelFormat); bpp = WICBitsPerPixel(pixelFormat);
} }
if (loadFlags & WIC_LOADER_FORCE_RGBA32) if (loadFlags & WIC_LOADER_FORCE_RGBA32)
@ -510,7 +510,7 @@ namespace
else if (twidth != width || theight != height) else if (twidth != width || theight != height)
{ {
// Resize // Resize
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;
@ -561,7 +561,7 @@ namespace
else else
{ {
// Format conversion but no resize // Format conversion but no resize
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;
@ -708,7 +708,7 @@ HRESULT DirectX::LoadWICTextureFromMemoryEx(
if (wicDataSize > UINT32_MAX) if (wicDataSize > UINT32_MAX)
return HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE); return HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE);
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;
@ -789,7 +789,7 @@ HRESULT DirectX::LoadWICTextureFromFileEx(
if (!d3dDevice || !fileName || !texture) if (!d3dDevice || !fileName || !texture)
return E_INVALIDARG; return E_INVALIDARG;
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;

16
WICTextureLoader/WICTextureLoader9.cpp
View File

@ -197,7 +197,7 @@ namespace
#endif #endif
} }
IWICImagingFactory* _GetWIC() noexcept IWICImagingFactory* GetWIC() noexcept
{ {
static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT; static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT;
@ -215,7 +215,7 @@ namespace
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
D3DFORMAT _WICToD3D9(const GUID& guid) noexcept D3DFORMAT WICToD3D9(const GUID& guid) noexcept
{ {
for (size_t i = 0; i < std::size(g_WICFormats); ++i) for (size_t i = 0; i < std::size(g_WICFormats); ++i)
{ {
@ -331,7 +331,7 @@ namespace
WICPixelFormatGUID convertGUID; WICPixelFormatGUID convertGUID;
memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &pixelFormat, sizeof(GUID)); memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &pixelFormat, sizeof(GUID));
D3DFORMAT format = _WICToD3D9(pixelFormat); D3DFORMAT format = WICToD3D9(pixelFormat);
if (format == D3DFMT_UNKNOWN) if (format == D3DFMT_UNKNOWN)
{ {
for (size_t i = 0; i < std::size(g_WICConvert); ++i) for (size_t i = 0; i < std::size(g_WICConvert); ++i)
@ -340,7 +340,7 @@ namespace
{ {
memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID)); memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID));
format = _WICToD3D9(g_WICConvert[i].target); format = WICToD3D9(g_WICConvert[i].target);
assert(format != D3DFMT_UNKNOWN); assert(format != D3DFMT_UNKNOWN);
break; break;
} }
@ -417,7 +417,7 @@ namespace
else if (twidth != width || theight != height) else if (twidth != width || theight != height)
{ {
// Resize // Resize
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;
@ -484,7 +484,7 @@ namespace
else else
{ {
// Format conversion but no resize // Format conversion but no resize
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;
@ -569,7 +569,7 @@ HRESULT DirectX::CreateWICTextureFromMemoryEx(
if (wicDataSize > UINT32_MAX) if (wicDataSize > UINT32_MAX)
return HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE); return HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE);
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;
@ -627,7 +627,7 @@ HRESULT DirectX::CreateWICTextureFromFileEx(
if (!d3dDevice || !fileName || !texture) if (!d3dDevice || !fileName || !texture)
return E_INVALIDARG; return E_INVALIDARG;
auto pWIC = _GetWIC(); auto pWIC = GetWIC();
if (!pWIC) if (!pWIC)
return E_NOINTERFACE; return E_NOINTERFACE;