Yidhra/DirectXTex
2
0
Fork 0
mirror of https://github.com/microsoft/DirectXTex.git synced 2025-07-10 04:00:13 +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__)

39
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,12 +493,7 @@ namespace
} }
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
namespace DirectX bool DirectX::Internal::IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept
{
bool _IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept;
// Also used by Image
bool _IsAlphaAllOpaqueBC(_In_ const Image& cImage) noexcept
{ {
if (!cImage.pixels) if (!cImage.pixels)
return false; return false;
@ -580,7 +576,6 @@ namespace DirectX
return true; 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();

240
DirectXTex/DirectXTexMipmaps.cpp
View File

@ -14,6 +14,7 @@
#include "filters.h" #include "filters.h"
using namespace DirectX; using namespace DirectX;
using namespace DirectX::Internal;
using Microsoft::WRL::ComPtr; using Microsoft::WRL::ComPtr;
namespace namespace
@ -104,7 +105,8 @@ namespace
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
{ {
hr = converter->Initialize(src, desiredPixelFormat, _GetWICDither(filter), nullptr, 0, WICBitmapPaletteTypeMedianCut); hr = converter->Initialize(src, desiredPixelFormat, GetWICDither(filter), nullptr,
0, WICBitmapPaletteTypeMedianCut);
} }
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
@ -160,7 +162,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;
} }
@ -173,7 +175,7 @@ namespace
*(ptr++) = XMVectorSelect(alpha, v, g_XMSelect1110); *(ptr++) = XMVectorSelect(alpha, v, 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;
} }
@ -242,13 +244,13 @@ namespace
size_t coverageCount = 0; size_t coverageCount = 0;
for (size_t y = 0; y < srcImage.height - 1; ++y) for (size_t y = 0; y < srcImage.height - 1; ++y)
{ {
if (!_LoadScanlineLinear(row0.get(), srcImage.width, pSrcRow0, srcImage.rowPitch, srcImage.format, TEX_FILTER_DEFAULT)) if (!LoadScanlineLinear(row0.get(), srcImage.width, pSrcRow0, srcImage.rowPitch, srcImage.format, TEX_FILTER_DEFAULT))
{ {
return E_FAIL; return E_FAIL;
} }
const uint8_t *pSrcRow1 = pSrcRow0 + srcImage.rowPitch; const uint8_t *pSrcRow1 = pSrcRow0 + srcImage.rowPitch;
if (!_LoadScanlineLinear(row1.get(), srcImage.width, pSrcRow1, srcImage.rowPitch, srcImage.format, TEX_FILTER_DEFAULT)) if (!LoadScanlineLinear(row1.get(), srcImage.width, pSrcRow1, srcImage.rowPitch, srcImage.format, TEX_FILTER_DEFAULT))
{ {
return E_FAIL; return E_FAIL;
} }
@ -343,20 +345,11 @@ namespace
} }
} }
_Use_decl_annotations_
namespace DirectX bool DirectX::Internal::CalculateMipLevels(
{ size_t width,
bool _CalculateMipLevels(_In_ size_t width, _In_ size_t height, _Inout_ size_t& mipLevels) noexcept; size_t height,
bool _CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth, _Inout_ size_t& mipLevels) noexcept; size_t& mipLevels) noexcept
// Also used by Compress
#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;
// Also used by Resize
#endif
bool _CalculateMipLevels(_In_ size_t width, _In_ size_t height, _Inout_ size_t& mipLevels) noexcept
{ {
if (mipLevels > 1) if (mipLevels > 1)
{ {
@ -375,7 +368,12 @@ namespace DirectX
return true; return true;
} }
bool _CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth, _Inout_ size_t& mipLevels) noexcept _Use_decl_annotations_
bool DirectX::Internal::CalculateMipLevels3D(
size_t width,
size_t height,
size_t depth,
size_t& mipLevels) noexcept
{ {
if (mipLevels > 1) if (mipLevels > 1)
{ {
@ -397,7 +395,7 @@ namespace DirectX
#ifdef WIN32 #ifdef WIN32
//--- Resizing color and alpha channels separately using WIC --- //--- Resizing color and alpha channels separately using WIC ---
_Use_decl_annotations_ _Use_decl_annotations_
HRESULT _ResizeSeparateColorAndAlpha( HRESULT DirectX::Internal::ResizeSeparateColorAndAlpha(
IWICImagingFactory* pWIC, IWICImagingFactory* pWIC,
bool iswic2, bool iswic2,
IWICBitmap* original, IWICBitmap* original,
@ -409,7 +407,7 @@ namespace DirectX
if (!pWIC || !original || !img) if (!pWIC || !original || !img)
return E_POINTER; return E_POINTER;
const WICBitmapInterpolationMode interpolationMode = _GetWICInterp(filter); const WICBitmapInterpolationMode interpolationMode = GetWICInterp(filter);
WICPixelFormatGUID desiredPixelFormat = GUID_WICPixelFormatUndefined; WICPixelFormatGUID desiredPixelFormat = GUID_WICPixelFormatUndefined;
HRESULT hr = original->GetPixelFormat(&desiredPixelFormat); HRESULT hr = original->GetPixelFormat(&desiredPixelFormat);
@ -612,7 +610,6 @@ namespace DirectX
return hr; return hr;
} }
#endif // WIN32 #endif // WIN32
}
namespace namespace
{ {
@ -770,7 +767,7 @@ namespace
if ((filter & TEX_FILTER_SEPARATE_ALPHA) && supportsTransparency) if ((filter & TEX_FILTER_SEPARATE_ALPHA) && supportsTransparency)
{ {
hr = _ResizeSeparateColorAndAlpha(pWIC, iswic2, source.Get(), width, height, filter, img); hr = ResizeSeparateColorAndAlpha(pWIC, iswic2, source.Get(), width, height, filter, img);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
} }
@ -784,7 +781,9 @@ namespace
if (img->rowPitch > UINT32_MAX || img->slicePitch > UINT32_MAX) if (img->rowPitch > UINT32_MAX || img->slicePitch > UINT32_MAX)
return HRESULT_E_ARITHMETIC_OVERFLOW; return HRESULT_E_ARITHMETIC_OVERFLOW;
hr = scaler->Initialize(source.Get(), static_cast<UINT>(width), static_cast<UINT>(height), _GetWICInterp(filter)); hr = scaler->Initialize(source.Get(),
static_cast<UINT>(width), static_cast<UINT>(height),
GetWICInterp(filter));
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -815,7 +814,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;
@ -943,7 +943,7 @@ namespace
{ {
if ((lasty ^ sy) >> 16) if ((lasty ^ sy) >> 16)
{ {
if (!_LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format)) if (!LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
return E_FAIL; return E_FAIL;
lasty = sy; lasty = sy;
} }
@ -955,7 +955,7 @@ namespace
sx += xinc; sx += xinc;
} }
if (!_StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth)) if (!StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
@ -976,6 +976,8 @@ namespace
//--- 2D Box Filter --- //--- 2D Box Filter ---
HRESULT Generate2DMipsBoxFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept HRESULT Generate2DMipsBoxFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
{ {
using namespace DirectX::Filters;
if (!mipChain.GetImages()) if (!mipChain.GetImages())
return E_INVALIDARG; return E_INVALIDARG;
@ -1033,13 +1035,13 @@ namespace
for (size_t y = 0; y < nheight; ++y) for (size_t y = 0; y < nheight; ++y)
{ {
if (!_LoadScanlineLinear(urow0, width, pSrc, rowPitch, src->format, filter)) if (!LoadScanlineLinear(urow0, width, pSrc, rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
pSrc += rowPitch; pSrc += rowPitch;
if (urow0 != urow1) if (urow0 != urow1)
{ {
if (!_LoadScanlineLinear(urow1, width, pSrc, rowPitch, src->format, filter)) if (!LoadScanlineLinear(urow1, width, pSrc, rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
pSrc += rowPitch; pSrc += rowPitch;
} }
@ -1051,7 +1053,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, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
} }
@ -1070,6 +1072,8 @@ namespace
//--- 2D Linear Filter --- //--- 2D Linear Filter ---
HRESULT Generate2DMipsLinearFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept HRESULT Generate2DMipsLinearFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
{ {
using namespace DirectX::Filters;
if (!mipChain.GetImages()) if (!mipChain.GetImages())
return E_INVALIDARG; return E_INVALIDARG;
@ -1113,10 +1117,10 @@ namespace
size_t rowPitch = src->rowPitch; size_t rowPitch = src->rowPitch;
size_t nwidth = (width > 1) ? (width >> 1) : 1; size_t nwidth = (width > 1) ? (width >> 1) : 1;
_CreateLinearFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, lfX); CreateLinearFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
size_t nheight = (height > 1) ? (height >> 1) : 1; size_t nheight = (height > 1) ? (height >> 1) : 1;
_CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY); CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
#ifdef _DEBUG #ifdef _DEBUG
memset(row0, 0xCD, sizeof(XMVECTOR)*width); memset(row0, 0xCD, sizeof(XMVECTOR)*width);
@ -1136,7 +1140,7 @@ namespace
{ {
u0 = toY.u0; u0 = toY.u0;
if (!_LoadScanlineLinear(row0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter)) if (!LoadScanlineLinear(row0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
else else
@ -1152,7 +1156,7 @@ namespace
{ {
u1 = toY.u1; u1 = toY.u1;
if (!_LoadScanlineLinear(row1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter)) if (!LoadScanlineLinear(row1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
@ -1163,7 +1167,7 @@ namespace
BILINEAR_INTERPOLATE(target[x], toX, toY, row0, row1) BILINEAR_INTERPOLATE(target[x], toX, toY, row0, row1)
} }
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
} }
@ -1181,6 +1185,8 @@ namespace
//--- 2D Cubic Filter --- //--- 2D Cubic Filter ---
HRESULT Generate2DMipsCubicFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept HRESULT Generate2DMipsCubicFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
{ {
using namespace DirectX::Filters;
if (!mipChain.GetImages()) if (!mipChain.GetImages())
return E_INVALIDARG; return E_INVALIDARG;
@ -1226,10 +1232,10 @@ namespace
size_t rowPitch = src->rowPitch; size_t rowPitch = src->rowPitch;
size_t nwidth = (width > 1) ? (width >> 1) : 1; size_t nwidth = (width > 1) ? (width >> 1) : 1;
_CreateCubicFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX); CreateCubicFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
size_t nheight = (height > 1) ? (height >> 1) : 1; size_t nheight = (height > 1) ? (height >> 1) : 1;
_CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY); CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
#ifdef _DEBUG #ifdef _DEBUG
memset(row0, 0xCD, sizeof(XMVECTOR)*width); memset(row0, 0xCD, sizeof(XMVECTOR)*width);
@ -1254,7 +1260,7 @@ namespace
{ {
u0 = toY.u0; u0 = toY.u0;
if (!_LoadScanlineLinear(row0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter)) if (!LoadScanlineLinear(row0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
else if (toY.u0 == u1) else if (toY.u0 == u1)
@ -1287,7 +1293,7 @@ namespace
{ {
u1 = toY.u1; u1 = toY.u1;
if (!_LoadScanlineLinear(row1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter)) if (!LoadScanlineLinear(row1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
else if (toY.u1 == u2) else if (toY.u1 == u2)
@ -1313,7 +1319,7 @@ namespace
{ {
u2 = toY.u2; u2 = toY.u2;
if (!_LoadScanlineLinear(row2, width, pSrc + (rowPitch * u2), rowPitch, src->format, filter)) if (!LoadScanlineLinear(row2, width, pSrc + (rowPitch * u2), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
else else
@ -1330,7 +1336,7 @@ namespace
{ {
u3 = toY.u3; u3 = toY.u3;
if (!_LoadScanlineLinear(row3, width, pSrc + (rowPitch * u3), rowPitch, src->format, filter)) if (!LoadScanlineLinear(row3, width, pSrc + (rowPitch * u3), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
@ -1348,7 +1354,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, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
} }
@ -1367,11 +1373,11 @@ namespace
//--- 2D Triangle Filter --- //--- 2D Triangle Filter ---
HRESULT Generate2DMipsTriangleFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept HRESULT Generate2DMipsTriangleFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
{ {
using namespace DirectX::Filters;
if (!mipChain.GetImages()) if (!mipChain.GetImages())
return E_INVALIDARG; return E_INVALIDARG;
using namespace TriangleFilter;
// This assumes that the base image is already placed into the mipChain at the top level... (see _Setup2DMips) // This assumes that the base image is already placed into the mipChain at the top level... (see _Setup2DMips)
assert(levels > 1); assert(levels > 1);
@ -1411,12 +1417,12 @@ namespace
uint8_t* pDest = dest->pixels; uint8_t* pDest = dest->pixels;
size_t nwidth = (width > 1) ? (width >> 1) : 1; size_t nwidth = (width > 1) ? (width >> 1) : 1;
HRESULT hr = _Create(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, tfX); HRESULT hr = CreateTriangleFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
size_t nheight = (height > 1) ? (height >> 1) : 1; size_t nheight = (height > 1) ? (height >> 1) : 1;
hr = _Create(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, tfY); hr = CreateTriangleFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -1483,7 +1489,7 @@ namespace
if ((pSrc + rowPitch) > pEndSrc) if ((pSrc + rowPitch) > pEndSrc)
return E_FAIL; return E_FAIL;
if (!_LoadScanlineLinear(row, width, pSrc, rowPitch, src->format, filter)) if (!LoadScanlineLinear(row, width, pSrc, rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
pSrc += rowPitch; pSrc += rowPitch;
@ -1555,7 +1561,7 @@ namespace
} }
// This performs any required clamping // This performs any required clamping
if (!_StoreScanlineLinear(pDest + (dest->rowPitch * v), dest->rowPitch, dest->format, pAccSrc, dest->width, filter)) if (!StoreScanlineLinear(pDest + (dest->rowPitch * v), dest->rowPitch, dest->format, pAccSrc, dest->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
@ -1698,7 +1704,7 @@ namespace
{ {
if ((lasty ^ sy) >> 16) if ((lasty ^ sy) >> 16)
{ {
if (!_LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format)) if (!LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
return E_FAIL; return E_FAIL;
lasty = sy; lasty = sy;
} }
@ -1710,7 +1716,7 @@ namespace
sx += xinc; sx += xinc;
} }
if (!_StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth)) if (!StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
@ -1747,7 +1753,7 @@ namespace
{ {
if ((lasty ^ sy) >> 16) if ((lasty ^ sy) >> 16)
{ {
if (!_LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format)) if (!LoadScanline(row, width, pSrc + (rowPitch * (sy >> 16)), rowPitch, src->format))
return E_FAIL; return E_FAIL;
lasty = sy; lasty = sy;
} }
@ -1759,7 +1765,7 @@ namespace
sx += xinc; sx += xinc;
} }
if (!_StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth)) if (!StoreScanline(pDest, dest->rowPitch, dest->format, target, nwidth))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
@ -1784,6 +1790,8 @@ namespace
//--- 3D Box Filter --- //--- 3D Box Filter ---
HRESULT Generate3DMipsBoxFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept HRESULT Generate3DMipsBoxFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
{ {
using namespace DirectX::Filters;
if (!depth || !mipChain.GetImages()) if (!depth || !mipChain.GetImages())
return E_INVALIDARG; return E_INVALIDARG;
@ -1860,24 +1868,24 @@ namespace
for (size_t y = 0; y < nheight; ++y) for (size_t y = 0; y < nheight; ++y)
{ {
if (!_LoadScanlineLinear(urow0, width, pSrc1, aRowPitch, srca->format, filter)) if (!LoadScanlineLinear(urow0, width, pSrc1, aRowPitch, srca->format, filter))
return E_FAIL; return E_FAIL;
pSrc1 += aRowPitch; pSrc1 += aRowPitch;
if (urow0 != urow1) if (urow0 != urow1)
{ {
if (!_LoadScanlineLinear(urow1, width, pSrc1, aRowPitch, srca->format, filter)) if (!LoadScanlineLinear(urow1, width, pSrc1, aRowPitch, srca->format, filter))
return E_FAIL; return E_FAIL;
pSrc1 += aRowPitch; pSrc1 += aRowPitch;
} }
if (!_LoadScanlineLinear(vrow0, width, pSrc2, bRowPitch, srcb->format, filter)) if (!LoadScanlineLinear(vrow0, width, pSrc2, bRowPitch, srcb->format, filter))
return E_FAIL; return E_FAIL;
pSrc2 += bRowPitch; pSrc2 += bRowPitch;
if (vrow0 != vrow1) if (vrow0 != vrow1)
{ {
if (!_LoadScanlineLinear(vrow1, width, pSrc2, bRowPitch, srcb->format, filter)) if (!LoadScanlineLinear(vrow1, width, pSrc2, bRowPitch, srcb->format, filter))
return E_FAIL; return E_FAIL;
pSrc2 += bRowPitch; pSrc2 += bRowPitch;
} }
@ -1890,7 +1898,7 @@ namespace
vrow0[x2], vrow1[x2], vrow2[x2], vrow3[x2]) vrow0[x2], vrow1[x2], vrow2[x2], vrow3[x2])
} }
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
} }
@ -1915,13 +1923,13 @@ namespace
for (size_t y = 0; y < nheight; ++y) for (size_t y = 0; y < nheight; ++y)
{ {
if (!_LoadScanlineLinear(urow0, width, pSrc, rowPitch, src->format, filter)) if (!LoadScanlineLinear(urow0, width, pSrc, rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
pSrc += rowPitch; pSrc += rowPitch;
if (urow0 != urow1) if (urow0 != urow1)
{ {
if (!_LoadScanlineLinear(urow1, width, pSrc, rowPitch, src->format, filter)) if (!LoadScanlineLinear(urow1, width, pSrc, rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
pSrc += rowPitch; pSrc += rowPitch;
} }
@ -1933,7 +1941,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, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
} }
@ -1956,6 +1964,8 @@ namespace
//--- 3D Linear Filter --- //--- 3D Linear Filter ---
HRESULT Generate3DMipsLinearFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept HRESULT Generate3DMipsLinearFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
{ {
using namespace DirectX::Filters;
if (!depth || !mipChain.GetImages()) if (!depth || !mipChain.GetImages())
return E_INVALIDARG; return E_INVALIDARG;
@ -1990,10 +2000,10 @@ namespace
for (size_t level = 1; level < levels; ++level) for (size_t level = 1; level < levels; ++level)
{ {
size_t nwidth = (width > 1) ? (width >> 1) : 1; size_t nwidth = (width > 1) ? (width >> 1) : 1;
_CreateLinearFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, lfX); CreateLinearFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, lfX);
size_t nheight = (height > 1) ? (height >> 1) : 1; size_t nheight = (height > 1) ? (height >> 1) : 1;
_CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY); CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
#ifdef _DEBUG #ifdef _DEBUG
memset(urow0, 0xCD, sizeof(XMVECTOR)*width); memset(urow0, 0xCD, sizeof(XMVECTOR)*width);
@ -2006,7 +2016,7 @@ namespace
{ {
// 3D linear filter // 3D linear filter
size_t ndepth = depth >> 1; size_t ndepth = depth >> 1;
_CreateLinearFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, lfZ); CreateLinearFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, lfZ);
for (size_t slice = 0; slice < ndepth; ++slice) for (size_t slice = 0; slice < ndepth; ++slice)
{ {
@ -2036,8 +2046,8 @@ namespace
{ {
u0 = toY.u0; u0 = toY.u0;
if (!_LoadScanlineLinear(urow0, width, srca->pixels + (srca->rowPitch * u0), srca->rowPitch, srca->format, filter) if (!LoadScanlineLinear(urow0, width, srca->pixels + (srca->rowPitch * u0), srca->rowPitch, srca->format, filter)
|| !_LoadScanlineLinear(vrow0, width, srcb->pixels + (srcb->rowPitch * u0), srcb->rowPitch, srcb->format, filter)) || !LoadScanlineLinear(vrow0, width, srcb->pixels + (srcb->rowPitch * u0), srcb->rowPitch, srcb->format, filter))
return E_FAIL; return E_FAIL;
} }
else else
@ -2054,8 +2064,8 @@ namespace
{ {
u1 = toY.u1; u1 = toY.u1;
if (!_LoadScanlineLinear(urow1, width, srca->pixels + (srca->rowPitch * u1), srca->rowPitch, srca->format, filter) if (!LoadScanlineLinear(urow1, width, srca->pixels + (srca->rowPitch * u1), srca->rowPitch, srca->format, filter)
|| !_LoadScanlineLinear(vrow1, width, srcb->pixels + (srcb->rowPitch * u1), srcb->rowPitch, srcb->format, filter)) || !LoadScanlineLinear(vrow1, width, srcb->pixels + (srcb->rowPitch * u1), srcb->rowPitch, srcb->format, filter))
return E_FAIL; return E_FAIL;
} }
@ -2066,7 +2076,7 @@ namespace
TRILINEAR_INTERPOLATE(target[x], toX, toY, toZ, urow0, urow1, vrow0, vrow1) TRILINEAR_INTERPOLATE(target[x], toX, toY, toZ, urow0, urow1, vrow0, vrow1)
} }
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
} }
@ -2099,7 +2109,7 @@ namespace
{ {
u0 = toY.u0; u0 = toY.u0;
if (!_LoadScanlineLinear(urow0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter)) if (!LoadScanlineLinear(urow0, width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
else else
@ -2115,7 +2125,7 @@ namespace
{ {
u1 = toY.u1; u1 = toY.u1;
if (!_LoadScanlineLinear(urow1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter)) if (!LoadScanlineLinear(urow1, width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
@ -2126,7 +2136,7 @@ namespace
BILINEAR_INTERPOLATE(target[x], toX, toY, urow0, urow1) BILINEAR_INTERPOLATE(target[x], toX, toY, urow0, urow1)
} }
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
} }
@ -2149,6 +2159,8 @@ namespace
//--- 3D Cubic Filter --- //--- 3D Cubic Filter ---
HRESULT Generate3DMipsCubicFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept HRESULT Generate3DMipsCubicFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
{ {
using namespace DirectX::Filters;
if (!depth || !mipChain.GetImages()) if (!depth || !mipChain.GetImages())
return E_INVALIDARG; return E_INVALIDARG;
@ -2192,10 +2204,10 @@ namespace
for (size_t level = 1; level < levels; ++level) for (size_t level = 1; level < levels; ++level)
{ {
size_t nwidth = (width > 1) ? (width >> 1) : 1; size_t nwidth = (width > 1) ? (width >> 1) : 1;
_CreateCubicFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX); CreateCubicFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, (filter & TEX_FILTER_MIRROR_U) != 0, cfX);
size_t nheight = (height > 1) ? (height >> 1) : 1; size_t nheight = (height > 1) ? (height >> 1) : 1;
_CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY); CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
#ifdef _DEBUG #ifdef _DEBUG
for (size_t j = 0; j < 4; ++j) for (size_t j = 0; j < 4; ++j)
@ -2211,7 +2223,7 @@ namespace
{ {
// 3D cubic filter // 3D cubic filter
size_t ndepth = depth >> 1; size_t ndepth = depth >> 1;
_CreateCubicFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, (filter & TEX_FILTER_MIRROR_W) != 0, cfZ); CreateCubicFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, (filter & TEX_FILTER_MIRROR_W) != 0, cfZ);
for (size_t slice = 0; slice < ndepth; ++slice) for (size_t slice = 0; slice < ndepth; ++slice)
{ {
@ -2246,10 +2258,10 @@ namespace
{ {
u0 = toY.u0; u0 = toY.u0;
if (!_LoadScanlineLinear(urow[0], width, srca->pixels + (srca->rowPitch * u0), srca->rowPitch, srca->format, filter) if (!LoadScanlineLinear(urow[0], width, srca->pixels + (srca->rowPitch * u0), srca->rowPitch, srca->format, filter)
|| !_LoadScanlineLinear(urow[1], width, srcb->pixels + (srcb->rowPitch * u0), srcb->rowPitch, srcb->format, filter) || !LoadScanlineLinear(urow[1], width, srcb->pixels + (srcb->rowPitch * u0), srcb->rowPitch, srcb->format, filter)
|| !_LoadScanlineLinear(urow[2], width, srcc->pixels + (srcc->rowPitch * u0), srcc->rowPitch, srcc->format, filter) || !LoadScanlineLinear(urow[2], width, srcc->pixels + (srcc->rowPitch * u0), srcc->rowPitch, srcc->format, filter)
|| !_LoadScanlineLinear(urow[3], width, srcd->pixels + (srcd->rowPitch * u0), srcd->rowPitch, srcd->format, filter)) || !LoadScanlineLinear(urow[3], width, srcd->pixels + (srcd->rowPitch * u0), srcd->rowPitch, srcd->format, filter))
return E_FAIL; return E_FAIL;
} }
else if (toY.u0 == u1) else if (toY.u0 == u1)
@ -2291,10 +2303,10 @@ namespace
{ {
u1 = toY.u1; u1 = toY.u1;
if (!_LoadScanlineLinear(vrow[0], width, srca->pixels + (srca->rowPitch * u1), srca->rowPitch, srca->format, filter) if (!LoadScanlineLinear(vrow[0], width, srca->pixels + (srca->rowPitch * u1), srca->rowPitch, srca->format, filter)
|| !_LoadScanlineLinear(vrow[1], width, srcb->pixels + (srcb->rowPitch * u1), srcb->rowPitch, srcb->format, filter) || !LoadScanlineLinear(vrow[1], width, srcb->pixels + (srcb->rowPitch * u1), srcb->rowPitch, srcb->format, filter)
|| !_LoadScanlineLinear(vrow[2], width, srcc->pixels + (srcc->rowPitch * u1), srcc->rowPitch, srcc->format, filter) || !LoadScanlineLinear(vrow[2], width, srcc->pixels + (srcc->rowPitch * u1), srcc->rowPitch, srcc->format, filter)
|| !_LoadScanlineLinear(vrow[3], width, srcd->pixels + (srcd->rowPitch * u1), srcd->rowPitch, srcd->format, filter)) || !LoadScanlineLinear(vrow[3], width, srcd->pixels + (srcd->rowPitch * u1), srcd->rowPitch, srcd->format, filter))
return E_FAIL; return E_FAIL;
} }
else if (toY.u1 == u2) else if (toY.u1 == u2)
@ -2326,10 +2338,10 @@ namespace
{ {
u2 = toY.u2; u2 = toY.u2;
if (!_LoadScanlineLinear(srow[0], width, srca->pixels + (srca->rowPitch * u2), srca->rowPitch, srca->format, filter) if (!LoadScanlineLinear(srow[0], width, srca->pixels + (srca->rowPitch * u2), srca->rowPitch, srca->format, filter)
|| !_LoadScanlineLinear(srow[1], width, srcb->pixels + (srcb->rowPitch * u2), srcb->rowPitch, srcb->format, filter) || !LoadScanlineLinear(srow[1], width, srcb->pixels + (srcb->rowPitch * u2), srcb->rowPitch, srcb->format, filter)
|| !_LoadScanlineLinear(srow[2], width, srcc->pixels + (srcc->rowPitch * u2), srcc->rowPitch, srcc->format, filter) || !LoadScanlineLinear(srow[2], width, srcc->pixels + (srcc->rowPitch * u2), srcc->rowPitch, srcc->format, filter)
|| !_LoadScanlineLinear(srow[3], width, srcd->pixels + (srcd->rowPitch * u2), srcd->rowPitch, srcd->format, filter)) || !LoadScanlineLinear(srow[3], width, srcd->pixels + (srcd->rowPitch * u2), srcd->rowPitch, srcd->format, filter))
return E_FAIL; return E_FAIL;
} }
else else
@ -2349,10 +2361,10 @@ namespace
{ {
u3 = toY.u3; u3 = toY.u3;
if (!_LoadScanlineLinear(trow[0], width, srca->pixels + (srca->rowPitch * u3), srca->rowPitch, srca->format, filter) if (!LoadScanlineLinear(trow[0], width, srca->pixels + (srca->rowPitch * u3), srca->rowPitch, srca->format, filter)
|| !_LoadScanlineLinear(trow[1], width, srcb->pixels + (srcb->rowPitch * u3), srcb->rowPitch, srcb->format, filter) || !LoadScanlineLinear(trow[1], width, srcb->pixels + (srcb->rowPitch * u3), srcb->rowPitch, srcb->format, filter)
|| !_LoadScanlineLinear(trow[2], width, srcc->pixels + (srcc->rowPitch * u3), srcc->rowPitch, srcc->format, filter) || !LoadScanlineLinear(trow[2], width, srcc->pixels + (srcc->rowPitch * u3), srcc->rowPitch, srcc->format, filter)
|| !_LoadScanlineLinear(trow[3], width, srcd->pixels + (srcd->rowPitch * u3), srcd->rowPitch, srcd->format, filter)) || !LoadScanlineLinear(trow[3], width, srcd->pixels + (srcd->rowPitch * u3), srcd->rowPitch, srcd->format, filter))
return E_FAIL; return E_FAIL;
} }
@ -2376,7 +2388,7 @@ namespace
CUBIC_INTERPOLATE(target[x], toZ.x, D[0], D[1], D[2], D[3]) CUBIC_INTERPOLATE(target[x], toZ.x, D[0], D[1], D[2], D[3])
} }
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
} }
@ -2412,7 +2424,7 @@ namespace
{ {
u0 = toY.u0; u0 = toY.u0;
if (!_LoadScanlineLinear(urow[0], width, pSrc + (rowPitch * u0), rowPitch, src->format, filter)) if (!LoadScanlineLinear(urow[0], width, pSrc + (rowPitch * u0), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
else if (toY.u0 == u1) else if (toY.u0 == u1)
@ -2445,7 +2457,7 @@ namespace
{ {
u1 = toY.u1; u1 = toY.u1;
if (!_LoadScanlineLinear(vrow[0], width, pSrc + (rowPitch * u1), rowPitch, src->format, filter)) if (!LoadScanlineLinear(vrow[0], width, pSrc + (rowPitch * u1), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
else if (toY.u1 == u2) else if (toY.u1 == u2)
@ -2471,7 +2483,7 @@ namespace
{ {
u2 = toY.u2; u2 = toY.u2;
if (!_LoadScanlineLinear(srow[0], width, pSrc + (rowPitch * u2), rowPitch, src->format, filter)) if (!LoadScanlineLinear(srow[0], width, pSrc + (rowPitch * u2), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
else else
@ -2488,7 +2500,7 @@ namespace
{ {
u3 = toY.u3; u3 = toY.u3;
if (!_LoadScanlineLinear(trow[0], width, pSrc + (rowPitch * u3), rowPitch, src->format, filter)) if (!LoadScanlineLinear(trow[0], width, pSrc + (rowPitch * u3), rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
} }
@ -2505,7 +2517,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, dest->rowPitch, dest->format, target, nwidth, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
} }
@ -2528,11 +2540,11 @@ namespace
//--- 3D Triangle Filter --- //--- 3D Triangle Filter ---
HRESULT Generate3DMipsTriangleFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept HRESULT Generate3DMipsTriangleFilter(size_t depth, size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain) noexcept
{ {
using namespace DirectX::Filters;
if (!depth || !mipChain.GetImages()) if (!depth || !mipChain.GetImages())
return E_INVALIDARG; return E_INVALIDARG;
using namespace TriangleFilter;
// This assumes that the base images are already placed into the mipChain at the top level... (see _Setup3DMips) // This assumes that the base images are already placed into the mipChain at the top level... (see _Setup3DMips)
assert(levels > 1); assert(levels > 1);
@ -2559,17 +2571,17 @@ namespace
for (size_t level = 1; level < levels; ++level) for (size_t level = 1; level < levels; ++level)
{ {
size_t nwidth = (width > 1) ? (width >> 1) : 1; size_t nwidth = (width > 1) ? (width >> 1) : 1;
HRESULT hr = _Create(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, tfX); HRESULT hr = CreateTriangleFilter(width, nwidth, (filter & TEX_FILTER_WRAP_U) != 0, tfX);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
size_t nheight = (height > 1) ? (height >> 1) : 1; size_t nheight = (height > 1) ? (height >> 1) : 1;
hr = _Create(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, tfY); hr = CreateTriangleFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, tfY);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
size_t ndepth = (depth > 1) ? (depth >> 1) : 1; size_t ndepth = (depth > 1) ? (depth >> 1) : 1;
hr = _Create(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, tfZ); hr = CreateTriangleFilter(depth, ndepth, (filter & TEX_FILTER_WRAP_W) != 0, tfZ);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -2649,7 +2661,7 @@ namespace
if ((pSrc + rowPitch) > pEndSrc) if ((pSrc + rowPitch) > pEndSrc)
return E_FAIL; return E_FAIL;
if (!_LoadScanlineLinear(row, width, pSrc, rowPitch, src->format, filter)) if (!LoadScanlineLinear(row, width, pSrc, rowPitch, src->format, filter))
return E_FAIL; return E_FAIL;
pSrc += rowPitch; pSrc += rowPitch;
@ -2738,7 +2750,7 @@ namespace
} }
// This performs any required clamping // This performs any required clamping
if (!_StoreScanlineLinear(pDest, dest->rowPitch, dest->format, pAccSrc, dest->width, filter)) if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, pAccSrc, dest->width, filter))
return E_FAIL; return E_FAIL;
pDest += dest->rowPitch; pDest += dest->rowPitch;
@ -2790,7 +2802,7 @@ HRESULT DirectX::GenerateMipMaps(
if (!baseImage.pixels) if (!baseImage.pixels)
return E_POINTER; return E_POINTER;
if (!_CalculateMipLevels(baseImage.width, baseImage.height, levels)) if (!CalculateMipLevels(baseImage.width, baseImage.height, levels))
return E_INVALIDARG; return E_INVALIDARG;
if (levels <= 1) if (levels <= 1)
@ -2809,7 +2821,7 @@ HRESULT DirectX::GenerateMipMaps(
bool usewic = UseWICFiltering(baseImage.format, filter); bool usewic = UseWICFiltering(baseImage.format, filter);
WICPixelFormatGUID pfGUID = {}; WICPixelFormatGUID pfGUID = {};
bool wicpf = (usewic) ? _DXGIToWIC(baseImage.format, pfGUID, true) : false; bool wicpf = (usewic) ? DXGIToWIC(baseImage.format, pfGUID, true) : false;
if (usewic && !wicpf) if (usewic && !wicpf)
{ {
@ -2854,7 +2866,7 @@ HRESULT DirectX::GenerateMipMaps(
// Case 2: Base image format is not supported by WIC, so we have to convert, generate, and convert back // Case 2: Base image format is not supported by WIC, so we have to convert, generate, and convert back
assert(baseImage.format != DXGI_FORMAT_R32G32B32A32_FLOAT); assert(baseImage.format != DXGI_FORMAT_R32G32B32A32_FLOAT);
ScratchImage temp; ScratchImage temp;
hr = _ConvertToR32G32B32A32(baseImage, temp); hr = ConvertToR32G32B32A32(baseImage, temp);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -2875,7 +2887,7 @@ HRESULT DirectX::GenerateMipMaps(
temp.Release(); temp.Release();
return _ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), baseImage.format, mipChain); return ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), baseImage.format, mipChain);
} }
} }
@ -2984,7 +2996,7 @@ HRESULT DirectX::GenerateMipMaps(
|| IsCompressed(metadata.format) || IsTypeless(metadata.format) || IsPlanar(metadata.format) || IsPalettized(metadata.format)) || IsCompressed(metadata.format) || IsTypeless(metadata.format) || IsPlanar(metadata.format) || IsPalettized(metadata.format))
return HRESULT_E_NOT_SUPPORTED; return HRESULT_E_NOT_SUPPORTED;
if (!_CalculateMipLevels(metadata.width, metadata.height, levels)) if (!CalculateMipLevels(metadata.width, metadata.height, levels))
return E_INVALIDARG; return E_INVALIDARG;
if (levels <= 1) if (levels <= 1)
@ -3024,7 +3036,7 @@ HRESULT DirectX::GenerateMipMaps(
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)
{ {
@ -3090,7 +3102,7 @@ HRESULT DirectX::GenerateMipMaps(
for (size_t item = 0; item < metadata.arraySize; ++item) for (size_t item = 0; item < metadata.arraySize; ++item)
{ {
ScratchImage temp; ScratchImage temp;
hr = _ConvertToR32G32B32A32(baseImages[item], temp); hr = ConvertToR32G32B32A32(baseImages[item], temp);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
@ -3103,7 +3115,7 @@ HRESULT DirectX::GenerateMipMaps(
return hr; return hr;
} }
return _ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), metadata.format, mipChain); return ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), metadata.format, mipChain);
} }
} }
@ -3220,7 +3232,7 @@ HRESULT DirectX::GenerateMipMaps3D(
size_t width = baseImages[0].width; size_t width = baseImages[0].width;
size_t height = baseImages[0].height; size_t height = baseImages[0].height;
if (!_CalculateMipLevels3D(width, height, depth, levels)) if (!CalculateMipLevels3D(width, height, depth, levels))
return E_INVALIDARG; return E_INVALIDARG;
if (levels <= 1) if (levels <= 1)
@ -3328,7 +3340,7 @@ HRESULT DirectX::GenerateMipMaps3D(
|| IsCompressed(metadata.format) || IsTypeless(metadata.format) || IsPlanar(metadata.format) || IsPalettized(metadata.format)) || IsCompressed(metadata.format) || IsTypeless(metadata.format) || IsPlanar(metadata.format) || IsPalettized(metadata.format))
return HRESULT_E_NOT_SUPPORTED; return HRESULT_E_NOT_SUPPORTED;
if (!_CalculateMipLevels3D(metadata.width, metadata.height, metadata.depth, levels)) if (!CalculateMipLevels3D(metadata.width, metadata.height, metadata.depth, levels))
return E_INVALIDARG; return E_INVALIDARG;
if (levels <= 1) if (levels <= 1)

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

88
DirectXTex/DirectXTexP.h
View File

@ -203,17 +203,20 @@ 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 // WIC helper functions
#ifdef WIN32 #ifdef WIN32
DXGI_FORMAT __cdecl _WICToDXGI(_In_ const GUID& guid) noexcept; DXGI_FORMAT __cdecl WICToDXGI(_In_ const GUID& guid) noexcept;
bool __cdecl _DXGIToWIC(_In_ DXGI_FORMAT format, _Out_ GUID& guid, _In_ bool ignoreRGBvsBGR = false) 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; TEX_FILTER_FLAGS __cdecl CheckWICColorSpace(_In_ const GUID& sourceGUID, _In_ const GUID& targetGUID) noexcept;
inline WICBitmapDitherType __cdecl _GetWICDither(_In_ TEX_FILTER_FLAGS flags) 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"); static_assert(TEX_FILTER_DITHER == 0x10000, "TEX_FILTER_DITHER* flag values don't match mask");
@ -233,7 +236,7 @@ namespace DirectX
} }
} }
inline WICBitmapDitherType __cdecl _GetWICDither(_In_ WIC_FLAGS flags) noexcept inline WICBitmapDitherType __cdecl GetWICDither(_In_ WIC_FLAGS flags) noexcept
{ {
switch (flags & TEX_FILTER_DITHER_MASK) switch (flags & TEX_FILTER_DITHER_MASK)
{ {
@ -248,7 +251,7 @@ namespace DirectX
} }
} }
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(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MASK");
@ -274,7 +277,7 @@ namespace DirectX
} }
} }
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) switch (flags & TEX_FILTER_MODE_MASK)
{ {
@ -296,11 +299,11 @@ namespace DirectX
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// 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;
@ -339,69 +342,84 @@ namespace DirectX
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,
_In_ float threshold, size_t y, size_t z,
_Inout_updates_all_opt_(count + 2) XMVECTOR* pDiffusionErrors) noexcept; _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;
HRESULT __cdecl ConvertFromR32G32B32A32(
_In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata, _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
_In_ DXGI_FORMAT format, _Out_ ScratchImage& result) noexcept; _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;

15
DirectXTex/filters.h
View File

@ -16,9 +16,11 @@
#include "scoped.h" #include "scoped.h"
namespace DirectX namespace DirectX
{ {
namespace Filters
{
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
// Box filtering helpers // Box filtering helpers
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
@ -59,7 +61,7 @@ struct LinearFilter
float weight1; float weight1;
}; };
inline void _CreateLinearFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Out_writes_(dest) LinearFilter* lf) noexcept inline void CreateLinearFilter(_In_ size_t source, _In_ size_t dest, _In_ bool wrap, _Out_writes_(dest) LinearFilter* lf) noexcept
{ {
assert(source > 0); assert(source > 0);
assert(dest > 0); assert(dest > 0);
@ -159,7 +161,7 @@ struct CubicFilter
float x; 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 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(source > 0);
assert(dest > 0); assert(dest > 0);
@ -209,8 +211,6 @@ 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; size_t u;
@ -246,7 +246,7 @@ namespace TriangleFilter
constexpr float TF_EPSILON = 0.00001f; 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 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(source > 0);
assert(dest > 0); assert(dest > 0);
@ -418,6 +418,5 @@ namespace TriangleFilter
return S_OK; return S_OK;
} }
} // namespace TriangleFilter } // namespace Filters
} // 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;