mirror of
https://github.com/RetroPortingToolKit/psxrecomp
synced 2026-10-25 18:05:12 -04:00
Matt Stanley
f9db2561d0
* fix: reuse resident HD textures and publish live background dumps * test: keep residency stubs local to the filtering fixture
636 lines
35 KiB
C++
636 lines
35 KiB
C++
#include "gpu_hd_textures.h"
|
|
#include "gpu_gl_renderer.h"
|
|
#include "hd_texture_pack.h"
|
|
#include "duckstation_texture_pack.h"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cmath>
|
|
#include <vector>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <deque>
|
|
#include <filesystem>
|
|
#include <memory>
|
|
#include <new>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
constexpr size_t kVramWords = 1024u * 512u;
|
|
constexpr size_t kCompositionBudget = 64u * 1024u * 1024u;
|
|
/* A tiled scene can use dozens of small compositions per frame. The byte
|
|
* budget bounds memory; a sixteen-entry limit thrashed below that budget. */
|
|
constexpr size_t kCompositionCount = 256;
|
|
constexpr uint32_t kCompositionDimension = 8192;
|
|
constexpr size_t kMaxParts = 64;
|
|
struct Composition {
|
|
std::vector<uint64_t> signature;
|
|
std::vector<uint8_t> rgba;
|
|
uint32_t width = 0, height = 0;
|
|
uint64_t cache_key = 0, last_use = 0;
|
|
uint64_t ready_mask = 0;
|
|
};
|
|
struct Session {
|
|
std::string root;
|
|
HdTexturePack* beetle = nullptr;
|
|
DuckTexturePack* duck = nullptr;
|
|
bool replacements = false;
|
|
bool dump = false;
|
|
bool dump_failed = false;
|
|
bool copy_pending = false;
|
|
std::vector<std::shared_ptr<Composition>> compositions;
|
|
size_t composition_bytes = 0;
|
|
uint64_t composition_clock = 0;
|
|
std::string dump_error;
|
|
std::deque<std::string> diagnostics;
|
|
/* Rectangles of uploads whose CRC keys a Beetle replacement, kept so a
|
|
* restage can re-verify them against the restored VRAM (bounded). */
|
|
std::vector<std::array<uint16_t, 4>> learned;
|
|
GpuHdTextureDiag diag{};
|
|
~Session() { hd_texture_pack_destroy(beetle); duck_texture_pack_destroy(duck); }
|
|
};
|
|
struct Lease {
|
|
HdTexturePixels beetle{};
|
|
DuckTexturePixels duck{};
|
|
std::shared_ptr<Composition> composition;
|
|
~Lease() { hd_texture_pixels_release(&beetle); duck_texture_pixels_release(&duck); }
|
|
};
|
|
std::unique_ptr<Session> session;
|
|
const uint16_t* native_vram = nullptr;
|
|
uint64_t generation = 1;
|
|
uint64_t composition_serial = 0;
|
|
|
|
struct DecodedParts {
|
|
std::array<DuckTexturePixels, kMaxParts> pixels{};
|
|
~DecodedParts() { for (auto& pixel : pixels) duck_texture_pixels_release(&pixel); }
|
|
};
|
|
|
|
void fail(char* error, size_t capacity, const char* message) {
|
|
if (error && capacity) std::snprintf(error, capacity, "%s", message);
|
|
}
|
|
bool is_beetle_root(const std::filesystem::path& root) {
|
|
std::error_code error;
|
|
if (std::filesystem::exists(root / "Hashes.ini", error)) return true;
|
|
if (std::filesystem::exists(root.parent_path() / "Hashes.ini", error)) return true;
|
|
const auto name = root.filename().u8string();
|
|
const std::string suffix = "-texture-replacements";
|
|
return name.size() >= suffix.size() &&
|
|
name.compare(name.size() - suffix.size(), suffix.size(), suffix) == 0;
|
|
}
|
|
int window_coord(int value, int mask, int offset) {
|
|
return (value & ~(mask * 8)) | ((offset & mask) * 8);
|
|
}
|
|
bool make_query(uint16_t texpage, uint16_t cx, uint16_t cy, const int limits[4],
|
|
uint32_t window, HdTextureDrawQuery& query) {
|
|
if (!native_vram || !limits || ((texpage >> 7) & 3u) == 3u) return false;
|
|
if (limits[0] < 0 || limits[1] < 0 || limits[2] > 255 || limits[3] > 255 ||
|
|
limits[0] > limits[2] || limits[1] > limits[3]) return false;
|
|
int first[2] = {255,255}, last[2] = {0,0};
|
|
for (int axis = 0; axis < 2; ++axis) {
|
|
int mask = (window >> (axis * 5)) & 31;
|
|
int offset = (window >> (10 + axis * 5)) & 31;
|
|
for (int p = limits[axis]; p <= limits[axis + 2]; ++p) {
|
|
const int mapped = window_coord(p, mask, offset);
|
|
first[axis] = std::min(first[axis], mapped);
|
|
last[axis] = std::max(last[axis], mapped);
|
|
}
|
|
}
|
|
query = {};
|
|
query.page_x = (texpage & 15u) * 64u;
|
|
query.page_y = ((texpage >> 4) & 1u) * 256u;
|
|
query.depth = (texpage >> 7) & 3u;
|
|
query.u_first = static_cast<uint8_t>(first[0]);
|
|
query.u_last = static_cast<uint8_t>(last[0]);
|
|
query.v_first = static_cast<uint8_t>(first[1]);
|
|
query.v_last = static_cast<uint8_t>(last[1]);
|
|
query.clut_x = cx; query.clut_y = cy;
|
|
query.vram = native_vram; query.vram_word_count = kVramWords;
|
|
return true;
|
|
}
|
|
uint8_t replacement_class(const uint8_t* pixel, bool semi) {
|
|
if (!semi) return pixel[3] >= 128 ? 255 : 0;
|
|
if (!(pixel[0] | pixel[1] | pixel[2] | pixel[3])) return 0;
|
|
if (pixel[3] <= 242) return 128;
|
|
return (pixel[0] | pixel[1] | pixel[2]) ? 255 : 0;
|
|
}
|
|
void replacement_pixel(const DuckTexturePixels& image, bool semi, bool linear,
|
|
double x, double y, uint8_t* output) {
|
|
const int nx = std::clamp(static_cast<int>(std::floor(x)), 0, static_cast<int>(image.width) - 1);
|
|
const int ny = std::clamp(static_cast<int>(std::floor(y)), 0, static_cast<int>(image.height) - 1);
|
|
const uint8_t* nearest = image.rgba + static_cast<size_t>(ny) * image.stride + nx * 4;
|
|
const uint8_t alpha = replacement_class(nearest, semi);
|
|
output[3] = alpha;
|
|
if (!alpha) { output[0] = output[1] = output[2] = 0; return; }
|
|
if (!linear) { std::memcpy(output, nearest, 3); return; }
|
|
/* Scaling filters colors within the nearest PSX class. Alpha class is
|
|
* discrete: mixing cutout/STP/opaque would alter the primitive's blend. */
|
|
x -= 0.5; y -= 0.5;
|
|
const int bx = static_cast<int>(std::floor(x)), by = static_cast<int>(std::floor(y));
|
|
const double fx = x - bx, fy = y - by;
|
|
double sum[3]{}, weight = 0;
|
|
for (int dy = 0; dy < 2; ++dy) for (int dx = 0; dx < 2; ++dx) {
|
|
const int px = std::clamp(bx + dx, 0, static_cast<int>(image.width) - 1);
|
|
const int py = std::clamp(by + dy, 0, static_cast<int>(image.height) - 1);
|
|
const uint8_t* pixel = image.rgba + static_cast<size_t>(py) * image.stride + px * 4;
|
|
if (replacement_class(pixel, semi) != alpha) continue;
|
|
const double w = (dx ? fx : 1 - fx) * (dy ? fy : 1 - fy);
|
|
for (int channel = 0; channel < 3; ++channel) sum[channel] += pixel[channel] * w;
|
|
weight += w;
|
|
}
|
|
for (int channel = 0; channel < 3; ++channel)
|
|
output[channel] = weight > 0 ? static_cast<uint8_t>(std::clamp(sum[channel] / weight + 0.5, 0.0, 255.0)) : nearest[channel];
|
|
}
|
|
void native_pixel(const HdTextureDrawQuery& query, const std::array<uint16_t,256>& palette,
|
|
int u, int v, uint8_t* output) {
|
|
const unsigned per_word = 4u >> query.depth;
|
|
uint16_t word = query.vram[(query.page_y + v) * 1024u + query.page_x + u / per_word];
|
|
if (query.depth == HD_TEXTURE_DEPTH_4BPP) word = palette[(word >> ((u & 3) * 4)) & 15];
|
|
else if (query.depth == HD_TEXTURE_DEPTH_8BPP) word = palette[(word >> ((u & 1) * 8)) & 255];
|
|
output[0] = static_cast<uint8_t>(((word & 31u) * 255u + 15u) / 31u);
|
|
output[1] = static_cast<uint8_t>((((word >> 5) & 31u) * 255u + 15u) / 31u);
|
|
output[2] = static_cast<uint8_t>((((word >> 10) & 31u) * 255u + 15u) / 31u);
|
|
output[3] = !word ? 0 : (word & 0x8000u) ? 128 : 255;
|
|
}
|
|
std::vector<uint64_t> composition_signature(const HdTextureDrawQuery& query,
|
|
const std::array<DuckTextureMatch,kMaxParts>& matches, size_t count,
|
|
std::array<uint16_t,256>& palette) {
|
|
const unsigned per_word = 4u >> query.depth;
|
|
const unsigned first_word = query.u_first / per_word, last_word = query.u_last / per_word;
|
|
const uint32_t native_height = query.v_last - query.v_first + 1;
|
|
const size_t palette_size = query.depth == HD_TEXTURE_DEPTH_4BPP ? 16 : query.depth == HD_TEXTURE_DEPTH_8BPP ? 256 : 0;
|
|
for (size_t i = 0; i < palette_size; ++i)
|
|
palette[i] = query.vram[(query.clut_y & 511u) * 1024u + ((query.clut_x + i) & 1023u)];
|
|
std::vector<uint64_t> signature{
|
|
static_cast<uint64_t>(query.page_x) | (static_cast<uint64_t>(query.page_y) << 16) | (static_cast<uint64_t>(query.depth) << 32),
|
|
static_cast<uint64_t>(query.u_first) | (static_cast<uint64_t>(query.v_first) << 8) |
|
|
(static_cast<uint64_t>(query.u_last) << 16) | (static_cast<uint64_t>(query.v_last) << 24),
|
|
duck_texture_hash_rect(query.vram, query.vram_word_count, query.page_x + first_word,
|
|
query.page_y + query.v_first, last_word - first_word + 1, native_height),
|
|
duck_texture_hash_words_le(palette.data(), palette_size)};
|
|
signature.push_back(duck_texture_pack_linear_filter(session->duck) != 0);
|
|
for (size_t i = 0; i < count; ++i) {
|
|
const auto& match = matches[i];
|
|
signature.insert(signature.end(), {match.entry_id, static_cast<uint32_t>(match.origin_u),
|
|
static_cast<uint32_t>(match.origin_v), match.source_width, match.source_height,
|
|
static_cast<uint32_t>(match.clip_u), static_cast<uint32_t>(match.clip_v),
|
|
match.clip_width, match.clip_height, match.key.semitransparent});
|
|
}
|
|
return signature;
|
|
}
|
|
std::shared_ptr<Composition> find_composition(const std::vector<uint64_t>& signature, uint64_t ready_mask) {
|
|
for (auto& cached : session->compositions)
|
|
if (cached->ready_mask == ready_mask && cached->signature == signature) {
|
|
++session->diag.composition_hits;
|
|
cached->last_use = ++session->composition_clock; return cached;
|
|
}
|
|
return {};
|
|
}
|
|
std::shared_ptr<Composition> compose(const HdTextureDrawQuery& query,
|
|
const std::array<DuckTextureMatch,kMaxParts>& matches, const DecodedParts& decoded, size_t count,
|
|
std::vector<uint64_t> signature, const std::array<uint16_t,256>& palette) {
|
|
const unsigned per_word = 4u >> query.depth;
|
|
if (query.page_x + query.u_last / per_word >= 1024 || query.page_y + query.v_last >= 512) return {};
|
|
const uint32_t native_width = query.u_last - query.u_first + 1;
|
|
const uint32_t native_height = query.v_last - query.v_first + 1;
|
|
const bool linear = duck_texture_pack_linear_filter(session->duck) != 0;
|
|
double scale_x = 1, scale_y = 1;
|
|
uint64_t ready_mask = 0;
|
|
for (size_t i = 0; i < count; ++i) {
|
|
const auto& pixel = decoded.pixels[i];
|
|
if (!pixel.rgba) continue;
|
|
ready_mask |= UINT64_C(1) << i;
|
|
scale_x = std::max(scale_x, static_cast<double>(pixel.width) / matches[i].source_width);
|
|
scale_y = std::max(scale_y, static_cast<double>(pixel.height) / matches[i].source_height);
|
|
}
|
|
if (auto cached = find_composition(signature, ready_mask)) return cached;
|
|
const double wanted_width = std::ceil(native_width * scale_x);
|
|
const double wanted_height = std::ceil(native_height * scale_y);
|
|
if (wanted_width > kCompositionDimension || wanted_height > kCompositionDimension) return {};
|
|
const uint32_t width = static_cast<uint32_t>(wanted_width), height = static_cast<uint32_t>(wanted_height);
|
|
const size_t bytes = static_cast<size_t>(width) * height * 4u;
|
|
if (bytes > kCompositionBudget) return {};
|
|
while (!session->compositions.empty() && (session->compositions.size() >= kCompositionCount ||
|
|
session->composition_bytes + bytes > kCompositionBudget)) {
|
|
auto oldest = std::min_element(session->compositions.begin(), session->compositions.end(),
|
|
[](const auto& a, const auto& b) { return a->last_use < b->last_use; });
|
|
session->composition_bytes -= (*oldest)->rgba.size(); session->compositions.erase(oldest);
|
|
}
|
|
auto result = std::make_shared<Composition>();
|
|
++session->diag.composition_builds;
|
|
session->diag.composition_pixels += static_cast<uint64_t>(width) * height;
|
|
result->signature = std::move(signature); result->width = width; result->height = height;
|
|
result->ready_mask = ready_mask;
|
|
result->rgba.resize(bytes);
|
|
for (uint32_t y = 0; y < height; ++y) for (uint32_t x = 0; x < width; ++x)
|
|
native_pixel(query, palette, query.u_first + (static_cast<uint64_t>(x) * 2 + 1) * native_width / (width * 2u),
|
|
query.v_first + (static_cast<uint64_t>(y) * 2 + 1) * native_height / (height * 2u),
|
|
result->rgba.data() + (static_cast<size_t>(y) * width + x) * 4);
|
|
for (size_t i = 0; i < count; ++i) {
|
|
const auto& image = decoded.pixels[i]; const auto& match = matches[i];
|
|
if (!image.rgba) continue;
|
|
const int x0 = std::clamp(static_cast<int>(std::floor((match.clip_u - query.u_first) * static_cast<double>(width) / native_width)), 0, static_cast<int>(width));
|
|
const int y0 = std::clamp(static_cast<int>(std::floor((match.clip_v - query.v_first) * static_cast<double>(height) / native_height)), 0, static_cast<int>(height));
|
|
const int x1 = std::clamp(static_cast<int>(std::ceil((match.clip_u + match.clip_width - query.u_first) * static_cast<double>(width) / native_width)), 0, static_cast<int>(width));
|
|
const int y1 = std::clamp(static_cast<int>(std::ceil((match.clip_v + match.clip_height - query.v_first) * static_cast<double>(height) / native_height)), 0, static_cast<int>(height));
|
|
for (int y = y0; y < y1; ++y) for (int x = x0; x < x1; ++x) {
|
|
const double u = query.u_first + (x + 0.5) * native_width / width;
|
|
const double v = query.v_first + (y + 0.5) * native_height / height;
|
|
if (u < match.clip_u || u >= match.clip_u + match.clip_width ||
|
|
v < match.clip_v || v >= match.clip_v + match.clip_height) continue;
|
|
replacement_pixel(image, match.key.semitransparent != 0, linear,
|
|
(u - match.origin_u) * image.width / match.source_width,
|
|
(v - match.origin_v) * image.height / match.source_height,
|
|
result->rgba.data() + (static_cast<size_t>(y) * width + x) * 4);
|
|
}
|
|
}
|
|
result->cache_key = (UINT64_C(1) << 63) | ++composition_serial;
|
|
result->last_use = ++session->composition_clock;
|
|
session->compositions.push_back(result); session->composition_bytes += bytes;
|
|
return result;
|
|
}
|
|
bool dumps_suppressed = false;
|
|
void dump_query(const HdTextureDrawQuery& query, int semi) {
|
|
if (!session->dump || session->dump_failed || dumps_suppressed) return;
|
|
char error[256]{};
|
|
const int status = duck_texture_pack_dump_draw(session->duck, &query, semi, error, sizeof(error));
|
|
if (status == HD_TEXTURE_LOOKUP_FOUND) ++session->diag.dumped_textures;
|
|
if (status < 0) {
|
|
/* Keep the configured raster authority until a safe session boundary.
|
|
* Tearing it down inside a pre-draw query would lose command order. */
|
|
session->dump_failed = true;
|
|
session->dump_error = error;
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" int gpu_hd_textures_configure(const char* root, int replacements,
|
|
int dump, char* error, size_t capacity) {
|
|
if (error && capacity) error[0] = 0;
|
|
if ((!root || !root[0]) && !replacements && !dump) {
|
|
gpu_hd_textures_shutdown(); return 1;
|
|
}
|
|
if (!root || !root[0]) { fail(error, capacity, "Select an external texture-pack directory."); return 0; }
|
|
try {
|
|
auto next = std::make_unique<Session>();
|
|
next->root = root; next->replacements = replacements != 0; next->dump = dump != 0;
|
|
const bool beetle = is_beetle_root(std::filesystem::u8path(root));
|
|
if (beetle) {
|
|
if (!hd_texture_pack_create(root, &next->beetle, error, capacity)) return 0;
|
|
} else {
|
|
char ignored[256]{};
|
|
hd_texture_pack_create(root, &next->beetle, ignored, sizeof(ignored));
|
|
}
|
|
if (!next->beetle) {
|
|
auto directory = std::filesystem::u8path(root);
|
|
if (directory.filename().u8string() == "replacements") directory = directory.parent_path();
|
|
std::filesystem::create_directories(directory / "replacements");
|
|
std::filesystem::create_directories(directory / "dumps");
|
|
}
|
|
if (!duck_texture_pack_create(root, &next->duck, error, capacity)) return 0;
|
|
/* Quiesce renderer users (GL render thread: dump_draw appends to the
|
|
* old session's sources) before flushing its dumps or reading its
|
|
* residency; the cache is rebuilt from the new session. */
|
|
if (session) gl_renderer_clear_hd_texture_cache();
|
|
if (session) {
|
|
char dump_error[256]{};
|
|
if (duck_texture_pack_flush_dumps(session->duck, dump_error, sizeof(dump_error)) < 0) {
|
|
session->dump_error = dump_error;
|
|
fail(error, capacity, dump_error); return 0;
|
|
}
|
|
}
|
|
if (session && (session->replacements || session->dump) && session->root == next->root) {
|
|
if (!duck_texture_pack_copy_tracking(next->duck, session->duck)) {
|
|
fail(error, capacity, "Could not preserve texture-upload tracking during reload."); return 0;
|
|
}
|
|
if (session->beetle && next->beetle) {
|
|
uint8_t* saved = nullptr; size_t saved_size = 0;
|
|
if (!hd_texture_pack_tracking_state_save(session->beetle, &saved, &saved_size)) {
|
|
fail(error, capacity, "Could not save Beetle texture-upload tracking during reload."); return 0;
|
|
}
|
|
const int restored = hd_texture_pack_tracking_state_load(next->beetle, saved, saved_size);
|
|
std::free(saved);
|
|
if (!restored) { fail(error, capacity, "Could not restore Beetle texture-upload tracking during reload."); return 0; }
|
|
/* Restage after rewind/load rehashes these bounded upload
|
|
* rectangles against restored VRAM. A same-pack reload must
|
|
* preserve that knowledge as well as current residency. */
|
|
next->learned = session->learned;
|
|
}
|
|
}
|
|
/* This also flushes all queued users before old replacement textures
|
|
* and pixel leases may be destroyed. */
|
|
gl_renderer_set_hd_texture_mode(next->replacements || next->dump);
|
|
gl_renderer_clear_hd_texture_cache();
|
|
session = std::move(next); ++generation;
|
|
DuckTexturePackInfo info{};
|
|
duck_texture_pack_get_info(session->duck, &info);
|
|
size_t replacements_found = info.replacement_count;
|
|
size_t ambiguous = info.ambiguous_count;
|
|
if (session->beetle) {
|
|
HdTexturePackInfo beetle_info{};
|
|
hd_texture_pack_get_info(session->beetle, &beetle_info);
|
|
replacements_found = beetle_info.unique_key_count;
|
|
ambiguous = beetle_info.ambiguous_key_count;
|
|
}
|
|
std::fprintf(stdout, "psxrecomp: texture pack '%s': %zu replacements, %zu ambiguous, %zu ignored\n",
|
|
session->root.c_str(), replacements_found, ambiguous, info.ignored_count);
|
|
if (info.diagnostic && info.diagnostic[0])
|
|
std::fprintf(stderr, "psxrecomp: texture pack: %s\n", info.diagnostic);
|
|
return 1;
|
|
} catch (const std::exception& exception) {
|
|
fail(error, capacity, exception.what()); return 0;
|
|
}
|
|
}
|
|
extern "C" void gpu_hd_textures_shutdown(void) {
|
|
gl_renderer_set_hd_texture_mode(0);
|
|
gl_renderer_clear_hd_texture_cache();
|
|
session.reset(); ++generation;
|
|
}
|
|
extern "C" int gpu_hd_textures_reload(char* error, size_t capacity) {
|
|
if (!session) { fail(error, capacity, "No texture-pack session is active."); return 0; }
|
|
const std::string root = session->root;
|
|
return gpu_hd_textures_configure(root.c_str(), session->replacements, session->dump, error, capacity);
|
|
}
|
|
extern "C" void gpu_hd_textures_set_dump_enabled(int enabled) {
|
|
if (!session || session->dump == (enabled != 0)) return;
|
|
/* The render thread may be dumping (dump_draw) or tracking residency. */
|
|
gl_renderer_render_thread_sync("hd_set_dump");
|
|
if (enabled && !session->replacements) gpu_hd_textures_reset_tracking();
|
|
if (!enabled) {
|
|
char error[256]{};
|
|
if (duck_texture_pack_flush_dumps(session->duck, error, sizeof(error)) < 0) {
|
|
session->dump_error = error; session->dump_failed = true; return;
|
|
}
|
|
}
|
|
gl_renderer_set_hd_texture_mode(session->replacements || enabled);
|
|
session->dump = enabled != 0;
|
|
session->dump_failed = false;
|
|
}
|
|
extern "C" int gpu_hd_textures_replacements_enabled(void) { return session && session->replacements; }
|
|
extern "C" int gpu_hd_textures_dump_enabled(void) { return session && session->dump; }
|
|
extern "C" int gpu_hd_textures_active(void) { return session && (session->replacements || session->dump); }
|
|
extern "C" void gpu_hd_textures_get_diag(GpuHdTextureDiag* out) {
|
|
if (!out) return;
|
|
*out = {};
|
|
if (!session) { out->root = ""; out->diagnostic = ""; return; }
|
|
/* Counters and dump queues are written by the GL render thread. */
|
|
gl_renderer_render_thread_sync("hd_diag");
|
|
*out = session->diag;
|
|
out->root = session->root.c_str(); out->active = gpu_hd_textures_active();
|
|
out->replacements = session->replacements; out->dump = session->dump && !session->dump_failed;
|
|
out->format = session->beetle ? 1 : 2;
|
|
DuckTexturePackInfo info{}; duck_texture_pack_get_info(session->duck, &info);
|
|
out->decoded_images = info.decoded_images;
|
|
out->decode_evictions = info.decode_evictions;
|
|
out->decoded_bytes = info.decoded_bytes;
|
|
out->dumped_textures = info.queued_dump_count; out->pending_dump_sources = info.pending_dump_sources;
|
|
if (session->beetle) { HdTexturePackInfo beetle_info{}; hd_texture_pack_get_info(session->beetle, &beetle_info); out->replacement_count = beetle_info.unique_key_count; }
|
|
else out->replacement_count = info.replacement_count;
|
|
std::string diagnostic = info.diagnostic ? info.diagnostic : "";
|
|
if (!session->dump_error.empty()) {
|
|
if (!diagnostic.empty()) diagnostic += "; ";
|
|
diagnostic += session->dump_error;
|
|
}
|
|
if (session->diagnostics.empty() || session->diagnostics.back() != diagnostic)
|
|
session->diagnostics.push_back(std::move(diagnostic));
|
|
out->diagnostic = session->diagnostics.back().c_str();
|
|
}
|
|
extern "C" void gpu_hd_textures_note_applied(void) { if (session) ++session->diag.applied_draws; }
|
|
extern "C" void gpu_hd_textures_note_gl_cache(int eviction) {
|
|
if (session) {
|
|
if (eviction) ++session->diag.gl_evictions;
|
|
else ++session->diag.gl_uploads;
|
|
}
|
|
}
|
|
extern "C" void gpu_hd_textures_bind_vram(const uint16_t* vram) { native_vram = vram; }
|
|
extern "C" void gpu_hd_textures_suppress_dumps(int on) { dumps_suppressed = on != 0; }
|
|
extern "C" void gpu_hd_textures_set_vram(const uint16_t* vram) { native_vram = vram; gpu_hd_textures_reset_tracking(); }
|
|
extern "C" void gpu_hd_textures_reset_tracking(void) {
|
|
if (!session) return;
|
|
gl_renderer_clear_hd_texture_cache();
|
|
session->compositions.clear(); session->composition_bytes = 0;
|
|
session->copy_pending = false;
|
|
hd_texture_pack_reset_tracking(session->beetle);
|
|
duck_texture_pack_reset_tracking(session->duck);
|
|
}
|
|
extern "C" void gpu_hd_textures_begin_upload(int x, int y, int width, int height) {
|
|
/* The GP0 header arrives before native payload writes. Complete uploads
|
|
* establish their fresh provenance only in track_upload(), after writing. */
|
|
gpu_hd_textures_invalidate(x, y, width, height);
|
|
}
|
|
extern "C" void gpu_hd_textures_begin_copy(int sx, int sy, int dx, int dy, int width, int height) {
|
|
if (!session || !native_vram) return;
|
|
session->copy_pending = false;
|
|
if (width < 1 || width > 1024 || height < 1 || height > 512) { gpu_hd_textures_reset_tracking(); return; }
|
|
hd_texture_pack_invalidate(session->beetle, dx & 1023, dy & 511, width, height);
|
|
session->copy_pending = duck_texture_pack_begin_copy(session->duck, sx & 1023, sy & 511,
|
|
dx & 1023, dy & 511, width, height, native_vram, kVramWords) > 0;
|
|
if (!session->copy_pending)
|
|
duck_texture_pack_invalidate(session->duck, dx & 1023, dy & 511, width, height);
|
|
}
|
|
extern "C" void gpu_hd_textures_end_copy(void) {
|
|
if (!session || !session->copy_pending) return;
|
|
session->copy_pending = false;
|
|
if (duck_texture_pack_end_copy(session->duck, native_vram, kVramWords) < 0)
|
|
gpu_hd_textures_reset_tracking();
|
|
}
|
|
namespace {
|
|
constexpr uint32_t kResidencyMagic = 0x52444850u; /* "PHDR" */
|
|
constexpr uint32_t kResidencyVersion = 2u; /* 2: + the pack's identity */
|
|
constexpr size_t kResidencyHeader = 16u;
|
|
void put32(uint8_t* at, uint32_t v) { for (int i = 0; i < 4; ++i) at[i] = uint8_t(v >> (8 * i)); }
|
|
uint32_t get32(const uint8_t* at) { uint32_t v = 0; for (int i = 0; i < 4; ++i) v |= uint32_t(at[i]) << (8 * i); return v; }
|
|
}
|
|
extern "C" int gpu_hd_textures_residency_save(uint8_t** data, size_t* size) {
|
|
if (data) *data = nullptr;
|
|
if (size) *size = 0;
|
|
if (!data || !size || !session || !session->beetle || !native_vram) return 0;
|
|
uint8_t* tracking = nullptr; size_t tracking_size = 0;
|
|
if (!hd_texture_pack_tracking_state_save(session->beetle, &tracking, &tracking_size)) return 0;
|
|
uint8_t* out = static_cast<uint8_t*>(std::malloc(kResidencyHeader + tracking_size));
|
|
if (!out) { std::free(tracking); return 0; }
|
|
put32(out, kResidencyMagic); put32(out + 4, kResidencyVersion);
|
|
put32(out + 8, hd_texture_crc32_words_le(native_vram, kVramWords));
|
|
put32(out + 12, hd_texture_pack_identity(session->beetle));
|
|
if (tracking_size) std::memcpy(out + kResidencyHeader, tracking, tracking_size);
|
|
std::free(tracking);
|
|
*data = out; *size = kResidencyHeader + tracking_size;
|
|
return 1;
|
|
}
|
|
extern "C" int gpu_hd_textures_residency_load(const uint8_t* data, size_t size) {
|
|
if (!data || size < kResidencyHeader || !session || !session->beetle || !native_vram) return 0;
|
|
if (get32(data) != kResidencyMagic || get32(data + 4) != kResidencyVersion) return 0;
|
|
/* Saved with another pack: its residency names other uploads. */
|
|
if (get32(data + 12) != hd_texture_pack_identity(session->beetle)) return 0;
|
|
if (get32(data + 8) != hd_texture_crc32_words_le(native_vram, kVramWords)) return 0;
|
|
if (!hd_texture_pack_tracking_state_check(data + kResidencyHeader, size - kResidencyHeader)) return 0;
|
|
return hd_texture_pack_tracking_state_load(session->beetle, data + kResidencyHeader,
|
|
size - kResidencyHeader);
|
|
}
|
|
extern "C" void gpu_hd_textures_invalidate(int x, int y, int width, int height) {
|
|
if (!session || width < 1 || height < 1) return;
|
|
if (width > 1024 || height > 512) { gpu_hd_textures_reset_tracking(); return; }
|
|
hd_texture_pack_invalidate(session->beetle, x & 1023, y & 511, width, height);
|
|
duck_texture_pack_invalidate(session->duck, x & 1023, y & 511, width, height);
|
|
}
|
|
extern "C" void gpu_hd_textures_track_upload(int x, int y, int width, int height,
|
|
const uint16_t* words) {
|
|
(void)words;
|
|
if (!session || !native_vram || width < 1 || width > 1024 || height < 1 || height > 512) return;
|
|
if (width == 1024 && height == 512) { gpu_hd_textures_reset_tracking(); return; }
|
|
/* gpu.c's A0 staging already contains post-mask words. Read the canonical
|
|
* mirror here also for host-initiated transfers which use raw input. */
|
|
const size_t count = static_cast<size_t>(width) * height;
|
|
std::unique_ptr<uint16_t[]> applied(new (std::nothrow) uint16_t[count]);
|
|
if (!applied) { gpu_hd_textures_reset_tracking(); return; }
|
|
for (int row = 0; row < height; ++row)
|
|
for (int col = 0; col < width; ++col)
|
|
applied[static_cast<size_t>(row) * width + col] =
|
|
native_vram[((y + row) & 511) * 1024 + ((x + col) & 1023)];
|
|
uint32_t hash = 0;
|
|
hd_texture_pack_track_upload(session->beetle, x & 1023, y & 511, width, height,
|
|
applied.get(), count, &hash);
|
|
duck_texture_pack_track_upload(session->duck, x & 1023, y & 511, width, height,
|
|
native_vram, kVramWords);
|
|
if (session->beetle && hd_texture_pack_has_texture(session->beetle, hash)) {
|
|
const std::array<uint16_t, 4> rect{uint16_t(x & 1023), uint16_t(y & 511),
|
|
uint16_t(width), uint16_t(height)};
|
|
if (std::find(session->learned.begin(), session->learned.end(), rect) == session->learned.end()) {
|
|
/* Bounded by count and by area: a restage re-hashes at most one
|
|
* VRAM's worth of words (~1 MiB of CRC), however large or many
|
|
* the learned uploads (oldest dropped first). */
|
|
session->learned.push_back(rect);
|
|
size_t area = 0;
|
|
for (const auto& r : session->learned) area += size_t(r[2]) * r[3];
|
|
while (session->learned.size() > 1 &&
|
|
(session->learned.size() > 256 || area > kVramWords)) {
|
|
const auto& r = session->learned.front();
|
|
area -= size_t(r[2]) * r[3];
|
|
session->learned.erase(session->learned.begin());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
extern "C" void gpu_hd_textures_restage(void) {
|
|
gpu_hd_textures_reset_tracking();
|
|
if (!session || !session->beetle || !native_vram) return;
|
|
/* Only a rectangle whose restored words still hash to a replacement key
|
|
* becomes resident again: the same words at the same place as an upload
|
|
* this session saw, so no identity is invented. */
|
|
std::vector<uint16_t> words;
|
|
for (const auto& r : session->learned) {
|
|
const size_t count = size_t(r[2]) * r[3];
|
|
words.resize(count);
|
|
for (unsigned row = 0; row < r[3]; ++row)
|
|
for (unsigned col = 0; col < r[2]; ++col)
|
|
words[size_t(row) * r[2] + col] = native_vram[((r[1] + row) & 511) * 1024 + ((r[0] + col) & 1023)];
|
|
if (hd_texture_pack_has_texture(session->beetle, hd_texture_crc32_words_le(words.data(), count)))
|
|
hd_texture_pack_track_upload(session->beetle, r[0], r[1], r[2], r[3], words.data(), count, nullptr);
|
|
}
|
|
}
|
|
static int acquire_draw(uint16_t tp, uint16_t cx, uint16_t cy,
|
|
const int limits[4], uint32_t window,
|
|
int semi, GpuHdTextureImage* image, bool allow_gl_cache) {
|
|
if (!image) return 0;
|
|
*image = {};
|
|
if (!session) return 0;
|
|
++session->diag.draw_queries;
|
|
HdTextureDrawQuery query{};
|
|
if (!make_query(tp, cx, cy, limits, window, query)) return 0;
|
|
dump_query(query, semi);
|
|
if (!session->replacements) return 0;
|
|
auto lease = std::unique_ptr<Lease>(new (std::nothrow) Lease);
|
|
if (!lease) return 0;
|
|
if (session->beetle) {
|
|
HdTextureMatch match{};
|
|
if (hd_texture_pack_match(session->beetle, &query, &match) != HD_TEXTURE_LOOKUP_FOUND) return 0;
|
|
++session->diag.matched_draws;
|
|
hd_texture_pack_request_decode(session->beetle, match.entry.texture_hash, match.entry.palette_hash);
|
|
if (hd_texture_pack_acquire_decoded(session->beetle, match.entry.texture_hash,
|
|
match.entry.palette_hash, &lease->beetle) != HD_TEXTURE_LOOKUP_FOUND) return 0;
|
|
const unsigned pixels_per_word = 4u >> query.depth;
|
|
image->rgba = lease->beetle.rgba; image->width = lease->beetle.width;
|
|
image->height = lease->beetle.height; image->stride = lease->beetle.stride;
|
|
image->source_width = match.upload_width_words * pixels_per_word;
|
|
image->source_height = match.upload_height;
|
|
image->origin_u = query.u_first - (match.source_word_x * pixels_per_word + (query.u_first % pixels_per_word));
|
|
image->origin_v = query.v_first - match.source_y;
|
|
image->cache_key = (static_cast<uint64_t>(match.entry.texture_hash) << 32) | match.entry.palette_hash;
|
|
image->alpha_mode = 1;
|
|
} else {
|
|
try {
|
|
std::array<DuckTextureMatch,kMaxParts> matches{}; size_t count = 0;
|
|
if (duck_texture_pack_match_parts(session->duck, &query, semi, matches.data(), matches.size(), &count) != HD_TEXTURE_LOOKUP_FOUND || !count) return 0;
|
|
++session->diag.matched_draws;
|
|
const auto& match = matches[0];
|
|
if (count == 1 && match.clip_u <= query.u_first && match.clip_v <= query.v_first &&
|
|
match.clip_u + match.clip_width > query.u_last && match.clip_v + match.clip_height > query.v_last) {
|
|
/* The GPU copy outlives the decoder's smaller CPU LRU. A draw
|
|
* using that copy must not queue another PNG decode. */
|
|
if (allow_gl_cache && gl_renderer_hd_texture_cached(match.entry_id, generation,
|
|
&image->width, &image->height)) {
|
|
image->stride = image->width * 4u;
|
|
} else {
|
|
duck_texture_pack_request_decode(session->duck, match.entry_id);
|
|
if (duck_texture_pack_acquire_decoded(session->duck, match.entry_id, &lease->duck) != HD_TEXTURE_LOOKUP_FOUND) return 0;
|
|
image->rgba = lease->duck.rgba; image->width = lease->duck.width;
|
|
image->height = lease->duck.height; image->stride = lease->duck.stride;
|
|
}
|
|
image->source_width = match.source_width; image->source_height = match.source_height;
|
|
image->origin_u = match.origin_u; image->origin_v = match.origin_v;
|
|
image->cache_key = match.entry_id;
|
|
image->alpha_mode = match.key.semitransparent ? 3 : 2;
|
|
} else {
|
|
std::array<uint16_t,256> palette{};
|
|
auto signature = composition_signature(query, matches, count, palette);
|
|
const uint64_t full_mask = count == 64 ? UINT64_MAX : (UINT64_C(1) << count) - 1;
|
|
/* An immutable, complete composition already owns all source
|
|
* pixels. Reuse it even after those decoded PNGs are evicted.
|
|
* Partial compositions still check for newly ready parts. */
|
|
lease->composition = find_composition(signature, full_mask);
|
|
if (!lease->composition) {
|
|
DecodedParts decoded; size_t ready = 0;
|
|
for (size_t i = 0; i < count; ++i) {
|
|
duck_texture_pack_request_decode(session->duck, matches[i].entry_id);
|
|
if (duck_texture_pack_acquire_decoded(session->duck, matches[i].entry_id, &decoded.pixels[i]) == HD_TEXTURE_LOOKUP_FOUND) ++ready;
|
|
}
|
|
if (!ready) return 0;
|
|
lease->composition = compose(query, matches, decoded, count, std::move(signature), palette);
|
|
}
|
|
if (!lease->composition) return 0;
|
|
const auto& composed = *lease->composition;
|
|
image->rgba = composed.rgba.data(); image->width = composed.width;
|
|
image->height = composed.height; image->stride = composed.width * 4u;
|
|
image->source_width = query.u_last - query.u_first + 1;
|
|
image->source_height = query.v_last - query.v_first + 1;
|
|
image->origin_u = query.u_first; image->origin_v = query.v_first;
|
|
image->cache_key = composed.cache_key; image->alpha_mode = 4;
|
|
}
|
|
} catch (const std::exception&) { return 0; }
|
|
}
|
|
image->generation = generation; image->lease = lease.release();
|
|
++session->diag.ready_draws;
|
|
return 1;
|
|
}
|
|
extern "C" int gpu_hd_textures_acquire_draw(uint16_t tp, uint16_t cx, uint16_t cy,
|
|
const int limits[4], uint32_t window, int semi, GpuHdTextureImage* image) {
|
|
return acquire_draw(tp, cx, cy, limits, window, semi, image, false);
|
|
}
|
|
extern "C" int gpu_hd_textures_acquire_gl_draw(uint16_t tp, uint16_t cx, uint16_t cy,
|
|
const int limits[4], uint32_t window, int semi, GpuHdTextureImage* image) {
|
|
return acquire_draw(tp, cx, cy, limits, window, semi, image, true);
|
|
}
|
|
extern "C" void gpu_hd_textures_release_image(GpuHdTextureImage* image) {
|
|
if (!image) return;
|
|
delete static_cast<Lease*>(image->lease); *image = {};
|
|
}
|
|
extern "C" void gpu_hd_textures_observe_draw(uint16_t tp, uint16_t cx, uint16_t cy,
|
|
const int limits[4], uint32_t window, int semi) {
|
|
if (!session || !session->dump || session->dump_failed) return;
|
|
HdTextureDrawQuery query{};
|
|
if (make_query(tp, cx, cy, limits, window, query)) {
|
|
++session->diag.draw_queries; dump_query(query, semi);
|
|
}
|
|
}
|