// Frame interpolation (RX_VK_FRAMEGEN=1; off by default): frames made between the game's, from its last two, shown in // between by a display thread, so a game at 60 fps is shown at 120 (RX_VK_FRAMEGEN_MULT=3: 180). The WebGPU // renderer's (gpu/render/rx_framegen.cpp, whose comments explain it), on Vulkan: // 1. each frame is copied (it may be drawn over next frame) and reduced to quarter-size luma; // 2. block matching: a vector per 16x16 pixels within +-32 pixels (RX_VK_FRAMEGEN_RADIUS quarter texels, default // 8), then a 3x3 median of them; // 3. each in-between frame at time t blends the last frame moved back along t and the new one forward along 1 - t. // Recorded into the present's own recording, after the game's work; the display thread shows the made frames and // then the game's, evenly over the game's recent frame time, about one frame behind the game. Loading hitches // (frames over 100 ms apart) are not interpolated. #include #include #include #include #include #include #include #include #include #include "vk_framegen.h" #include "vk_fsr3_inputs.h" // (AMD FSR 3.1 frame interpolation's depth and motion) #include "vk_fsr3fi.h" #include "vk_menu.h" #include "vk_present_rect.h" #include "vk_texture.h" #include "shaders/fg_copy_comp_spv.h" #include "shaders/fg_flow_comp_spv.h" #include "shaders/fg_luma_comp_spv.h" #include "shaders/fg_median_comp_spv.h" #include "shaders/fg_scale_comp_spv.h" #include "shaders/fg_synth_comp_spv.h" #include "shaders/fsr1_easu_comp_spv.h" #include "shaders/fsr1_rcas_comp_spv.h" #include "shaders/hdr_encode_comp_spv.h" #include "vk_work.h" // (after the others: counts the commands that do GPU work, for full_barrier) #ifndef CREATE_WAITABLE_TIMER_HIGH_RESOLUTION // (older Windows SDKs lack it: Windows 10 1803 and later take it) #define CREATE_WAITABLE_TIMER_HIGH_RESOLUTION 0x00000002 #endif namespace mkwvk { int display_refresh_mhz(); // (vk_main.cpp: the window's display, mHz; outside the unnamed namespace, where it is defined) extern std::atomic present_kind; // (vk_replay.cpp: the frame log's) namespace { constexpr int kMaxMult = 8; // (up to 8x: players asked; the made frames are allocated for the multiplier chosen only) struct Img { VkImage image = VK_NULL_HANDLE; VmaAllocation alloc = nullptr; VkImageView view = VK_NULL_HANDLE; }; struct OutSet { Img frame[kMaxMult]; int made = 0; // (frame[0..made) are made frames; frame[made] is the game's) bool busy = false; // (Auto: frame[0..shown) each at its own time, due[k] (steady clock), game[k] the game's own frame; shown < 0: the // fixed multipliers' frames, made + 1 of them, shown evenly) int shown = -1; int64_t due[kMaxMult] = {}; bool game[kMaxMult] = {}; }; struct Job { OutSet* set; int64_t at; uint64_t value; // (the recording that makes its frames) }; struct Pipe { VkDescriptorSetLayout set = VK_NULL_HANDLE; VkPipelineLayout layout = VK_NULL_HANDLE; VkPipeline pipe = VK_NULL_HANDLE; }; struct State { bool init = false; std::atomic failed{false}; // also read by Reflex's game-thread eligibility check uint32_t w = 0, h = 0; Pipe copy, luma, flow, median, synth; VkSampler nearest = VK_NULL_HANDLE, linear = VK_NULL_HANDLE; Img frames[2], lumas[2], flows[2]; OutSet sets[3]; // (one shown, one waiting its place on the line, one being made: the pacer never holds the game back) int cur = 0, next_set = 0; bool have_prev = false; int64_t last_at = 0; std::mutex mu; std::condition_variable cv; std::deque jobs; bool thread_started = false; OutSet* recorded = nullptr; // (the set the last framegen_record filled, for framegen_queue) int64_t recorded_at = 0; int mult = 0; // (the multiplier the sets' frames were made for) int64_t game_ns = 0; // (Auto: the game's frame time, smoothed: the delay its frames are shown at) int64_t slot_next = 0; // (Auto: the display's next refresh to be given a frame, on the game's timeline) } fg; // Used only by present_image, whose lock serializes direct and interpolated presents. struct ScaleState { bool init = false, failed = false; Pipe pipe; Pipe easu, rcas; // (Triforce: Upscaling = AMD FSR 1, shaders/fsr1_*.hlsl) VkSampler linear = VK_NULL_HANDLE, nearest = VK_NULL_HANDLE; Img cropped, scaled, small; // (small: the picture at 1/8, for ultrawide's blurred menu sides) Img easu_img; // (FSR 1: EASU's output, RCAS's input, the window's size) uint32_t cropped_w = 0, cropped_h = 0, scaled_w = 0, scaled_h = 0, small_w = 0, small_h = 0; } scale; struct HdrState { // (hookshot) the HDR10 pass (framegen_hdr) bool init = false, failed = false; Pipe pipe; Img out; uint32_t w = 0, h = 0; } hdr; int64_t now_ns() { return std::chrono::duration_cast(std::chrono::steady_clock::now().time_since_epoch()).count(); } // (hookshot) Frame generation's Auto (the menu's 1): a frame for each refresh of the display, no more. Each game frame // is given the display's refreshes that fall between it and the game's frame before (on the game's own timeline, a // refresh period apart), and each of them a frame made at its place between the two: 45 fps on a 60 Hz display makes one // frame for every three of the game's (3 of 4 shown are made, at 3/4, 1/2, 1/4), on 120 Hz two or three a frame; at // 60 fps on 60 Hz none (a refresh near a game frame shows it), and faster than the display a game frame may be given no refresh and is not shown. Shown one // game frame time later, each at its refresh's time. The sets' frames are made once for the most a game frame may be // given (the refresh over 30 fps, 2 to 4). An unknown refresh counts as 60 Hz. int auto_cap() { const int hz = (display_refresh_mhz() + 500) / 1000; return std::clamp(hz > 0 ? (hz + 29) / 30 : 2, 2, 4); } int multiplier() { // (the Insert menu; 1 Auto (its most); the game's frames alone at 0) return opts.framegen == 1 ? auto_cap() : std::clamp(opts.framegen, 1, kMaxMult); } /// Auto: the display's refreshes in the game frame's interval (last, now], next the first not given a frame yet (moved /// past them). Each one's place between the two game frames in t (1: this one) and its time in at; most of them at the /// most, those past it skipped. A timeline outside the interval (the first frame, a hitch) starts again at now. int auto_slots(int64_t last, int64_t now, int64_t period, int64_t& next, float* t, int64_t* at, int most) { if (now <= last || period <= 0) return 0; if (next <= last || next > now + period) next = now; int n = 0; for (; next <= now; next += period) if (n < most) t[n] = (float)(next - last) / (float)(now - last), at[n++] = next; // A refresh within a quarter period of the game's frame shows that frame itself: at the game's rate the frames come // a little early or late (jitter), and without this nearly every refresh got a made frame at t near 1 and some game // frames none (their neighbour two). The timeline is pulled an eighth of the way to the frame, so that a game at the // display's rate (or a whole fraction of it) stays on it while the two clocks drift apart, and other rates hardly // change how many frames the display is given const int64_t snap = period / 4; // (not "near": windows.h defines it empty) if (next - now < snap) { n = std::min(n + 1, most); t[n - 1] = 1.0f, at[n - 1] = now, next += period + (now - next) / 8; } else if (n > 0 && now - (next - period) < snap) { t[n - 1] = 1.0f, at[n - 1] = now, next += (now - (next - period)) / 8; } return n; } void drop_pipe(Pipe& p) { if (p.pipe) vkDestroyPipeline(dev.device, p.pipe, nullptr); if (p.layout) vkDestroyPipelineLayout(dev.device, p.layout, nullptr); if (p.set) vkDestroyDescriptorSetLayout(dev.device, p.set, nullptr); p = {}; } /// A compute pipeline over bindings of these types (push descriptors), push constants of push bytes bool make_pipe(Pipe& p, const uint32_t* code, size_t bytes, std::initializer_list types, uint32_t push, const VkSpecializationInfo* spec = nullptr) { Pipe made; const auto undo = [&] { drop_pipe(made); return false; }; std::vector b; for (VkDescriptorType t : types) b.push_back({(uint32_t)b.size(), t, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr}); VkDescriptorSetLayoutCreateInfo li{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO}; li.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR; li.bindingCount = (uint32_t)b.size(); li.pBindings = b.data(); if (vkCreateDescriptorSetLayout(dev.device, &li, nullptr, &made.set) != VK_SUCCESS) return false; const VkPushConstantRange pr{VK_SHADER_STAGE_COMPUTE_BIT, 0, std::max(push, 4u)}; VkPipelineLayoutCreateInfo pi{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; pi.setLayoutCount = 1; pi.pSetLayouts = &made.set; pi.pushConstantRangeCount = push ? 1 : 0; pi.pPushConstantRanges = ≺ if (vkCreatePipelineLayout(dev.device, &pi, nullptr, &made.layout) != VK_SUCCESS) { made.layout = VK_NULL_HANDLE; return undo(); } VkShaderModuleCreateInfo mi{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO}; mi.codeSize = bytes; mi.pCode = code; VkShaderModule m = VK_NULL_HANDLE; if (vkCreateShaderModule(dev.device, &mi, nullptr, &m) != VK_SUCCESS) return undo(); VkComputePipelineCreateInfo ci{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO}; ci.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; ci.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT; ci.stage.module = m; ci.stage.pName = "main"; ci.stage.pSpecializationInfo = spec; ci.layout = made.layout; const VkResult r = vkCreateComputePipelines(dev.device, VK_NULL_HANDLE, 1, &ci, nullptr, &made.pipe); vkDestroyShaderModule(dev.device, m, nullptr); if (r != VK_SUCCESS) return undo(); p = made; return true; } // The optional interpolation is disabled after setup fails: retain none of its unused setup objects. void drop_setup() { for (Pipe* p : {&fg.copy, &fg.luma, &fg.flow, &fg.median, &fg.synth}) drop_pipe(*p); if (fg.nearest) vkDestroySampler(dev.device, fg.nearest, nullptr); if (fg.linear) vkDestroySampler(dev.device, fg.linear, nullptr); fg.nearest = fg.linear = VK_NULL_HANDLE; } bool init() { if (fg.init) return !fg.failed; fg.init = true; fg.failed = true; const auto undo = [] { drop_setup(); return false; }; if (!dev.push_descriptor || !vkCmdPushDescriptorSetKHR) return false; const VkDescriptorType S = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, I = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; const int radius = getenv("RX_VK_FRAMEGEN_RADIUS") ? std::clamp(atoi(getenv("RX_VK_FRAMEGEN_RADIUS")), 1, 16) : 8; const VkSpecializationMapEntry me{0, 0, 4}; const VkSpecializationInfo spec{1, &me, 4, &radius}; if (!make_pipe(fg.copy, FG_COPY_COMP_SPV, sizeof FG_COPY_COMP_SPV, {S, I}, 16) || !make_pipe(fg.luma, FG_LUMA_COMP_SPV, sizeof FG_LUMA_COMP_SPV, {S, I}, 0) || !make_pipe(fg.flow, FG_FLOW_COMP_SPV, sizeof FG_FLOW_COMP_SPV, {S, S, I}, 0, &spec) || !make_pipe(fg.median, FG_MEDIAN_COMP_SPV, sizeof FG_MEDIAN_COMP_SPV, {S, I}, 0) || !make_pipe(fg.synth, FG_SYNTH_COMP_SPV, sizeof FG_SYNTH_COMP_SPV, {S, S, S, I}, 4)) return undo(); VkSamplerCreateInfo si{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO}; si.addressModeU = si.addressModeV = si.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; si.maxLod = 0.25f; if (vkCreateSampler(dev.device, &si, nullptr, &fg.nearest) != VK_SUCCESS) { fg.nearest = VK_NULL_HANDLE; return undo(); } si.magFilter = si.minFilter = VK_FILTER_LINEAR; if (vkCreateSampler(dev.device, &si, nullptr, &fg.linear) != VK_SUCCESS) { fg.linear = VK_NULL_HANDLE; return undo(); } fg.failed = false; if (opts.framegen == 1) logf("vk: frame interpolation ready: Auto, a frame for each of the display's refreshes (%d Hz; up to %d a game frame)", (display_refresh_mhz() + 500) / 1000, multiplier()); else logf("vk: frame interpolation ready: %dx the game's frames (made from its last two, shown evenly)", multiplier()); return true; } bool init_scale() { if (scale.init) return !scale.failed; scale.init = scale.failed = true; if (!dev.push_descriptor || !vkCmdPushDescriptorSetKHR) return false; const VkDescriptorType S = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, I = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; if (make_pipe(scale.pipe, FG_SCALE_COMP_SPV, sizeof FG_SCALE_COMP_SPV, {S, I, S}, 20)) { VkSamplerCreateInfo si{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO}; si.addressModeU = si.addressModeV = si.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; si.maxLod = 0.25f; si.magFilter = si.minFilter = VK_FILTER_LINEAR; if (vkCreateSampler(dev.device, &si, nullptr, &scale.linear) == VK_SUCCESS) { scale.failed = false; // (Triforce: AMD FSR 1's two passes and RCAS's point sampler. Any of them missing: Upscaling 3 runs the filter above) si.magFilter = si.minFilter = VK_FILTER_NEAREST; if (!make_pipe(scale.easu, FSR1_EASU_COMP_SPV, sizeof FSR1_EASU_COMP_SPV, {S, I}, 16) || !make_pipe(scale.rcas, FSR1_RCAS_COMP_SPV, sizeof FSR1_RCAS_COMP_SPV, {S, I}, 16) || vkCreateSampler(dev.device, &si, nullptr, &scale.nearest) != VK_SUCCESS) { drop_pipe(scale.easu), drop_pipe(scale.rcas); scale.nearest = VK_NULL_HANDLE; logf("vk: AMD FSR 1 could not be set up: Upscaling 3 runs as Catmull-Rom"); } return true; } scale.linear = VK_NULL_HANDLE; } drop_pipe(scale.pipe); return false; } bool make_img(Img& i, uint32_t w, uint32_t h, VkFormat f, VkImageUsageFlags usage) { Img made; VkImageCreateInfo ci{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO}; ci.imageType = VK_IMAGE_TYPE_2D; ci.format = f; ci.extent = {w, h, 1}; ci.mipLevels = ci.arrayLayers = 1; ci.samples = VK_SAMPLE_COUNT_1_BIT; ci.usage = usage; if (!create_image(ci, made.image, made.alloc)) return false; VkImageViewCreateInfo vi{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO}; vi.image = made.image; vi.viewType = VK_IMAGE_VIEW_TYPE_2D; vi.format = f; vi.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; if (vkCreateImageView(dev.device, &vi, nullptr, &made.view) != VK_SUCCESS) { destroy_image(made.image, made.alloc); return false; } i = made; return true; } void drop_img(Img& i) { if (i.view) vkDestroyImageView(dev.device, i.view, nullptr); if (i.image) destroy_image(i.image, i.alloc); i = {}; } void to_general(VkCommandBuffer cmd, VkImage image) { VkImageMemoryBarrier2 b{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2}; b.srcStageMask = b.dstStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT; b.dstAccessMask = VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT; b.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; b.newLayout = VK_IMAGE_LAYOUT_GENERAL; b.srcQueueFamilyIndex = b.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; b.image = image; b.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; VkDependencyInfo d{VK_STRUCTURE_TYPE_DEPENDENCY_INFO}; d.imageMemoryBarrierCount = 1; d.pImageMemoryBarriers = &b; vkCmdPipelineBarrier2(cmd, &d); } // Only after the display jobs and device have drained (ensure_size), or before any frame used these images. void drop_size() { for (int i = 0; i < 2; i++) { drop_img(fg.frames[i]), drop_img(fg.lumas[i]), drop_img(fg.flows[i]); } for (OutSet& set : fg.sets) for (Img& t : set.frame) drop_img(t); fg.w = fg.h = 0; fg.mult = 0; fg.have_prev = false; fg.recorded = nullptr; } bool ensure_size(VkCommandBuffer cmd, uint32_t w, uint32_t h) { if (fg.w == w && fg.h == h && fg.mult == multiplier()) return true; { // (the display thread is done with the old sets first) std::unique_lock lk(fg.mu); fg.cv.wait(lk, [] { return fg.jobs.empty() && !fg.sets[0].busy && !fg.sets[1].busy && !fg.sets[2].busy; }); } { std::lock_guard qk(dev.present_mu); // (every queue idle: the present queue's too, device_wait_idle_locked) device_wait_idle_locked(); } drop_size(); const uint32_t qw = (w + 3) / 4, qh = (h + 3) / 4, cw = (qw + 3) / 4, ch = (qh + 3) / 4; const VkImageUsageFlags rw = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT; bool ok = true; for (int i = 0; i < 2; i++) { ok = ok && make_img(fg.frames[i], w, h, VK_FORMAT_R8G8B8A8_UNORM, rw | VK_IMAGE_USAGE_TRANSFER_SRC_BIT); ok = ok && make_img(fg.lumas[i], qw, qh, VK_FORMAT_R16_SFLOAT, rw); ok = ok && make_img(fg.flows[i], cw, ch, VK_FORMAT_R16G16B16A16_SFLOAT, rw); } const int mult = multiplier(); for (OutSet& set : fg.sets) for (int k = 0; k < mult; k++) ok = ok && make_img(set.frame[k], w, h, VK_FORMAT_R8G8B8A8_UNORM, rw | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT); if (!ok) { fg.failed = true; drop_size(); // Older submissions were drained above; ensure_size precedes every pass recorded by framegen_record. drop_setup(); logf("vk: frame interpolation: its images (%ux%u) were not made: off", w, h); return false; } fg.w = w, fg.h = h, fg.mult = mult; for (int i = 0; i < 2; i++) { to_general(cmd, fg.frames[i].image), to_general(cmd, fg.lumas[i].image), to_general(cmd, fg.flows[i].image); } for (OutSet& set : fg.sets) for (Img& t : set.frame) if (t.image) to_general(cmd, t.image); // (only the multiplier's frames are made: a barrier on no image crashed the driver) fg.have_prev = false; return true; } /// One pass: pipe over w x h in 8x8 groups, the bindings in order (a sampler when one is given: a sampled image) void pass(VkCommandBuffer cmd, const Pipe& p, std::initializer_list> bindings, uint32_t w, uint32_t h, const void* push = nullptr, uint32_t push_bytes = 0) { VkDescriptorImageInfo ii[8]; VkWriteDescriptorSet ws[8]; uint32_t n = 0; for (const auto& [view, sampler] : bindings) { ii[n] = {sampler, view, VK_IMAGE_LAYOUT_GENERAL}; ws[n] = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}; ws[n].dstBinding = n; ws[n].descriptorCount = 1; ws[n].descriptorType = sampler ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; ws[n].pImageInfo = &ii[n]; n++; } vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, p.pipe); vkCmdPushDescriptorSetKHR(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, p.layout, 0, n, ws); if (push_bytes) vkCmdPushConstants(cmd, p.layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, push_bytes, push); vkCmdDispatch(cmd, (w + 7) / 8, (h + 7) / 8, 1); full_barrier(cmd); } // (hookshot) The display thread's wait for a frame's time, on a high-resolution timer. sleep_for rests on the system timer, // whose 1 ms (timeBeginPeriod) Windows 11 does not keep for a process whose window it takes as unseen: with the presents // no longer blocking (a present queue of their own) the thread slept before most frames and woke up to 20 ms after their time. void wait_until_near(int64_t ns) { static HANDLE timer = CreateWaitableTimerExW(nullptr, nullptr, CREATE_WAITABLE_TIMER_HIGH_RESOLUTION, TIMER_ALL_ACCESS); LARGE_INTEGER d; d.QuadPart = -std::max(1, ns / 100); // (relative, 100 ns units) if (timer && SetWaitableTimerEx(timer, &d, 0, nullptr, nullptr, nullptr, 0)) { WaitForSingleObject(timer, INFINITE); return; } std::this_thread::sleep_for(std::chrono::nanoseconds(ns)); } void display_main() { SetThreadDescription(GetCurrentThread(), L"mkw_vk display"); SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); int64_t interval = 16666667, last_at = 0; struct { int on_time, late, skipped; int64_t since; } stat{}; int64_t next_show = 0, shown_at = 0; int hist[6] = {}; for (;;) { Job j; { std::unique_lock lk(fg.mu); fg.cv.wait(lk, [] { return !fg.jobs.empty(); }); j = fg.jobs.front(); fg.jobs.pop_front(); } if (last_at) { const int64_t d = j.at - last_at; if (d > 0 && d < 100000000) interval = (interval * 7 + std::clamp(d, 4000000, 50000000)) / 8; } last_at = j.at; if (!stat.since) stat.since = j.at; if (j.at - stat.since > 5000000000LL) { logf("vk: frame interpolation: %d frames shown on time, %d late (over 2 ms); shown apart: <7 ms %d, 7-9 %d, 9-12 %d, " "12-17 %d, 17-25 %d, over 25 %d", stat.on_time, stat.late, hist[0], hist[1], hist[2], hist[3], hist[4], hist[5]); memset(hist, 0, sizeof hist); stat = {0, 0, 0, j.at}; } // (hookshot) The pacer. The game hands over frames 12 to 28 ms apart around a mean of 19, and shown as they came that // was the stutter, whatever the frame rate. Every frame now has its place on an even line, the recent frame time // apart, a frame early waiting for it: never more than one game frame behind what the game handed over, and a line // that has fallen behind what came starts again from now. RX_VK_PACE=0: as they come. const bool pace = opts.pace != 0; const bool timed = j.set->shown >= 0; // (Auto: each frame at its own refresh's time) const int shown = timed ? j.set->shown : j.set->made + 1; const int64_t step = interval / std::max(shown, 1); if (timed) menu_note_frame(true, 0); // (the overlay's game rate: Auto counts each game frame, given a refresh or not) for (int k = 0; k < shown; k++) { int64_t due = timed ? j.set->due[k] : pace ? next_show : 0; const int64_t now = now_ns(); if (due < now) due = now; if (!timed && due > j.at + interval + step) due = j.at + interval + step; if (timed && due > now + 100000000) due = now; // (a game frame time gone wrong: not held back) if (due - now > 1000000) wait_until_near(due - now - 1000000); while (now_ns() < due) SwitchToThread(); const int64_t t = now_ns(); present_kind.store(timed ? (j.set->game[k] ? 0 : 1) : k < j.set->made ? 1 : 0); present_image(j.set->frame[k].image, fg.w, fg.h, nullptr, j.set->frame[k].view); menu_note_frame(!timed && k == j.set->made); if (shown_at) { const int64_t d = t - shown_at; hist[d < 7000000 ? 0 : d < 9000000 ? 1 : d < 12000000 ? 2 : d < 17000000 ? 3 : d < 25000000 ? 4 : 5]++; } shown_at = t; next_show = t + step; (t - due > 2000000 ? stat.late : stat.on_time)++; } std::lock_guard lk(fg.mu); j.set->busy = false; fg.cv.notify_all(); } } } // namespace // The Insert menu's Frame generation is off at 0. While it was ignored, every present still copied the frame and // reduced it to luma (framegen_record), then a second thread showed it. Open areas paid for that on a full GPU and // gained no made frames. Auto (1) and 2x and up are the interpolation; RX_VK_FRAMEGEN=0 keeps it off entirely. bool framegen_wanted(int menu_value, int allow) { return allow && menu_value >= 1; // (1: Auto) } bool framegen_on() { static const int allow = !getenv("RX_VK_FRAMEGEN") || atoi(getenv("RX_VK_FRAMEGEN")) != 0; return framegen_wanted(opts.framegen, allow) && !dev.offscreen && !fg.failed; } // Ultrawide's menus (the Insert menu's Ultrawide menus): which of nx2/oot_wide.py's keep-list screens keep the whole picture, told // to the game's side each present, and, while a menu shows, the sides of the middle 16:9 to show out of focus (1) // or black (2), as fractions of the width. A menu's layout is set up once, when it is first opened: what tells one is // that the frame draws no world (vk_draw.cpp world_drawn_at), as a pause, the map, a loading screen or a movie // does not (3 presents' grace for a frame the world skips). The middle is centred: its right edge is 1 - x0. One 8-byte atomic: the // frame generation's display thread reads it (framegen_scale) while the replay thread writes it (wide_sides_tick) struct WideSides { float x0 = 0.0f; int side = 0; }; std::atomic wide_possible{false}; // (a margin and the setting on: vk_replay.cpp takes the scale pass's path for the sides) WideSides wide_sides() { WideSides w; if (!host || !host->wide_menus) return w; // (KEEP_VTABLES 1 and 3: the pause and map menus. 0, the item wheel's background, and 2, the fades, keep covering the whole picture) constexpr uint32_t kMenus = 0xa; const float margin = host->wide_menus(opts.wide_menus ? 0xfu & ~kMenus : 0xfu); extern std::atomic world_drawn_at; extern int64_t presents_now; extern std::atomic wheel_drawn_at; // (no world: a menu. But not the item wheel, whose background is the last frame of play over the whole picture, as on the // console: its sides are left as the game draws them) const bool no_world = presents_now - world_drawn_at.load(std::memory_order_relaxed) > 3 && presents_now - wheel_drawn_at.load(std::memory_order_relaxed) > 3; wide_possible.store(opts.wide_menus && margin > 0.0f, std::memory_order_relaxed); if (opts.wide_menus && margin > 0.0f && no_world) w.x0 = margin, w.side = opts.wide_menus; static int told = 0; if (w.side != told) { // (each change logged: a report of blurred sides in play says when they came and went) logf("vk: ultrawide menu sides %s at present %lld (the world last drawn at present %lld)", w.side ? "on" : "off", (long long)presents_now, (long long)world_drawn_at.load(std::memory_order_relaxed)); told = w.side; } return w; } std::atomic wide_now; // (wide_sides_tick's, each present) bool wide_sides_possible() { return wide_possible.load(std::memory_order_relaxed); } VkImage framegen_scale(VkCommandBuffer cmd, VkImageView src, VkImage image, uint32_t sw, uint32_t sh, const int crop[4], uint32_t dw, uint32_t dh) { const WideSides wide = wide_now.load(std::memory_order_relaxed); // (wide_sides_tick, each present) if (!opts.upscale && !opts.sharpness && !wide.side) return VK_NULL_HANDLE; if (!src || !image || !sw || !sh || !dw || !dh) return VK_NULL_HANDLE; const PresentSourceRect source = present_source_rect(sw, sh, crop); if (!source.w || !source.h) return VK_NULL_HANDLE; if (!init_scale()) return VK_NULL_HANDLE; // (the game draws into part of its window textures, 2048 x 1152 of 2560 x 1440 here: the filter was given the whole texture, and the // picture came out in the top left corner of the window with black around it. The crop first, then the filter) if (source.x || source.y || source.w != sw || source.h != sh) { const uint32_t cw = source.w, ch = source.h; if (scale.cropped_w != cw || scale.cropped_h != ch) { { std::lock_guard qk(dev.present_mu); device_wait_idle_locked(); } drop_img(scale.cropped); scale.cropped_w = scale.cropped_h = 0; if (!make_img(scale.cropped, cw, ch, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT)) { drop_img(scale.cropped); return VK_NULL_HANDLE; } scale.cropped_w = cw, scale.cropped_h = ch; to_general(cmd, scale.cropped.image); } VkImageBlit b{}; b.srcSubresource = b.dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}; b.srcOffsets[0] = {(int)source.x, (int)source.y, 0}; b.srcOffsets[1] = {(int)(source.x + cw), (int)(source.y + ch), 1}; b.dstOffsets[1] = {(int)cw, (int)ch, 1}; vkCmdBlitImage(cmd, image, VK_IMAGE_LAYOUT_GENERAL, scale.cropped.image, VK_IMAGE_LAYOUT_GENERAL, 1, &b, VK_FILTER_NEAREST); full_barrier(cmd); src = scale.cropped.view; } if (scale.scaled_w != dw || scale.scaled_h != dh) { { std::lock_guard qk(dev.present_mu); // (the queue is idle only while nothing else submits to it) device_wait_idle_locked(); } drop_img(scale.scaled); scale.scaled_w = scale.scaled_h = 0; // (Triforce, 11-13: SAMPLED too. On an HDR10 display the HDR pass (framegen_hdr) samples this image whenever the // picture was scaled or sharpened first; made without that usage, sampling it is not allowed, and the window was // black with Sharpness or Upscaling on ("Sharpness slider deletes all visuals", RTX 3060 Ti on an HDR10 surface; // shown in the lab with RX_VK_TEST_HDR_PASS=1: the window's mean brightness 0 with Sharpness 70, 131 with 0)) if (!make_img(scale.scaled, dw, dh, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT)) { drop_img(scale.scaled); return VK_NULL_HANDLE; } scale.scaled_w = dw, scale.scaled_h = dh; to_general(cmd, scale.scaled.image); // (Triforce: AMD FSR 1's middle image, EASU's output and RCAS's input, at the window's size. Without it Upscaling 3 falls // to the filter below) drop_img(scale.easu_img); if (scale.easu.pipe && scale.rcas.pipe && scale.nearest && make_img(scale.easu_img, dw, dh, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT)) to_general(cmd, scale.easu_img.image); else drop_img(scale.easu_img); } if (opts.upscale == 3 && scale.easu_img.view) { // (Triforce: AMD FSR 1, EvilOOT's own window filter: EASU, the edge-adaptive upscale, then RCAS at the Sharpness row. // The size the picture is at: the cropped one when the game drew into part of its texture) const uint32_t iw = src == scale.cropped.view ? scale.cropped_w : sw, ih = src == scale.cropped.view ? scale.cropped_h : sh; const uint32_t ep[4] = {iw, ih, dw, dh}; pass(cmd, scale.easu, {{src, scale.linear}, {scale.easu_img.view, VK_NULL_HANDLE}}, dw, dh, ep, sizeof ep); const struct { uint32_t w, h; float sharp, pad; } rp{dw, dh, opts.sharpness / 100.0f, 0.0f}; pass(cmd, scale.rcas, {{scale.easu_img.view, scale.nearest}, {scale.scaled.view, VK_NULL_HANDLE}}, dw, dh, &rp, sizeof rp); return scale.scaled.image; } struct { int mode; float sharp; float x0, x1; int side; } pc{opts.upscale, opts.sharpness / 100.0f, wide.x0, 1.0f - wide.x0, wide.side}; if (wide.side == 1) { // (the blurred sides: first the picture at 1/8, each pixel the mean of its 8 x 8, which they blur) // (from #1448's checked source rectangle, as the crop above: the picture src now holds) const uint32_t smw = std::max(1u, source.w / 8), smh = std::max(1u, source.h / 8); if (scale.small_w != smw || scale.small_h != smh) { { std::lock_guard qk(dev.present_mu); device_wait_idle_locked(); } drop_img(scale.small); scale.small_w = scale.small_h = 0; if (!make_img(scale.small, smw, smh, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT)) { drop_img(scale.small); return VK_NULL_HANDLE; } scale.small_w = smw, scale.small_h = smh; to_general(cmd, scale.small.image); } pc.side = 3; // (fg_scale.comp: make the small copy) pass(cmd, scale.pipe, {{src, scale.linear}, {scale.small.view, VK_NULL_HANDLE}, {src, scale.linear}}, smw, smh, &pc, sizeof pc); full_barrier(cmd); pc.side = 1; } pass(cmd, scale.pipe, {{src, scale.linear}, {scale.scaled.view, VK_NULL_HANDLE}, {wide.side == 1 ? scale.small.view : src, scale.linear}}, dw, dh, &pc, sizeof pc); static const bool report = getenv("RX_VK_UPSCALE_LOG") != nullptr; static bool reported = false; if (report && !reported) { reported = true; logf("vk: upscale dispatched: mode %d, sharpness %d%% (of RCAS's strongest, neighbours one source pixel apart), source %ux%u, " "crop request %d,%d %dx%d, destination %ux%u", opts.upscale, opts.sharpness, sw, sh, crop ? crop[0] : 0, crop ? crop[1] : 0, crop ? crop[2] : (int)sw, crop ? crop[3] : (int)sh, dw, dh); } return scale.scaled.image; } VkImageView framegen_scaled_view() { return scale.scaled.view; } /// (hookshot) The Insert menu's HDR: src's crop to a dw x dh HDR10 image (PQ, Rec. 2020, 10 bits), to be copied into an HDR10 /// swapchain's image as the SDR picture is (shaders/hdr_encode.comp); null when it cannot be made (then the SDR picture) VkImage framegen_hdr(VkCommandBuffer cmd, VkImageView src, uint32_t sw, uint32_t sh, const int crop[4], uint32_t dw, uint32_t dh) { if (!src || !sw || !sh || !dw || !dh) return VK_NULL_HANDLE; const PresentSourceRect source = present_source_rect(sw, sh, crop); if (!source.w || !source.h) return VK_NULL_HANDLE; if (!hdr.init) { hdr.init = hdr.failed = true; const VkDescriptorType S = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, I = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; if (dev.push_descriptor && vkCmdPushDescriptorSetKHR && init_scale() && make_pipe(hdr.pipe, HDR_ENCODE_COMP_SPV, sizeof HDR_ENCODE_COMP_SPV, {S, I}, 32)) hdr.failed = false; else logf("vk: HDR: the HDR pass could not be made: SDR"); } if (hdr.failed) return VK_NULL_HANDLE; if (hdr.w != dw || hdr.h != dh) { { std::lock_guard qk(dev.present_mu); device_wait_idle_locked(); } drop_img(hdr.out); hdr.w = hdr.h = 0; if (!make_img(hdr.out, dw, dh, VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT)) { drop_img(hdr.out); static bool told; if (!told) told = true, logf("vk: HDR: no 10-bit storage image on this GPU: SDR"); return VK_NULL_HANDLE; } hdr.w = dw, hdr.h = dh; to_general(cmd, hdr.out.image); } const float x0 = source.x / (float)sw, y0 = source.y / (float)sh; const float x1 = (source.x + source.w) / (float)sw, y1 = (source.y + source.h) / (float)sh; const struct { float uv[4]; float white, peak, knee, pad; } pc{{x0, y0, x1, y1}, (float)std::clamp(opts.hdr_white, 80, 500), (float)std::clamp(opts.hdr_peak, 400, 10000), 0.6f, 0.0f}; pass(cmd, hdr.pipe, {{src, scale.linear}, {hdr.out.view, VK_NULL_HANDLE}}, dw, dh, &pc, sizeof pc); return hdr.out.image; } VkImage framegen_made_image(uint32_t* w, uint32_t* h) { if (!fg.recorded || !fg.recorded->made) return VK_NULL_HANDLE; *w = fg.w, *h = fg.h; return fg.recorded->frame[0].image; } /// (hookshot) The made frame of a 2x set by AMD FSR 3.1's frame interpolation (vk_fsr3fi.h), from this frame's colour and /// the scene's depth and motion (vk_fsr3_inputs.h): 1 when it made it into set.frame[0], 0 when it did not (no inputs this /// present, a reset, anything not made), which leaves the set to the interpolation below. sequence: framegen_record's count /// of its presents (one it did not hand over, a gap among them, makes the next one a reset: vk_fsr3fi.h Inputs::sequence) int fsr3fi_frame(VkCommandBuffer cmd, OutSet& set, int cur, uint32_t uw, uint32_t uh, uint64_t sequence) { // (every 600 presents asked: how many FSR made, and how many it left to the interpolation below and why) static uint64_t asked = 0, made = 0, no_inputs = 0; if (++asked % 600 == 0) logf("vk: fsr3fi: %llu of the last 600 made frames by FSR 3.1, %llu without its inputs (the renderer's own made them)", (unsigned long long)made, (unsigned long long)no_inputs), made = no_inputs = 0; fsr3_inputs::Frame f; if (!fsr3_inputs::take(f)) return no_inputs++, 0; fsr3fi::Inputs in; in.color = fg.frames[cur].view; in.color_image = fg.frames[cur].image; in.color_format = VK_FORMAT_R8G8B8A8_UNORM; // (ensure_size, for fg.frames) in.width = uw, in.height = uh; in.depth = f.depth, in.motion = f.motion; in.render_width = f.width, in.render_height = f.height; in.jitter[0] = f.jitter[0], in.jitter[1] = f.jitter[1]; in.camera = f.camera; in.frame_time_ms = f.frame_ms; in.reset = f.reset; in.sequence = sequence; if (!fsr3fi::generate(cmd, in) || !fsr3fi::made_image()) return 0; const VkImageCopy c{{VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {uw, uh, 1}}; vkCmdCopyImage(cmd, fsr3fi::made_image(), VK_IMAGE_LAYOUT_GENERAL, set.frame[0].image, VK_IMAGE_LAYOUT_GENERAL, 1, &c); made++; static bool told = false; if (!told) { told = true; logf("vk: fsr3fi: AMD FSR 3.1 makes the frame between each two of the game's (%ux%u, its depth and motion %ux%u)", uw, uh, f.width, f.height); } return 1; } bool framegen_record(VkCommandBuffer cmd, VkImageView src, uint32_t sw, uint32_t sh, const int crop[4]) { const PresentSourceRect source = present_source_rect(sw, sh, crop); const int x0 = (int)source.x, y0 = (int)source.y, w = (int)source.w, h = (int)source.h; if (!src || w <= 0 || h <= 0 || !init() || !ensure_size(cmd, (uint32_t)w, (uint32_t)h)) return false; if (!fg.thread_started) { fg.thread_started = true; std::thread(display_main).detach(); } const int64_t now = now_ns(), before = fg.last_at; const bool gap = fg.last_at && now - fg.last_at > 100000000; // (a loading hitch: nothing to blend) if (fg.last_at && !gap) fg.game_ns = fg.game_ns ? (fg.game_ns * 7 + (now - fg.last_at)) / 8 : now - fg.last_at; fg.last_at = now; OutSet* set; { std::unique_lock lk(fg.mu); fg.cv.wait(lk, [] { return !fg.sets[fg.next_set].busy; }); set = &fg.sets[fg.next_set]; set->busy = true; fg.next_set = (fg.next_set + 1) % 3; } const int cur = fg.cur, prev = cur ^ 1, m = multiplier(); const bool blend = fg.have_prev && !gap; static uint64_t sequence = 0; sequence++; const uint32_t uw = (uint32_t)w, uh = (uint32_t)h; const uint32_t qw = (uw + 3) / 4, qh = (uh + 3) / 4, cw = (qw + 3) / 4, ch = (qh + 3) / 4; full_barrier(cmd); const int32_t pc[4] = {x0, y0, w, h}; pass(cmd, fg.copy, {{src, fg.nearest}, {fg.frames[cur].view, VK_NULL_HANDLE}}, uw, uh, pc, sizeof pc); pass(cmd, fg.luma, {{fg.frames[cur].view, fg.nearest}, {fg.lumas[cur].view, VK_NULL_HANDLE}}, qw, qh); set->made = 0; set->shown = -1; if (opts.framegen == 1) { // (Auto: a frame for each of the display's refreshes, at its own time) const int mhz = display_refresh_mhz(); const int64_t period = (int64_t)(1e12 / (mhz > 0 ? mhz : 60000)); float t[kMaxMult]; int64_t at[kMaxMult]; int n; if (blend) { n = auto_slots(before, now, period, fg.slot_next, t, at, std::min(fg.mult, kMaxMult)); } else { // (nothing to blend from: the game's frame, and the timeline starts at it) n = 1, t[0] = 1.0f, at[0] = now, fg.slot_next = now + period; } bool flow = false; for (int k = 0; k < n; k++) { set->game[k] = t[k] > 0.999f; set->due[k] = at[k] + fg.game_ns; if (set->game[k]) { const VkImageCopy c{{VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {uw, uh, 1}}; vkCmdCopyImage(cmd, fg.frames[cur].image, VK_IMAGE_LAYOUT_GENERAL, set->frame[k].image, VK_IMAGE_LAYOUT_GENERAL, 1, &c); continue; } if (!flow) { flow = true; pass(cmd, fg.flow, {{fg.lumas[prev].view, fg.nearest}, {fg.lumas[cur].view, fg.nearest}, {fg.flows[0].view, VK_NULL_HANDLE}}, cw, ch); pass(cmd, fg.median, {{fg.flows[0].view, fg.nearest}, {fg.flows[1].view, VK_NULL_HANDLE}}, cw, ch); } pass(cmd, fg.synth, {{fg.frames[prev].view, fg.linear}, {fg.frames[cur].view, fg.linear}, {fg.flows[1].view, fg.nearest}, {set->frame[k].view, VK_NULL_HANDLE}}, uw, uh, &t[k], 4); } set->shown = n; set->made = n > 0 && !set->game[n - 1] ? n : std::max(0, n - 1); // (for framegen_made_image: any made) full_barrier(cmd); fg.have_prev = true; fg.cur = prev; fg.recorded = set; fg.recorded_at = now; return true; } // (hookshot) At 2x, AMD FSR 3.1's frame interpolation where it runs; it makes the midpoint only, so 3x and more (and Auto, // above) stay with the interpolation below, as does any present it does not take if (blend && m == 2 && fsr3fi::frames_wanted()) set->made = fsr3fi_frame(cmd, *set, cur, uw, uh, sequence); if (set->made == 0 && blend && m > 1) { pass(cmd, fg.flow, {{fg.lumas[prev].view, fg.nearest}, {fg.lumas[cur].view, fg.nearest}, {fg.flows[0].view, VK_NULL_HANDLE}}, cw, ch); pass(cmd, fg.median, {{fg.flows[0].view, fg.nearest}, {fg.flows[1].view, VK_NULL_HANDLE}}, cw, ch); for (int k = 1; k < m; k++) { const float t = (float)k / (float)m; pass(cmd, fg.synth, {{fg.frames[prev].view, fg.linear}, {fg.frames[cur].view, fg.linear}, {fg.flows[1].view, fg.nearest}, {set->frame[k - 1].view, VK_NULL_HANDLE}}, uw, uh, &t, 4); } set->made = m - 1; } const VkImageCopy c{{VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {uw, uh, 1}}; vkCmdCopyImage(cmd, fg.frames[cur].image, VK_IMAGE_LAYOUT_GENERAL, set->frame[set->made].image, VK_IMAGE_LAYOUT_GENERAL, 1, &c); full_barrier(cmd); fg.have_prev = true; fg.cur = prev; fg.recorded = set; fg.recorded_at = now; return true; } void framegen_queue(uint64_t value) { if (!fg.recorded) return; std::lock_guard lk(fg.mu); fg.jobs.push_back({fg.recorded, fg.recorded_at, value}); fg.recorded = nullptr; fg.cv.notify_all(); } /// Each present (vk_replay.cpp): ultrawide's menu setting to the game's side, and the sides to treat now void wide_sides_tick() { wide_now = wide_sides(); } } // namespace mkwvk