api: add CORS policy (#878)

## Link to GitHub Issue or related Pull Request, if one exists
n/a

## Description of change
Adds `Access-Control-Allow-Origin: *` to the video stream server's
responses.

## Testing
Tested with substream project.

.gitattributes

@@ -0,0 +1,46 @@
+# Normalize every text file to LF in the repository.
+# The build runs under Linux/MinGW containers, so LF is also used in the
+# working tree; Windows editors and toolchains handle LF fine.
+* text=auto eol=lf
+
+# Windows-only files that must keep CRLF in the working tree.
+*.bat        text eol=crlf
+*.cmd        text eol=crlf
+*.sln        text eol=crlf
+*.vcproj     text eol=crlf
+*.vcxproj    text eol=crlf
+*.props      text eol=crlf
+*.filters    text eol=crlf
+
+# Files that must keep LF even if a Windows editor rewrites them.
+*.sh         text eol=lf
+*.in         text eol=lf
+*.cmake      text eol=lf
+*.mk         text eol=lf
+Makefile     text eol=lf
+Dockerfile   text eol=lf
+
+# Binary files - never touch the contents.
+*.bin        binary
+*.ico        binary
+*.ttf        binary
+*.otf        binary
+*.png        binary
+*.jpg        binary
+*.jpeg       binary
+*.gif        binary
+*.bmp        binary
+*.zip        binary
+*.7z         binary
+*.gz         binary
+*.dll        binary
+*.exe        binary
+*.lib        binary
+*.a          binary
+*.o          binary
+*.obj        binary
+*.pdb        binary
+
+# Vendored code is stored and checked out byte-for-byte as upstream ships it,
+# so re-importing a library never produces line-ending-only diffs.
+src/spice2x/external/** -text

src/spice2x/CMakeLists.txt

@@ -256,6 +256,57 @@ add_subdirectory(external/imgui EXCLUDE_FROM_ALL)
 add_subdirectory(external/minhook EXCLUDE_FROM_ALL)
 add_subdirectory(external/cpu_features EXCLUDE_FROM_ALL)
 
+# libjpeg-turbo, prebuilt into the deps image. The WinXP toolchains have their own
+# sysroot and cannot see it, so those targets build without JPEG support.
+add_library(spice_jpeg INTERFACE)
+if(NOT SPICE_XP)
+    # search static archives only: the mingw package also ships an import library,
+    # and linking that one would pull in a libjpeg DLL at runtime
+    set(SPICE_JPEG_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX})
+    find_package(JPEG)
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${SPICE_JPEG_SUFFIXES})
+
+    if(JPEG_FOUND)
+        target_link_libraries(spice_jpeg INTERFACE JPEG::JPEG)
+        target_compile_definitions(spice_jpeg INTERFACE SPICE_JPEG=1)
+    else()
+        message(WARNING
+                "libjpeg-turbo not found: screen capture over the API is disabled")
+    endif()
+endif()
+
+# x264 for the API H.264 video stream, installed into the mingw sysroots by the
+# deps image. The WinXP toolchains deliberately go without it and serve MJPEG only.
+add_library(spice_x264 INTERFACE)
+if(NOT SPICE_XP)
+    # search static archives only: the mingw package also ships an import library,
+    # and linking that one would pull in a libx264 DLL at runtime
+    set(SPICE_X264_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX})
+    find_library(X264_LIBRARY NAMES x264 libx264)
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${SPICE_X264_SUFFIXES})
+
+    find_path(X264_INCLUDE_DIR NAMES x264.h)
+    if(X264_LIBRARY AND X264_INCLUDE_DIR)
+        target_include_directories(spice_x264 INTERFACE "${X264_INCLUDE_DIR}")
+        target_link_libraries(spice_x264 INTERFACE "${X264_LIBRARY}")
+        target_compile_definitions(spice_x264 INTERFACE SPICE_H264=1)
+    else()
+        message(WARNING
+                "x264 not found: the api video stream will only offer MJPEG")
+    endif()
+endif()
+
+# fpng's SIMD needs the whole unit built for SSE4.1, which its runtime CPU check
+# cannot undo, so keep it scalar rather than raising the CPU baseline
+set_source_files_properties(external/fpng/fpng.cpp PROPERTIES
+        COMPILE_DEFINITIONS "FPNG_NO_SSE=1")
+if(NOT MSVC)
+    set_source_files_properties(external/fpng/fpng.cpp PROPERTIES
+            COMPILE_OPTIONS "-fno-strict-aliasing")
+endif()
+
 # set link time optimizations (disabled for Debug builds for speed, disabled
 # for RelWithDebInfo builds due to "lto1: error: two or more sections for"
 # errors)
@@ -317,6 +368,10 @@ set(SOURCE_FILES ${SOURCE_FILES}
         # api
         api/controller.cpp
         api/websocket.cpp
+        api/capture_pump.cpp
+        api/h264_stream.cpp
+        api/stream_format.cpp
+        api/stream_server.cpp
         api/request.cpp
         api/response.cpp
         api/module.cpp
@@ -380,7 +435,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
         external/tinyxml2/tinyxml2.cpp
         external/http-parser/http_parser.c
         external/usbhidusage/usb-hid-usage.c
-        external/toojpeg/toojpeg.cpp
+        external/fpng/fpng.cpp
         external/scard/scard.cpp
 
         # games
@@ -532,10 +587,12 @@ set(SOURCE_FILES ${SOURCE_FILES}
         hooks/devicehook.cpp
         hooks/graphics/graphics.cpp
         hooks/graphics/graphics_windowed.cpp
+        hooks/graphics/jpeg_encoder.cpp
         hooks/graphics/nvapi_impl.cpp
         hooks/graphics/nvapi_hook.cpp
         hooks/graphics/nvenc_hook.cpp
         hooks/graphics/backends/d3d9/d3d9_backend.cpp
+        hooks/graphics/backends/d3d9/d3d9_readback.cpp
         hooks/graphics/backends/d3d9/d3d9_screenshot.cpp
         hooks/graphics/backends/d3d9/d3d9_device.cpp
         hooks/graphics/backends/d3d9/d3d9_gfdm.cpp
@@ -740,7 +797,7 @@ endfunction()
 add_library(spicetools_spice_objs OBJECT ${SOURCE_FILES})
 target_link_libraries(spicetools_spice_objs
         PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp
-        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features)
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
 target_link_libraries(spicetools_spice_objs PUBLIC winscard)
 
 if(NOT MSVC)
@@ -780,7 +837,7 @@ set(RESOURCE_FILES build/manifest.manifest build/manifest.rc build/icon.rc cfg/W
 add_executable(spicetools_spice_linux ${SOURCE_FILES} ${RESOURCE_FILES})
 target_link_libraries(spicetools_spice_linux
         PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp
-        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features)
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
 set_target_properties(spicetools_spice_linux PROPERTIES PREFIX "")
 set_target_properties(spicetools_spice_linux PROPERTIES OUTPUT_NAME "spice_linux")
 target_compile_definitions(spicetools_spice_linux PRIVATE NO_SCARD=1 PRIVATE SPICE_LINUX=1)
@@ -798,7 +855,7 @@ add_executable(spicetools_spice64 ${SOURCE_FILES} ${RESOURCE_FILES})
 # do NOT link against: mf, mfplat, mfreadwrite; otherwise unity games will break
 target_link_libraries(spicetools_spice64
         PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp mfuuid strmiids dxva2
-        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features)
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
 target_link_libraries(spicetools_spice64 PUBLIC winscard)
 set_target_properties(spicetools_spice64 PROPERTIES PREFIX "")
 set_target_properties(spicetools_spice64 PROPERTIES OUTPUT_NAME "spice64")
@@ -821,7 +878,7 @@ add_executable(spicetools_spice64_linux ${SOURCE_FILES} ${RESOURCE_FILES})
 # do NOT link against: mf, mfplat, mfreadwrite; otherwise unity games will break
 target_link_libraries(spicetools_spice64_linux
         PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp mfuuid strmiids dxva2
-        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features)
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
 set_target_properties(spicetools_spice64_linux PROPERTIES PREFIX "")
 set_target_properties(spicetools_spice64_linux PROPERTIES OUTPUT_NAME "spice64_linux")
 target_compile_definitions(spicetools_spice64_linux PRIVATE SPICE64=1)
@@ -840,6 +897,7 @@ endif()
 set(SOURCE_FILES ${SOURCE_FILES} launcher/options.h launcher/options.cpp)
 set(RESOURCE_FILES cfg/manifest.manifest cfg/manifest.rc cfg/icon.rc cfg/Win32D.rc)
 add_executable(spicetools_cfg WIN32 ${SOURCE_FILES} ${RESOURCE_FILES})
+# the configurator serves neither the API nor the video stream, so it needs no codecs
 target_link_libraries(spicetools_cfg
         PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp strmiids
         PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features)

src/spice2x/README.md

@@ -291,6 +291,42 @@ which also means that your hex edits are applicable directly.
 - image_resize_set_scene(scene: int)
   - sets the active scene for image resize state; set to 0 to disable resize
 
+## Video Stream
+
+Separate from the JSON API, spice can serve the mirrored screen as a video
+stream over plain HTTP. Enable it with `-apistream`. It listens on the API port
+plus two, in the same way the WebSocket server uses the API port plus one, so
+`-api 1337` puts the stream on 1339. This means `-api` has to be enabled too.
+
+Two formats are served:
+
+    http://host:1339/stream.mjpg    JPEG frames, multipart/x-mixed-replace
+    http://host:1339/stream.h264    H.264 annex-b, no container
+
+All accept the same optional query parameters:
+
+- `screen` - which screen to mirror, 0-3. Defaults to the subscreen when the
+  game has one, otherwise the main screen.
+- `fps` - frames per second, 1-60. Default 30.
+- `q` - quality, 1-100. Default 70. This is the JPEG quality for `stream.mjpg`
+  and is mapped onto the H.264 rate factor for `stream.h264`, so the same number
+  does not mean the same thing for both.
+
+For example:
+
+    http://host:1339/stream.h264?screen=1&fps=30&q=70
+
+See the wiki for format tradeoffs, latency tuning, testing commands and client
+notes.
+
+The stream is view only. Touch and other input still go through the JSON API,
+so a companion app needs both. There is no authentication on the stream port -
+anyone who can reach it can watch the screen.
+
+WinXP builds have no video stream. Neither encoder is compiled in, so every
+endpoint returns 404, and the JSON API's JPEG screen capture is unavailable for
+the same reason.
+
 ## Native wrapper libraries
 Spicetools provides wrapper libraries in: Arduino, C++, Dart, and Python.
 Python is the only one that is fully spec compliant.

src/spice2x/api/capture_pump.cpp

@@ -0,0 +1,58 @@
+#include "capture_pump.h"
+
+#include <array>
+#include <mutex>
+
+#include "hooks/graphics/graphics.h"
+
+namespace api::capture_pump {
+
+    namespace {
+
+        std::array<std::mutex, GRAPHICS_CAPTURE_SCREEN_NO> CONSUMER_M;
+
+        std::mutex CLAIMED_M;
+        std::array<bool, GRAPHICS_CAPTURE_SCREEN_NO> CLAIMED {};
+
+        bool valid_screen(int screen) {
+            return 0 <= screen && screen < static_cast<int>(GRAPHICS_CAPTURE_SCREEN_NO);
+        }
+    }
+
+    bool capture_direct(int screen, std::shared_ptr<uint8_t[]> &out, int divide,
+            uint64_t *timestamp, int *width, int *height) {
+
+        if (!valid_screen(screen)) {
+            return false;
+        }
+
+        std::lock_guard<std::mutex> lock(CONSUMER_M[screen]);
+        graphics_capture_trigger(screen);
+        return graphics_capture_receive_raw(
+                screen, out, divide, timestamp, width, height);
+    }
+
+    bool claim_screen(int screen) {
+        if (!valid_screen(screen)) {
+            return false;
+        }
+
+        std::lock_guard<std::mutex> lock(CLAIMED_M);
+
+        if (CLAIMED[screen]) {
+            return false;
+        }
+
+        CLAIMED[screen] = true;
+        return true;
+    }
+
+    void release_screen(int screen) {
+        if (!valid_screen(screen)) {
+            return;
+        }
+
+        std::lock_guard<std::mutex> lock(CLAIMED_M);
+        CLAIMED[screen] = false;
+    }
+}

src/spice2x/api/capture_pump.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+namespace api::capture_pump {
+
+    struct Frame {
+        // packed 24bpp RGB, width * height * 3 bytes
+        std::shared_ptr<uint8_t[]> pixels;
+        uint64_t timestamp = 0;
+        int width = 0;
+        int height = 0;
+    };
+
+    // the graphics layer has one capture slot per screen, so concurrent waiters would steal
+    // each other's frames; everything that captures goes through here to keep it serialized
+    bool capture_direct(int screen, std::shared_ptr<uint8_t[]> &out, int divide,
+            uint64_t *timestamp = nullptr, int *width = nullptr, int *height = nullptr);
+
+    // a screen carries one stream at a time; false when another connection already holds it
+    bool claim_screen(int screen);
+    void release_screen(int screen);
+}

src/spice2x/api/h264_stream.cpp

@@ -0,0 +1,224 @@
+#include "h264_stream.h"
+
+#ifdef SPICE_H264
+
+#include <vector>
+
+#include <x264.h>
+
+#include "util/logging.h"
+
+namespace api {
+
+    namespace {
+
+        // BT.601 limited range, the range every decoder assumes for H.264 without
+        // explicit colour metadata
+        inline uint8_t rgb_to_y(int r, int g, int b) {
+            return static_cast<uint8_t>(((66 * r + 129 * g + 25 * b + 128) >> 8) + 16);
+        }
+
+        inline uint8_t rgb_to_u(int r, int g, int b) {
+            return static_cast<uint8_t>(((-38 * r - 74 * g + 112 * b + 128) >> 8) + 128);
+        }
+
+        inline uint8_t rgb_to_v(int r, int g, int b) {
+            return static_cast<uint8_t>(((112 * r - 94 * g - 18 * b + 128) >> 8) + 128);
+        }
+
+        // a bare annex-b elementary stream, one encoder per connection so every client
+        // starts on its own keyframe. no container, so nothing here keeps a media clock
+        class H264Writer : public StreamWriter {
+        public:
+
+            H264Writer(int quality, int fps) : quality(quality), fps(fps) {}
+
+            ~H264Writer() override {
+                this->close();
+            }
+
+            std::string content_type() const override {
+                return "video/h264";
+            }
+
+            bool write(const StreamSend &send, const capture_pump::Frame &frame) override {
+
+                // I420 needs even dimensions
+                const int width = frame.width & ~1;
+                const int height = frame.height & ~1;
+                if (width <= 0 || height <= 0) {
+                    return true;
+                }
+
+                if (this->encoder == nullptr) {
+                    if (!this->open(width, height)) {
+                        return false;
+                    }
+                } else if (width != this->width || height != this->height) {
+                    // the encoder is fixed at the size it opened with; let the client reconnect
+                    log_info("api::stream", "capture size changed, ending H.264 client");
+                    return false;
+                }
+
+                this->convert(frame.pixels.get(), frame.width);
+
+                this->picture.i_pts = this->frame_index;
+
+                x264_nal_t *nals = nullptr;
+                int nal_count = 0;
+                x264_picture_t picture_out;
+                const int size = x264_encoder_encode(
+                        this->encoder, &nals, &nal_count, &this->picture, &picture_out);
+
+                if (size < 0) {
+                    log_warning("api::stream", "H.264 encode failed");
+                    return false;
+                }
+
+                this->frame_index++;
+
+                if (size == 0) {
+                    return true;
+                }
+
+                // x264 lays every NAL of the frame out back to back. an SEI or delimiter
+                // carries no picture, so only the parameter sets and the slice go through
+                this->annexb.clear();
+                for (int i = 0; i < nal_count; i++) {
+                    switch (nals[i].i_type) {
+                        case NAL_SEI:
+                        case NAL_AUD:
+                        case NAL_FILLER:
+                            continue;
+                        default:
+                            break;
+                    }
+                    this->annexb.insert(this->annexb.end(),
+                            nals[i].p_payload, nals[i].p_payload + nals[i].i_payload);
+                }
+
+                if (this->annexb.empty()) {
+                    return true;
+                }
+
+                return send(this->annexb.data(), this->annexb.size());
+            }
+
+        private:
+
+            bool open(int width, int height) {
+
+                x264_param_t param;
+                if (x264_param_default_preset(&param, "ultrafast", "zerolatency") < 0) {
+                    return false;
+                }
+
+                param.i_csp = X264_CSP_I420;
+                param.i_width = width;
+                param.i_height = height;
+                param.i_fps_num = this->fps;
+                param.i_fps_den = 1;
+                param.i_threads = 1;
+                param.b_annexb = 1;
+                // SPS/PPS ahead of every IDR, so a client can start decoding cold
+                param.b_repeat_headers = 1;
+                // a keyframe every two seconds bounds how long a new client waits
+                param.i_keyint_max = this->fps * 2;
+                param.i_log_level = X264_LOG_NONE;
+                param.rc.i_rc_method = X264_RC_CRF;
+                param.rc.f_rf_constant = 40.0f - (this->quality * 0.25f);
+
+                // baseline keeps hardware decode available on the widest range of phones
+                if (x264_param_apply_profile(&param, "baseline") < 0) {
+                    return false;
+                }
+
+                this->encoder = x264_encoder_open(&param);
+                if (this->encoder == nullptr) {
+                    log_warning("api::stream", "could not open the H.264 encoder");
+                    return false;
+                }
+
+                if (x264_picture_alloc(&this->picture, X264_CSP_I420, width, height) < 0) {
+                    this->close();
+                    return false;
+                }
+                this->picture_ready = true;
+
+                this->width = width;
+                this->height = height;
+                return true;
+            }
+
+            void close() {
+                if (this->picture_ready) {
+                    x264_picture_clean(&this->picture);
+                    this->picture_ready = false;
+                }
+                if (this->encoder != nullptr) {
+                    x264_encoder_close(this->encoder);
+                    this->encoder = nullptr;
+                }
+            }
+
+            // packed 24bpp RGB to I420, averaging each 2x2 block for the chroma planes
+            void convert(const uint8_t *rgb, int source_width) {
+
+                uint8_t *plane_y = this->picture.img.plane[0];
+                uint8_t *plane_u = this->picture.img.plane[1];
+                uint8_t *plane_v = this->picture.img.plane[2];
+                const int stride_y = this->picture.img.i_stride[0];
+                const int stride_u = this->picture.img.i_stride[1];
+                const int stride_v = this->picture.img.i_stride[2];
+
+                for (int y = 0; y < this->height; y++) {
+                    const uint8_t *row = rgb + static_cast<size_t>(y) * source_width * 3;
+                    uint8_t *out_y = plane_y + static_cast<size_t>(y) * stride_y;
+
+                    for (int x = 0; x < this->width; x++) {
+                        const uint8_t *pixel = row + x * 3;
+                        out_y[x] = rgb_to_y(pixel[0], pixel[1], pixel[2]);
+                    }
+                }
+
+                for (int y = 0; y < this->height / 2; y++) {
+                    const uint8_t *row0 = rgb + static_cast<size_t>(y * 2) * source_width * 3;
+                    const uint8_t *row1 = row0 + static_cast<size_t>(source_width) * 3;
+                    uint8_t *out_u = plane_u + static_cast<size_t>(y) * stride_u;
+                    uint8_t *out_v = plane_v + static_cast<size_t>(y) * stride_v;
+
+                    for (int x = 0; x < this->width / 2; x++) {
+                        const uint8_t *p00 = row0 + (x * 2) * 3;
+                        const uint8_t *p01 = p00 + 3;
+                        const uint8_t *p10 = row1 + (x * 2) * 3;
+                        const uint8_t *p11 = p10 + 3;
+
+                        const int r = (p00[0] + p01[0] + p10[0] + p11[0] + 2) / 4;
+                        const int g = (p00[1] + p01[1] + p10[1] + p11[1] + 2) / 4;
+                        const int b = (p00[2] + p01[2] + p10[2] + p11[2] + 2) / 4;
+
+                        out_u[x] = rgb_to_u(r, g, b);
+                        out_v[x] = rgb_to_v(r, g, b);
+                    }
+                }
+            }
+
+            int quality;
+            int fps;
+            int width = 0;
+            int height = 0;
+            int64_t frame_index = 0;
+            std::vector<uint8_t> annexb;
+
+            x264_t *encoder = nullptr;
+            x264_picture_t picture {};
+            bool picture_ready = false;
+        };
+    }
+
+    std::unique_ptr<StreamWriter> make_h264_writer(int quality, int fps) {
+        return std::make_unique<H264Writer>(quality, fps);
+    }
+}
+
+#endif // SPICE_H264

src/spice2x/api/h264_stream.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <memory>
+
+#include "stream_format.h"
+
+namespace api {
+
+    // bare annex-b H.264; null when the build has no encoder
+    std::unique_ptr<StreamWriter> make_h264_writer(int quality, int fps);
+}

src/spice2x/api/modules/capture.cpp

@@ -2,8 +2,10 @@
 #include <functional>
 #include <mutex>
 #include <unordered_map>
+#include "api/capture_pump.h"
 #include "external/rapidjson/document.h"
 #include "hooks/graphics/graphics.h"
+#include "hooks/graphics/jpeg_encoder.h"
 #include "util/crypt.h"
 
 using namespace std::placeholders;
@@ -93,8 +95,6 @@ namespace api::modules {
      * reduce: uint for dividing image size
      */
     void Capture::get_jpg(Request &req, Response &res) {
-        CAPTURE_BUFFER.clear();
-        CAPTURE_BUFFER.reserve(1024 * 128);
 
         // settings
         int screen = 0;
@@ -120,10 +120,16 @@ namespace api::modules {
         uint64_t timestamp = 0;
         int width = 0;
         int height = 0;
-        graphics_capture_trigger(screen);
-        bool success = graphics_capture_receive_jpeg(screen, [] (uint8_t byte) {
-            CAPTURE_BUFFER.push_back(byte);
-        }, true, quality, true, divide, &timestamp, &width, &height);
+
+        std::shared_ptr<uint8_t[]> pixels;
+        bool success = capture_pump::capture_direct(
+                screen, pixels, divide, &timestamp, &width, &height);
+
+        if (success) {
+            CAPTURE_BUFFER.clear();
+            success = jpeg_encoder::encode(
+                    CAPTURE_BUFFER, pixels.get(), width, height, quality);
+        }
 
         if (success) {
             add_jpeg_response(screen, timestamp, width, height, CAPTURE_BUFFER, res);

src/spice2x/api/stream_format.cpp

@@ -0,0 +1,70 @@
+#include "stream_format.h"
+
+#include <vector>
+
+#include "h264_stream.h"
+#include "hooks/graphics/jpeg_encoder.h"
+
+namespace api {
+
+    namespace {
+
+#ifdef SPICE_JPEG
+        constexpr const char *MJPEG_BOUNDARY = "spice2xframe";
+
+        // multipart/x-mixed-replace: every frame is a standalone JPEG, no inter-frame state
+        class MjpegWriter : public StreamWriter {
+        public:
+
+            explicit MjpegWriter(int quality) : quality(quality) {}
+
+            std::string content_type() const override {
+                return std::string("multipart/x-mixed-replace; boundary=") + MJPEG_BOUNDARY;
+            }
+
+            bool write(const StreamSend &send, const capture_pump::Frame &frame) override {
+                this->jpeg.clear();
+                if (!jpeg_encoder::encode(
+                        this->jpeg, frame.pixels.get(),
+                        frame.width, frame.height, this->quality)) {
+                    // a frame the encoder rejects is not worth dropping the client over
+                    return true;
+                }
+
+                const std::string part =
+                        "--" + std::string(MJPEG_BOUNDARY) + "\r\n"
+                        "Content-Type: image/jpeg\r\n"
+                        "Content-Length: " + std::to_string(this->jpeg.size()) + "\r\n"
+                        "\r\n";
+
+                return send(part.data(), part.size())
+                        && send(this->jpeg.data(), this->jpeg.size())
+                        && send("\r\n", 2);
+            }
+
+        private:
+            int quality;
+            std::vector<uint8_t> jpeg;
+        };
+#endif
+    }
+
+    // both parameters go unused on toolchains that compile in neither format
+    std::unique_ptr<StreamWriter> make_stream_writer(
+            const std::string &path, [[maybe_unused]] int quality, [[maybe_unused]] int fps) {
+
+#ifdef SPICE_JPEG
+        if (path == "/stream.mjpg") {
+            return std::make_unique<MjpegWriter>(quality);
+        }
+#endif
+
+#ifdef SPICE_H264
+        if (path == "/stream.h264") {
+            return make_h264_writer(quality, fps);
+        }
+#endif
+
+        return nullptr;
+    }
+}

src/spice2x/api/stream_format.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <string>
+
+#include "capture_pump.h"
+
+namespace api {
+
+    // writes bytes to the client; false once the connection is gone
+    using StreamSend = std::function<bool(const void *, size_t)>;
+
+    // one wire format, instantiated per connection so it can keep encoder state across frames
+    class StreamWriter {
+    public:
+        virtual ~StreamWriter() = default;
+
+        StreamWriter(const StreamWriter &) = delete;
+        StreamWriter &operator=(const StreamWriter &) = delete;
+
+        // value for the HTTP Content-Type response header
+        virtual std::string content_type() const = 0;
+
+        // for formats that open with an init segment; runs once before any frame
+        virtual bool begin(const StreamSend &send) { return true; }
+
+        virtual bool write(const StreamSend &send, const capture_pump::Frame &frame) = 0;
+
+    protected:
+        StreamWriter() = default;
+    };
+
+    // null when the path does not name a format this build supports
+    std::unique_ptr<StreamWriter> make_stream_writer(
+            const std::string &path, int quality, int fps);
+}

src/spice2x/api/stream_server.cpp

@@ -0,0 +1,476 @@
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+#include "stream_server.h"
+
+#include <algorithm>
+#include <cctype>
+#include <chrono>
+#include <limits>
+#include <map>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "capture_pump.h"
+#include "hooks/graphics/graphics.h"
+#include "stream_format.h"
+#include "util/logging.h"
+#include "util/utils.h"
+
+namespace api {
+
+    namespace {
+
+        struct HttpRequest {
+            std::string method;
+            std::string path;
+            std::map<std::string, std::string> query;
+        };
+
+        bool send_all(SOCKET socket, const void *data, size_t size) {
+            auto cursor = reinterpret_cast<const char *>(data);
+            size_t remaining = size;
+
+            while (remaining > 0) {
+                const int sent = send(socket, cursor, static_cast<int>(remaining), 0);
+                if (sent <= 0) {
+                    return false;
+                }
+                cursor += sent;
+                remaining -= static_cast<size_t>(sent);
+            }
+
+            return true;
+        }
+
+        bool send_all(SOCKET socket, const std::string &text) {
+            return send_all(socket, text.data(), text.size());
+        }
+
+        // a viewer leaving is normally noticed by a failing send, so a stream with no frame
+        // to push has to ask the socket instead
+        bool client_gone(SOCKET socket) {
+            fd_set read_set;
+            FD_ZERO(&read_set);
+            FD_SET(socket, &read_set);
+
+            // the socket is blocking with a receive timeout, so poll before touching it
+            timeval immediately {};
+            const int ready = select(0, &read_set, nullptr, nullptr, &immediately);
+            if (ready == 0) {
+                return false;
+            }
+            if (ready < 0) {
+                return true;
+            }
+
+            // consumed rather than peeked: a stray byte would otherwise sit in front of the
+            // FIN and keep hiding it for as long as the stream runs
+            char discard[256];
+            return recv(socket, discard, sizeof(discard), 0) <= 0;
+        }
+
+        std::string url_decode(const std::string &input) {
+            std::string out;
+            out.reserve(input.size());
+
+            for (size_t i = 0; i < input.size(); i++) {
+                if (input[i] == '+') {
+                    out.push_back(' ');
+                } else if (input[i] == '%' && i + 2 < input.size()
+                        && isxdigit(static_cast<unsigned char>(input[i + 1]))
+                        && isxdigit(static_cast<unsigned char>(input[i + 2]))) {
+                    out.push_back(static_cast<char>(
+                            std::stoi(input.substr(i + 1, 2), nullptr, 16)));
+                    i += 2;
+                } else {
+                    out.push_back(input[i]);
+                }
+            }
+
+            return out;
+        }
+
+        void parse_query(const std::string &query, HttpRequest &request) {
+            size_t pos = 0;
+
+            while (pos < query.size()) {
+                auto end = query.find('&', pos);
+                if (end == std::string::npos) {
+                    end = query.size();
+                }
+
+                const auto pair = query.substr(pos, end - pos);
+                const auto split = pair.find('=');
+                if (split != std::string::npos && split > 0) {
+                    request.query[url_decode(pair.substr(0, split))] =
+                            url_decode(pair.substr(split + 1));
+                }
+
+                pos = end + 1;
+            }
+        }
+
+        // reads the request head only; anything oversized or malformed is refused
+        bool read_request(SOCKET socket, size_t size_limit, HttpRequest &request) {
+            std::string head;
+            char buffer[1024];
+
+            while (head.find("\r\n\r\n") == std::string::npos) {
+                if (head.size() >= size_limit) {
+                    return false;
+                }
+
+                // read no further than the limit, so the head cannot overshoot it
+                const size_t budget = std::min(sizeof(buffer), size_limit - head.size());
+                const int received = recv(socket, buffer, static_cast<int>(budget), 0);
+                if (received <= 0) {
+                    return false;
+                }
+
+                head.append(buffer, static_cast<size_t>(received));
+            }
+
+            const auto line_end = head.find("\r\n");
+            const auto line = head.substr(0, line_end);
+
+            const auto method_end = line.find(' ');
+            if (method_end == std::string::npos) {
+                return false;
+            }
+
+            const auto target_end = line.find(' ', method_end + 1);
+            if (target_end == std::string::npos) {
+                return false;
+            }
+
+            request.method = line.substr(0, method_end);
+            auto target = line.substr(method_end + 1, target_end - method_end - 1);
+
+            const auto query_start = target.find('?');
+            if (query_start != std::string::npos) {
+                parse_query(target.substr(query_start + 1), request);
+                target = target.substr(0, query_start);
+            }
+
+            request.path = url_decode(target);
+            return true;
+        }
+
+        int query_int(const HttpRequest &request, const std::string &name, int fallback,
+                int min, int max) {
+
+            const auto pos = request.query.find(name);
+            if (pos == request.query.end()) {
+                return fallback;
+            }
+
+            try {
+                return std::clamp(std::stoi(pos->second), min, max);
+            } catch (const std::exception &) {
+                return fallback;
+            }
+        }
+
+        // an <img> can show a cross-origin stream without this, but a browser client that
+        // decodes the bytes itself has to fetch() them, and fetch is subject to CORS. errors
+        // carry it too, or the client sees an opaque failure instead of the status.
+        constexpr const char *cors_header = "Access-Control-Allow-Origin: *\r\n";
+
+        void send_error(SOCKET socket, const char *status) {
+            const std::string response =
+                    std::string("HTTP/1.0 ") + status + "\r\n"
+                    + cors_header +
+                    "Content-Length: 0\r\n"
+                    "Connection: close\r\n"
+                    "\r\n";
+            send_all(socket, response);
+        }
+    }
+
+    StreamServer::StreamServer(unsigned short port)
+        : port(port)
+    {
+        if (!this->open_listener()) {
+            // the stream was asked for explicitly, so say plainly that it is not there
+            log_warning("api::stream",
+                    "the video stream is not available on port {}", this->port);
+            return;
+        }
+
+        this->running = true;
+        this->acceptor = std::thread([this] {
+            this->accept_worker();
+        });
+
+        // deliberately not logging a full URL; local IPs would leak into shared logs
+        log_info("api::stream", "video stream is listening on port: {}", this->port);
+        log_warning("api::stream",
+                "the video stream is unauthenticated - anyone who can reach port {} can watch "
+                "the game screen", this->port);
+    }
+
+    bool StreamServer::open_listener() {
+        WSADATA wsa_data;
+        const int error = WSAStartup(MAKEWORD(2, 2), &wsa_data);
+        if (error != 0) {
+            log_warning("api::stream", "WSAStartup() returned {}", error);
+            return false;
+        }
+        this->wsa_started = true;
+
+        this->listener = socket(AF_INET, SOCK_STREAM, 0);
+        if (this->listener == INVALID_SOCKET) {
+            log_warning("api::stream", "could not create listener socket: {}",
+                    get_last_error_string());
+            return false;
+        }
+
+        int opt_enable = 1;
+        if (setsockopt(this->listener, SOL_SOCKET, SO_REUSEADDR,
+                reinterpret_cast<const char *>(&opt_enable), sizeof(int)) == -1) {
+            log_warning("api::stream", "could not set socket option SO_REUSEADDR: {}",
+                    get_last_error_string());
+        }
+
+        sockaddr_in server_address {};
+        server_address.sin_family = AF_INET;
+        server_address.sin_port = htons(this->port);
+        server_address.sin_addr.s_addr = INADDR_ANY;
+
+        if (bind(this->listener, (sockaddr *) &server_address, sizeof(sockaddr)) == -1) {
+            log_warning("api::stream", "could not bind socket on port {}: {}",
+                    this->port, get_last_error_string());
+            closesocket(this->listener);
+            this->listener = INVALID_SOCKET;
+            return false;
+        }
+
+        if (listen(this->listener, server_backlog) == -1) {
+            log_warning("api::stream", "could not listen on port {}: {}",
+                    this->port, get_last_error_string());
+            closesocket(this->listener);
+            this->listener = INVALID_SOCKET;
+            return false;
+        }
+
+        return true;
+    }
+
+    StreamServer::~StreamServer() {
+
+        this->running = false;
+
+        if (this->listener != INVALID_SOCKET) {
+            closesocket(this->listener);
+            this->listener = INVALID_SOCKET;
+        }
+
+        // drops the client threads out of their blocking send/recv
+        {
+            std::lock_guard<std::mutex> lock(this->clients_m);
+            for (auto &client : this->clients) {
+                if (client.socket != INVALID_SOCKET) {
+                    ::shutdown(client.socket, SD_BOTH);
+                }
+            }
+        }
+
+        if (this->acceptor.joinable()) {
+            this->acceptor.join();
+        }
+
+        // joining is what guarantees no client thread outlives this object
+        for (auto &client : this->clients) {
+            if (client.thread.joinable()) {
+                client.thread.join();
+            }
+        }
+
+        if (this->wsa_started) {
+            WSACleanup();
+        }
+    }
+
+    void StreamServer::accept_worker() {
+
+        while (this->running) {
+            sockaddr_in client_address {};
+            int client_address_size = sizeof(sockaddr_in);
+
+            const SOCKET client = accept(
+                    this->listener, (sockaddr *) &client_address, &client_address_size);
+            if (client == INVALID_SOCKET) {
+                // on shutdown the listener is closed under us; otherwise do not spin
+                if (this->running) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                }
+                continue;
+            }
+
+            if (!this->running) {
+                closesocket(client);
+                break;
+            }
+
+            char address_data[INET_ADDRSTRLEN] {};
+            inet_ntop(AF_INET, &client_address.sin_addr, address_data, INET_ADDRSTRLEN);
+            std::string address(address_data);
+
+            // every client costs an encode and real bandwidth, so the cap protects the game
+            int slot = -1;
+            {
+                std::lock_guard<std::mutex> lock(this->clients_m);
+                for (size_t i = 0; i < this->clients.size(); i++) {
+                    if (!this->clients[i].active) {
+                        this->clients[i].active = true;
+                        this->clients[i].socket = client;
+                        slot = static_cast<int>(i);
+                        break;
+                    }
+                }
+            }
+
+            if (slot < 0) {
+                log_warning("api::stream", "client limit of {} hit", client_limit);
+                send_error(client, "503 Service Unavailable");
+                closesocket(client);
+                continue;
+            }
+
+            // this thread is the only one that touches the thread objects, so the slot's
+            // previous occupant gets reaped here rather than being detached
+            if (this->clients[slot].thread.joinable()) {
+                this->clients[slot].thread.join();
+            }
+
+            this->clients[slot].thread = std::thread([this, slot, client, address] {
+                this->client_worker(slot, client, address);
+            });
+        }
+    }
+
+    void StreamServer::client_worker(int slot, SOCKET socket, std::string address) {
+
+        DWORD timeout = request_timeout_ms;
+        setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO,
+                reinterpret_cast<const char *>(&timeout), sizeof(timeout));
+
+        timeout = send_timeout_ms;
+        setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO,
+                reinterpret_cast<const char *>(&timeout), sizeof(timeout));
+
+        int opt_enable = 1;
+        setsockopt(socket, IPPROTO_TCP, TCP_NODELAY,
+                reinterpret_cast<const char *>(&opt_enable), sizeof(int));
+
+        // whatever sits in the send buffer is already stale, and the default holds about a
+        // third of a second of H.264 because the bitrate is so low. keeping it small makes a
+        // slow reader block the sender, which then skips to the newest frame instead of
+        // handing over a backlog
+        int send_buffer = send_buffer_bytes;
+        setsockopt(socket, SOL_SOCKET, SO_SNDBUF,
+                reinterpret_cast<const char *>(&send_buffer), sizeof(send_buffer));
+
+        HttpRequest request;
+        if (read_request(socket, request_size_limit, request)) {
+            if (request.method != "GET") {
+                send_error(socket, "405 Method Not Allowed");
+            } else {
+                const int fps = query_int(request, "fps", 30, 1, fps_limit);
+                const int quality = query_int(request, "q", 70, 1, 100);
+
+                auto writer = make_stream_writer(request.path, quality, fps);
+                if (!writer) {
+                    send_error(socket, "404 Not Found");
+                } else {
+                    std::vector<int> screens;
+                    graphics_screens_get(screens);
+
+                    // registration takes a raw swapchain index and never bounds it, so the
+                    // capture range has to be enforced here rather than assumed
+                    const auto streamable = [&screens](int screen) {
+                        return screen < static_cast<int>(GRAPHICS_CAPTURE_SCREEN_NO)
+                                && std::find(screens.begin(), screens.end(), screen)
+                                        != screens.end();
+                    };
+
+                    // screen 1 is the subscreen in every game that has one; single-screen games
+                    // only ever register screen 0, so resolve the default against what exists.
+                    // left unclamped so a nonsense screen is reported as what was asked for
+                    int screen = query_int(request, "screen", -1, 0,
+                            std::numeric_limits<int>::max());
+                    if (screen < 0) {
+                        screen = streamable(1) ? 1 : 0;
+                    }
+
+                    // the default always lands on a screen that exists, so this is only ever
+                    // an explicit request for one that cannot be captured
+                    if (!streamable(screen)) {
+                        log_warning("api::stream",
+                                "screen {} is not available, refusing {}", screen, address);
+                        send_error(socket, "404 Not Found");
+                    } else if (!capture_pump::claim_screen(screen)) {
+                        log_warning("api::stream",
+                                "screen {} is already being streamed, refusing {}",
+                                screen, address);
+                        send_error(socket, "503 Service Unavailable");
+                    } else {
+                        log_info("api::stream",
+                                "client connected: {} ({}, screen={}, fps={}, quality={})",
+                                address, request.path, screen, fps, quality);
+
+                        const std::string header =
+                                "HTTP/1.0 200 OK\r\n"
+                                "Connection: close\r\n"
+                                + std::string(cors_header) +
+                                "Cache-Control: no-store, no-cache, must-revalidate\r\n"
+                                "Pragma: no-cache\r\n"
+                                "Content-Type: " + writer->content_type() + "\r\n"
+                                "\r\n";
+
+                        const StreamSend stream_send = [socket](const void *data, size_t size) {
+                            return send_all(socket, data, size);
+                        };
+
+                        if (send_all(socket, header) && writer->begin(stream_send)) {
+                            const auto interval = std::chrono::microseconds(1000000 / fps);
+
+                            while (this->running) {
+                                const auto started = std::chrono::steady_clock::now();
+
+                                capture_pump::Frame frame;
+                                const bool ok = capture_pump::capture_direct(
+                                        screen, frame.pixels, 1,
+                                        &frame.timestamp, &frame.width, &frame.height);
+
+                                if (ok && frame.pixels) {
+                                    if (!writer->write(stream_send, frame)) {
+                                        break;
+                                    }
+                                } else if (client_gone(socket)) {
+                                    break;
+                                }
+
+                                // a failed capture still paces, or a stalled game spins this
+                                std::this_thread::sleep_until(started + interval);
+                            }
+                        }
+
+                        capture_pump::release_screen(screen);
+                        log_info("api::stream", "client disconnected: {}", address);
+                    }
+                }
+            }
+        }
+
+        {
+            std::lock_guard<std::mutex> lock(this->clients_m);
+            this->clients[slot].socket = INVALID_SOCKET;
+            this->clients[slot].active = false;
+        }
+
+        closesocket(socket);
+    }
+}

src/spice2x/api/stream_server.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <array>
+#include <atomic>
+#include <cstdint>
+#include <mutex>
+#include <string>
+#include <thread>
+
+#include <winsock2.h>
+
+namespace api {
+
+    class StreamServer {
+    public:
+
+        explicit StreamServer(unsigned short port);
+        ~StreamServer();
+
+        StreamServer(const StreamServer &) = delete;
+        StreamServer &operator=(const StreamServer &) = delete;
+
+    private:
+
+        // configuration
+        static constexpr int server_backlog = 4;
+        static constexpr int client_limit = 4;
+        static constexpr int request_size_limit = 8 * 1024;
+        static constexpr int request_timeout_ms = 5000;
+        static constexpr int send_timeout_ms = 5000;
+        // small enough that a low bitrate stream cannot hide a backlog of stale frames in it
+        static constexpr int send_buffer_bytes = 16 * 1024;
+        static constexpr int fps_limit = 60;
+
+        struct Client {
+            std::thread thread;
+            SOCKET socket = INVALID_SOCKET;
+            bool active = false;
+        };
+
+        void accept_worker();
+        bool open_listener();
+        void client_worker(int slot, SOCKET socket, std::string address);
+
+        unsigned short port;
+        SOCKET listener = INVALID_SOCKET;
+        bool wsa_started = false;
+        std::atomic_bool running { false };
+        std::thread acceptor;
+        std::mutex clients_m;
+        // socket and active are guarded by clients_m; only the acceptor touches thread
+        std::array<Client, client_limit> clients;
+    };
+}

src/spice2x/api/websocket.cpp

@@ -12,6 +12,20 @@ using namespace headsocket;
 
 namespace api {
 
+    namespace {
+
+        // how long a single handshake read may stall before the connection is dropped;
+        // headsocket reads the request a byte at a time, so this is an idle timeout between
+        // bytes rather than a deadline for the whole handshake
+        constexpr int handshake_timeout_ms = 5000;
+
+        void set_recv_timeout(connection &conn, int milliseconds) {
+            DWORD timeout = static_cast<DWORD>(milliseconds);
+            setsockopt(conn.impl()->socket, SOL_SOCKET, SO_RCVTIMEO,
+                    reinterpret_cast<const char *>(&timeout), sizeof(timeout));
+        }
+    }
+
     /*
      * Client class declaration
      */
@@ -37,6 +51,21 @@ namespace api {
         HEADSOCKET_SERVER(WebSocketServer, web_socket_server);
     public:
         WebSocketController *websocket;
+
+    protected:
+        bool handshake(connection &conn) override {
+
+            // headsocket runs the handshake on its single accept thread with a blocking
+            // recv, so a peer that connects and then says nothing would park that thread and
+            // leave every later connection sitting unaccepted in the backlog
+            set_recv_timeout(conn, handshake_timeout_ms);
+            const bool accepted = base_t::handshake(conn);
+
+            // from here the client thread owns the socket and wants to block on reads
+            set_recv_timeout(conn, 0);
+
+            return accepted;
+        }
     };
 
     void api::WebSocketServer::init() {}

src/spice2x/external/docker/Dockerfile

@@ -7,6 +7,7 @@ RUN pacman --noconfirm -Syu git \
     ninja \
     cmake \
     unzip \
+    nasm \
     mingw-w64-crt \
     mingw-w64-winpthreads \
     mingw-w64-gcc \
@@ -23,3 +24,11 @@ ENV PATH="$PATH:/opt/llvm-mingw-xp/bin"
 
 RUN curl -fsSL "https://github.com/mon/windows-dll-compat-checker/releases/download/v1.3/windows_dll_compat_checker-linux-x86_64.tar.xz" \
     | tar -xJ -C /usr/local/bin
+
+# libjpeg-turbo for JPEG encoding. Only the mingw-w64 toolchains get it;
+# the WinXP targets build without JPEG support entirely.
+RUN su user -c "yay --noconfirm -S mingw-w64-libjpeg-turbo"
+
+# x264 for the API H.264 video stream. Only the mingw-w64 toolchains need it;
+# the WinXP targets build without the stream encoder.
+RUN su user -c "yay --noconfirm -S mingw-w64-x264"

src/spice2x/external/fpng/fpng.h

@@ -0,0 +1,122 @@
+// fpng.h - unlicense (see end of fpng.cpp)
+#pragma once
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <vector>
+
+#ifndef FPNG_TRAIN_HUFFMAN_TABLES
+	// Set to 1 when using the -t (training) option in fpng_test to generate new opaque/alpha Huffman tables for the single pass encoder.
+	#define FPNG_TRAIN_HUFFMAN_TABLES (0)
+#endif
+
+namespace fpng
+{
+	// ---- Library initialization - call once to identify if the processor supports SSE.
+	// Otherwise you'll only get scalar fallbacks.
+	void fpng_init();
+
+	// ---- Useful Utilities
+
+	// Returns true if the CPU supports SSE 4.1, and SSE support wasn't disabled by setting FPNG_NO_SSE=1.
+	// fpng_init() must have been called first, or it'll assert and return false.
+	bool fpng_cpu_supports_sse41();
+
+	// Fast CRC-32 SSE4.1+pclmul or a scalar fallback (slice by 4)
+	const uint32_t FPNG_CRC32_INIT = 0;
+	uint32_t fpng_crc32(const void* pData, size_t size, uint32_t prev_crc32 = FPNG_CRC32_INIT);
+
+	// Fast Adler32 SSE4.1 Adler-32 with a scalar fallback.
+	const uint32_t FPNG_ADLER32_INIT = 1;
+	uint32_t fpng_adler32(const void* pData, size_t size, uint32_t adler = FPNG_ADLER32_INIT);
+
+	// ---- Compression
+	enum
+	{
+		// Enables computing custom Huffman tables for each file, instead of using the custom global tables. 
+		// Results in roughly 6% smaller files on average, but compression is around 40% slower.
+		FPNG_ENCODE_SLOWER = 1, 
+		
+		// Only use raw Deflate blocks (no compression at all). Intended for testing.
+		FPNG_FORCE_UNCOMPRESSED = 2,
+	};
+
+	// Fast PNG encoding. The resulting file can be decoded either using a standard PNG decoder or by the fpng_decode_memory() function below.
+	// pImage: pointer to RGB or RGBA image pixels, R first in memory, B/A last.
+	// w/h - image dimensions. Image's row pitch in bytes must is w*num_chans.
+	// num_chans must be 3 or 4. 
+	bool fpng_encode_image_to_memory(const void* pImage, uint32_t w, uint32_t h, uint32_t num_chans, std::vector<uint8_t>& out_buf, uint32_t flags = 0);
+
+#ifndef FPNG_NO_STDIO
+	// Fast PNG encoding to the specified file.
+	bool fpng_encode_image_to_file(const char* pFilename, const void* pImage, uint32_t w, uint32_t h, uint32_t num_chans, uint32_t flags = 0);
+#endif
+
+	// ---- Decompression
+		
+	enum
+	{
+		FPNG_DECODE_SUCCESS = 0,				// file is a valid PNG file and written by FPNG and the decode succeeded
+		
+		FPNG_DECODE_NOT_FPNG,					// file is a valid PNG file, but it wasn't written by FPNG so you should try decoding it with a general purpose PNG decoder
+
+		FPNG_DECODE_INVALID_ARG,				// invalid function parameter
+
+		FPNG_DECODE_FAILED_NOT_PNG,				// file cannot be a PNG file
+		FPNG_DECODE_FAILED_HEADER_CRC32,		// a chunk CRC32 check failed, file is likely corrupted or not PNG
+		FPNG_DECODE_FAILED_INVALID_DIMENSIONS,  // invalid image dimensions in IHDR chunk (0 or too large)
+		FPNG_DECODE_FAILED_DIMENSIONS_TOO_LARGE, // decoding the file fully into memory would likely require too much memory (only on 32bpp builds)
+		FPNG_DECODE_FAILED_CHUNK_PARSING,		// failed while parsing the chunk headers, or file is corrupted
+		FPNG_DECODE_FAILED_INVALID_IDAT,		// IDAT data length is too small and cannot be valid, file is either corrupted or it's a bug
+
+		// fpng_decode_file() specific errors
+		FPNG_DECODE_FILE_OPEN_FAILED,
+		FPNG_DECODE_FILE_TOO_LARGE,
+		FPNG_DECODE_FILE_READ_FAILED,
+		FPNG_DECODE_FILE_SEEK_FAILED
+	};
+
+	// Fast PNG decoding of files ONLY created by fpng_encode_image_to_memory() or fpng_encode_image_to_file().
+	// If fpng_get_info() or fpng_decode_memory() returns FPNG_DECODE_NOT_FPNG, you should decode the PNG by falling back to a general purpose decoder.
+	//
+	// fpng_get_info() parses the PNG header and iterates through all chunks to determine if it's a file written by FPNG, but does not decompress the actual image data so it's relatively fast.
+	// 
+	// pImage, image_size: Pointer to PNG image data and its size
+	// width, height: output image's dimensions
+	// channels_in_file: will be 3 or 4
+	// 
+	// Returns FPNG_DECODE_SUCCESS on success, otherwise one of the failure codes above.
+	// If FPNG_DECODE_NOT_FPNG is returned, you must decompress the file with a general purpose PNG decoder.
+	// If another error occurs, the file is likely corrupted or invalid, but you can still try to decompress the file with another decoder (which will likely fail).
+	int fpng_get_info(const void* pImage, uint32_t image_size, uint32_t& width, uint32_t& height, uint32_t& channels_in_file);
+
+	// fpng_decode_memory() decompresses 24/32bpp PNG files ONLY encoded by this module.
+	// If the image was written by FPNG, it will decompress the image data, otherwise it will return FPNG_DECODE_NOT_FPNG in which case you should fall back to a general purpose PNG decoder (lodepng, stb_image, libpng, etc.)
+	//
+	// pImage, image_size: Pointer to PNG image data and its size
+	// out: Output 24/32bpp image buffer
+	// width, height: output image's dimensions
+	// channels_in_file: will be 3 or 4
+	// desired_channels: must be 3 or 4 
+	// 
+	// If the image is 24bpp and 32bpp is requested, the alpha values will be set to 0xFF. 
+	// If the image is 32bpp and 24bpp is requested, the alpha values will be discarded.
+	// 
+	// Returns FPNG_DECODE_SUCCESS on success, otherwise one of the failure codes above.
+	// If FPNG_DECODE_NOT_FPNG is returned, you must decompress the file with a general purpose PNG decoder.
+	// If another error occurs, the file is likely corrupted or invalid, but you can still try to decompress the file with another decoder (which will likely fail).
+	int fpng_decode_memory(const void* pImage, uint32_t image_size, std::vector<uint8_t>& out, uint32_t& width, uint32_t& height, uint32_t& channels_in_file, uint32_t desired_channels);
+
+#ifndef FPNG_NO_STDIO
+	int fpng_decode_file(const char* pFilename, std::vector<uint8_t>& out, uint32_t& width, uint32_t& height, uint32_t& channels_in_file, uint32_t desired_channels);
+#endif
+
+	// ---- Internal API used for Huffman table training purposes
+
+#if FPNG_TRAIN_HUFFMAN_TABLES
+	const uint32_t HUFF_COUNTS_SIZE = 288;
+	extern uint64_t g_huff_counts[HUFF_COUNTS_SIZE];
+	bool create_dynamic_block_prefix(uint64_t* pFreq, uint32_t num_chans, std::vector<uint8_t>& prefix, uint64_t& bit_buf, int& bit_buf_size, uint32_t *pCodes, uint8_t *pCodesizes);
+#endif
+
+} // namespace fpng

src/spice2x/external/toojpeg/LICENSE

@@ -1,10 +0,0 @@
-zlib License
-
-Copyright (c) 2011-2016 Stephan Brumme
-
-This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software.
-   If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.

src/spice2x/external/toojpeg/toojpeg.cpp

@@ -1,665 +0,0 @@
-// //////////////////////////////////////////////////////////
-// toojpeg.cpp
-// written by Stephan Brumme, 2018-2019
-// see https://create.stephan-brumme.com/toojpeg/
-//
-
-#include "toojpeg.h"
-
-// - the "official" specifications: https://www.w3.org/Graphics/JPEG/itu-t81.pdf and https://www.w3.org/Graphics/JPEG/jfif3.pdf
-// - Wikipedia has a short description of the JFIF/JPEG file format: https://en.wikipedia.org/wiki/JPEG_File_Interchange_Format
-// - the popular STB Image library includes Jon's JPEG encoder as well: https://github.com/nothings/stb/blob/master/stb_image_write.h
-// - the most readable JPEG book (from a developer's perspective) is Miano's "Compressed Image File Formats" (1999, ISBN 0-201-60443-4),
-//   used copies are really cheap nowadays and include a CD with C++ sources as well (plus great format descriptions of GIF & PNG)
-// - much more detailled is Mitchell/Pennebaker's "JPEG: Still Image Data Compression Standard" (1993, ISBN 0-442-01272-1)
-//   which contains the official JPEG standard, too - fun fact: I bought a signed copy in a second-hand store without noticing
-
-namespace // anonymous namespace to hide local functions / constants / etc.
-{
-// ////////////////////////////////////////
-// data types
-using uint8_t  = unsigned char;
-using uint16_t = unsigned short;
-using  int16_t =          short;
-using  int32_t =          int; // at least four bytes
-
-// ////////////////////////////////////////
-// constants
-
-// quantization tables from JPEG Standard, Annex K
-const uint8_t DefaultQuantLuminance[8*8] =
-    { 16, 11, 10, 16, 24, 40, 51, 61, // there are a few experts proposing slightly more efficient values,
-      12, 12, 14, 19, 26, 58, 60, 55, // e.g. https://www.imagemagick.org/discourse-server/viewtopic.php?t=20333
-      14, 13, 16, 24, 40, 57, 69, 56, // btw: Google's Guetzli project optimizes the quantization tables per image
-      14, 17, 22, 29, 51, 87, 80, 62,
-      18, 22, 37, 56, 68,109,103, 77,
-      24, 35, 55, 64, 81,104,113, 92,
-      49, 64, 78, 87,103,121,120,101,
-      72, 92, 95, 98,112,100,103, 99 };
-const uint8_t DefaultQuantChrominance[8*8] =
-    { 17, 18, 24, 47, 99, 99, 99, 99,
-      18, 21, 26, 66, 99, 99, 99, 99,
-      24, 26, 56, 99, 99, 99, 99, 99,
-      47, 66, 99, 99, 99, 99, 99, 99,
-      99, 99, 99, 99, 99, 99, 99, 99,
-      99, 99, 99, 99, 99, 99, 99, 99,
-      99, 99, 99, 99, 99, 99, 99, 99,
-      99, 99, 99, 99, 99, 99, 99, 99 };
-
-// 8x8 blocks are processed in zig-zag order
-// most encoders use a zig-zag "forward" table, I switched to its inverse for performance reasons
-// note: ZigZagInv[ZigZag[i]] = i
-const uint8_t ZigZagInv[8*8] =
-    {  0, 1, 8,16, 9, 2, 3,10,   // ZigZag[] =  0, 1, 5, 6,14,15,27,28,
-      17,24,32,25,18,11, 4, 5,   //             2, 4, 7,13,16,26,29,42,
-      12,19,26,33,40,48,41,34,   //             3, 8,12,17,25,30,41,43,
-      27,20,13, 6, 7,14,21,28,   //             9,11,18,24,31,40,44,53,
-      35,42,49,56,57,50,43,36,   //            10,19,23,32,39,45,52,54,
-      29,22,15,23,30,37,44,51,   //            20,22,33,38,46,51,55,60,
-      58,59,52,45,38,31,39,46,   //            21,34,37,47,50,56,59,61,
-      53,60,61,54,47,55,62,63 }; //            35,36,48,49,57,58,62,63
-
-// static Huffman code tables from JPEG standard Annex K
-// - CodesPerBitsize tables define how many Huffman codes will have a certain bitsize (plus 1 because there nothing with zero bits),
-//   e.g. DcLuminanceCodesPerBitsize[2] = 5 because there are 5 Huffman codes being 2+1=3 bits long
-// - Values tables are a list of values ordered by their Huffman code bitsize,
-//   e.g. AcLuminanceValues => Huffman(0x01,0x02 and 0x03) will have 2 bits, Huffman(0x00) will have 3 bits, Huffman(0x04,0x11 and 0x05) will have 4 bits, ...
-
-// Huffman definitions for first DC/AC tables (luminance / Y channel)
-const uint8_t DcLuminanceCodesPerBitsize[16]   = { 0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0 };   // sum = 12
-const uint8_t DcLuminanceValues         [12]   = { 0,1,2,3,4,5,6,7,8,9,10,11 };         // => 12 codes
-const uint8_t AcLuminanceCodesPerBitsize[16]   = { 0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,125 }; // sum = 162
-const uint8_t AcLuminanceValues        [162]   =                                        // => 162 codes
-    { 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xA1,0x08, // 16*10+2 symbols because
-      0x23,0x42,0xB1,0xC1,0x15,0x52,0xD1,0xF0,0x24,0x33,0x62,0x72,0x82,0x09,0x0A,0x16,0x17,0x18,0x19,0x1A,0x25,0x26,0x27,0x28, // upper 4 bits can be 0..F
-      0x29,0x2A,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x53,0x54,0x55,0x56,0x57,0x58,0x59, // while lower 4 bits can be 1..A
-      0x5A,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x83,0x84,0x85,0x86,0x87,0x88,0x89, // plus two special codes 0x00 and 0xF0
-      0x8A,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xB2,0xB3,0xB4,0xB5,0xB6, // order of these symbols was determined empirically by JPEG committee
-      0xB7,0xB8,0xB9,0xBA,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xE1,0xE2,
-      0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA };
-// Huffman definitions for second DC/AC tables (chrominance / Cb and Cr channels)
-const uint8_t DcChrominanceCodesPerBitsize[16] = { 0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0 };   // sum = 12
-const uint8_t DcChrominanceValues         [12] = { 0,1,2,3,4,5,6,7,8,9,10,11 };         // => 12 codes (identical to DcLuminanceValues)
-const uint8_t AcChrominanceCodesPerBitsize[16] = { 0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,119 }; // sum = 162
-const uint8_t AcChrominanceValues        [162] =                                        // => 162 codes
-    { 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91, // same number of symbol, just different order
-      0xA1,0xB1,0xC1,0x09,0x23,0x33,0x52,0xF0,0x15,0x62,0x72,0xD1,0x0A,0x16,0x24,0x34,0xE1,0x25,0xF1,0x17,0x18,0x19,0x1A,0x26, // (which is more efficient for AC coding)
-      0x27,0x28,0x29,0x2A,0x35,0x36,0x37,0x38,0x39,0x3A,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x53,0x54,0x55,0x56,0x57,0x58,
-      0x59,0x5A,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x82,0x83,0x84,0x85,0x86,0x87,
-      0x88,0x89,0x8A,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xB2,0xB3,0xB4,
-      0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,
-      0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA };
-const int16_t CodeWordLimit = 2048; // +/-2^11, maximum value after DCT
-
-// ////////////////////////////////////////
-// structs
-
-// represent a single Huffman code
-struct BitCode
-{
-  BitCode() = default; // undefined state, must be initialized at a later time
-  BitCode(uint16_t code_, uint8_t numBits_)
-  : code(code_), numBits(numBits_) {}
-  uint16_t code;       // JPEG's Huffman codes are limited to 16 bits
-  uint8_t  numBits;    // number of valid bits
-};
-
-// wrapper for bit output operations
-struct BitWriter
-{
-  // user-supplied callback that writes/stores one byte
-  TooJpeg::WRITE_ONE_BYTE output;
-  // initialize writer
-  explicit BitWriter(TooJpeg::WRITE_ONE_BYTE output_) : output(output_) {}
-
-  // store the most recently encoded bits that are not written yet
-  struct BitBuffer
-  {
-    int32_t data    = 0; // actually only at most 24 bits are used
-    uint8_t numBits = 0; // number of valid bits (the right-most bits)
-  } buffer;
-
-  // write Huffman bits stored in BitCode, keep excess bits in BitBuffer
-  BitWriter& operator<<(const BitCode& data)
-  {
-    // append the new bits to those bits leftover from previous call(s)
-    buffer.numBits += data.numBits;
-    buffer.data   <<= data.numBits;
-    buffer.data    |= data.code;
-
-    // write all "full" bytes
-    while (buffer.numBits >= 8)
-    {
-      // extract highest 8 bits
-      buffer.numBits -= 8;
-      auto oneByte = uint8_t(buffer.data >> buffer.numBits);
-      output(oneByte);
-
-      if (oneByte == 0xFF) // 0xFF has a special meaning for JPEGs (it's a block marker)
-        output(0);         // therefore pad a zero to indicate "nope, this one ain't a marker, it's just a coincidence"
-
-      // note: I don't clear those written bits, therefore buffer.bits may contain garbage in the high bits
-      //       if you really want to "clean up" (e.g. for debugging purposes) then uncomment the following line
-      //buffer.bits &= (1 << buffer.numBits) - 1;
-    }
-    return *this;
-  }
-
-  // write all non-yet-written bits, fill gaps with 1s (that's a strange JPEG thing)
-  void flush()
-  {
-    // at most seven set bits needed to "fill" the last byte: 0x7F = binary 0111 1111
-    *this << BitCode(0x7F, 7); // I should set buffer.numBits = 0 but since there are no single bits written after flush() I can safely ignore it
-  }
-
-  // NOTE: all the following BitWriter functions IGNORE the BitBuffer and write straight to output !
-  // write a single byte
-  BitWriter& operator<<(uint8_t oneByte)
-  {
-    output(oneByte);
-    return *this;
-  }
-
-  // write an array of bytes
-  template <typename T, int Size>
-  BitWriter& operator<<(T (&manyBytes)[Size])
-  {
-    for (auto c : manyBytes)
-      output(c);
-    return *this;
-  }
-
-  // start a new JFIF block
-  void addMarker(uint8_t id, uint16_t length)
-  {
-    output(0xFF); output(id);     // ID, always preceded by 0xFF
-    output(uint8_t(length >> 8)); // length of the block (big-endian, includes the 2 length bytes as well)
-    output(uint8_t(length & 0xFF));
-  }
-};
-
-// ////////////////////////////////////////
-// functions / templates
-
-// same as std::min()
-template <typename Number>
-Number minimum(Number value, Number maximum)
-{
-  return value <= maximum ? value : maximum;
-}
-
-// restrict a value to the interval [minimum, maximum]
-template <typename Number, typename Limit>
-Number clamp(Number value, Limit minValue, Limit maxValue)
-{
-  if (value <= minValue) return minValue; // never smaller than the minimum
-  if (value >= maxValue) return maxValue; // never bigger  than the maximum
-  return value;                           // value was inside interval, keep it
-}
-
-// convert from RGB to YCbCr, constants are similar to ITU-R, see https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion
-float rgb2y (float r, float g, float b) { return +0.299f   * r +0.587f   * g +0.114f   * b; }
-float rgb2cb(float r, float g, float b) { return -0.16874f * r -0.33126f * g +0.5f     * b; }
-float rgb2cr(float r, float g, float b) { return +0.5f     * r -0.41869f * g -0.08131f * b; }
-
-// forward DCT computation "in one dimension" (fast AAN algorithm by Arai, Agui and Nakajima: "A fast DCT-SQ scheme for images")
-void DCT(float block[8*8], uint8_t stride) // stride must be 1 (=horizontal) or 8 (=vertical)
-{
-  const auto SqrtHalfSqrt = 1.306562965f; //    sqrt((2 + sqrt(2)) / 2) = cos(pi * 1 / 8) * sqrt(2)
-  const auto InvSqrt      = 0.707106781f; // 1 / sqrt(2)                = cos(pi * 2 / 8)
-  const auto HalfSqrtSqrt = 0.382683432f; //     sqrt(2 - sqrt(2)) / 2  = cos(pi * 3 / 8)
-  const auto InvSqrtSqrt  = 0.541196100f; // 1 / sqrt(2 - sqrt(2))      = cos(pi * 3 / 8) * sqrt(2)
-
-  // modify in-place
-  auto& block0 = block[0         ];
-  auto& block1 = block[1 * stride];
-  auto& block2 = block[2 * stride];
-  auto& block3 = block[3 * stride];
-  auto& block4 = block[4 * stride];
-  auto& block5 = block[5 * stride];
-  auto& block6 = block[6 * stride];
-  auto& block7 = block[7 * stride];
-
-  // based on https://dev.w3.org/Amaya/libjpeg/jfdctflt.c , the original variable names can be found in my comments
-  auto add07 = block0 + block7; auto sub07 = block0 - block7; // tmp0, tmp7
-  auto add16 = block1 + block6; auto sub16 = block1 - block6; // tmp1, tmp6
-  auto add25 = block2 + block5; auto sub25 = block2 - block5; // tmp2, tmp5
-  auto add34 = block3 + block4; auto sub34 = block3 - block4; // tmp3, tmp4
-
-  auto add0347 = add07 + add34; auto sub07_34 = add07 - add34; // tmp10, tmp13 ("even part" / "phase 2")
-  auto add1256 = add16 + add25; auto sub16_25 = add16 - add25; // tmp11, tmp12
-
-  block0 = add0347 + add1256; block4 = add0347 - add1256; // "phase 3"
-
-  auto z1 = (sub16_25 + sub07_34) * InvSqrt; // all temporary z-variables kept their original names
-  block2 = sub07_34 + z1; block6 = sub07_34 - z1; // "phase 5"
-
-  auto sub23_45 = sub25 + sub34; // tmp10 ("odd part" / "phase 2")
-  auto sub12_56 = sub16 + sub25; // tmp11
-  auto sub01_67 = sub16 + sub07; // tmp12
-
-  auto z5 = (sub23_45 - sub01_67) * HalfSqrtSqrt;
-  auto z2 = sub23_45 * InvSqrtSqrt  + z5;
-  auto z3 = sub12_56 * InvSqrt;
-  auto z4 = sub01_67 * SqrtHalfSqrt + z5;
-  auto z6 = sub07 + z3; // z11 ("phase 5")
-  auto z7 = sub07 - z3; // z13
-  block1 = z6 + z4; block7 = z6 - z4; // "phase 6"
-  block5 = z7 + z2; block3 = z7 - z2;
-}
-
-// run DCT, quantize and write Huffman bit codes
-int16_t encodeBlock(BitWriter& writer, float block[8][8], const float scaled[8*8], int16_t lastDC,
-                    const BitCode huffmanDC[256], const BitCode huffmanAC[256], const BitCode* codewords)
-{
-  // "linearize" the 8x8 block, treat it as a flat array of 64 floats
-  auto block64 = (float*) block;
-
-  // DCT: rows
-  for (auto offset = 0; offset < 8; offset++)
-    DCT(block64 + offset*8, 1);
-  // DCT: columns
-  for (auto offset = 0; offset < 8; offset++)
-    DCT(block64 + offset*1, 8);
-
-  // scale
-  for (auto i = 0; i < 8*8; i++)
-    block64[i] *= scaled[i];
-
-  // encode DC (the first coefficient is the "average color" of the 8x8 block)
-  auto DC = int(block64[0] + (block64[0] >= 0 ? +0.5f : -0.5f)); // C++11's nearbyint() achieves a similar effect
-
-  // quantize and zigzag the other 63 coefficients
-  auto posNonZero = 0; // find last coefficient which is not zero (because trailing zeros are encoded differently)
-  int16_t quantized[8*8];
-  for (auto i = 1; i < 8*8; i++) // start at 1 because block64[0]=DC was already processed
-  {
-    auto value = block64[ZigZagInv[i]];
-    // round to nearest integer
-    quantized[i] = int(value + (value >= 0 ? +0.5f : -0.5f)); // C++11's nearbyint() achieves a similar effect
-    // remember offset of last non-zero coefficient
-    if (quantized[i] != 0)
-      posNonZero = i;
-  }
-
-  // same "average color" as previous block ?
-  auto diff = DC - lastDC;
-  if (diff == 0)
-    writer << huffmanDC[0x00];   // yes, write a special short symbol
-  else
-  {
-    auto bits = codewords[diff]; // nope, encode the difference to previous block's average color
-    writer << huffmanDC[bits.numBits] << bits;
-  }
-
-  // encode ACs (quantized[1..63])
-  auto offset = 0; // upper 4 bits count the number of consecutive zeros
-  for (auto i = 1; i <= posNonZero; i++) // quantized[0] was already written, skip all trailing zeros, too
-  {
-    // zeros are encoded in a special way
-    while (quantized[i] == 0) // found another zero ?
-    {
-      offset    += 0x10; // add 1 to the upper 4 bits
-      // split into blocks of at most 16 consecutive zeros
-      if (offset > 0xF0) // remember, the counter is in the upper 4 bits, 0xF = 15
-      {
-        writer << huffmanAC[0xF0]; // 0xF0 is a special code for "16 zeros"
-        offset = 0;
-      }
-      i++;
-    }
-
-    auto encoded = codewords[quantized[i]];
-    // combine number of zeros with the number of bits of the next non-zero value
-    writer << huffmanAC[offset + encoded.numBits] << encoded; // and the value itself
-    offset = 0;
-  }
-
-  // send end-of-block code (0x00), only needed if there are trailing zeros
-  if (posNonZero < 8*8 - 1) // = 63
-    writer << huffmanAC[0x00];
-
-  return DC;
-}
-
-// Jon's code includes the pre-generated Huffman codes
-// I don't like these "magic constants" and compute them on my own :-)
-void generateHuffmanTable(const uint8_t numCodes[16], const uint8_t* values, BitCode result[256])
-{
-  // process all bitsizes 1 thru 16, no JPEG Huffman code is allowed to exceed 16 bits
-  auto huffmanCode = 0;
-  for (auto numBits = 1; numBits <= 16; numBits++)
-  {
-    // ... and each code of these bitsizes
-    for (auto i = 0; i < numCodes[numBits - 1]; i++) // note: numCodes array starts at zero, but smallest bitsize is 1
-      result[*values++] = BitCode(huffmanCode++, numBits);
-
-    // next Huffman code needs to be one bit wider
-    huffmanCode <<= 1;
-  }
-}
-
-} // end of anonymous namespace
-
-// -------------------- externally visible code --------------------
-
-namespace TooJpeg
-{
-// the only exported function ...
-bool writeJpeg(WRITE_ONE_BYTE output, const void* pixels_, unsigned short width, unsigned short height,
-               bool isRGB, unsigned char quality_, bool downsample, const char* comment)
-{
-  // reject invalid pointers
-  if (output == nullptr || pixels_ == nullptr)
-    return false;
-  // check image format
-  if (width == 0 || height == 0)
-    return false;
-
-  // number of components
-  const auto numComponents = isRGB ? 3 : 1;
-  // note: if there is just one component (=grayscale), then only luminance needs to be stored in the file
-  //       thus everything related to chrominance need not to be written to the JPEG
-  //       I still compute a few things, like quantization tables to avoid a complete code mess
-
-  // grayscale images can't be downsampled (because there are no Cb + Cr channels)
-  if (!isRGB)
-    downsample = false;
-
-  // wrapper for all output operations
-  BitWriter bitWriter(output);
-
-  // ////////////////////////////////////////
-  // JFIF headers
-  const uint8_t HeaderJfif[2+2+16] =
-      { 0xFF,0xD8,         // SOI marker (start of image)
-        0xFF,0xE0,         // JFIF APP0 tag
-        0,16,              // length: 16 bytes (14 bytes payload + 2 bytes for this length field)
-        'J','F','I','F',0, // JFIF identifier, zero-terminated
-        1,1,               // JFIF version 1.1
-        0,                 // no density units specified
-        0,1,0,1,           // density: 1 pixel "per pixel" horizontally and vertically
-        0,0 };             // no thumbnail (size 0 x 0)
-  bitWriter << HeaderJfif;
-
-  // ////////////////////////////////////////
-  // comment (optional)
-  if (comment != nullptr)
-  {
-    // look for zero terminator
-    auto length = 0; // = strlen(comment);
-    while (comment[length] != 0)
-      length++;
-
-    // write COM marker
-    bitWriter.addMarker(0xFE, 2+length); // block size is number of bytes (without zero terminator) + 2 bytes for this length field
-    // ... and write the comment itself
-    for (auto i = 0; i < length; i++)
-      bitWriter << comment[i];
-  }
-
-  // ////////////////////////////////////////
-  // adjust quantization tables to desired quality
-
-  // quality level must be in 1 ... 100
-  auto quality = clamp<uint16_t>(quality_, 1, 100);
-  // convert to an internal JPEG quality factor, formula taken from libjpeg
-  quality = quality < 50 ? 5000 / quality : 200 - quality * 2;
-
-  uint8_t quantLuminance  [8*8];
-  uint8_t quantChrominance[8*8];
-  for (auto i = 0; i < 8*8; i++)
-  {
-    int luminance   = (DefaultQuantLuminance  [ZigZagInv[i]] * quality + 50) / 100;
-    int chrominance = (DefaultQuantChrominance[ZigZagInv[i]] * quality + 50) / 100;
-
-    // clamp to 1..255
-    quantLuminance  [i] = clamp(luminance,   1, 255);
-    quantChrominance[i] = clamp(chrominance, 1, 255);
-  }
-
-  // write quantization tables
-  bitWriter.addMarker(0xDB, 2 + (isRGB ? 2 : 1) * (1 + 8*8)); // length: 65 bytes per table + 2 bytes for this length field
-                                                              // each table has 64 entries and is preceded by an ID byte
-
-  bitWriter   << 0x00 << quantLuminance;   // first  quantization table
-  if (isRGB)
-    bitWriter << 0x01 << quantChrominance; // second quantization table, only relevant for color images
-
-  // ////////////////////////////////////////
-  // write image infos (SOF0 - start of frame)
-  bitWriter.addMarker(0xC0, 2+6+3*numComponents); // length: 6 bytes general info + 3 per channel + 2 bytes for this length field
-
-  // 8 bits per channel
-  bitWriter << 0x08
-  // image dimensions (big-endian)
-            << (height >> 8) << (height & 0xFF)
-            << (width  >> 8) << (width  & 0xFF);
-
-  // sampling and quantization tables for each component
-  bitWriter << numComponents;       // 1 component (grayscale, Y only) or 3 components (Y,Cb,Cr)
-  for (auto id = 1; id <= numComponents; id++)
-    bitWriter <<  id                // component ID (Y=1, Cb=2, Cr=3)
-    // bitmasks for sampling: highest 4 bits: horizontal, lowest 4 bits: vertical
-              << (id == 1 && downsample ? 0x22 : 0x11) // 0x11 is default YCbCr 4:4:4 and 0x22 stands for YCbCr 4:2:0
-              << (id == 1 ? 0 : 1); // use quantization table 0 for Y, table 1 for Cb and Cr
-
-  // ////////////////////////////////////////
-  // Huffman tables
-  // DHT marker - define Huffman tables
-  bitWriter.addMarker(0xC4, isRGB ? (2+208+208) : (2+208));
-                            // 2 bytes for the length field, store chrominance only if needed
-                            //   1+16+12  for the DC luminance
-                            //   1+16+162 for the AC luminance   (208 = 1+16+12 + 1+16+162)
-                            //   1+16+12  for the DC chrominance
-                            //   1+16+162 for the AC chrominance (208 = 1+16+12 + 1+16+162, same as above)
-
-  // store luminance's DC+AC Huffman table definitions
-  bitWriter << 0x00 // highest 4 bits: 0 => DC, lowest 4 bits: 0 => Y (baseline)
-            << DcLuminanceCodesPerBitsize
-            << DcLuminanceValues;
-  bitWriter << 0x10 // highest 4 bits: 1 => AC, lowest 4 bits: 0 => Y (baseline)
-            << AcLuminanceCodesPerBitsize
-            << AcLuminanceValues;
-
-  // compute actual Huffman code tables (see Jon's code for precalculated tables)
-  BitCode huffmanLuminanceDC[256];
-  BitCode huffmanLuminanceAC[256];
-  generateHuffmanTable(DcLuminanceCodesPerBitsize, DcLuminanceValues, huffmanLuminanceDC);
-  generateHuffmanTable(AcLuminanceCodesPerBitsize, AcLuminanceValues, huffmanLuminanceAC);
-
-  // chrominance is only relevant for color images
-  BitCode huffmanChrominanceDC[256];
-  BitCode huffmanChrominanceAC[256];
-  if (isRGB)
-  {
-    // store luminance's DC+AC Huffman table definitions
-    bitWriter << 0x01 // highest 4 bits: 0 => DC, lowest 4 bits: 1 => Cr,Cb (baseline)
-              << DcChrominanceCodesPerBitsize
-              << DcChrominanceValues;
-    bitWriter << 0x11 // highest 4 bits: 1 => AC, lowest 4 bits: 1 => Cr,Cb (baseline)
-              << AcChrominanceCodesPerBitsize
-              << AcChrominanceValues;
-
-    // compute actual Huffman code tables (see Jon's code for precalculated tables)
-    generateHuffmanTable(DcChrominanceCodesPerBitsize, DcChrominanceValues, huffmanChrominanceDC);
-    generateHuffmanTable(AcChrominanceCodesPerBitsize, AcChrominanceValues, huffmanChrominanceAC);
-  }
-
-  // ////////////////////////////////////////
-  // start of scan (there is only a single scan for baseline JPEGs)
-  bitWriter.addMarker(0xDA, 2+1+2*numComponents+3); // 2 bytes for the length field, 1 byte for number of components,
-                                                    // then 2 bytes for each component and 3 bytes for spectral selection
-
-  // assign Huffman tables to each component
-  bitWriter << numComponents;
-  for (auto id = 1; id <= numComponents; id++)
-    // highest 4 bits: DC Huffman table, lowest 4 bits: AC Huffman table
-    bitWriter << id << (id == 1 ? 0x00 : 0x11); // Y: tables 0 for DC and AC; Cb + Cr: tables 1 for DC and AC
-
-  // constant values for our baseline JPEGs (which have a single sequential scan)
-  static const uint8_t Spectral[3] = { 0, 63, 0 }; // spectral selection: must be from 0 to 63; successive approximation must be 0
-  bitWriter << Spectral;
-
-  // ////////////////////////////////////////
-  // adjust quantization tables with AAN scaling factors to simplify DCT
-  float scaledLuminance  [8*8];
-  float scaledChrominance[8*8];
-  for (auto i = 0; i < 8*8; i++)
-  {
-    auto row    = ZigZagInv[i] / 8; // same as ZigZagInv[i] >> 3
-    auto column = ZigZagInv[i] % 8; // same as ZigZagInv[i] &  7
-
-    // scaling constants for AAN DCT algorithm: AanScaleFactors[0] = 1, AanScaleFactors[k=1..7] = cos(k*PI/16) * sqrt(2)
-    static const float AanScaleFactors[8] = { 1, 1.387039845f, 1.306562965f, 1.175875602f, 1, 0.785694958f, 0.541196100f, 0.275899379f };
-    auto factor = 1 / (AanScaleFactors[row] * AanScaleFactors[column] * 8);
-    scaledLuminance  [ZigZagInv[i]] = factor / quantLuminance  [i];
-    scaledChrominance[ZigZagInv[i]] = factor / quantChrominance[i];
-    // if you really want JPEGs that are bitwise identical to Jon Olick's code then you need slightly different formulas (note: sqrt(8) = 2.828427125f)
-    //static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f, 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f }; // line 240 of jo_jpeg.cpp
-    //scaledLuminance  [ZigZagInv[i]] = 1 / (quantLuminance  [i] * aasf[row] * aasf[column]); // lines 266-267 of jo_jpeg.cpp
-    //scaledChrominance[ZigZagInv[i]] = 1 / (quantChrominance[i] * aasf[row] * aasf[column]);
-  }
-
-  // ////////////////////////////////////////
-  // precompute JPEG codewords for quantized DCT
-  BitCode  codewordsArray[2 * CodeWordLimit];          // note: quantized[i] is found at codewordsArray[quantized[i] + CodeWordLimit]
-  BitCode* codewords = &codewordsArray[CodeWordLimit]; // allow negative indices, so quantized[i] is at codewords[quantized[i]]
-  uint8_t numBits = 1; // each codeword has at least one bit (value == 0 is undefined)
-  int32_t mask    = 1; // mask is always 2^numBits - 1, initial value 2^1-1 = 2-1 = 1
-  for (int16_t value = 1; value < CodeWordLimit; value++)
-  {
-    // numBits = position of highest set bit (ignoring the sign)
-    // mask    = (2^numBits) - 1
-    if (value > mask) // one more bit ?
-    {
-      numBits++;
-      mask = (mask << 1) | 1; // append a set bit
-    }
-    codewords[-value] = BitCode(mask - value, numBits); // note that I use a negative index => codewords[-value] = codewordsArray[CodeWordLimit  value]
-    codewords[+value] = BitCode(       value, numBits);
-  }
-
-  // just convert image data from void*
-  auto pixels = (const uint8_t*)pixels_;
-
-  // the next two variables are frequently used when checking for image borders
-  const auto maxWidth  = width  - 1; // "last row"
-  const auto maxHeight = height - 1; // "bottom line"
-
-  // process MCUs (minimum codes units) => image is subdivided into a grid of 8x8 or 16x16 tiles
-  const auto sampling = downsample ? 2 : 1; // 1x1 or 2x2 sampling
-  const auto mcuSize  = 8 * sampling;
-
-  // average color of the previous MCU
-  int16_t lastYDC = 0, lastCbDC = 0, lastCrDC = 0;
-  // convert from RGB to YCbCr
-  float Y[8][8], Cb[8][8], Cr[8][8];
-
-  for (auto mcuY = 0; mcuY < height; mcuY += mcuSize) // each step is either 8 or 16 (=mcuSize)
-    for (auto mcuX = 0; mcuX < width; mcuX += mcuSize)
-    {
-      // YCbCr 4:4:4 format: each MCU is a 8x8 block - the same applies to grayscale images, too
-      // YCbCr 4:2:0 format: each MCU represents a 16x16 block, stored as 4x 8x8 Y-blocks plus 1x 8x8 Cb and 1x 8x8 Cr block)
-      for (auto blockY = 0; blockY < mcuSize; blockY += 8) // iterate once (YCbCr444 and grayscale) or twice (YCbCr420)
-        for (auto blockX = 0; blockX < mcuSize; blockX += 8)
-        {
-          // now we finally have an 8x8 block ...
-          for (auto deltaY = 0; deltaY < 8; deltaY++)
-          {
-            auto column = minimum(mcuX + blockX         , maxWidth); // must not exceed image borders, replicate last row/column if needed
-            auto row    = minimum(mcuY + blockY + deltaY, maxHeight);
-            for (auto deltaX = 0; deltaX < 8; deltaX++)
-            {
-              // find actual pixel position within the current image
-              auto pixelPos = row * int(width) + column; // the cast ensures that we don't run into multiplication overflows
-              if (column < maxWidth)
-                column++;
-
-              // grayscale images have solely a Y channel which can be easily derived from the input pixel by shifting it by 128
-              if (!isRGB)
-              {
-                Y[deltaY][deltaX] = pixels[pixelPos] - 128.f;
-                continue;
-              }
-
-              // RGB: 3 bytes per pixel (whereas grayscale images have only 1 byte per pixel)
-              auto r = pixels[3 * pixelPos    ];
-              auto g = pixels[3 * pixelPos + 1];
-              auto b = pixels[3 * pixelPos + 2];
-
-              Y   [deltaY][deltaX] = rgb2y (r, g, b) - 128; // again, the JPEG standard requires Y to be shifted by 128
-              // YCbCr444 is easy - the more complex YCbCr420 has to be computed about 20 lines below in a second pass
-              if (!downsample)
-              {
-                Cb[deltaY][deltaX] = rgb2cb(r, g, b); // standard RGB-to-YCbCr conversion
-                Cr[deltaY][deltaX] = rgb2cr(r, g, b);
-              }
-            }
-          }
-
-        // encode Y channel
-        lastYDC = encodeBlock(bitWriter, Y, scaledLuminance, lastYDC, huffmanLuminanceDC, huffmanLuminanceAC, codewords);
-        // Cb and Cr are encoded about 50 lines below
-      }
-
-      // grayscale images don't need any Cb and Cr information
-      if (!isRGB)
-        continue;
-
-      // ////////////////////////////////////////
-      // the following lines are only relevant for YCbCr420:
-      // average/downsample chrominance of four pixels while respecting the image borders
-      if (downsample)
-        for (short deltaY = 7; downsample && deltaY >= 0; deltaY--) // iterating loop in reverse increases cache read efficiency
-        {
-          auto row      = minimum(mcuY + 2*deltaY, maxHeight); // each deltaX/Y step covers a 2x2 area
-          auto column   =         mcuX;                        // column is updated inside next loop
-          auto pixelPos = (row * int(width) + column) * 3;     // numComponents = 3
-
-          // deltas (in bytes) to next row / column, must not exceed image borders
-          auto rowStep    = (row    < maxHeight) ? 3 * int(width) : 0; // always numComponents*width except for bottom    line
-          auto columnStep = (column < maxWidth ) ? 3              : 0; // always numComponents       except for rightmost pixel
-
-          for (short deltaX = 0; deltaX < 8; deltaX++)
-          {
-            // let's add all four samples (2x2 area)
-            auto right     = pixelPos + columnStep;
-            auto down      = pixelPos +              rowStep;
-            auto downRight = pixelPos + columnStep + rowStep;
-
-            // note: cast from 8 bits to >8 bits to avoid overflows when adding
-            auto r = short(pixels[pixelPos    ]) + pixels[right    ] + pixels[down    ] + pixels[downRight    ];
-            auto g = short(pixels[pixelPos + 1]) + pixels[right + 1] + pixels[down + 1] + pixels[downRight + 1];
-            auto b = short(pixels[pixelPos + 2]) + pixels[right + 2] + pixels[down + 2] + pixels[downRight + 2];
-
-            // convert to Cb and Cr
-            Cb[deltaY][deltaX] = rgb2cb(r, g, b) / 4; // I still have to divide r,g,b by 4 to get their average values
-            Cr[deltaY][deltaX] = rgb2cr(r, g, b) / 4; // it's a bit faster if done AFTER CbCr conversion
-
-            // step forward to next 2x2 area
-            pixelPos += 2*3; // 2 pixels => 6 bytes (2*numComponents)
-            column   += 2;
-
-            // reached right border ?
-            if (column >= maxWidth)
-            {
-              columnStep = 0;
-              pixelPos = ((row + 1) * int(width) - 1) * 3; // same as (row * width + maxWidth) * numComponents => current's row last pixel
-            }
-          }
-        } // end of YCbCr420 code for Cb and Cr
-
-      // encode Cb and Cr
-      lastCbDC = encodeBlock(bitWriter, Cb, scaledChrominance, lastCbDC, huffmanChrominanceDC, huffmanChrominanceAC, codewords);
-      lastCrDC = encodeBlock(bitWriter, Cr, scaledChrominance, lastCrDC, huffmanChrominanceDC, huffmanChrominanceAC, codewords);
-    }
-
-  bitWriter.flush(); // now image is completely encoded, write any bits still left in the buffer
-
-  // ///////////////////////////
-  // EOI marker
-  bitWriter << 0xFF << 0xD9; // this marker has no length, therefore I can't use addMarker()
-  return true;
-} // writeJpeg()
-} // namespace TooJpeg

src/spice2x/external/toojpeg/toojpeg.h

@@ -1,62 +0,0 @@
-// //////////////////////////////////////////////////////////
-// toojpeg.h
-// written by Stephan Brumme, 2018-2019
-// see https://create.stephan-brumme.com/toojpeg/
-//
-
-// This is a compact baseline JPEG/JFIF writer, written in C++ (but looks like C for the most part).
-// Its interface has only one function: writeJpeg() - and that's it !
-//
-// basic example:
-// => create an image with any content you like, e.g. 1024x768, RGB = 3 bytes per pixel
-// auto pixels = new unsigned char[1024*768*3];
-// => you need to define a callback that receives the compressed data byte-by-byte from my JPEG writer
-// void myOutput(unsigned char oneByte) { fputc(oneByte, myFileHandle); } // save byte to file
-// => let's go !
-// TooJpeg::writeJpeg(myOutput, mypixels, 1024, 768);
-
-#pragma once
-
-namespace TooJpeg
-{
-  // write one byte (to disk, memory, ...)
-  typedef void (*WRITE_ONE_BYTE)(unsigned char);
-  // this callback is called for every byte generated by the encoder and behaves similar to fputc
-  // if you prefer stylish C++11 syntax then it can be a lambda, too:
-  // auto myOutput = [](unsigned char oneByte) { fputc(oneByte, output); };
-
-  // output       - callback that stores a single byte (writes to disk, memory, ...)
-  // pixels       - stored in RGB format or grayscale, stored from upper-left to lower-right
-  // width,height - image size
-  // isRGB        - true if RGB format (3 bytes per pixel); false if grayscale (1 byte per pixel)
-  // quality      - between 1 (worst) and 100 (best)
-  // downsample   - if true then YCbCr 4:2:0 format is used (smaller size, minor quality loss) instead of 4:4:4, not relevant for grayscale
-  // comment      - optional JPEG comment (0/NULL if no comment), must not contain ASCII code 0xFF
-  bool writeJpeg(WRITE_ONE_BYTE output, const void* pixels, unsigned short width, unsigned short height,
-                 bool isRGB = true, unsigned char quality = 90, bool downsample = false, const char* comment = nullptr);
-} // namespace TooJpeg
-
-// My main inspiration was Jon Olick's Minimalistic JPEG writer
-// ( https://www.jonolick.com/code.html => direct link is https://www.jonolick.com/uploads/7/9/2/1/7921194/jo_jpeg.cpp ).
-// However, his code documentation is quite sparse - probably because it wasn't written from scratch and is (quote:) "based on a javascript jpeg writer",
-// most likely Andreas Ritter's code: https://github.com/eugeneware/jpeg-js/blob/master/lib/encoder.js
-//
-// Therefore I wrote the whole lib from scratch and tried hard to add tons of comments to my code, especially describing where all those magic numbers come from.
-// And I managed to remove the need for any external includes ...
-// yes, that's right: my library has no (!) includes at all, not even #include <stdlib.h>
-// Depending on your callback WRITE_ONE_BYTE, the library writes either to disk, or in-memory, or wherever you wish.
-// Moreover, no dynamic memory allocations are performed, just a few bytes on the stack.
-//
-// In contrast to Jon's code, compression can be significantly improved in many use cases:
-// a) grayscale JPEG images need just a single Y channel, no need to save the superfluous Cb + Cr channels
-// b) YCbCr 4:2:0 downsampling is often about 20% more efficient (=smaller) than the default YCbCr 4:4:4 with only little visual loss
-//
-// TooJpeg 1.2+ compresses about twice as fast as jo_jpeg (and about half as fast as libjpeg-turbo).
-// A few benchmark numbers can be found on my website https://create.stephan-brumme.com/toojpeg/#benchmark
-//
-// Last but not least you can optionally add a JPEG comment.
-//
-// Your C++ compiler needs to support a reasonable subset of C++11 (g++ 4.7 or Visual C++ 2013 are sufficient).
-// I haven't tested the code on big-endian systems or anything that smells like an apple.
-//
-// USE AT YOUR OWN RISK. Because you are a brave soul :-)

src/spice2x/games/iidx/iidx.cpp

@@ -279,6 +279,26 @@ namespace games::iidx {
         return nullptr;
     }
 
+    // best-effort read of a TDJ ROM file to determine if the game is running in TDJ mode
+    //
+    // these paths are not emulated - they hit whatever is actually mounted at that drive letter.
+    // an empty optical or removable drive raises the modal "insert a disk" error (the launcher
+    // clears SEM_FAILCRITICALERRORS process-wide) and a downed network drive stalls on redirector
+    // timeouts, so only probe what a TDJ cabinet would actually be laid out on.
+    // drive_path must be absolute and start with a drive letter.
+    static bool tdj_rom_matches(const char *drive_path, const char *expected) {
+        const wchar_t root[] = { (wchar_t) drive_path[0], L':', L'\\', L'\0' };
+        const auto drive_type = GetDriveTypeW(root);
+
+        if (drive_type != DRIVE_FIXED && drive_type != DRIVE_RAMDISK) {
+            log_misc("iidx", "not probing '{}' for TDJ, not a local disk (drive type {})",
+                    drive_path, drive_type);
+            return false;
+        }
+
+        return fileutils::text_read(drive_path) == expected;
+    }
+
 #endif
 
     IIDXGame::IIDXGame() : Game("Beatmania IIDX") {
@@ -339,8 +359,10 @@ namespace games::iidx {
             HAS_LIBAIO = true;
 
             // check TDJ mode
-            TDJ_MODE |= fileutils::text_read("C:\\000rom.txt") == "TDJ-JA";
-            TDJ_MODE |= fileutils::text_read("D:\\001rom.txt") == "TDJ";
+            if (!TDJ_MODE) {
+                TDJ_MODE = tdj_rom_matches("C:\\000rom.txt", "TDJ-JA")
+                        || tdj_rom_matches("D:\\001rom.txt", "TDJ");
+            }
 
             // force TDJ mode
             if (TDJ_MODE) {

src/spice2x/hooks/devicehook.cpp

@@ -574,7 +574,7 @@ void devicehook_init(HMODULE module) {
     STORE(EscapeCommFunction_orig, detour::iat_try("EscapeCommFunction", EscapeCommFunction_hook, module));
     STORE(GetCommState_orig, detour::iat_try("GetCommState", GetCommState_hook, module));
     STORE(GetFileSize_orig, detour::iat_try("GetFileSize", GetFileSize_hook, module));
-    STORE(GetFileSizeEx_orig, detour::iat_try("GetFileSize", GetFileSizeEx_hook, module));
+    STORE(GetFileSizeEx_orig, detour::iat_try("GetFileSizeEx", GetFileSizeEx_hook, module));
     STORE(GetFileInformationByHandle_orig, detour::iat_try(
                 "GetFileInformationByHandle", GetFileInformationByHandle_hook, module));
     STORE(PurgeComm_orig, detour::iat_try("PurgeComm", PurgeComm_hook, module));

src/spice2x/hooks/graphics/backends/d3d9/d3d9_device.cpp

@@ -17,6 +17,7 @@
 
 #include "d3d9_backend.h"
 #include "d3d9_live2d.h"
+#include "d3d9_readback.h"
 #include "d3d9_texture.h"
 
 #ifndef SPICE64
@@ -156,6 +157,8 @@ ULONG STDMETHODCALLTYPE WrappedIDirect3DDevice9::Release() {
             }
         }
 
+        d3d9_readback::release_device_resources(this->pReal);
+
         if (overlay::ENABLED) {
             const std::lock_guard<std::mutex> lock(overlay::OVERLAY_MUTEX);
 

src/spice2x/hooks/graphics/backends/d3d9/d3d9_readback.cpp

@@ -0,0 +1,241 @@
+#include "d3d9_readback.h"
+
+#include <mutex>
+#include <vector>
+
+#include "hooks/graphics/graphics.h"
+#include "util/logging.h"
+
+namespace d3d9_readback {
+
+namespace {
+
+SurfacePtr create_readback_surface(IDirect3DDevice9 *device, const D3DSURFACE_DESC &desc) {
+    IDirect3DSurface9 *surface = nullptr;
+    const HRESULT hr = device->CreateOffscreenPlainSurface(
+            desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &surface, nullptr);
+
+    if (FAILED(hr) || surface == nullptr) {
+        log_warning("graphics::d3d9",
+                "failed to create readback surface, hr={}",
+                FMT_HRESULT(hr));
+        return nullptr;
+    }
+
+    return SurfacePtr(surface);
+}
+
+size_t surface_bytes(const D3DSURFACE_DESC &desc) {
+    size_t bytes_per_pixel = 4;
+    switch (desc.Format) {
+        case D3DFMT_R5G6B5:
+        case D3DFMT_X1R5G5B5:
+        case D3DFMT_A1R5G5B5:
+            bytes_per_pixel = 2;
+            break;
+        default:
+            break;
+    }
+
+    return static_cast<size_t>(desc.Width) * desc.Height * bytes_per_pixel;
+}
+
+// idle surfaces are kept between captures, bucketed by layout so that screens of
+// differing resolution do not evict each other. a new device drops everything,
+// since system memory surfaces outlive Reset but not the device itself
+class ReadbackPool {
+public:
+    SurfacePtr acquire(IDirect3DDevice9 *device, const D3DSURFACE_DESC &desc) {
+        {
+            std::lock_guard<std::mutex> lock(this->mutex);
+
+            if (this->device != device) {
+                this->drop();
+                this->device = device;
+            }
+
+            auto *bucket = this->find(desc);
+            if (bucket && !bucket->idle.empty()) {
+                auto surface = std::move(bucket->idle.back());
+                bucket->idle.pop_back();
+
+                const size_t bytes = surface_bytes(desc);
+                this->idle_bytes = this->idle_bytes > bytes ? this->idle_bytes - bytes : 0;
+                return surface;
+            }
+        }
+
+        return create_readback_surface(device, desc);
+    }
+
+    void release(IDirect3DDevice9 *device, SurfacePtr surface) {
+        if (!surface) {
+            return;
+        }
+
+        D3DSURFACE_DESC desc {};
+        if (FAILED(surface->GetDesc(&desc))) {
+            return;
+        }
+
+        const size_t bytes = surface_bytes(desc);
+
+        std::lock_guard<std::mutex> lock(this->mutex);
+        if (this->device != device || this->idle_bytes + bytes > MAX_IDLE_BYTES) {
+            return;
+        }
+
+        auto *bucket = this->find(desc);
+        if (bucket == nullptr) {
+            if (this->buckets.size() >= MAX_BUCKETS) {
+                return;
+            }
+
+            this->buckets.push_back(Bucket { desc.Width, desc.Height, desc.Format, {} });
+            bucket = &this->buckets.back();
+        }
+
+        if (bucket->idle.size() < MAX_IDLE_PER_BUCKET) {
+            bucket->idle.push_back(std::move(surface));
+            this->idle_bytes += bytes;
+        }
+    }
+
+    // every cached surface holds a reference on the device, so they have to go
+    // before it does or the device never reaches a zero reference count
+    void clear_device(IDirect3DDevice9 *device) {
+        std::lock_guard<std::mutex> lock(this->mutex);
+        if (this->device != device) {
+            return;
+        }
+
+        this->drop();
+        this->device = nullptr;
+    }
+
+private:
+    struct Bucket {
+        UINT width;
+        UINT height;
+        D3DFORMAT format;
+        std::vector<SurfacePtr> idle;
+    };
+
+    static constexpr size_t MAX_BUCKETS = GRAPHICS_CAPTURE_SCREEN_NO;
+
+    // one returning surface plus one for the next capture; a full screen surface
+    // is several megabytes, so the cap matters
+    static constexpr size_t MAX_IDLE_PER_BUCKET = 2;
+
+    // a 4K surface is 33MB, so the per bucket count alone does not bound this
+    static constexpr size_t MAX_IDLE_BYTES = 64u * 1024 * 1024;
+
+    void drop() {
+        this->buckets.clear();
+        this->idle_bytes = 0;
+    }
+
+    Bucket *find(const D3DSURFACE_DESC &desc) {
+        for (auto &bucket : this->buckets) {
+            if (bucket.width == desc.Width
+                    && bucket.height == desc.Height
+                    && bucket.format == desc.Format) {
+                return &bucket;
+            }
+        }
+
+        return nullptr;
+    }
+
+    std::mutex mutex;
+    std::vector<Bucket> buckets;
+    IDirect3DDevice9 *device = nullptr;
+    size_t idle_bytes = 0;
+};
+
+// deliberately never destroyed: releasing D3D surfaces during static destruction
+// would run after d3d9 may already be unloaded
+ReadbackPool &pool() {
+    static ReadbackPool *instance = new ReadbackPool();
+    return *instance;
+}
+
+} // namespace
+
+void release_device_resources(IDirect3DDevice9 *device) {
+    pool().clear_device(device);
+}
+
+BackbufferCopy::~BackbufferCopy() {
+    if (this->pooled && this->surface) {
+        pool().release(this->device, std::move(this->surface));
+    }
+}
+
+std::optional<BackbufferCopy> acquire_backbuffer_copy(
+        IDirect3DDevice9 *device, IDirect3DSwapChain9 *swap_chain, int screen, bool pooled) {
+
+    IDirect3DSurface9 *buffer = nullptr;
+    HRESULT hr = swap_chain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &buffer);
+    if (FAILED(hr) || buffer == nullptr) {
+        log_warning("graphics::d3d9",
+                "failed to get back buffer for screen {}, hr={}",
+                screen,
+                FMT_HRESULT(hr));
+        return std::nullopt;
+    }
+
+    D3DSURFACE_DESC desc {};
+    hr = buffer->GetDesc(&desc);
+    if (FAILED(hr)) {
+        log_warning("graphics::d3d9",
+                "failed to acquire back buffer descriptor, hr={}",
+                FMT_HRESULT(hr));
+        buffer->Release();
+        return std::nullopt;
+    }
+
+    // GetRenderTargetData rejects multisampled sources. no supported game has been
+    // seen presenting one, so resolving is left unimplemented rather than untested
+    if (desc.MultiSampleType != D3DMULTISAMPLE_NONE) {
+        static std::once_flag warned;
+        std::call_once(warned, [&desc] {
+            log_warning("graphics::d3d9",
+                    "back buffer is multisampled ({}), screenshots and capture are unsupported",
+                    static_cast<uint32_t>(desc.MultiSampleType));
+        });
+        buffer->Release();
+        return std::nullopt;
+    }
+
+    auto destination = pooled
+            ? pool().acquire(device, desc)
+            : create_readback_surface(device, desc);
+    if (!destination) {
+        buffer->Release();
+        return std::nullopt;
+    }
+
+    hr = device->GetRenderTargetData(buffer, destination.get());
+    buffer->Release();
+
+    if (FAILED(hr)) {
+        log_warning("graphics::d3d9",
+                "failed to copy back buffer contents, hr={}",
+                FMT_HRESULT(hr));
+        if (pooled) {
+            pool().release(device, std::move(destination));
+        }
+        return std::nullopt;
+    }
+
+    BackbufferCopy copy;
+    copy.screen = screen;
+    copy.desc = desc;
+    copy.device = device;
+    copy.surface = std::move(destination);
+    copy.pooled = pooled;
+
+    return copy;
+}
+}

src/spice2x/hooks/graphics/backends/d3d9/d3d9_readback.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+
+#include <d3d9.h>
+
+namespace d3d9_readback {
+
+    struct SurfaceReleaser {
+        void operator()(IDirect3DSurface9 *surface) const {
+            surface->Release();
+        }
+    };
+
+    using SurfacePtr = std::unique_ptr<IDirect3DSurface9, SurfaceReleaser>;
+
+    // system memory copy of a back buffer; locking it neither stalls the GPU nor reads over PCIe
+    struct BackbufferCopy {
+        int screen {};
+        D3DSURFACE_DESC desc {};
+        IDirect3DDevice9 *device = nullptr;
+        SurfacePtr surface;
+        bool pooled = false;
+
+        BackbufferCopy() = default;
+        BackbufferCopy(BackbufferCopy &&) noexcept = default;
+        BackbufferCopy &operator=(BackbufferCopy &&) noexcept = default;
+        BackbufferCopy(const BackbufferCopy &) = delete;
+        BackbufferCopy &operator=(const BackbufferCopy &) = delete;
+        ~BackbufferCopy();
+    };
+
+    // pooled copies reuse surfaces across calls and return them once the copy is destroyed,
+    // so the caller must keep it alive for as long as the pixels are being read
+    std::optional<BackbufferCopy> acquire_backbuffer_copy(
+            IDirect3DDevice9 *device,
+            IDirect3DSwapChain9 *swap_chain,
+            int screen,
+            bool pooled);
+
+    // pooled surfaces hold references on the device; call this before releasing it
+    void release_device_resources(IDirect3DDevice9 *device);
+}

src/spice2x/hooks/graphics/backends/d3d9/d3d9_screenshot.cpp

@@ -1,7 +1,10 @@
 #include "d3d9_screenshot.h"
 
 #include <cstdint>
+#include <cstring>
 #include <filesystem>
+#include <future>
+#include <limits>
 #include <memory>
 #include <mutex>
 #include <optional>
@@ -10,38 +13,21 @@
 #include <vector>
 
 #include <external/robin_hood.h>
-
-#ifdef __GNUC__
-#include <d3dx9tex.h>
-#endif
+#include <external/fpng/fpng.h>
 
 #include "avs/game.h"
 #include "hooks/graphics/graphics.h"
 #include "misc/clipboard.h"
 #include "overlay/notifications.h"
 #include "util/fileutils.h"
-#include "util/libutils.h"
 #include "util/logging.h"
 #include "util/threadpool.h"
 
 #include "d3d9_device.h"
+#include "d3d9_readback.h"
 
-#ifdef __GNUC__
-typedef decltype(D3DXSaveSurfaceToFileA) *D3DXSaveSurfaceToFileA_t;
-#else
-#define D3DXIFF_PNG ((DWORD) 3)
-
-typedef HRESULT (WINAPI *D3DXSaveSurfaceToFileA_t)(
-        LPCSTR pDestFile,
-        DWORD DestFormat,
-        LPDIRECT3DSURFACE9 pSrcSurface,
-        CONST PALETTEENTRY *pSrcPalette,
-        CONST RECT *pSrcRect);
-#endif
-
-static bool ATTEMPTED_D3DX9_LOAD_LIBRARY = false;
-
-// genpath picks free filenames by probing the disk, so only one save may run at a time
+// genpath picks filenames by probing the disk, so the whole save has to be serialised:
+// a name is only taken once its file exists, not when genpath hands it out
 static std::mutex SCREENSHOT_SAVE_M;
 
 namespace {
@@ -56,56 +42,146 @@ struct ImageRequest {
     int screen;
 };
 
-struct SurfaceReleaser {
-    void operator()(IDirect3DSurface9 *surface) const {
-        surface->Release();
-    }
-};
-
-using SurfacePtr = std::unique_ptr<IDirect3DSurface9, SurfaceReleaser>;
-
-struct BackbufferCopy {
+// a screen already read out of its surface, so nothing here touches D3D. the bytes
+// are still in the surface's format; converting them is left to the encode
+struct PendingWrite {
     int screen {};
-    D3DSURFACE_DESC desc {};
-    SurfacePtr surface;
+    D3DFORMAT format {};
+    UINT width {};
+    UINT height {};
+    size_t pitch {};
+    std::vector<uint8_t> data;
+    std::string path;
+    bool saved = false;
 };
 
-} // namespace
+struct PendingCapture {
+    int screen {};
+    D3DFORMAT format {};
+    UINT width {};
+    UINT height {};
+    size_t pitch {};
+    std::vector<uint8_t> data;
+};
 
-static void save_capture(
-        int screen,
+// packed 24bpp RGB, what both the png encoder and the api capture consume
+constexpr size_t RGB_PIXEL_SIZE = 3;
+
+// the formats surface_to_rgb knows how to convert; the two must stay in sync
+static std::optional<size_t> surface_pixel_size(D3DFORMAT format) {
+    switch (format) {
+        // what back buffers are actually created as in practice
+        case D3DFMT_X8R8G8B8:
+        case D3DFMT_A8R8G8B8:
+
+        // a valid display format, but no supported game has been seen presenting one
+        case D3DFMT_A2R10G10B10:
+            return 4;
+
+        // valid display formats, but no supported game has been seen presenting one
+        case D3DFMT_R5G6B5:
+        case D3DFMT_X1R5G5B5:
+        case D3DFMT_A1R5G5B5:
+            return 2;
+
+        default:
+            return std::nullopt;
+    }
+}
+
+struct ImageSize {
+    size_t row_size {};
+    size_t total_size {};
+};
+
+static std::optional<ImageSize> compute_image_size(
+        UINT width,
+        UINT height,
+        size_t bytes_per_pixel) {
+
+    if (width == 0 || height == 0
+            || width > std::numeric_limits<size_t>::max() / bytes_per_pixel) {
+        return std::nullopt;
+    }
+
+    const size_t row_size = static_cast<size_t>(width) * bytes_per_pixel;
+    if (height > std::numeric_limits<size_t>::max() / row_size) {
+        return std::nullopt;
+    }
+
+    return ImageSize { row_size, static_cast<size_t>(height) * row_size };
+}
+
+static bool resize_pixels(std::vector<uint8_t> &pixels, size_t size) {
+    try {
+        pixels.resize(size);
+        return true;
+    } catch (const std::exception &error) {
+        log_warning("graphics::d3d9", "failed to allocate image buffer: {}", error.what());
+        return false;
+    }
+}
+
+// the api capture stages a whole back buffer every frame, so the staging buffer
+// is recycled rather than reallocated. returned buffers keep their size, which
+// leaves the reuse free of a zero fill
+class CaptureBuffers {
+public:
+    std::vector<uint8_t> take() {
+        std::lock_guard<std::mutex> lock(this->mutex);
+        if (this->idle.empty()) {
+            return {};
+        }
+
+        auto buffer = std::move(this->idle.back());
+        this->idle.pop_back();
+        return buffer;
+    }
+
+    void give(std::vector<uint8_t> buffer) {
+        std::lock_guard<std::mutex> lock(this->mutex);
+        if (this->idle.size() < MAX_IDLE) {
+            this->idle.push_back(std::move(buffer));
+        }
+    }
+
+private:
+    // one per save in flight plus one for the next capture; a full screen is
+    // several megabytes, so the cap matters
+    static constexpr size_t MAX_IDLE = 2;
+
+    std::mutex mutex;
+    std::vector<std::vector<uint8_t>> idle;
+};
+
+// deliberately never destroyed, so a save still running at process exit cannot
+// hand a buffer back to a dead free list
+CaptureBuffers &capture_buffers() {
+    static CaptureBuffers *instance = new CaptureBuffers();
+    return *instance;
+}
+
+// encodes get their own pool: the dispatch below already occupies a worker on its
+// pool, so queueing onto that one and waiting could starve itself. never destroyed
+// for the same reason as the buffers above
+ThreadPool &encode_pool() {
+    static auto *instance = new ThreadPool(2);
+    return *instance;
+}
+
+// normalize the supported D3D formats to packed 24bpp RGB. callers screen the
+// format through surface_pixel_size first, so the black fill below is a fallback
+void surface_to_rgb(
         D3DFORMAT format,
         UINT width,
         UINT height,
-        IDirect3DSurface9 *surface) {
-    HRESULT hr;
+        const uint8_t *data,
+        size_t pitch,
+        uint8_t *pixels) {
 
-    // lock surface to be able to access the data
-    D3DLOCKED_RECT finished_copy {};
-    hr = surface->LockRect(&finished_copy, nullptr, 0);
-    if (FAILED(hr)) {
-        log_warning("graphics::d3d9", "failed to lock screenshot surface, hr={}", FMT_HRESULT(hr));
-        graphics_capture_skip(screen);
-        return;
-    }
-
-    // normalize supported D3D formats to packed RGB for API capture
-    size_t pitch = finished_copy.Pitch;
-    auto data = reinterpret_cast<uint8_t *>(finished_copy.pBits);
-    auto pixels = std::unique_ptr<uint8_t[]>(new uint8_t[width * height * 3]);
     for (size_t row = 0; row < height; row++) {
         size_t offset_row = row * width * 3;
         switch (format) {
-            case D3DFMT_R8G8B8: {
-                for (size_t column = 0; column < width; column++) {
-                    auto cell = data + row * pitch + column * 3;
-                    auto pixel = &pixels[offset_row + column * 3];
-                    pixel[0] = cell[0];
-                    pixel[1] = cell[1];
-                    pixel[2] = cell[2];
-                }
-                break;
-            }
             case D3DFMT_X8R8G8B8:
             case D3DFMT_A8R8G8B8: {
                 for (size_t column = 0; column < width; column++) {
@@ -117,14 +193,45 @@ static void save_capture(
                 }
                 break;
             }
-            case D3DFMT_X8B8G8R8:
-            case D3DFMT_A8B8G8R8: {
+            // the 5 and 6 bit channels are widened by bit replication so that
+            // full scale stays full scale
+            case D3DFMT_R5G6B5: {
+                auto cells = reinterpret_cast<const uint16_t *>(data + row * pitch);
                 for (size_t column = 0; column < width; column++) {
-                    auto cell = data + row * pitch + column * 4;
+                    const uint16_t cell = cells[column];
+                    const uint8_t red = (cell >> 11) & 0x1F;
+                    const uint8_t green = (cell >> 5) & 0x3F;
+                    const uint8_t blue = cell & 0x1F;
                     auto pixel = &pixels[offset_row + column * 3];
-                    pixel[0] = cell[0];
-                    pixel[1] = cell[1];
-                    pixel[2] = cell[2];
+                    pixel[0] = (red << 3) | (red >> 2);
+                    pixel[1] = (green << 2) | (green >> 4);
+                    pixel[2] = (blue << 3) | (blue >> 2);
+                }
+                break;
+            }
+            case D3DFMT_X1R5G5B5:
+            case D3DFMT_A1R5G5B5: {
+                auto cells = reinterpret_cast<const uint16_t *>(data + row * pitch);
+                for (size_t column = 0; column < width; column++) {
+                    const uint16_t cell = cells[column];
+                    const uint8_t red = (cell >> 10) & 0x1F;
+                    const uint8_t green = (cell >> 5) & 0x1F;
+                    const uint8_t blue = cell & 0x1F;
+                    auto pixel = &pixels[offset_row + column * 3];
+                    pixel[0] = (red << 3) | (red >> 2);
+                    pixel[1] = (green << 3) | (green >> 2);
+                    pixel[2] = (blue << 3) | (blue >> 2);
+                }
+                break;
+            }
+            case D3DFMT_A2R10G10B10: {
+                auto cells = reinterpret_cast<const uint32_t *>(data + row * pitch);
+                for (size_t column = 0; column < width; column++) {
+                    const uint32_t cell = cells[column];
+                    auto pixel = &pixels[offset_row + column * 3];
+                    pixel[0] = static_cast<uint8_t>((cell >> 22) & 0xFF);
+                    pixel[1] = static_cast<uint8_t>((cell >> 12) & 0xFF);
+                    pixel[2] = static_cast<uint8_t>((cell >> 2) & 0xFF);
                 }
                 break;
             }
@@ -138,99 +245,148 @@ static void save_capture(
             }
         }
     }
+}
 
-    // unlock surface
-    hr = surface->UnlockRect();
-    if (FAILED(hr)) {
-        log_warning("graphics::d3d9", "failed to unlock screenshot surface, hr={}", FMT_HRESULT(hr));
-        graphics_capture_skip(screen);
+} // namespace
+
+using d3d9_readback::BackbufferCopy;
+
+static void save_capture(PendingCapture capture) {
+    const auto size = compute_image_size(capture.width, capture.height, RGB_PIXEL_SIZE);
+    if (!size.has_value()) {
+        capture_buffers().give(std::move(capture.data));
+        graphics_capture_skip(capture.screen);
         return;
     }
 
-    // enqueue
-    graphics_capture_enqueue(screen, pixels.release(), width, height);
+    auto pixels = std::unique_ptr<uint8_t[]>(new (std::nothrow) uint8_t[size->total_size]);
+    if (!pixels) {
+        log_warning("graphics::d3d9", "failed to allocate capture image buffer");
+        capture_buffers().give(std::move(capture.data));
+        graphics_capture_skip(capture.screen);
+        return;
+    }
+
+    // a format we cannot read still has to produce a frame, or api clients stall
+    if (capture.data.empty()) {
+        std::memset(pixels.get(), 0, size->total_size);
+    } else {
+        surface_to_rgb(
+                capture.format,
+                capture.width,
+                capture.height,
+                capture.data.data(),
+                capture.pitch,
+                pixels.get());
+
+        capture_buffers().give(std::move(capture.data));
+    }
+
+    graphics_capture_enqueue(capture.screen, pixels.release(), capture.width, capture.height);
 }
 
-static bool save_screenshot(
+enum class SurfaceRead {
+    Ok,
+    Unsupported,
+    Failed,
+};
+
+// copying the surface touches D3D, so it stays on the caller's thread. the bytes come
+// out in the surface's own format; converting them is plain memory work for later
+static SurfaceRead read_surface_raw(
+        const BackbufferCopy &copy,
+        size_t &row_size,
+        std::vector<uint8_t> &out) {
+
+    const auto bytes_per_pixel = surface_pixel_size(copy.desc.Format);
+    if (!bytes_per_pixel.has_value()) {
+        static std::once_flag warned;
+        std::call_once(warned, [&copy] {
+            log_warning("graphics::d3d9",
+                    "unsupported surface format {}",
+                    static_cast<uint32_t>(copy.desc.Format));
+        });
+        return SurfaceRead::Unsupported;
+    }
+
+    const auto size = compute_image_size(copy.desc.Width, copy.desc.Height, *bytes_per_pixel);
+    if (!size.has_value() || !resize_pixels(out, size->total_size)) {
+        return SurfaceRead::Failed;
+    }
+
+    D3DLOCKED_RECT locked {};
+    HRESULT hr = copy.surface->LockRect(&locked, nullptr, D3DLOCK_READONLY);
+    if (FAILED(hr)) {
+        log_warning("graphics::d3d9", "failed to lock capture surface, hr={}", FMT_HRESULT(hr));
+        return SurfaceRead::Failed;
+    }
+
+    if (locked.Pitch < 0 || static_cast<size_t>(locked.Pitch) < size->row_size) {
+        log_warning("graphics::d3d9", "capture surface has invalid pitch {}", locked.Pitch);
+        copy.surface->UnlockRect();
+        return SurfaceRead::Failed;
+    }
+
+    auto data = reinterpret_cast<const uint8_t *>(locked.pBits);
+    for (size_t row = 0; row < copy.desc.Height; row++) {
+        std::memcpy(
+                out.data() + row * size->row_size,
+                data + row * locked.Pitch,
+                size->row_size);
+    }
+
+    hr = copy.surface->UnlockRect();
+    if (FAILED(hr)) {
+        log_warning("graphics::d3d9", "failed to unlock capture surface, hr={}", FMT_HRESULT(hr));
+        return SurfaceRead::Failed;
+    }
+
+    row_size = size->row_size;
+    return SurfaceRead::Ok;
+}
+
+static bool read_capture_surface(
+        const BackbufferCopy &copy,
+        PendingCapture &capture) {
+
+    capture.screen = copy.screen;
+    capture.format = copy.desc.Format;
+    capture.width = copy.desc.Width;
+    capture.height = copy.desc.Height;
+
+    capture.data = capture_buffers().take();
+    const auto result = read_surface_raw(copy, capture.pitch, capture.data);
+    if (result == SurfaceRead::Ok) {
+        return true;
+    }
+
+    capture_buffers().give(std::move(capture.data));
+    capture.data.clear();
+
+    // a format we cannot read is reported as a black frame rather than nothing,
+    // so a client polling the api keeps getting responses
+    return result == SurfaceRead::Unsupported;
+}
+
+static bool write_screenshot_png(
         const std::string &file_path,
-        D3DFORMAT format,
         UINT width,
         UINT height,
-        IDirect3DSurface9 *surface) {
-    // 32-bit XRGB and ARGB surfaces use byte 3 as alpha; force opaque PNG output
-    if (format == D3DFMT_X8R8G8B8 || format == D3DFMT_A8R8G8B8 ||
-        format == D3DFMT_X8B8G8R8 || format == D3DFMT_A8B8G8R8) {
+        const std::vector<uint8_t> &pixels) {
 
-        D3DLOCKED_RECT finished_copy {};
-        HRESULT hr = surface->LockRect(&finished_copy, nullptr, 0);
-        if (FAILED(hr)) {
-            log_warning("graphics::d3d9", "failed to lock screenshot surface, hr={}", FMT_HRESULT(hr));
-            return false;
-        }
+    // a no-op while FPNG_NO_SSE is set, but fpng requires it before any encode
+    static std::once_flag fpng_ready;
+    std::call_once(fpng_ready, [] { fpng::fpng_init(); });
 
-        const size_t pitch = finished_copy.Pitch;
-        auto data = reinterpret_cast<uint8_t *>(finished_copy.pBits);
-        for (size_t row = 0; row < height; row++) {
-            for (size_t column = 0; column < width; column++) {
-                data[row * pitch + column * 4 + 3] = 255;
-            }
-        }
-
-        hr = surface->UnlockRect();
-        if (FAILED(hr)) {
-            log_warning("graphics::d3d9", "failed to unlock screenshot surface, hr={}", FMT_HRESULT(hr));
-            return false;
-        }
-    }
-
-    // lazy load function
-    static D3DXSaveSurfaceToFileA_t D3DXSaveSurfaceToFileA_ptr = nullptr;
-    if (D3DXSaveSurfaceToFileA_ptr == nullptr) {
-        D3DXSaveSurfaceToFileA_ptr = libutils::try_proc<D3DXSaveSurfaceToFileA_t>("D3DXSaveSurfaceToFileA");
-
-        // check if function was not found, likely because d3dx9 is not loaded
-        if (!ATTEMPTED_D3DX9_LOAD_LIBRARY && D3DXSaveSurfaceToFileA_ptr == nullptr) {
-            ATTEMPTED_D3DX9_LOAD_LIBRARY = true;
-
-            // prefer the newest installed helper while supporting older D3DX9 runtimes
-            for (size_t i = 43; i >= 24; i--) {
-                auto lib_name = fmt::format("d3dx9_{}.dll", i);
-                auto d3dx9 = libutils::try_library(lib_name);
-
-                // Check if library was not found
-                if (d3dx9 == nullptr) {
-                    continue;
-                }
-
-                D3DXSaveSurfaceToFileA_ptr = libutils::try_proc<D3DXSaveSurfaceToFileA_t>(
-                        d3dx9, "D3DXSaveSurfaceToFileA");
-
-                // Check if function was not found
-                if (D3DXSaveSurfaceToFileA_ptr == nullptr) {
-                    FreeLibrary(d3dx9);
-                    d3dx9 = nullptr;
-
-                    continue;
-                }
-
-                log_info("graphics::d3d9", "found surface save function in '{}'", lib_name);
-                break;
-            }
-        }
-    }
-
-    if (D3DXSaveSurfaceToFileA_ptr == nullptr) {
-        log_warning("graphics::d3d9", "Direct3D save helper function not available");
-        return false;
-    }
-
-    // save to file
     log_info("graphics::d3d9", "saving screenshot to {}", file_path);
-    const HRESULT save_result = D3DXSaveSurfaceToFileA_ptr(
-        file_path.c_str(), D3DXIFF_PNG, surface, nullptr, nullptr);
 
-    if (FAILED(save_result)) {
-        log_warning("graphics::d3d9", "Failed to save screenshot");
+    if (!fpng::fpng_encode_image_to_file(
+            file_path.c_str(),
+            pixels.data(),
+            static_cast<uint32_t>(width),
+            static_cast<uint32_t>(height),
+            3)) {
+        log_warning("graphics::d3d9", "failed to write screenshot png");
         return false;
     }
 
@@ -249,113 +405,139 @@ static std::string screenshot_path_for_screen(const std::string &primary_path, i
             .string();
 }
 
-static std::optional<BackbufferCopy> acquire_backbuffer_copy(
-    IDirect3DDevice9 *device, IDirect3DSwapChain9 *swap_chain, int screen) {
-
-    IDirect3DSurface9 *buffer = nullptr;
-    HRESULT hr = swap_chain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &buffer);
-    if (FAILED(hr) || buffer == nullptr) {
-        log_warning("graphics::d3d9",
-                "failed to get back buffer for screen {}, hr={}",
-                screen,
-                FMT_HRESULT(hr));
-        return std::nullopt;
-    }
-
-    D3DSURFACE_DESC desc {};
-    hr = buffer->GetDesc(&desc);
-    if (FAILED(hr)) {
-        log_warning("graphics::d3d9",
-                "failed to acquire back buffer descriptor, hr={}",
-                FMT_HRESULT(hr));
-        buffer->Release();
-        return std::nullopt;
-    }
-
-    // TODO: cache render targets
-    IDirect3DSurface9 *temp_surface = nullptr;
-    hr = device->CreateRenderTarget(
-            desc.Width, desc.Height, desc.Format, desc.MultiSampleType,
-            desc.MultiSampleQuality, TRUE, &temp_surface, nullptr);
-    if (FAILED(hr) || temp_surface == nullptr) {
-        log_warning("graphics::d3d9",
-                "failed to acquire temporary surface, hr={}",
-                FMT_HRESULT(hr));
-        buffer->Release();
-        return std::nullopt;
-    }
-
-    hr = device->StretchRect(buffer, nullptr, temp_surface, nullptr, D3DTEXF_NONE);
-    if (FAILED(hr)) {
-        log_warning("graphics::d3d9",
-                "failed to copy back buffer contents, hr={}",
-                FMT_HRESULT(hr));
-        temp_surface->Release();
-        buffer->Release();
-        return std::nullopt;
-    }
-
-    // release original back buffer reference
-    buffer->Release();
-
-    return BackbufferCopy {
-        .screen = screen,
-        .desc = desc,
-        .surface = SurfacePtr(temp_surface),
+// games that crash or hang when the screenshot processor runs on another thread.
+// D3DCREATE_MULTITHREADED is not a predictor of this; MDX omits it and threads fine
+static bool image_processing_must_be_inline() {
+    static const robin_hood::unordered_set<std::string> THREAD_BAN {
+            "JMA",
+#ifndef SPICE64
+            // KFC only crashes under threaded processing in 32-bit builds
+            "KFC",
+#endif
+            "KMA",
+            "KLP",
+            "LMA",
     };
+
+    return THREAD_BAN.contains(avs::game::MODEL);
 }
 
-static void dispatch_surface_save(
-        const ImageRequest &request,
-        std::vector<BackbufferCopy> copies,
-        size_t screen_count) {
-    auto surface_process = [request, screen_count, copies = std::move(copies)]() {
-        switch (request.kind) {
-            case ImageRequestKind::Capture: {
-                const auto &copy = copies.front();
-                save_capture(
-                        request.screen,
-                        copy.desc.Format,
-                        copy.desc.Width,
-                        copy.desc.Height,
-                        copy.surface.get());
-                break;
+static void dispatch_capture_save(PendingCapture capture) {
+    auto capture_process = [capture = std::move(capture)]() mutable {
+        // an escape from here would cross a thread boundary and terminate
+        try {
+            save_capture(std::move(capture));
+        } catch (const std::exception &error) {
+            log_warning("graphics::d3d9", "capture save failed: {}", error.what());
+        } catch (...) {
+            log_warning("graphics::d3d9", "capture save failed");
         }
+    };
 
-            case ImageRequestKind::Screenshot: {
+    if (image_processing_must_be_inline()) {
+        capture_process();
+    } else {
+        static auto pool = ThreadPool(2);
+        pool.add(std::move(capture_process));
+    }
+}
+
+// by this point the pixels are plain memory, so none of this needs the device
+static void dispatch_screenshot_save(std::vector<PendingWrite> writes, size_t screen_count) {
+    auto screenshot_process = [writes = std::move(writes), screen_count]() mutable {
         std::lock_guard<std::mutex> lock(SCREENSHOT_SAVE_M);
 
         std::vector<int> screens;
-                screens.reserve(copies.size());
-                for (const auto &copy : copies) {
-                    screens.push_back(copy.screen);
+        screens.reserve(writes.size());
+        for (const auto &write : writes) {
+            screens.push_back(write.screen);
         }
 
         const auto base_path = graphics_screenshot_genpath(screens);
         if (base_path.empty()) {
-                    break;
+            return;
+        }
+
+        for (auto &write : writes) {
+            write.path = screenshot_path_for_screen(base_path, write.screen);
+        }
+
+        // screens missing from writes either failed to be acquired or failed to read
+        size_t failed = screen_count - writes.size();
+
+        // a throw here would otherwise reach a thread boundary and terminate
+        auto encode_one = [](PendingWrite &write) {
+            try {
+                const auto rgb = compute_image_size(write.width, write.height, RGB_PIXEL_SIZE);
+                std::vector<uint8_t> pixels;
+                if (!rgb.has_value() || !resize_pixels(pixels, rgb->total_size)) {
+                    write.saved = false;
+                    return;
+                }
+
+                surface_to_rgb(
+                        write.format,
+                        write.width,
+                        write.height,
+                        write.data.data(),
+                        write.pitch,
+                        pixels.data());
+
+                // the encode below is the long part; the raw copy is dead by now
+                write.data.clear();
+                write.data.shrink_to_fit();
+
+                write.saved = write_screenshot_png(
+                        write.path, write.width, write.height, pixels);
+            } catch (const std::exception &error) {
+                log_warning("graphics::d3d9",
+                        "screenshot encode failed for {}: {}", write.path, error.what());
+                write.saved = false;
+            } catch (...) {
+                log_warning("graphics::d3d9",
+                        "screenshot encode failed for {}", write.path);
+                write.saved = false;
+            }
+        };
+
+        {
+            // sized up front and assigned by index: storing a future must not be able
+            // to throw once its task is queued, or the screen would encode twice
+            std::vector<std::future<void>> pending(writes.empty() ? 0 : writes.size() - 1);
+            for (size_t i = 1; i < writes.size(); i++) {
+                try {
+                    pending[i - 1] = encode_pool().add([&writes, &encode_one, i] {
+                        encode_one(writes[i]);
+                    });
+                } catch (const std::exception &) {
+                    // nothing to queue onto; encoding it here still makes progress
+                    encode_one(writes[i]);
+                }
+            }
+
+            if (!writes.empty()) {
+                encode_one(writes.front());
+            }
+
+            for (auto &task : pending) {
+                if (task.valid()) {
+                    task.wait();
+                }
+            }
         }
 
-                // screens missing from copies already failed to be acquired
-                size_t failed = screen_count - copies.size();
         std::string primary_path;
         std::string notify_path;
-                for (const auto &copy : copies) {
-                    const auto path = screenshot_path_for_screen(base_path, copy.screen);
-                    if (!save_screenshot(
-                            path,
-                            copy.desc.Format,
-                            copy.desc.Width,
-                            copy.desc.Height,
-                            copy.surface.get())) {
+        for (const auto &write : writes) {
+            if (!write.saved) {
                 failed++;
                 continue;
             }
             if (notify_path.empty()) {
-                        notify_path = path;
+                notify_path = write.path;
             }
-                    if (copy.screen == 0) {
-                        primary_path = path;
+            if (write.screen == 0) {
+                primary_path = write.path;
             }
         }
 
@@ -376,29 +558,25 @@ static void dispatch_surface_save(
         if (failed > 0) {
             log_warning("graphics::d3d9", "{} screenshot screen(s) missing", failed);
         }
-                break;
-            }
+    };
+
+    // genpath and the path building below allocate, so an escape from here would
+    // cross a thread boundary and terminate
+    auto guarded = [process = std::move(screenshot_process)]() mutable {
+        try {
+            process();
+        } catch (const std::exception &error) {
+            log_warning("graphics::d3d9", "screenshot save failed: {}", error.what());
+        } catch (...) {
+            log_warning("graphics::d3d9", "screenshot save failed");
         }
     };
 
-    // list of games that crash when running the screenshot processor on another thread
-    static const robin_hood::unordered_set<std::string> THREAD_BAN {
-            "JMA",
-#ifndef SPICE64
-            // KFC only crashes under threaded processing in 32-bit builds
-            "KFC",
-#endif
-            "KMA",
-            "KLP",
-            "LMA",
-    };
-
-    // run the save operation on another thread for supported games
-    if (THREAD_BAN.contains(avs::game::MODEL)) {
-        surface_process();
+    if (image_processing_must_be_inline()) {
+        guarded();
     } else {
         static auto pool = ThreadPool(2);
-        pool.add(std::move(surface_process));
+        pool.add(std::move(guarded));
     }
 }
 
@@ -427,7 +605,8 @@ static void process_image_request(
                     screen,
                     FMT_HRESULT(hr));
         } else {
-            copy = acquire_backbuffer_copy(device, swap_chain, screen);
+            // only the API capture path runs often enough to benefit from pooling
+            copy = d3d9_readback::acquire_backbuffer_copy(device, swap_chain, screen, !screenshot);
             swap_chain->Release();
         }
 
@@ -443,7 +622,39 @@ static void process_image_request(
         return;
     }
 
-    dispatch_surface_save(request, std::move(copies), screens.size());
+    if (!screenshot) {
+        PendingCapture capture;
+        if (!read_capture_surface(copies.front(), capture)) {
+            graphics_capture_skip(request.screen);
+            return;
+        }
+
+        copies.clear();
+        dispatch_capture_save(std::move(capture));
+        return;
+    }
+
+    // reading a surface touches the device, and doing that off the present thread
+    // has been seen to deadlock games whose device has no internal locking
+    std::vector<PendingWrite> writes;
+    writes.reserve(copies.size());
+    for (const auto &copy : copies) {
+        PendingWrite write;
+        write.screen = copy.screen;
+        write.format = copy.desc.Format;
+        write.width = copy.desc.Width;
+        write.height = copy.desc.Height;
+
+        if (read_surface_raw(copy, write.pitch, write.data) != SurfaceRead::Ok) {
+            continue;
+        }
+
+        writes.push_back(std::move(write));
+    }
+
+    copies.clear();
+
+    dispatch_screenshot_save(std::move(writes), screens.size());
 }
 
 void graphics_d3d9_process_screenshot(

src/spice2x/hooks/graphics/graphics.cpp

@@ -20,6 +20,7 @@
 #include "games/io.h"
 #include "games/sdvx/sdvx.h"
 #include "games/popn/popn.h"
+#include "hooks/graphics/jpeg_encoder.h"
 #include "hooks/graphics/backends/d3d9/d3d9_backend.h"
 #include "hooks/graphics/backends/d3d11/d3d11_backend.h"
 #include "launcher/shutdown.h"
@@ -64,7 +65,6 @@ static bool GRAPHICS_SCREENSHOT_TRIGGER = false;
 static std::set<int> GRAPHICS_SCREENS { 0 };
 static std::mutex GRAPHICS_SCREENS_M {};
 static std::vector<int> GRAPHICS_CAPTURE_SCREENS;
-static const size_t GRAPHICS_CAPTURE_SCREEN_NO = 4;
 static std::mutex GRAPHICS_CAPTURE_SCREENS_M {};
 static CaptureData GRAPHICS_CAPTURE_BUFFER[GRAPHICS_CAPTURE_SCREEN_NO] {};
 static std::mutex GRAPHICS_CAPTURE_BUFFER_M[GRAPHICS_CAPTURE_SCREEN_NO] {};
@@ -1481,10 +1481,12 @@ void graphics_capture_skip(int screen) {
     GRAPHICS_CAPTURE_CV[screen].notify_one();
 }
 
-bool graphics_capture_receive_jpeg(int screen, TooJpeg::WRITE_ONE_BYTE receiver,
-        bool rgb, int quality, bool downsample, int divide, uint64_t *timestamp,
+bool graphics_capture_receive_raw(int screen, std::shared_ptr<uint8_t[]> &out,
+        int divide, uint64_t *timestamp,
         int *width, int *height) {
 
+    out = nullptr;
+
     if (screen < 0 || screen >= static_cast<int>(GRAPHICS_CAPTURE_SCREEN_NO)) {
         return false;
     }
@@ -1556,11 +1558,7 @@ bool graphics_capture_receive_jpeg(int screen, TooJpeg::WRITE_ONE_BYTE receiver,
         capture_height = height_new;
     }
 
-    // compress
-    auto success = TooJpeg::writeJpeg(
-            receiver, capture_data.get(),
-            capture_width, capture_height,
-            rgb, quality, downsample);
+    out = std::move(capture_data);
 
     // status
     if (timestamp) {
@@ -1573,6 +1571,40 @@ bool graphics_capture_receive_jpeg(int screen, TooJpeg::WRITE_ONE_BYTE receiver,
         *height = capture_height;
     }
 
+    return true;
+}
+
+bool graphics_capture_receive_jpeg(int screen, std::vector<uint8_t> &out,
+        int quality, int divide, uint64_t *timestamp,
+        int *width, int *height) {
+
+    out.clear();
+
+    std::shared_ptr<uint8_t[]> pixels;
+    int capture_width = 0;
+    int capture_height = 0;
+    if (!graphics_capture_receive_raw(
+            screen, pixels, divide, timestamp, &capture_width, &capture_height)) {
+        return false;
+    }
+
+    // compress
+    const bool success = jpeg_encoder::encode(
+            out, pixels.get(),
+            capture_width, capture_height, quality);
+
+    if (!success) {
+        out.clear();
+    }
+
+    // status
+    if (width) {
+        *width = capture_width;
+    }
+    if (height) {
+        *height = capture_height;
+    }
+
     // clean up
     return success;
 }

src/spice2x/hooks/graphics/graphics.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <atomic>
+#include <memory>
 #include <string>
 #include <vector>
 #include <optional>
@@ -12,8 +13,6 @@
 #include <dwmapi.h>
 #endif
 
-#include "external/toojpeg/toojpeg.h"
-
 // order must match spice2x_AutoOrientation UI enum order
 enum graphics_orientation {
     ORIENTATION_CW = 0,
@@ -140,12 +139,21 @@ void graphics_screens_get(std::vector<int> &screens);
 void graphics_poll_screenshot_hotkey();
 void graphics_screenshot_trigger();
 bool graphics_screenshot_consume();
+
+inline constexpr size_t GRAPHICS_CAPTURE_SCREEN_NO = 4;
+
 void graphics_capture_trigger(int screen);
 bool graphics_capture_consume(int *screen);
 void graphics_capture_enqueue(int screen, uint8_t *data, size_t width, size_t height);
 void graphics_capture_skip(int screen);
-bool graphics_capture_receive_jpeg(int screen, TooJpeg::WRITE_ONE_BYTE receiver,
-        bool rgb = true, int quality = 80, bool downsample = true, int divide = 0,
+// on success `out` owns packed 24bpp RGB pixels, width * height * 3 bytes
+bool graphics_capture_receive_raw(int screen, std::shared_ptr<uint8_t[]> &out,
+        int divide = 0,
+        uint64_t *timestamp = nullptr,
+        int *width = nullptr, int *height = nullptr);
+// on success `out` holds the encoded JPEG; its storage is reused across calls
+bool graphics_capture_receive_jpeg(int screen, std::vector<uint8_t> &out,
+        int quality = 80, int divide = 0,
         uint64_t *timestamp = nullptr,
         int *width = nullptr, int *height = nullptr);
 // the returned path is for screen 0; any extra screens only reserve their suffixed names

src/spice2x/hooks/graphics/jpeg_encoder.cpp

@@ -0,0 +1,156 @@
+#include "jpeg_encoder.h"
+
+#ifdef SPICE_JPEG
+
+#include <csetjmp>
+#include <cstdio>
+
+#include <jpeglib.h>
+
+namespace jpeg_encoder {
+
+namespace {
+
+constexpr size_t CHUNK_SIZE = 16 * 1024;
+
+// libjpeg writes through a destination manager; this one appends straight into
+// the caller's vector so the encoded frame is never copied
+struct VectorDestination {
+    jpeg_destination_mgr mgr {};
+    std::vector<uint8_t> *out = nullptr;
+    uint8_t chunk[CHUNK_SIZE] {};
+};
+
+void dest_init(j_compress_ptr cinfo) {
+    auto dest = reinterpret_cast<VectorDestination *>(cinfo->dest);
+    dest->mgr.next_output_byte = dest->chunk;
+    dest->mgr.free_in_buffer = CHUNK_SIZE;
+}
+
+// libjpeg cannot unwind a C++ exception out of its own frames, so growing the
+// output has to fail by value and be turned into an error_exit by the caller
+bool dest_append(VectorDestination *dest, size_t size) {
+    try {
+        dest->out->insert(dest->out->end(), dest->chunk, dest->chunk + size);
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+boolean dest_empty(j_compress_ptr cinfo) {
+    auto dest = reinterpret_cast<VectorDestination *>(cinfo->dest);
+
+    // returning FALSE would mean suspension to libjpeg, not failure
+    if (!dest_append(dest, CHUNK_SIZE)) {
+        (*cinfo->err->error_exit)(reinterpret_cast<j_common_ptr>(cinfo));
+    }
+
+    dest->mgr.next_output_byte = dest->chunk;
+    dest->mgr.free_in_buffer = CHUNK_SIZE;
+    return TRUE;
+}
+
+void dest_term(j_compress_ptr cinfo) {
+    auto dest = reinterpret_cast<VectorDestination *>(cinfo->dest);
+    if (!dest_append(dest, CHUNK_SIZE - dest->mgr.free_in_buffer)) {
+        (*cinfo->err->error_exit)(reinterpret_cast<j_common_ptr>(cinfo));
+    }
+}
+
+// the default handler calls exit(), which is not an option inside a game process
+struct ErrorManager {
+    jpeg_error_mgr mgr {};
+    jmp_buf escape {};
+};
+
+void on_error(j_common_ptr cinfo) {
+    longjmp(reinterpret_cast<ErrorManager *>(cinfo->err)->escape, 1);
+}
+
+void on_message(j_common_ptr) {
+}
+
+} // namespace
+
+bool encode(
+        std::vector<uint8_t> &out,
+        const uint8_t *pixels,
+        int width,
+        int height,
+        int quality) {
+
+    if (!pixels || width <= 0 || height <= 0) {
+        return false;
+    }
+
+    if (quality < 1) {
+        quality = 1;
+    } else if (quality > 100) {
+        quality = 100;
+    }
+
+    // zero init is load bearing: the trap below is armed before the struct is
+    // created, and jpeg_destroy_compress only tolerates that on a zeroed struct
+    jpeg_compress_struct cinfo {};
+    ErrorManager err;
+    VectorDestination dest;
+
+    cinfo.err = jpeg_std_error(&err.mgr);
+    err.mgr.error_exit = on_error;
+    err.mgr.output_message = on_message;
+
+    if (setjmp(err.escape)) {
+        jpeg_destroy_compress(&cinfo);
+        return false;
+    }
+
+    jpeg_create_compress(&cinfo);
+
+    dest.out = &out;
+    dest.mgr.init_destination = dest_init;
+    dest.mgr.empty_output_buffer = dest_empty;
+    dest.mgr.term_destination = dest_term;
+    cinfo.dest = &dest.mgr;
+
+    cinfo.image_width = static_cast<JDIMENSION>(width);
+    cinfo.image_height = static_cast<JDIMENSION>(height);
+    cinfo.in_color_space = JCS_RGB;
+    cinfo.input_components = 3;
+
+    jpeg_set_defaults(&cinfo);
+    jpeg_set_quality(&cinfo, quality, TRUE);
+
+    // 4:2:0, matching what the capture path asked the previous encoder for
+    cinfo.comp_info[0].h_samp_factor = 2;
+    cinfo.comp_info[0].v_samp_factor = 2;
+
+    jpeg_start_compress(&cinfo, TRUE);
+
+    const size_t pitch = static_cast<size_t>(width) * 3;
+    while (cinfo.next_scanline < cinfo.image_height) {
+        auto row = const_cast<uint8_t *>(pixels + cinfo.next_scanline * pitch);
+        JSAMPROW rows[1] = { row };
+        jpeg_write_scanlines(&cinfo, rows, 1);
+    }
+
+    jpeg_finish_compress(&cinfo);
+    jpeg_destroy_compress(&cinfo);
+
+    return true;
+}
+}
+
+#else // SPICE_JPEG
+
+namespace jpeg_encoder {
+
+// builds without libjpeg-turbo (the WinXP toolchains) simply cannot encode;
+// callers already treat a false return as "no frame available"
+bool encode(std::vector<uint8_t> &out, const uint8_t *, int, int, int) {
+    out.clear();
+    return false;
+}
+}
+
+#endif // SPICE_JPEG

src/spice2x/hooks/graphics/jpeg_encoder.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+namespace jpeg_encoder {
+
+    // appends a baseline 4:2:0 JPEG of packed 24bpp RGB pixels to `out`
+    bool encode(
+            std::vector<uint8_t> &out,
+            const uint8_t *pixels,
+            int width,
+            int height,
+            int quality);
+}

src/spice2x/launcher/launcher.cpp

@@ -14,6 +14,7 @@
 #include "acio/icca/icca.h"
 #include "acio/mdxf/mdxf.h"
 #include "api/controller.h"
+#include "api/stream_server.h"
 #include "avs/automap.h"
 #include "avs/core.h"
 #include "avs/ea3.h"
@@ -150,6 +151,7 @@ std::string CARD_OVERRIDES[2];
 
 // sub-systems
 std::unique_ptr<api::Controller> API_CONTROLLER;
+std::unique_ptr<api::StreamServer> API_STREAM_SERVER;
 std::unique_ptr<rawinput::RawInputManager> RI_MGR;
 
 // trigger NVIDIA Optimus & AMD Enduro High Performance Graphics
@@ -198,6 +200,7 @@ int main_implementation(int argc, char *argv[]) {
     bool api_pretty = false;
     bool api_debug = false;
     unsigned short api_port = 1337;
+    bool api_stream_enable = false;
     std::string api_pass = "";
     std::vector<std::string> api_serial_port;
     std::vector<DWORD> api_serial_baud;
@@ -1032,6 +1035,9 @@ int main_implementation(int argc, char *argv[]) {
     if (options[launcher::Options::APIScreenMirrorDivide].is_active()) {
         api::modules::CAPTURE_DIVIDE = options[launcher::Options::APIScreenMirrorDivide].value_uint32();
     }
+    if (options[launcher::Options::APIStreamEnable].value_bool() && !cfg::CONFIGURATOR_STANDALONE) {
+        api_stream_enable = true;
+    }
 
     if (options[launcher::Options::DisableDebugHooks].value_bool()) {
         debughook::DEBUGHOOK_LOGGING = false;
@@ -1683,6 +1689,26 @@ int main_implementation(int argc, char *argv[]) {
             });
     }
 
+    if (options[launcher::Options::PathToModules].is_active() && !cfg::CONFIGURATOR_STANDALONE) {
+        log_warning(
+            "launcher",
+            "WARNING - user specified -modules option\n\n\n"
+            "!!!                                                             !!!\n"
+            "!!! Using -modules changes which game DLLs get loaded!          !!!\n"
+            "!!! Unless you know exactly what you are doing, clear -modules  !!!\n"
+            "!!!   and try again; usually this is accidentally set by users  !!!\n"
+            "!!!   without understanding the implications.                   !!!\n"
+            "!!!                                                             !!!\n"
+            );
+        deferredlogs::defer_error_messages({
+            "-modules option specified by user",
+            "    game DLLs and patches are loaded from that folder instead of the spice folder,",
+            "    and it is also prepended to the DLL search path, so dependencies may resolve to",
+            "    unexpected copies; instead, clear -modules option and place spice binaries in",
+            "    the intended game directory",
+            });
+    }
+
     if (launcher::signal::DISABLE && !cfg::CONFIGURATOR_STANDALONE) {
         log_warning(
             "launcher",
@@ -2711,6 +2737,20 @@ int main_implementation(int argc, char *argv[]) {
     for (size_t i = 0; i < std::min(api_serial_port.size(), api_serial_baud.size()); i++) {
         API_CONTROLLER->listen_serial(api_serial_port[i], api_serial_baud[i]);
     }
+    // the websocket already sits on the API port plus one, so the stream takes plus two
+    if (api_stream_enable) {
+        if (!api_enable) {
+            log_fatal("launcher", "video stream requires API port to be set (-api)");
+        } else if (api_port + 2 > 65535) {
+            log_fatal(
+                "launcher",
+                "ignoring the video stream, API port {} leaves no room for port plus two",
+                api_port);
+        } else {
+            API_STREAM_SERVER = std::make_unique<api::StreamServer>(
+                    static_cast<unsigned short>(api_port + 2));
+        }
+    }
 
     // pin macro
     if (!cfg::CONFIGURATOR_STANDALONE && PIN_MACRO_ENABLED) {
@@ -2799,6 +2839,7 @@ int main_implementation(int argc, char *argv[]) {
     }
 
     // free api controller
+    API_STREAM_SERVER.reset();
     API_CONTROLLER.reset();
 
     eamuse_pin_macro_stop_thread();

src/spice2x/launcher/logger.cpp

@@ -1,6 +1,7 @@
 #include "logger.h"
 
 #include <algorithm>
+#include <atomic>
 #include <condition_variable>
 #include <mutex>
 #include <thread>
@@ -25,13 +26,16 @@ namespace logger {
     bool COLOR = true;
 
     // state
-    static bool RUNNING = false;
+    static std::atomic<bool> RUNNING = false;
     static WORD DEFAULT_ATTRIBUTES = 0;
     static std::mutex EVENT_MUTEX;
     static std::condition_variable EVENT_CV;
     static std::thread *THREAD = nullptr;
+    static HANDLE THREAD_FINISHED = nullptr;
+    static std::atomic<bool> THREAD_ABANDONED = false;
     static std::mutex OUTPUT_MUTEX;
-    static bool OUTPUT_BUFFER_HOT = false;
+    static std::mutex FLUSH_MUTEX;
+    static std::atomic<bool> OUTPUT_BUFFER_HOT = false;
     static std::vector<std::pair<std::string, Style>> OUTPUT_BUFFER1;
     static std::vector<std::pair<std::string, Style>> OUTPUT_BUFFER2;
     static std::vector<std::pair<std::string, Style>> *OUTPUT_BUFFER = &OUTPUT_BUFFER1;
@@ -71,7 +75,9 @@ namespace logger {
         SetConsoleTextAttribute(hTerminal, info.wAttributes);
     }
 
-    static void output_buffer_flush() {
+    // the buffer is swapped under OUTPUT_MUTEX but drained outside of it, so two concurrent
+    // drains would leave one of them iterating a buffer that push() has started appending to
+    static void output_buffer_flush_locked() {
 
         // get buffer and swap
         auto buffer = output_buffer_swap();
@@ -142,6 +148,23 @@ namespace logger {
         }
     }
 
+    static void output_buffer_flush() {
+
+        // a detached logging thread can hold FLUSH_MUTEX forever, so never wait on it
+        if (THREAD_ABANDONED) {
+            std::unique_lock<std::mutex> guard(FLUSH_MUTEX, std::try_to_lock);
+            if (guard.owns_lock()) {
+                output_buffer_flush_locked();
+            }
+
+            return;
+        }
+
+        std::lock_guard<std::mutex> guard(FLUSH_MUTEX);
+
+        output_buffer_flush_locked();
+    }
+
     void start() {
 
         // don't start if blocking
@@ -151,6 +174,7 @@ namespace logger {
 
         // start logging thread
         RUNNING = true;
+        THREAD_FINISHED = CreateEvent(nullptr, TRUE, FALSE, nullptr);
         THREAD = new std::thread([] {
             std::unique_lock<std::mutex> lock(EVENT_MUTEX);
 
@@ -160,7 +184,7 @@ namespace logger {
             while (RUNNING) {
 
                 // wait for hot buffer
-                EVENT_CV.wait(lock, [] { return OUTPUT_BUFFER_HOT; });
+                EVENT_CV.wait(lock, [] { return OUTPUT_BUFFER_HOT.load(); });
                 OUTPUT_BUFFER_HOT = false;
 
                 // flush buffer
@@ -180,22 +204,51 @@ namespace logger {
                 HANDLE hTerminal = GetStdHandle(STD_OUTPUT_HANDLE);
                 SetConsoleTextAttribute(hTerminal, DEFAULT_ATTRIBUTES);
             }
+
+            if (THREAD_FINISHED) {
+                SetEvent(THREAD_FINISHED);
+            }
         });
     }
 
     void stop() {
-        log_info("logger", "stop");
+
+        // NOTE: don't log to the logger here!
+
+        RUNNING = false;
 
         // clean up thread if required
-        RUNNING = false;
         if (THREAD) {
 
             // fake notify to exit wait loop
             OUTPUT_BUFFER_HOT = true;
             EVENT_CV.notify_all();
 
-            // join and clean up
+            // never block forever - this also runs on the fatal/crash path, where the logging
+            // thread may be suspended or wedged and would take the whole process down with it
+            const bool finished = THREAD_FINISHED != nullptr &&
+                    WaitForSingleObject(THREAD_FINISHED, 1000) == WAIT_OBJECT_0;
+
+            if (finished) {
                 THREAD->join();
+
+                CloseHandle(THREAD_FINISHED);
+                THREAD_FINISHED = nullptr;
+            } else {
+                THREAD->detach();
+                THREAD_ABANDONED = true;
+
+                // THREAD_FINISHED is leaked on purpose: the detached thread can still wake up and
+                // signal it, and closing it here risks signaling an unrelated recycled handle
+
+                // write out whatever the logging thread never got to
+                output_buffer_flush();
+
+                if (LOG_FILE && LOG_FILE != INVALID_HANDLE_VALUE) {
+                    FlushFileBuffers(LOG_FILE);
+                }
+            }
+
             delete THREAD;
             THREAD = nullptr;
         }
@@ -229,17 +282,14 @@ namespace logger {
         // check if blocking or the logging thread is not running
         if (BLOCKING || !RUNNING) {
 
-            // blocking guard
-            static std::mutex blocking_lock;
-            std::lock_guard<std::mutex> blocking_guard(blocking_lock);
-
             // immediately process logs
             output_buffer_flush();
 
         } else {
 
-            // mark buffer as hot
-            std::unique_lock<std::mutex> lock(EVENT_MUTEX);
+            // never block here - the logging thread can be suspended while holding EVENT_MUTEX,
+            // and it re-checks OUTPUT_BUFFER_HOT before waiting again
+            std::unique_lock<std::mutex> lock(EVENT_MUTEX, std::try_to_lock);
             OUTPUT_BUFFER_HOT = true;
             EVENT_CV.notify_one();
         }

src/spice2x/launcher/options.cpp

@@ -1743,6 +1743,21 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .setting_name = "1",
         .category = "Companion & API",
     },
+    {
+        // APIStreamEnable
+        .title = "API Video Stream Server Enable",
+        .name = "apistream",
+        .desc = "Serves the mirrored screen as a video stream, on the API port plus two; "
+            "alternative to API screen capture. Requires -api.\n\n"
+            "http://host:apiport+2/stream.mjpg - MJPEG\n\n"
+            "http://host:apiport+2/stream.h264 - H.264\n\n"
+            "Parameters: screen (0-3), fps (1-60, default 30), q (1-100, default 70).\n\n"
+            "Example with -api 1337: http://host:1339/stream.h264?fps=30&q=70\n\n"
+            "VIEW ONLY - touch input still requires -api. "
+            "No password protection or encryption of any kind; video sent in the clear!",
+        .type = OptionType::Bool,
+        .category = "Companion & API",
+    },
     {
         .title = "Enable All IO Modules",
         .name = "io",

src/spice2x/launcher/options.h

@@ -170,6 +170,7 @@ namespace launcher {
             APIDebugMode,
             APIScreenMirrorQuality,
             APIScreenMirrorDivide,
+            APIStreamEnable,
             EnableAllIOModules,
             EnableACIOModule,
             EnableICCAModule,

src/spice2x/licenses.txt

@@ -527,25 +527,78 @@ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABI
 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-toojpeg (zlib)
+fpng (Unlicense)
 -------------------------------------------
-zlib License
+Copyright (c) 2021 Richard Geldreich, Jr.
+Incorporates public domain code by Alex Evans, the original miniz by
+Richard Geldreich, Jr., and Huffman code size work by Alistair Moffat and
+Jyrki Katajainen.
 
-Copyright (c) 2011-2016 Stephan Brumme
+This is free and unencumbered software released into the public domain.
 
-This software is provided 'as-is', without any express or implied warranty. In
-no event will the authors be held liable for any damages arising from the use
-of this software.
-Permission is granted to anyone to use this software for any purpose, including
-commercial applications, and to alter it and redistribute it freely, subject to
-the following restrictions:
-1. The origin of this software must not be misrepresented; you must not claim
-   that you wrote the original software. If you use this software in a product,
-   an acknowledgment in the product documentation would be appreciated but is
-   not required.
-2. Altered source versions must be plainly marked as such, and must not be
-   misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute
+this software, either in source code form or as a compiled binary, for any
+purpose, commercial or non-commercial, and by any means.
+
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+libjpeg-turbo (IJG)
+-------------------------------------------
+This software is based in part on the work of the Independent JPEG Group.
+
+Only the libjpeg API library is used here. Per the libjpeg-turbo licensing
+terms that portion is covered by the IJG License, reproduced below; the SIMD
+sources bear the zlib License, whose terms are subsumed by the IJG License in
+the context of the overall libjpeg API library. The Modified (3-clause) BSD
+License covers the TurboJPEG API library and build system, neither of which is
+distributed here.
+
+The authors make NO WARRANTY or representation, either express or implied,
+with respect to this software, its quality, accuracy, merchantability, or
+fitness for a particular purpose.  This software is provided "AS IS", and you,
+its user, assume the entire risk as to its quality and accuracy.
+
+This software is copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding.
+All Rights Reserved except as specified below.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+software (or portions thereof) for any purpose, without fee, subject to these
+conditions:
+(1) If any part of the source code for this software is distributed, then this
+README file must be included, with this copyright and no-warranty notice
+unaltered; and any additions, deletions, or changes to the original files
+must be clearly indicated in accompanying documentation.
+(2) If only executable code is distributed, then the accompanying
+documentation must state that "this software is based in part on the work of
+the Independent JPEG Group".
+(3) Permission for use of this software is granted only if the user accepts
+full responsibility for any undesirable consequences; the authors accept
+NO LIABILITY for damages of any kind.
+
+These conditions apply to any software derived from or based on the IJG code,
+not just to the unmodified library.  If you use our work, you ought to
+acknowledge us.
+
+Permission is NOT granted for the use of any IJG author's name or company name
+in advertising or publicity relating to this software or products derived from
+it.  This software may be referred to only as "the Independent JPEG Group's
+software".
+
+We specifically permit and encourage the use of this software as the basis of
+commercial products, provided that all warranty or liability claims are
+assumed by the product vendor.
 
 robin_hood.h (MIT)
 -------------------------------------------
@@ -1353,3 +1406,23 @@ Contributions
 -------------------------------------------
 cardio - Felix - MIT License
 scard - nolm - MIT License
+
+x264 (GPL-2.0-or-later)
+-------------------------------------------
+https://www.videolan.org/developers/x264.html
+Statically linked for the API video stream H.264 encoder.
+
+Copyright (C) 2003-2024 x264 project
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
+Street, Fifth Floor, Boston, MA 02110-1301, USA.

src/spice2x/misc/clipboard.cpp

@@ -58,17 +58,18 @@ namespace clipboard {
             return;
         }
 
-        // If the screenshot button is print screen, the OpenClipboard call seems to fail often if we only
-        // call it once, probably due to a race condition. So, we can try calling a lot until we can open it.
+        // print screen key leaves the OS briefly holding the clipboard, so retry
+        // spinning without yielding starves the thread we are waiting on and looks like a hang
         bool clipboard_open = false;
-        for (int i = 0; i < 1000000; i++) {
+        for (int i = 0; i < 100; i++) {
             if (OpenClipboard(nullptr)) {
                 clipboard_open = true;
                 break;
             }
+            Sleep(5);
         }
         if (!clipboard_open) {
-            log_warning("clipboard", "Failed to open clipboard");
+            log_warning("clipboard", "failed to open clipboard");
             return;
         }
 

src/spice2x/patcher/runtime.cpp

@@ -669,6 +669,11 @@ namespace patcher {
         signature.erase(std::remove(signature.begin(), signature.end(), ' '), signature.end());
         replacement.erase(std::remove(replacement.begin(), replacement.end(), ' '), replacement.end());
 
+        if (signature.empty() || (signature.length() % 2) != 0
+            || replacement.empty() || (replacement.length() % 2) != 0) {
+            return {.fatal_error = true};
+        }
+
         // build pattern
         std::string pattern_str(signature);
         strreplace(pattern_str, "??", "00");
@@ -717,13 +722,26 @@ namespace patcher {
         }
         std::string replace_mask_str = replace_mask.str();
 
-        // find offset
+        // replacement applies at signature_match + offset; must stay inside the signature
+        const size_t sig_len = signature_mask_str.length();
+        const size_t repl_len = replace_mask_str.length();
+        if (offset > sig_len || repl_len == 0 || offset + repl_len > sig_len) {
+            log_warning("patchmanager",
+                        "signature patch '{}': offset {} + replacement {} exceeds signature {}",
+                        patch->name, offset, repl_len, sig_len);
+            return {.fatal_error = true};
+        }
+
+        // Locate signature *start* (find_pattern offset arg = 0). JSON "offset" is applied
+        // below. Old code passed JSON offset into find_pattern but still indexed
+        // signature/replacement from 0 → mis-aligned when offset != 0.
         uint64_t data_offset = 0;
-        uint8_t *data_offset_ptr = nullptr;
-        uintptr_t data_offset_ptr_base = 0;
+        uint8_t *read_ptr = nullptr;
+        HMODULE module = nullptr;
+        bool module_free = false;
+
         if (cfg::CONFIGURATOR_STANDALONE) {
 
-            // load file into dll map if missing
             auto it = DLL_MAP.find(dll_name);
             if (it == DLL_MAP.end()) {
                 DLL_MAP[dll_name] =
@@ -732,16 +750,21 @@ namespace patcher {
                 it = DLL_MAP.find(dll_name);
             }
 
-            // find pattern
-            data_offset = find_pattern(*it->second, 0, pattern_bin.get(), signature_mask_str.c_str(), offset, usage);
-            data_offset_ptr = reinterpret_cast<uint8_t *>(data_offset);
-            data_offset_ptr_base = (uintptr_t) it->second->data();
+            // base=0 → file offset of signature start; 0 also means "not found"
+            const intptr_t match = find_pattern(
+                    *it->second, 0, pattern_bin.get(), signature_mask_str.c_str(), 0, usage);
+            if (match == 0) {
+                return {.fatal_error = true};
+            }
+            data_offset = static_cast<uint64_t>(match) + offset;
+            if (data_offset + repl_len > it->second->size()) {
+                return {.fatal_error = true};
+            }
+            read_ptr = it->second->data() + data_offset;
 
         } else {
 
-            // get module
-            auto module = libutils::try_module(dll_path);
-            bool module_free = false;
+            module = libutils::try_module(dll_path);
             if (!module) {
                 module = libutils::try_library(dll_path);
                 if (module) {
@@ -751,59 +774,71 @@ namespace patcher {
                 }
             }
 
-            // find pattern
-            data_offset_ptr = reinterpret_cast<uint8_t *>(
-                    find_pattern(module, pattern_bin.get(), signature_mask_str.c_str(), offset, usage));
-
-            // convert back to offset
-            data_offset = libutils::rva2offset(dll_path, (intptr_t) (data_offset_ptr - (uint8_t*) module));
-
-            // clean
+            const intptr_t match_va = find_pattern(
+                    module, pattern_bin.get(), signature_mask_str.c_str(), 0, usage);
+            auto *match_ptr = reinterpret_cast<uint8_t *>(match_va);
+            if (match_ptr == nullptr) {
                 if (module_free) {
                     FreeLibrary(module);
                 }
-        }
-
-        // check pointers
-        if (data_offset_ptr == nullptr) {
                 return {.fatal_error = true};
             }
 
-        // get disabled/enabled data
-        size_t data_len = std::max(signature_mask_str.length(), replace_mask_str.length());
-        std::shared_ptr<uint8_t[]> data_disabled(new uint8_t[data_len]);
-        std::shared_ptr<uint8_t[]> data_enabled(new uint8_t[data_len]);
-        memutils::VProtectGuard data_guard(data_offset_ptr + data_offset_ptr_base, data_len);
-        for (size_t i = 0; i < data_len; ++i) {
-            if (i >= signature_mask_str.length() || signature_mask_str[i] != 'X') {
-                data_disabled.get()[i] = (data_offset_ptr + data_offset_ptr_base)[i];
+            const intptr_t file_off = libutils::rva2offset(
+                    dll_path, (intptr_t) (match_ptr - (uint8_t *) module));
+            if (file_off < 0) {
+                if (module_free) {
+                    FreeLibrary(module);
+                }
+                return {.fatal_error = true};
+            }
+            data_offset = static_cast<uint64_t>(file_off) + offset;
+            read_ptr = match_ptr + offset;
+        }
+
+        // Build disabled/enabled for the replacement window only.
+        std::shared_ptr<uint8_t[]> data_disabled(new uint8_t[repl_len]);
+        std::shared_ptr<uint8_t[]> data_enabled(new uint8_t[repl_len]);
+        {
+            memutils::VProtectGuard data_guard(read_ptr, repl_len);
+            for (size_t i = 0; i < repl_len; ++i) {
+                const size_t si = static_cast<size_t>(offset) + i;
+                if (signature_mask_str[si] != 'X') {
+                    data_disabled.get()[i] = read_ptr[i];
                 } else {
-                data_disabled.get()[i] = pattern_bin.get()[i];
+                    data_disabled.get()[i] = pattern_bin.get()[si];
                 }
-        }
-        for (size_t i = 0; i < data_len; ++i) {
-            if (i >= replace_mask_str.length() || replace_mask_str[i] != 'X') {
-                data_enabled.get()[i] = (data_offset_ptr + data_offset_ptr_base)[i];
+                if (replace_mask_str[i] != 'X') {
+                    data_enabled.get()[i] = read_ptr[i];
                 } else {
                     data_enabled.get()[i] = replace_data_bin.get()[i];
                 }
             }
+        }
+
+        // Drop temporary LoadLibrary mapping only after reads above.
+        if (module_free) {
+            FreeLibrary(module);
+        }
 
-        // log edit
         log_misc("patchmanager", "found {}: {:#08X}: {} -> {}",
                  patch->name, data_offset,
-                 bin2hex(data_disabled.get(), data_len),
-                 bin2hex(data_enabled.get(), data_len));
+                 bin2hex(data_disabled.get(), repl_len),
+                 bin2hex(data_enabled.get(), repl_len));
 
-        // build patch
+        // BUGFIX: never cache a pointer here.
+        // - standalone used to store (uint8_t*)file_offset, so is_patch_active skipped
+        //   re-resolve and memcmp'd a fake address → "neither on or off".
+        // - in-game used to keep a pointer that FreeLibrary may invalidate.
+        // is_patch_active / apply_patch re-resolve from data_offset when ptr is nullptr.
         return MemoryPatch {
                 .dll_name = dll_name,
                 .data_disabled = std::move(data_disabled),
-                .data_disabled_len = data_len,
+                .data_disabled_len = repl_len,
                 .data_enabled = std::move(data_enabled),
-                .data_enabled_len = data_len,
+                .data_enabled_len = repl_len,
                 .data_offset = data_offset,
-                .data_offset_ptr = data_offset_ptr,
+                .data_offset_ptr = nullptr,
         };
     }
 

src/spice2x/util/detour.cpp

@@ -119,6 +119,14 @@ static void *pe_offset(void *ptr, size_t offset) {
     return reinterpret_cast<uint8_t *>(ptr) + offset;
 }
 
+// foreign modules (injected, manually mapped) have no import table to patch - skip them
+// instead of taking the process down
+static bool has_pe_header(HMODULE module) {
+    const auto dos_headers = reinterpret_cast<const IMAGE_DOS_HEADER *>(module);
+
+    return dos_headers->e_magic == IMAGE_DOS_SIGNATURE;
+}
+
 void **detour::iat_find(const char *function, HMODULE module, const char *iid_name) {
 
     // check module
@@ -127,11 +135,13 @@ void **detour::iat_find(const char *function, HMODULE module, const char *iid_na
     }
 
     // check signature
-    const IMAGE_DOS_HEADER *pImgDosHeaders = (IMAGE_DOS_HEADER *) module;
-    if (pImgDosHeaders->e_magic != IMAGE_DOS_SIGNATURE) {
-        log_fatal("detour", "signature mismatch ({} != {})", pImgDosHeaders->e_magic, IMAGE_DOS_SIGNATURE);
+    if (!has_pe_header(module)) {
+        log_misc("detour", "no PE header in {}, not looking for {}", fmt::ptr(module), function);
+        return nullptr;
     }
 
+    const IMAGE_DOS_HEADER *pImgDosHeaders = (IMAGE_DOS_HEADER *) module;
+
     // get import table
     const auto nt_headers = reinterpret_cast<IMAGE_NT_HEADERS *>(pe_offset(module, pImgDosHeaders->e_lfanew));
     const auto data_dir = &nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
@@ -191,11 +201,13 @@ void **detour::iat_find_ordinal(const char *iid_name, DWORD ordinal, HMODULE mod
     }
 
     // check signature
-    const auto pImgDosHeaders = reinterpret_cast<IMAGE_DOS_HEADER *>(module);
-    if (pImgDosHeaders->e_magic != IMAGE_DOS_SIGNATURE) {
-        log_fatal("detour", "signature error");
+    if (!has_pe_header(module)) {
+        log_misc("detour", "no PE header in {}, not looking for {}:{}", fmt::ptr(module), iid_name, ordinal);
+        return nullptr;
     }
 
+    const auto pImgDosHeaders = reinterpret_cast<IMAGE_DOS_HEADER *>(module);
+
     // get import table
     const auto nt_headers = reinterpret_cast<IMAGE_NT_HEADERS *>(pe_offset(module, pImgDosHeaders->e_lfanew));
     const auto data_dir = &nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
@@ -246,11 +258,13 @@ void **detour::iat_find_proc(const char *iid_name, void *proc, HMODULE module) {
     }
 
     // check signature
-    const auto pImgDosHeaders = reinterpret_cast<IMAGE_DOS_HEADER *>(module);
-    if (pImgDosHeaders->e_magic != IMAGE_DOS_SIGNATURE) {
-        log_fatal("detour", "signature error");
+    if (!has_pe_header(module)) {
+        log_misc("detour", "no PE header in {}, not looking for {}", fmt::ptr(module), iid_name);
+        return nullptr;
     }
 
+    const auto pImgDosHeaders = reinterpret_cast<IMAGE_DOS_HEADER *>(module);
+
     // get import table
     const auto nt_headers = reinterpret_cast<IMAGE_NT_HEADERS *>(pe_offset(module, pImgDosHeaders->e_lfanew));
     const auto data_dir = &nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
@@ -298,7 +312,9 @@ void *detour::iat_try(const char *function, void *new_func, HMODULE module, cons
         while (cur_entry != nullptr) {
             module = reinterpret_cast<HMODULE>(cur_entry->DllBase);
 
-            if (module) {
+            // walking the PEB turns up foreign modules too, and those are expected to have
+            // nothing to patch - filter them here so iat_find only complains about real callers
+            if (module && has_pe_header(module)) {
                 auto old_func = iat_try(function, new_func, module, iid_name);
                 ret = ret != nullptr ? ret : old_func;
             }
@@ -328,7 +344,6 @@ void *detour::iat_try(const char *function, void *new_func, HMODULE module, cons
 }
 
 void *detour::iat_try_ordinal(const char *iid_name, DWORD ordinal, void *new_func, HMODULE module) {
-
     // fail when no module was specified
     if (module == nullptr) {
         return nullptr;
@@ -367,7 +382,7 @@ void *detour::iat_try_proc(const char *iid_name, void *proc, void *new_func, HMO
         while (cur_entry != nullptr) {
             module = reinterpret_cast<HMODULE>(cur_entry->DllBase);
 
-            if (module) {
+            if (module && has_pe_header(module)) {
                 auto old_func = iat_try_proc(iid_name, proc, new_func, module);
                 ret = ret != nullptr ? ret : old_func;
             }