mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-19 16:20:01 -04:00
290 lines
12 KiB
Python
290 lines
12 KiB
Python
"""Exercise the actual generic upscale fallback without Vulkan or a GPU.
|
|
|
|
python tests/test_upscale_fallback.py [--source gpu/vk/vk_draw.cpp] [--cxx clang++]
|
|
Use --cxx g++ on Linux, or --cxx cl in a configured Visual Studio compiler shell. No SDK needed.
|
|
"""
|
|
import argparse
|
|
import os
|
|
from pathlib import Path
|
|
import subprocess
|
|
import tempfile
|
|
|
|
RUN_ALL_ARGS = ["--cxx", "g++"]
|
|
|
|
ROOT = next(p for p in Path(__file__).resolve().parents if (p / 'gpu/vk/vk_draw.cpp').is_file())
|
|
|
|
def block(text, marker):
|
|
start = text.index(marker)
|
|
end = text.index('{', start) + 1
|
|
depth = 1
|
|
while depth:
|
|
depth += (text[end] == '{') - (text[end] == '}')
|
|
end += 1
|
|
return text[start:end]
|
|
|
|
PREFIX = r'''
|
|
#define _CRT_SECURE_NO_WARNINGS
|
|
|
|
#include <algorithm>
|
|
#include <atomic>
|
|
#include <cassert>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
|
|
// Only the Vulkan declarations used by upscale_stub; no Vulkan SDK or runtime.
|
|
using VkCommandBuffer = uintptr_t;
|
|
using VkImage = uintptr_t;
|
|
using VkImageView = uintptr_t;
|
|
using VkPhysicalDevice = uintptr_t;
|
|
using VkFormat = uint32_t;
|
|
using VkFormatFeatureFlags = uint32_t;
|
|
using VkImageAspectFlags = uint32_t;
|
|
using VkImageType = uint32_t;
|
|
using VkImageViewType = uint32_t;
|
|
constexpr uint32_t VK_IMAGE_VIEW_TYPE_2D = 1;
|
|
using VkSampleCountFlagBits = uint32_t;
|
|
using VkImageLayout = uint32_t;
|
|
using VkFilter = uint32_t;
|
|
constexpr uint32_t VK_FORMAT_UNDEFINED = 0, VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
|
|
VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, VK_FORMAT_R8G8B8A8_UNORM = 37;
|
|
constexpr uint32_t VK_IMAGE_TYPE_2D = 1, VK_IMAGE_ASPECT_COLOR_BIT = 1, VK_SAMPLE_COUNT_1_BIT = 1,
|
|
VK_IMAGE_LAYOUT_GENERAL = 1, VK_FILTER_LINEAR = 1;
|
|
constexpr uint32_t VK_FORMAT_FEATURE_BLIT_SRC_BIT = 1, VK_FORMAT_FEATURE_BLIT_DST_BIT = 2,
|
|
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 4,
|
|
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 8, VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 16;
|
|
struct VkFormatProperties {
|
|
VkFormatFeatureFlags optimalTilingFeatures{};
|
|
};
|
|
struct Subresource {
|
|
uint32_t aspectMask{}, mipLevel{}, baseArrayLayer{}, layerCount{};
|
|
};
|
|
struct Offset {
|
|
int32_t x{}, y{}, z{};
|
|
};
|
|
struct VkImageBlit {
|
|
Subresource srcSubresource;
|
|
Offset srcOffsets[2];
|
|
Subresource dstSubresource;
|
|
Offset dstOffsets[2];
|
|
};
|
|
constexpr int NVN_FORMAT_RGB9E5F = 64, NVN_FORMAT_R11G11B10F = 63;
|
|
constexpr unsigned NVN_TEXTURE_SWIZZLE_R = 2, NVN_TEXTURE_SWIZZLE_G = 3, NVN_TEXTURE_SWIZZLE_B = 4;
|
|
struct Desc {
|
|
int target = 2, format = 64;
|
|
unsigned width = 64, height = 32, depth = 1;
|
|
unsigned swizzle_r = 2, swizzle_g = 3, swizzle_b = 4;
|
|
};
|
|
struct nvn_tex {
|
|
Desc d;
|
|
uint64_t gpu = 10, serial = 99;
|
|
};
|
|
struct nvn_view {};
|
|
struct NvnState {
|
|
uint64_t tex[6][128]{}, img[6][32]{};
|
|
};
|
|
struct Texture {
|
|
VkImage image = (VkImage)11;
|
|
VkFormat format = VK_FORMAT_B10G11R11_UFLOAT_PACK32;
|
|
unsigned width = 64, height = 32, depth = 1, layers = 1, levels = 1, skip = 0;
|
|
VkImageType type = VK_IMAGE_TYPE_2D;
|
|
VkImageAspectFlags aspect = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
bool bc = false;
|
|
VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
|
|
};
|
|
Texture src, dst;
|
|
nvn_tex source, destination;
|
|
bool override_view = false, movie = false, pipeline_ok = true;
|
|
bool missing_storage = false, missing_sample = false, missing_linear = false;
|
|
bool missing_input_view = false, missing_output_view = false;
|
|
unsigned blits = 0, typed_calls = 0, views = 0, movie_calls = 0, writes = 0, gameplay_logs = 0, gameplay_warnings = 0;
|
|
struct {
|
|
VkPhysicalDevice physical{};
|
|
} dev;
|
|
void cs_slot_counts(const NvnState &, uint32_t *t, uint32_t *i) { *t = *i = 1; }
|
|
bool texture_of(int h, nvn_tex *t, nvn_view *v, bool *hv) {
|
|
assert(h == 1 || h == 2);
|
|
*t = h == 1 ? source : destination;
|
|
*v = {};
|
|
*hv = override_view;
|
|
return true;
|
|
}
|
|
Texture *texture_get(const nvn_tex *t, bool) { return t->gpu == 10 ? &src : &dst; }
|
|
void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice, VkFormat format, VkFormatProperties *p) {
|
|
p->optimalTilingFeatures = VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT |
|
|
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
|
|
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
|
|
if (missing_storage && format == VK_FORMAT_B10G11R11_UFLOAT_PACK32)
|
|
p->optimalTilingFeatures &= ~VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
|
|
if (missing_sample && format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32)
|
|
p->optimalTilingFeatures &= ~VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
|
|
if (missing_linear && format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32)
|
|
p->optimalTilingFeatures &= ~VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
|
|
}
|
|
void end_pass(VkCommandBuffer) {}
|
|
// (the temporal upscaler, off here: upscale_stub offers it the frame first, vk_draw.cpp temporal_rejected_network)
|
|
bool temporal_wanted() { return false; }
|
|
static bool temporal_rejected_network(VkCommandBuffer, uint64_t, Texture *, const nvn_tex *, Texture *, const nvn_tex *) {
|
|
return false;
|
|
}
|
|
void full_barrier(VkCommandBuffer) {}
|
|
bool dump_on() { return false; }
|
|
void logf(const char *format, ...) {
|
|
if (std::strstr(format, "gameplay RGB9E5 upscale uses the typed fallback"))
|
|
gameplay_logs++;
|
|
if (std::strstr(format, "gameplay RGB9E5 upscale unavailable"))
|
|
gameplay_warnings++;
|
|
}
|
|
void texture_written(Texture *t) {
|
|
assert(t == &dst);
|
|
writes++;
|
|
}
|
|
void dump_image(VkCommandBuffer, Texture *, unsigned, unsigned, const char *) {}
|
|
bool movie_upscale(VkCommandBuffer, uint64_t, uint64_t, Texture *) {
|
|
movie_calls++;
|
|
return movie;
|
|
}
|
|
bool gameplay_network(uint64_t key) {
|
|
return key == 0xfd029a317a9a4b94ull || key == 0x9dc98871eb7fc101ull;
|
|
}
|
|
enum class ViewUse { Sample, Storage };
|
|
VkImageView texture_view(Texture *t, const nvn_tex *, const nvn_view *v, VkImageViewType type,
|
|
ViewUse use, VkFormat *f, VkFormat forced = VK_FORMAT_UNDEFINED) {
|
|
assert(!v && type == VK_IMAGE_VIEW_TYPE_2D);
|
|
views++;
|
|
if (t == &src) {
|
|
assert(use == ViewUse::Sample && forced == VK_FORMAT_UNDEFINED);
|
|
*f = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
|
|
return missing_input_view ? 0 : (VkImageView)101;
|
|
}
|
|
assert(t == &dst && use == ViewUse::Storage && forced == VK_FORMAT_B10G11R11_UFLOAT_PACK32);
|
|
*f = VK_FORMAT_B10G11R11_UFLOAT_PACK32;
|
|
return missing_output_view ? 0 : (VkImageView)102;
|
|
}
|
|
static bool typed_upscale(VkCommandBuffer, VkImageView input, VkImageView output, Texture *t,
|
|
uint32_t level, uint64_t, const char *, bool temporal) {
|
|
assert(input == (VkImageView)101 && output == (VkImageView)102 && t == &dst && level == 0 &&
|
|
!temporal);
|
|
typed_calls++;
|
|
return pipeline_ok;
|
|
}
|
|
void vkCmdBlitImage(VkCommandBuffer, VkImage a, VkImageLayout al, VkImage b, VkImageLayout bl,
|
|
uint32_t n, const VkImageBlit *r, VkFilter filter) {
|
|
assert(a == src.image && b == dst.image && al == VK_IMAGE_LAYOUT_GENERAL &&
|
|
bl == VK_IMAGE_LAYOUT_GENERAL && n == 1 && filter == VK_FILTER_LINEAR);
|
|
assert(r->srcSubresource.mipLevel == 0 && r->srcSubresource.baseArrayLayer == 0 &&
|
|
r->dstSubresource.mipLevel == 0 && r->dstSubresource.baseArrayLayer == 0);
|
|
assert(r->srcOffsets[1].x == 64 && r->srcOffsets[1].y == 32 && r->dstOffsets[1].x == 128 &&
|
|
r->dstOffsets[1].y == 64);
|
|
blits++;
|
|
}
|
|
'''
|
|
SUFFIX = r'''
|
|
int main(int argc, char **argv) {
|
|
assert(argc == 2);
|
|
const std::string mode = argv[1];
|
|
uint64_t key = 0x0775215f8da720e6ull;
|
|
destination.gpu = 20;
|
|
destination.d.format = 63;
|
|
destination.d.width = 128;
|
|
destination.d.height = 64;
|
|
dst.width = 128;
|
|
dst.height = 64;
|
|
dst.image = (VkImage)22;
|
|
if (mode == "r11" || mode == "fd-r11")
|
|
source.d.format = 63;
|
|
if (mode == "movie") {
|
|
dst.format = VK_FORMAT_R8G8B8A8_UNORM;
|
|
movie = true;
|
|
}
|
|
if (mode == "view" || mode == "fd-view")
|
|
override_view = true;
|
|
if (mode == "skip")
|
|
src.skip = 1;
|
|
if (mode == "mip")
|
|
src.levels = 2;
|
|
if (mode == "swizzle")
|
|
source.d.swizzle_r = 4;
|
|
if (mode.compare(0, 2, "fd") == 0)
|
|
key = 0xfd029a317a9a4b94ull;
|
|
if (mode == "9dc")
|
|
key = 0x9dc98871eb7fc101ull;
|
|
if (mode == "pipeline-failure" || mode == "fd-pipeline-failure")
|
|
pipeline_ok = false;
|
|
if (mode == "no-storage" || mode == "fd-no-storage")
|
|
missing_storage = true;
|
|
if (mode == "no-e5-sample" || mode == "fd-no-e5-sample")
|
|
missing_sample = true;
|
|
if (mode == "no-e5-linear" || mode == "fd-no-e5-linear")
|
|
missing_linear = true;
|
|
if (mode == "null-input-view" || mode == "fd-null-input-view")
|
|
missing_input_view = true;
|
|
if (mode == "null-output-view" || mode == "fd-null-output-view")
|
|
missing_output_view = true;
|
|
NvnState state;
|
|
state.tex[5][0] = 1;
|
|
state.img[5][0] = 2;
|
|
assert(upscale_stub((VkCommandBuffer)5, state, key));
|
|
if (mode == "captured" || mode == "fd") {
|
|
if (typed_calls != 1 || views != 2 || blits != 0) {
|
|
puts("RED: RGB9E5 input still used physical-format blit");
|
|
return 7;
|
|
}
|
|
assert(writes == 1);
|
|
assert(gameplay_logs == (mode == "fd" ? 1u : 0u) && gameplay_warnings == 0);
|
|
} else if (mode == "movie") {
|
|
assert(movie_calls == 1 && typed_calls == 0 && blits == 0 && writes == 1);
|
|
} else if (mode == "pipeline-failure" || mode == "fd-pipeline-failure") {
|
|
assert(typed_calls == 1 && views == 2 && blits == 1 && writes == 1);
|
|
} else if (missing_input_view || missing_output_view) {
|
|
assert(typed_calls == 0 && views == 2 && blits == 1 && writes == 1);
|
|
} else {
|
|
assert(typed_calls == 0 && views == 0 && blits == 1 && writes == 1);
|
|
}
|
|
if (mode == "fd-view" || mode == "fd-pipeline-failure" || mode == "fd-no-storage" ||
|
|
mode == "fd-no-e5-sample" || mode == "fd-no-e5-linear" ||
|
|
mode == "fd-null-input-view" || mode == "fd-null-output-view")
|
|
assert(gameplay_warnings == 1 && gameplay_logs == 0);
|
|
if (mode == "fd-r11" || mode == "9dc")
|
|
assert(gameplay_warnings == 0 && gameplay_logs == 0);
|
|
printf("PASS: %s\n", mode.c_str());
|
|
}
|
|
'''
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument('--source', type=Path, default=ROOT / 'gpu/vk/vk_draw.cpp')
|
|
parser.add_argument('--cxx', default='clang++')
|
|
args = parser.parse_args()
|
|
body = block(args.source.read_text(encoding='utf-8'), 'bool upscale_stub(')
|
|
env = os.environ.copy()
|
|
env.pop('RX_VK_NO_UPSCALE_STUB', None)
|
|
with tempfile.TemporaryDirectory(prefix='upscale-fallback-') as tmp:
|
|
tmp = Path(tmp)
|
|
source = tmp / 'check.cpp'
|
|
exe = tmp / ('check.exe' if os.name == 'nt' else 'check')
|
|
source.write_text(PREFIX + body + SUFFIX, encoding='utf-8')
|
|
if Path(args.cxx).name.lower() in ('cl', 'cl.exe', 'clang-cl', 'clang-cl.exe'):
|
|
command = [args.cxx, '/nologo', '/std:c++20', '/EHsc', '/UNDEBUG', str(source),
|
|
'/Fo' + str(tmp / 'check.obj'), '/Fe' + str(exe)]
|
|
cwd = tmp
|
|
else:
|
|
command = [args.cxx, '-std=c++20', '-UNDEBUG', str(source), '-o', str(exe)]
|
|
cwd = None
|
|
subprocess.run(command, cwd=cwd, env=env, check=True)
|
|
cases = ('captured', 'r11', 'movie', 'view', 'skip', 'mip', 'swizzle', 'fd', 'fd-r11',
|
|
'fd-view', 'fd-pipeline-failure', 'fd-no-storage', 'fd-no-e5-sample',
|
|
'fd-no-e5-linear', 'fd-null-input-view', 'fd-null-output-view', '9dc',
|
|
'pipeline-failure', 'no-storage', 'no-e5-sample', 'no-e5-linear',
|
|
'null-input-view', 'null-output-view')
|
|
for case in cases:
|
|
subprocess.run([str(exe), case], env=env, check=True)
|
|
|
|
if __name__ == '__main__':
|
|
main()
|