From 0fd3a1a2b8e09f2e7d5cc8811df792071077e404 Mon Sep 17 00:00:00 2001 From: Leask Wong Date: Sun, 11 Oct 2026 23:52:18 -0400 Subject: [PATCH] Normalize swapchain backbuffers for the opt-in D3D9 single-sample path --- .../american-nightmare-pixel-debug.md | 16 ++ tools/dxvk/build.sh | 1 + tools/dxvk/check_d3d9_single_sample.py | 112 +++++++++ .../0004-d3d9-force-single-sample.patch | 20 ++ tools/dxvk/tests/d3d9_single_sample.cpp | 214 ++++++++++++++++++ 5 files changed, 363 insertions(+) create mode 100644 tools/dxvk/check_d3d9_single_sample.py create mode 100644 tools/dxvk/tests/d3d9_single_sample.cpp diff --git a/docs/development/american-nightmare-pixel-debug.md b/docs/development/american-nightmare-pixel-debug.md index 1f5291a455..ef5992dd03 100644 --- a/docs/development/american-nightmare-pixel-debug.md +++ b/docs/development/american-nightmare-pixel-debug.md @@ -29,6 +29,19 @@ alpha-to-coverage. It is a compatibility override, not transparent MSAA emulatio or a universal PowerVR default. Existing low32, BC-format, present synchronization and tiler workarounds must remain intact. +Swapchain backbuffers have a separate creation path. With the override enabled, +that path now validates a copy of the original requested descriptor and transfers +the effective sample type/quality before allocation, so automatic depth surfaces +and backbuffers agree. Validation uses the application's lockable-backbuffer flag; +the internal lockability required for GDI fallback is retained on the allocated +backbuffer. With the override disabled the original backbuffer path is unchanged. +This correction addresses official PR602 review 5486295088. Its CPU harness +compiles the actual DXVK sample decoder, surface normalizer and backbuffer method, +plus the automatic-depth descriptor and framebuffer depth-binding excerpts. +Fifteen cases cover on/off, NONMASKABLE quality, matching depth, no-depth operation, +unsupported/invalid/lockable requests, allocation cleanup and recreation. Backend +images and adapter capabilities are mocked; these are not GPU or gameplay tests. + ## Independent HUD correction The diagnostic frametimes HUD bound an R8_UINT storage texel buffer to a shader @@ -172,6 +185,9 @@ runtime or APK. Its output directory must be new or empty (including hidden entries). Prior or partially built outputs are refused before fetching sources, left untouched and never included in a new DLL manifest. Use a fresh directory after a failed build. +The recipe also requires a native C++17 compiler for +`python3 tools/dxvk/check_d3d9_single_sample.py /path/to/patched-dxvk` before DLL +compilation. Add `--sanitize` on supported hosts to run its ASan/UBSan controls. The compositor ownership safeguards are independently proposed in . Those native changes were present diff --git a/tools/dxvk/build.sh b/tools/dxvk/build.sh index f5d6563a20..d403aa0506 100755 --- a/tools/dxvk/build.sh +++ b/tools/dxvk/build.sh @@ -27,6 +27,7 @@ for patch in "$root"/tools/dxvk/patches/*.patch; do done python3 "$root/tools/dxvk/check_present_sync.py" "$work/source/src/dxvk/dxvk_presenter.cpp" python3 "$root/tools/dxvk/check_hud_storage_format.py" "$work/source/src/dxvk/hud/shaders/hud_frame_time_eval.comp" +python3 "$root/tools/dxvk/check_d3d9_single_sample.py" "$work/source" for arch in 32 64; do meson setup "$work/build$arch" "$work/source" --cross-file "$work/source/build-win$arch.txt" \ --buildtype release --prefix "$out" --bindir "x$arch" --libdir "x$arch" -Db_ndebug=if-release --strip diff --git a/tools/dxvk/check_d3d9_single_sample.py b/tools/dxvk/check_d3d9_single_sample.py new file mode 100644 index 0000000000..8f73a3f3a7 --- /dev/null +++ b/tools/dxvk/check_d3d9_single_sample.py @@ -0,0 +1,112 @@ +#!/usr/bin/env python3 +"""Compile pinned DXVK's actual descriptor paths against a controlled backend. + +This checks CPU control flow, not GPU rendering. No Wine/game/device is started. +""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import re +import subprocess +import sys +import tempfile + +CASES = ('forced_msaa_depth', 'default_msaa_depth', 'forced_nonmaskable', + 'default_nonmaskable', 'forced_already_single', 'forced_no_depth', + 'forced_unsupported', 'forced_invalid_type', 'forced_lockable_msaa', + 'forced_lockable_single', 'forced_allocation_failure', + 'default_allocation_failure', 'forced_recreate', 'ordinary_surface', + 'ordinary_invalid_lockable') + + +def function(text, signature): + start = text.index(signature) + opening = text.index('{', start) + # Ignore braces in comments and strings while preserving source positions. + stripped = re.sub(r'//[^\n]*|/\*.*?\*/|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'', + lambda m: ' ' * len(m.group()), text, flags=re.S) + depth = 0 + for index in range(opening, len(stripped)): + depth += (stripped[index] == '{') - (stripped[index] == '}') + if depth == 0: + return text[start:index + 1] + raise ValueError('Unterminated source function: ' + signature) + + +def production(source): + base = source / 'src/d3d9' + common = (base / 'd3d9_common_texture.cpp').read_text() + header = (base / 'd3d9_common_texture.h').read_text() + swap = (base / 'd3d9_swapchain.cpp').read_text() + device = (base / 'd3d9_device.cpp').read_text() + util = (base / 'd3d9_util.cpp').read_text() + pieces = { + 'decode': function(util, 'HRESULT DecodeMultiSampleType('), + 'normalize': function(common, 'HRESULT D3D9CommonTexture::NormalizeTextureProperties('), + 'backbuffers': function(swap, 'HRESULT D3D9SwapChainEx::CreateBackBuffers('), + 'uses_image': function(header, 'static bool TextureUsesImage('), + } + reset = function(device, 'HRESULT D3D9DeviceEx::ResetSwapChain(') + begin = reset.index('D3D9_COMMON_TEXTURE_DESC desc;', reset.index('if (pPresentationParameters->EnableAutoDepthStencil)')) + end = reset.index('m_autoDepthStencil =', begin) + pieces['auto_depth'] = reset[begin:end].rstrip() + framebuffer = function(device, 'void D3D9DeviceEx::BindFramebuffer(') + begin = framebuffer.index('const bool mismatch =') + end = framebuffer.index(';', framebuffer.index('const bool bindDS =', begin)) + 1 + pieces['depth_binding'] = framebuffer[begin:end] + return pieces + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('source', type=Path, help='Pinned DXVK tree with downstream patches applied') + parser.add_argument('--cxx', default=os.environ.get('CXX', 'c++')) + parser.add_argument('--sanitize', action='store_true', help='Enable ASan/UBSan on the CPU harness') + args = parser.parse_args() + pieces = production(args.source) + harness = (Path(__file__).parent / 'tests/d3d9_single_sample.cpp').read_text() + harness = harness.replace('/* PRODUCTION_USES_IMAGE */', pieces['uses_image']) + with tempfile.TemporaryDirectory(prefix='dxvk-d3d9-') as directory: + out = Path(directory) + (out / 'harness.cpp').write_text(harness) + include = '\n\n'.join(pieces[key] for key in ('decode', 'normalize', 'backbuffers')) + include += '\nHRESULT auto_depth(D3D9DeviceEx* device, D3DPRESENT_PARAMETERS* pPresentationParameters, D3D9_COMMON_TEXTURE_DESC* output) {\n' + include += 'auto* self = device;\n' + pieces['auto_depth'].replace('(this,', '(self,') + include += '\n*output = desc; return D3D_OK;\n}\n' + include += '\nbool depth_binds(const ImageInfo& color, const ImageInfo& dsInfo) {\n' + include += 'auto sampleCount = color.sampleCount; auto renderArea = color.extent;\n' + include += 'const bool noRT0Bound = false, ignoreRT0 = false;\n' + include += pieces['depth_binding'] + '\nreturn bindDS;\n}\n' + (out / 'd3d9_production.inc').write_text(include) + command = [args.cxx, '-std=c++17', '-Wall', '-Wextra', '-Werror', + '-Wno-unused-parameter', str(out / 'harness.cpp'), '-o', str(out / 'check')] + # The original CreateBackBuffers does not use Flags; that known baseline + # warning must not turn a negative control into a compiler-fixture error. + if args.sanitize: + command[1:1] = ['-fsanitize=address,undefined', '-fno-omit-frame-pointer'] + compilation = subprocess.run(command, capture_output=True, text=True) + if compilation.returncode: + raise SystemExit(compilation.stderr) + results = [] + for case in CASES: + process = subprocess.run([str(out / 'check'), case], capture_output=True, + text=True, timeout=10, cwd=out, + env={'ASAN_OPTIONS': 'detect_leaks=' + + ('0' if sys.platform == 'darwin' else '1')}) + results.append({'case': case, 'passed': process.returncode == 0, + 'exit': process.returncode, 'detail': process.stderr.strip()[-800:]}) + result = {'cases': results, 'passed': sum(row['passed'] for row in results), + 'failed': sum(not row['passed'] for row in results), + 'production_sha256': {key: hashlib.sha256(value.encode()).hexdigest() + for key, value in pieces.items()}, + 'backend_and_adapter_mocked': True, 'GPU_test': False, + 'sanitizers': args.sanitize, + 'leak_detection': args.sanitize and sys.platform != 'darwin'} + print(json.dumps(result, indent=2)) + return bool(result['failed']) + + +if __name__ == '__main__': + raise SystemExit(main()) diff --git a/tools/dxvk/patches/0004-d3d9-force-single-sample.patch b/tools/dxvk/patches/0004-d3d9-force-single-sample.patch index dcceaf2d00..6ae7343c16 100644 --- a/tools/dxvk/patches/0004-d3d9-force-single-sample.patch +++ b/tools/dxvk/patches/0004-d3d9-force-single-sample.patch @@ -64,3 +64,23 @@ index e69a39a..4478420 100644 /// Allow D3DLOCK_DISCARD bool allowDiscard; +diff --git a/src/d3d9/d3d9_swapchain.cpp b/src/d3d9/d3d9_swapchain.cpp +--- a/src/d3d9/d3d9_swapchain.cpp ++++ b/src/d3d9/d3d9_swapchain.cpp +@@ -1055,1 +1055,16 @@ namespace dxvk { ++ if (m_parent->GetOptions()->forceSingleSample) { ++ // Backbuffers bypass the normal surface-creation entry points. Validate ++ // the application's request, then apply the same effective sample count. ++ // IsLockable above is an internal GDI fallback requirement, not the ++ // application's lockability request used by MSAA validation. ++ auto requestedDesc = desc; ++ requestedDesc.IsLockable = (Flags & D3DPRESENTFLAG_LOCKABLE_BACKBUFFER) != 0; ++ HRESULT hr = D3D9CommonTexture::NormalizeTextureProperties( ++ m_parent, D3DRTYPE_SURFACE, &requestedDesc); ++ if (FAILED(hr)) ++ return hr; ++ desc.MultiSample = requestedDesc.MultiSample; ++ desc.MultisampleQuality = requestedDesc.MultisampleQuality; ++ } ++ + const bool isExtended = m_parent->IsD3DCompatibile(D3DCompatibility::D3D9Ex); diff --git a/tools/dxvk/tests/d3d9_single_sample.cpp b/tools/dxvk/tests/d3d9_single_sample.cpp new file mode 100644 index 0000000000..2c9782f92e --- /dev/null +++ b/tools/dxvk/tests/d3d9_single_sample.cpp @@ -0,0 +1,214 @@ +// Backend/adapter fixture for the verbatim DXVK functions in d3d9_production.inc. +#include +#include +#include +#include +#include +#include +#include + +using HRESULT = int32_t; +using DWORD = uint32_t; +using UINT = uint32_t; +using VkSampleCountFlagBits = uint32_t; +constexpr HRESULT D3D_OK = 0, D3DERR_INVALIDCALL = -1, + D3DERR_NOTAVAILABLE = -2, D3DERR_OUTOFVIDEOMEMORY = -3; +constexpr uint32_t VK_SAMPLE_COUNT_1_BIT = 1, VK_IMAGE_ASPECT_COLOR_BIT = 1; +constexpr bool FALSE = false, TRUE = true; +#define FAILED(x) ((x) < 0) +#define unlikely(x) (x) +enum D3DMULTISAMPLE_TYPE { D3DMULTISAMPLE_NONE, D3DMULTISAMPLE_NONMASKABLE, + D3DMULTISAMPLE_16_SAMPLES = 16 }; +enum D3DRESOURCETYPE { D3DRTYPE_SURFACE, D3DRTYPE_CUBETEXTURE, D3DRTYPE_VOLUMETEXTURE }; +enum D3DPOOL { D3DPOOL_DEFAULT, D3DPOOL_MANAGED, D3DPOOL_SYSTEMMEM, D3DPOOL_SCRATCH }; +enum class D3DCompatibility { D3D9Ex }; +enum class D3D9Format { X8R8G8B8, D24S8, A8, NULL_FORMAT, ATI2, + D32_LOCKABLE, D32F_LOCKABLE, D16_LOCKABLE, S8_LOCKABLE }; +constexpr DWORD D3DUSAGE_RENDERTARGET = 1, D3DUSAGE_DEPTHSTENCIL = 2, + D3DUSAGE_DYNAMIC = 4, D3DUSAGE_WRITEONLY = 8, D3DUSAGE_AUTOGENMIPMAP = 16; +constexpr DWORD D3DPRESENTFLAG_LOCKABLE_BACKBUFFER = 1, D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL = 2; +constexpr int D3DDEVTYPE_HAL = 1, VK_IMAGE_LAYOUT_UNDEFINED = 0; +struct Extent { uint32_t width, height, depth = 1; }; +namespace util { +uint32_t computeMipLevelCount(Extent e) { + uint32_t n = std::max({e.width, e.height, e.depth}), levels = 0; + do { ++levels; n >>= 1; } while (n); + return levels; +} +} +bool IsPoolManaged(D3DPOOL pool) { return pool == D3DPOOL_MANAGED; } +bool IsDXTFormat(D3D9Format) { return false; } +bool IsDepthStencilFormat(D3D9Format format) { return format == D3D9Format::D24S8; } +bool IsLockableDepthStencilFormat(D3D9Format) { return false; } +struct D3D9_FORMAT_BLOCK_SIZE { uint32_t Width, Height; }; +D3D9_FORMAT_BLOCK_SIZE GetFormatAlignedBlockSize(D3D9Format) { return {1, 1}; } +D3D9Format EnumerateFormat(D3D9Format format) { return format; } +struct D3D9_COMMON_TEXTURE_DESC { + uint32_t Width = 1280, Height = 720, Depth = 1, MipLevels = 1, ArraySize = 1; + D3D9Format Format = D3D9Format::X8R8G8B8; + D3DMULTISAMPLE_TYPE MultiSample = D3DMULTISAMPLE_NONE; + DWORD MultisampleQuality = 0; + D3DPOOL Pool = D3DPOOL_DEFAULT; + DWORD Usage = D3DUSAGE_RENDERTARGET; + bool Discard = false, IsBackBuffer = false, IsAttachmentOnly = false, IsLockable = false; +}; +struct D3DPRESENT_PARAMETERS { + uint32_t BackBufferWidth = 1280, BackBufferHeight = 720; + D3D9Format BackBufferFormat = D3D9Format::X8R8G8B8; + D3DMULTISAMPLE_TYPE MultiSampleType = D3DMULTISAMPLE_TYPE(4); + DWORD MultiSampleQuality = 0, Flags = 0; + D3D9Format AutoDepthStencilFormat = D3D9Format::D24S8; +}; +struct Options { + bool forceSingleSample = false, extraFrontbuffer = false, + disableA8RT = false, supportCubeDepthFormats = false; +}; +struct FormatMapping { + uint32_t Aspect; + bool IsValid() const { return true; } +}; +struct Adapter { + bool supported = true; + std::vector checked; + HRESULT CheckDeviceMultiSampleType(int, D3D9Format, bool, D3DMULTISAMPLE_TYPE samples, void*) { + checked.push_back(samples); + return supported ? D3D_OK : D3DERR_NOTAVAILABLE; + } +}; +struct ImageInfo { Extent extent; VkSampleCountFlagBits sampleCount; }; +struct DxvkImage { ImageInfo info; }; +template using Rc = std::shared_ptr; +template using small_vector = std::vector; +struct DxvkContext { + unsigned initialized = 0; + void initImage(const Rc&, int) { ++initialized; } +}; +struct D3D9DeviceEx { + Options options; + Adapter adapter; + DxvkContext context; + unsigned attempts = 0, failAt = 0, losable = 0, live = 0, injected = 0; + std::vector created; + Options* GetOptions() { return &options; } + Adapter* GetAdapter() { return &adapter; } + FormatMapping LookupFormat(D3D9Format format) { return {IsDepthStencilFormat(format) ? 2u : 1u}; } + struct Unsupported { unsigned elementSize = 0; }; + Unsupported unsupported; + const Unsupported* UnsupportedFormatInfo(D3D9Format) { return &unsupported; } + bool IsD3DCompatibile(D3DCompatibility) { return false; } + void IncrementLosableCounter() { ++losable; } + template void InjectCs(F function) { ++injected; function(&context); } +}; +HRESULT DecodeMultiSampleType(D3DMULTISAMPLE_TYPE, DWORD, VkSampleCountFlagBits*); +struct D3D9CommonTexture { + Rc image; + const Rc& GetImage() const { return image; } + static HRESULT NormalizeTextureProperties(D3D9DeviceEx*, D3DRESOURCETYPE, D3D9_COMMON_TEXTURE_DESC*); + /* PRODUCTION_USES_IMAGE */ +}; +class DxvkError : public std::runtime_error { +public: + using std::runtime_error::runtime_error; + std::string message() const { return what(); } +}; +struct Logger { static void err(const std::string&) {} }; +struct D3D9SwapChainEx; +struct D3D9Surface { + D3D9CommonTexture texture; + D3D9DeviceEx* device; + D3D9Surface(D3D9DeviceEx* d, D3D9_COMMON_TEXTURE_DESC* desc, bool, D3D9SwapChainEx*, void*) : device(d) { + if (++d->attempts == d->failAt) throw DxvkError("controlled allocation failure"); + VkSampleCountFlagBits samples; + if (FAILED(DecodeMultiSampleType(desc->MultiSample, desc->MultisampleQuality, &samples))) + throw DxvkError("invalid backend sample count"); + texture.image = std::make_shared(DxvkImage{{{desc->Width, desc->Height}, samples}}); + d->created.push_back(*desc); ++d->live; + } + ~D3D9Surface() { --device->live; } + D3D9CommonTexture* GetCommonTexture() { return &texture; } +}; +struct D3D9SwapChainEx { + D3D9DeviceEx* m_parent; + D3DPRESENT_PARAMETERS m_presentParams; + std::vector> m_backBuffers; + bool flip = false; + unsigned destroys = 0; + bool SwapWithFrontBuffer() { return flip; } + void DestroyBackBuffers() { ++destroys; m_backBuffers.clear(); } + HRESULT CreateBackBuffers(uint32_t, DWORD); +}; +#include "d3d9_production.inc" + +void paired(bool enabled, D3DMULTISAMPLE_TYPE type, DWORD quality) { + D3D9DeviceEx device; device.options.forceSingleSample = enabled; + device.options.extraFrontbuffer = true; + D3D9SwapChainEx chain{&device, {}, {}}; + chain.m_presentParams.MultiSampleType = type; chain.m_presentParams.MultiSampleQuality = quality; + assert(chain.CreateBackBuffers(2, 0) == D3D_OK); + D3D9_COMMON_TEXTURE_DESC depth; + assert(auto_depth(&device, &chain.m_presentParams, &depth) == D3D_OK); + VkSampleCountFlagBits requested, dsSamples; + assert(DecodeMultiSampleType(type, quality, &requested) == D3D_OK); + assert(DecodeMultiSampleType(depth.MultiSample, depth.MultisampleQuality, &dsSamples) == D3D_OK); + assert(chain.m_backBuffers.size() == 3 && device.context.initialized == 3); + for (const auto& surface : chain.m_backBuffers) { + const auto& image = surface->GetCommonTexture()->GetImage()->info; + assert(image.sampleCount == (enabled ? 1u : requested)); + assert(depth_binds(image, {{depth.Width, depth.Height}, dsSamples})); + } + for (const auto& desc : device.created) { + assert(desc.IsLockable && desc.IsBackBuffer && !desc.IsAttachmentOnly); + assert(desc.MultiSample == (enabled ? D3DMULTISAMPLE_NONE : type)); + assert(desc.MultisampleQuality == (enabled ? 0u : quality)); + } + // Original presentation parameters remain available for reset/auto-depth validation. + assert(chain.m_presentParams.MultiSampleType == type && chain.m_presentParams.MultiSampleQuality == quality); + if (enabled && requested > 1) assert(device.adapter.checked.front() == D3DMULTISAMPLE_TYPE(requested)); +} + +int main(int argc, char** argv) { + assert(argc == 2); std::string name = argv[1]; + if (name == "forced_msaa_depth") paired(true, D3DMULTISAMPLE_TYPE(4), 0); + else if (name == "default_msaa_depth") paired(false, D3DMULTISAMPLE_TYPE(4), 0); + else if (name == "forced_nonmaskable") paired(true, D3DMULTISAMPLE_NONMASKABLE, 2); + else if (name == "default_nonmaskable") paired(false, D3DMULTISAMPLE_NONMASKABLE, 2); + else if (name == "forced_already_single") paired(true, D3DMULTISAMPLE_NONE, 0); + else if (name == "forced_no_depth" || name == "forced_lockable_single") { + D3D9DeviceEx d; d.options.forceSingleSample = true; + D3D9SwapChainEx c{&d, {}, {}}; + if (name == "forced_lockable_single") c.m_presentParams.MultiSampleType = D3DMULTISAMPLE_NONE; + assert(c.CreateBackBuffers(1, name == "forced_lockable_single" ? D3DPRESENTFLAG_LOCKABLE_BACKBUFFER : 0) == D3D_OK); + assert(c.m_backBuffers.size() == 1 && d.created[0].MultiSample == D3DMULTISAMPLE_NONE); + assert(d.created[0].IsLockable && d.context.initialized == 1); + } else if (name == "forced_unsupported" || name == "forced_invalid_type" || name == "forced_lockable_msaa") { + D3D9DeviceEx d; d.options.forceSingleSample = true; + D3D9SwapChainEx c{&d, {}, {}}; + if (name == "forced_unsupported") d.adapter.supported = false; + if (name == "forced_invalid_type") c.m_presentParams.MultiSampleType = D3DMULTISAMPLE_TYPE(17); + HRESULT expected = name == "forced_unsupported" ? D3DERR_NOTAVAILABLE : D3DERR_INVALIDCALL; + assert(c.CreateBackBuffers(2, name == "forced_lockable_msaa" ? D3DPRESENTFLAG_LOCKABLE_BACKBUFFER : 0) == expected); + assert(d.attempts == 0 && d.losable == 0 && d.injected == 0 && c.m_backBuffers.empty()); + } else if (name == "forced_allocation_failure" || name == "default_allocation_failure") { + D3D9DeviceEx d; d.options.forceSingleSample = name == "forced_allocation_failure"; d.failAt = 2; + D3D9SwapChainEx c{&d, {}, {}}; + assert(c.CreateBackBuffers(3, 0) == D3DERR_OUTOFVIDEOMEMORY); + assert(d.attempts == 2 && d.losable == 1 && d.live == 0 && d.injected == 0 && c.m_backBuffers.empty()); + } else if (name == "forced_recreate") { + D3D9DeviceEx d; d.options.forceSingleSample = true; + D3D9SwapChainEx c{&d, {}, {}}; + assert(c.CreateBackBuffers(3, 0) == D3D_OK); + c.m_presentParams.MultiSampleType = D3DMULTISAMPLE_TYPE(8); + assert(c.CreateBackBuffers(1, 0) == D3D_OK); + assert(d.live == 1 && c.m_backBuffers.size() == 1 && c.destroys == 2); + assert(d.adapter.checked.size() == 2 && d.adapter.checked.back() == D3DMULTISAMPLE_TYPE(8)); + assert(c.m_backBuffers[0]->GetCommonTexture()->GetImage()->info.sampleCount == 1); + } else if (name == "ordinary_surface" || name == "ordinary_invalid_lockable") { + D3D9DeviceEx d; d.options.forceSingleSample = true; + D3D9_COMMON_TEXTURE_DESC desc; desc.MultiSample = D3DMULTISAMPLE_TYPE(4); + desc.IsLockable = name == "ordinary_invalid_lockable"; + assert(D3D9CommonTexture::NormalizeTextureProperties(&d, D3DRTYPE_SURFACE, &desc) + == (desc.IsLockable ? D3DERR_INVALIDCALL : D3D_OK)); + if (!desc.IsLockable) assert(desc.MultiSample == D3DMULTISAMPLE_NONE && desc.MultisampleQuality == 0); + } else assert(false); + return 0; +}