exlude line ending enforcement for external dir

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

## Description of change
For popn HC, some transparency effects, like the one for touch feedback,
rendered incorrectly; this is due to how alpha channel is handled for
subscreen overlay drawing on top of ImGui.

## Testing
Tested popn and iidx.

.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

.github/workflows/ci.yml

@@ -1,32 +1,32 @@
-on: [push, pull_request]
-name: Continuous Integration
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  fw-ci:
-    name: Build
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./src/spice2x
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set ccache environment variables
-        run: |
-          echo "CCACHE_DIR=${{ github.workspace }}/src/spice2x/.ccache" >> $GITHUB_ENV
-      - name: Install ccache
-        uses: hendrikmuhs/ccache-action@v1.2
-      - name: Calculate commit SHA
-        id: vars
-        run: |
-          calculatedSha=$(git rev-parse --short ${{ github.sha }})
-          echo "COMMIT_SHORT_SHA=$calculatedSha" >> $GITHUB_ENV
-      - name: Compile
-        run: ./build_docker.sh
-      - uses: actions/upload-artifact@v4
-        with:
-          name: spice2x-ci-${{ env.COMMIT_SHORT_SHA }}
-          path: src/spice2x/bin
+on: [push, pull_request]
+name: Continuous Integration
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  fw-ci:
+    name: Build
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./src/spice2x
+    steps:
+      - uses: actions/checkout@v5
+      - name: Set ccache environment variables
+        run: |
+          echo "CCACHE_DIR=${{ github.workspace }}/src/spice2x/.ccache" >> $GITHUB_ENV
+      - name: Install ccache
+        uses: hendrikmuhs/ccache-action@v1.2.23
+      - name: Calculate commit SHA
+        id: vars
+        run: |
+          calculatedSha=$(git rev-parse --short ${{ github.sha }})
+          echo "COMMIT_SHORT_SHA=$calculatedSha" >> $GITHUB_ENV
+      - name: Compile
+        run: ./build_docker.sh
+      - uses: actions/upload-artifact@v6
+        with:
+          name: spice2x-ci-${{ env.COMMIT_SHORT_SHA }}
+          path: src/spice2x/bin
           if-no-files-found: error

.github/workflows/release.yml

@@ -0,0 +1,49 @@
+name: Draft Release
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  release:
+    name: Build and Draft Release
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./src/spice2x
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: main
+          fetch-depth: 0
+      - name: Clean leftover build artifacts
+        run: |
+          rm -rf .ccache dist bin cmake-build-*
+      - name: Compile
+        run: ./build_docker.sh
+      - name: Determine release name from dist filename
+        run: |
+          dist=$(basename "$(ls dist/spice2x-*.zip | grep -v -- '-full.zip')")
+          # strip the ".zip" to get the base name, e.g. spice2x-26-06-28
+          name="${dist%.zip}"
+          # the tag is the date portion, e.g. 26-06-28
+          tag="${name#spice2x-}"
+          echo "RELEASE_NAME=$name" >> $GITHUB_ENV
+          echo "RELEASE_TAG=$tag" >> $GITHUB_ENV
+      - name: Create draft release
+        uses: softprops/action-gh-release@v3
+        with:
+          draft: true
+          prerelease: true
+          tag_name: ${{ env.RELEASE_TAG }}
+          name: ${{ env.RELEASE_NAME }}
+          target_commitish: main
+          generate_release_notes: true
+          files: |
+            src/spice2x/dist/spice2x-*.zip

CONTRIBUTING.md

@@ -11,13 +11,17 @@ To contribute, fork the repo (just the main branch), make changes in your fork,
 * For a new game that was never supported (not a new version of a game, but rather a new series): please wait 1 year after official AC release in Japan.
 * For new version of an already supported game: proceed with caution and use generally-accepted community guidelines.
 
-### Forbidden "features" that will never be accepted
+### Pull requests that will not be accepted
 
-* Performing decryption of encrypted files
-* Including (bundling), distributing, or linking to game data, or making it easier to find/download game data
+* Performing decryption of encrypted files.
+* Including (bundling), distributing, or linking to game data, or making it easier to find/download game data.
 * Any features that [phone home](https://en.wikipedia.org/wiki/Phoning_home)
   * This includes automatic updaters.
   * Exception: we have allowed the "patch import from URL" feature, but this has only been done under very careful considerations and plenty of warnings to the user.
+* Built-in EA server that saves data. They should live in a separate project.
+* Any additions to built-in patches (modifications / removals are OK if we have a good reason).
+* Changes to the software license terms.
+* Localization / translation for UI text. It becomes too difficult to manage by the maintainers.
 
 ### Avoiding regressions
 

src/spice2x/CMakeLists.txt

@@ -332,6 +332,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
         api/modules/control.cpp
         api/modules/touch.cpp
         api/modules/iidx.cpp
+        api/modules/sdvx.cpp
         api/serial.cpp
         api/modules/drs.cpp
         api/modules/lcd.cpp
@@ -408,13 +409,17 @@ set(SOURCE_FILES ${SOURCE_FILES}
         games/iidx/mf_wrappers.cpp
         games/sdvx/bi2x_hook.cpp
         games/sdvx/sdvx.cpp
+        games/sdvx/sdvx_live2d.cpp
         games/sdvx/io.cpp
         games/sdvx/camera.cpp
+        games/jb/bi2x_hook.cpp
         games/jb/jb.cpp
+        games/jb/jb_touch.cpp
         games/jb/io.cpp
         games/nost/nost.cpp
         games/nost/io.cpp
         games/nost/poke.cpp
+        games/nost/touch_mode.cpp
         games/gitadora/gitadora.cpp
         games/gitadora/asio.cpp
         games/gitadora/io.cpp
@@ -430,6 +435,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
         games/rb/rb.cpp
         games/rb/io.cpp
         games/rb/touch.cpp
+        games/rb/touch_debug.cpp
         games/bs/bs.cpp
         games/bs/io.cpp
         games/rf3d/rf3d.cpp
@@ -499,6 +505,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
         hooks/audio/buffer.cpp
         hooks/audio/mme.cpp
         hooks/audio/util.cpp
+        hooks/audio/xact.cpp
         hooks/audio/backends/dsound/dsound_backend.cpp
         hooks/audio/backends/mmdevice/audio_endpoint_volume.cpp
         hooks/audio/backends/mmdevice/device.cpp
@@ -525,10 +532,14 @@ set(SOURCE_FILES ${SOURCE_FILES}
         hooks/devicehook.cpp
         hooks/graphics/graphics.cpp
         hooks/graphics/graphics_windowed.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_screenshot.cpp
         hooks/graphics/backends/d3d9/d3d9_device.cpp
+        hooks/graphics/backends/d3d9/d3d9_gfdm.cpp
+        hooks/graphics/backends/d3d9/d3d9_live2d.cpp
         hooks/graphics/backends/d3d9/d3d9_fake_swapchain.cpp
         hooks/graphics/backends/d3d9/d3d9_swapchain.cpp
         hooks/graphics/backends/d3d9/d3d9_texture.cpp
@@ -567,7 +578,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
         misc/device.cpp
         misc/eamuse.cpp
         misc/extdev.cpp
-        misc/nativetouchhook.cpp
+        misc/hotkeys.cpp
         misc/sciunit.cpp
         misc/sde.cpp
         misc/wintouchemu.cpp
@@ -605,12 +616,27 @@ set(SOURCE_FILES ${SOURCE_FILES}
         overlay/windows/keypad.cpp
         overlay/windows/log.cpp
         overlay/windows/midi.cpp
+        overlay/windows/nostalgia_touch_piano.cpp
+        overlay/windows/obs.cpp
+        overlay/windows/obs_websocket.cpp
         overlay/windows/patch_manager.cpp
         overlay/windows/popn_sub.cpp
         overlay/windows/wnd_manager.cpp
 
+        # patcher
+        patcher/config.cpp
+        patcher/lifecycle.cpp
+        patcher/loader.cpp
+        patcher/loader_group.cpp
+        patcher/runtime.cpp
+
+        # external
+        external/easywsclient/easywsclient.cpp
+
         # rawinput
         rawinput/rawinput.cpp
+        rawinput/rawinput_handles.cpp
+        rawinput/midi.cpp
         rawinput/sextet.cpp
         rawinput/piuio.cpp
         rawinput/touch.cpp
@@ -637,8 +663,14 @@ set(SOURCE_FILES ${SOURCE_FILES}
         stubs/stubs.cpp
 
         # touch
+        touch/gdi_overlay.cpp
+        touch/native/inject.cpp
+        touch/native/inject_mouse.cpp
+        touch/native/inject_synthetic.cpp
+        touch/native/nativetouchhook.cpp
+        touch/native/transform.cpp
         touch/touch.cpp
-        touch/touch_indicators.cpp
+        touch/touch_gestures.cpp
         touch/win7.cpp
         touch/win8.cpp
 
@@ -671,6 +703,33 @@ set(SOURCE_FILES ${SOURCE_FILES}
 
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "Source Files" FILES ${SOURCE_FILES})
 
+# guard against statically importing DLLs that must always be loaded dynamically:
+#   * DLLs users override via the modules directory (e.g. DXVK's d3d9.dll) - a
+#     static import loads the system copy at startup and preempts the override
+#     (issue #779).
+#   * Media Foundation DLLs (mf/mfplat/mfreadwrite) - a static import breaks
+#     Unity games.
+# the check runs objdump on each produced binary and fails the build if any
+# forbidden DLL is imported.
+set(SPICE_FORBIDDEN_STATIC_IMPORTS
+        d3d8.dll d3d9.dll d3d10core.dll d3d11.dll dxgi.dll opengl32.dll
+        mf.dll mfplat.dll mfreadwrite.dll)
+
+function(spice_guard_dll_imports target)
+    if(MSVC)
+        # objdump-based parsing assumes a GNU/LLVM toolchain
+        return()
+    endif()
+    add_custom_command(TARGET ${target} POST_BUILD
+            COMMAND ${CMAKE_COMMAND}
+                -DOBJDUMP=${CMAKE_OBJDUMP}
+                -DTARGET_FILE=$<TARGET_FILE:${target}>
+                "-DFORBIDDEN=${SPICE_FORBIDDEN_STATIC_IMPORTS}"
+                -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/check_no_static_dll_imports.cmake
+            VERBATIM
+            COMMENT "Checking ${target} for forbidden static DLL imports")
+endfunction()
+
 # spice.exe / spice_laa.exe shared objects
 ###########################################
 # spice.exe and spice_laa.exe are compiled identically; the only difference is
@@ -955,3 +1014,16 @@ set_target_properties(spicetools_spice64 spicetools_spice64_linux spicetools_stu
         ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/archive64"
         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/spicetools/64"
         RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/spicetools/64")
+
+# forbidden static DLL import guard
+###################################
+# apply the check to every executable and DLL produced by this project.
+get_property(spice_all_targets DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY BUILDSYSTEM_TARGETS)
+foreach(spice_target IN LISTS spice_all_targets)
+    get_target_property(spice_target_type ${spice_target} TYPE)
+    if(spice_target_type STREQUAL "EXECUTABLE"
+            OR spice_target_type STREQUAL "SHARED_LIBRARY"
+            OR spice_target_type STREQUAL "MODULE_LIBRARY")
+        spice_guard_dll_imports(${spice_target})
+    endif()
+endforeach()

src/spice2x/README.md

@@ -267,6 +267,20 @@ which also means that your hex edits are applicable directly.
     - `Side Panel Right Inner`
     - `Side Panel Right`
 
+#### SDVX
+- tapeled_get(name: str, ...)
+  - returns a list containing a dict of the current tape LED states. The dict keys are:
+    - `Title`
+    - `Upper Left Speaker`
+    - `Upper Right Speaker`
+    - `Left Wing`
+    - `Right Wing`
+    - `Control Panel`
+    - `Lower Left Speaker`
+    - `Lower Right Speaker`
+    - `Woofer`
+    - `V Unit`
+
 #### LCD
 - info()
   - returns information about the serial LCD controller some games use

src/spice2x/acio/core/core.cpp

@@ -4,6 +4,7 @@
 #include "launcher/launcher.h"
 #include "misc/wintouchemu.h"
 #include "rawinput/rawinput.h"
+#include "touch/native/nativetouchhook.h"
 
 // static stuff
 static int ACIO_WARMUP = 0;
@@ -140,8 +141,9 @@ static int __cdecl ac_io_update(int a1) {
     // flush device output
     RI_MGR->devices_flush_output();
 
-    // update wintouchemu
+    // update touch emulation
     wintouchemu::update();
+    nativetouch::refresh_contact_lifetime();
 
     return 1;
 }

src/spice2x/acio/panb/panb.cpp

@@ -3,6 +3,7 @@
 #include "rawinput/rawinput.h"
 #include "games/nost/io.h"
 #include "games/nost/nost.h"
+#include "games/nost/touch_mode.h"
 #include "util/logging.h"
 #include "avs/game.h"
 
@@ -16,6 +17,7 @@ using namespace GameAPI;
 // static stuff
 static uint8_t STATUS_BUFFER[277];
 static bool STATUS_BUFFER_FREEZE = false;
+static constexpr uint8_t NOST_TOUCH_PIANO_VELOCITY = 11;
 
 /*
  * Implementations
@@ -226,6 +228,8 @@ static bool __cdecl ac_io_panb_update_control_status_buffer() {
                 games::nost::Analogs::Key27, games::nost::Analogs::Key28,
         };
 
+        const auto touch_key_state = games::nost::touch_mode::piano_key_state();
+
         // iterate pairs of keys
         for (size_t key_pair = 0; key_pair < 28 / 2; key_pair++) {
 
@@ -257,6 +261,10 @@ static bool __cdecl ac_io_panb_update_control_status_buffer() {
             if (button0 > 0) {
                 state0 = button0;
             }
+            if ((touch_key_state & (UINT32_C(1) << (key_pair * 2))) &&
+                state0 < NOST_TOUCH_PIANO_VELOCITY) {
+                state0 = NOST_TOUCH_PIANO_VELOCITY;
+            }
 
             const auto button1 = panb_get_button_velocity(
                 buttons.at(button_mapping[key_pair * 2 + 1]),
@@ -267,6 +275,10 @@ static bool __cdecl ac_io_panb_update_control_status_buffer() {
             if (button1 > 0) {
                 state1 = button1;
             }
+            if ((touch_key_state & (UINT32_C(1) << (key_pair * 2 + 1))) &&
+                state1 < NOST_TOUCH_PIANO_VELOCITY) {
+                state1 = NOST_TOUCH_PIANO_VELOCITY;
+            }
 
             // build value
             uint8_t value = 0;

src/spice2x/acioemu/icca.cpp

@@ -239,7 +239,7 @@ bool ICCADevice::parse_msg(MessageData *msg_in,
             // SDVX Old cabinet mode
             if (avs::game::is_model("KFC") && avs::game::SPEC[0] != 'G' && avs::game::SPEC[0] != 'H')
                 answer_type = 1;
-            if (avs::game::is_model("L44"))
+            if (avs::game::is_model({ "L44", "T44" }))
                 answer_type = 2;
 
             // check answer type

src/spice2x/api/client.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <atomic>
+#include <cstdint>
+
+namespace api {
+
+    extern std::atomic_uint32_t CLIENT_COUNT;
+
+    inline bool has_clients() {
+        return CLIENT_COUNT.load(std::memory_order_relaxed) > 0;
+    }
+}

src/spice2x/api/controller.cpp

@@ -5,6 +5,7 @@
 
 #include <utility>
 
+#include "client.h"
 #include "cfg/configurator.h"
 #include "external/rapidjson/document.h"
 #include "util/crypt.h"
@@ -28,6 +29,7 @@
 #include "modules/lcd.h"
 #include "modules/lights.h"
 #include "modules/memory.h"
+#include "modules/sdvx.h"
 #include "modules/touch.h"
 #include "modules/resize.h"
 #include "request.h"
@@ -36,6 +38,8 @@
 using namespace rapidjson;
 using namespace api;
 
+std::atomic_uint32_t api::CLIENT_COUNT = 0;
+
 Controller::Controller(unsigned short port, std::string password, bool pretty)
     : port(port), password(std::move(password)), pretty(pretty)
 {
@@ -411,8 +415,11 @@ void Controller::init_state(api::ClientState *state) {
     state->modules.push_back(new modules::LCD());
     state->modules.push_back(new modules::Lights());
     state->modules.push_back(new modules::Memory());
+    state->modules.push_back(new modules::SDVX());
     state->modules.push_back(new modules::Touch());
     state->modules.push_back(new modules::Resize());
+
+    CLIENT_COUNT.fetch_add(1, std::memory_order_relaxed);
 }
 
 void Controller::free_state(api::ClientState *state) {
@@ -424,6 +431,8 @@ void Controller::free_state(api::ClientState *state) {
 
     // free cipher
     delete state->cipher;
+
+    CLIENT_COUNT.fetch_sub(1, std::memory_order_relaxed);
 }
 
 void Controller::free_socket() {

src/spice2x/api/modules/ddr.cpp

@@ -1,54 +1,54 @@
-#include "ddr.h"
-#include <functional>
-#include "external/rapidjson/document.h"
-#include "games/ddr/ddr.h"
-
-using namespace std::placeholders;
-using namespace rapidjson;
-
-namespace api::modules {
-
-    DDR::DDR() : Module("ddr") {
-        functions["tapeled_get"] = std::bind(&DDR::tapeled_get, this, _1, _2);
-    }
-
-    /**
-     * Allows fetching of the RGB LED strips that are gold cabinets, via SpiceAPI
-     */
-    void DDR::tapeled_get(Request &req, Response &res) {
-        static const char* device_names[11] = {
-            "p1_foot_up",
-            "p1_foot_right",
-            "p1_foot_left",
-            "p1_foot_down",
-            "p2_foot_up",
-            "p2_foot_right",
-            "p2_foot_left",
-            "p2_foot_down",
-            "top_panel",
-            "monitor_left",
-            "monitor_right"
-        };
-
-        Value response_object(kObjectType);
-
-        // Iterate through each device and dump its lights data into the response
-        for (size_t device = 0; device < 11; device++) {
-            size_t num_leds = 25;
-            if (device > 7)
-                num_leds = 50;
-
-            Value light_state(kArrayType);
-            light_state.Reserve(num_leds * 3, res.doc()->GetAllocator());
-            for (size_t led = 0; led < num_leds; led++) {
-                light_state.PushBack(games::ddr::DDR_TAPELEDS[device][led][0], res.doc()->GetAllocator());
-                light_state.PushBack(games::ddr::DDR_TAPELEDS[device][led][1], res.doc()->GetAllocator());
-                light_state.PushBack(games::ddr::DDR_TAPELEDS[device][led][2], res.doc()->GetAllocator());
-            }
-
-            response_object.AddMember(StringRef(device_names[device]), light_state, res.doc()->GetAllocator());
-        }
-
-        res.add_data(response_object);
-    }
-}
+#include "ddr.h"
+#include <functional>
+#include "external/rapidjson/document.h"
+#include "games/ddr/ddr.h"
+
+using namespace std::placeholders;
+using namespace rapidjson;
+
+namespace api::modules {
+
+    DDR::DDR() : Module("ddr") {
+        functions["tapeled_get"] = std::bind(&DDR::tapeled_get, this, _1, _2);
+    }
+
+    /**
+     * Allows fetching of the RGB LED strips that are gold cabinets, via SpiceAPI
+     */
+    void DDR::tapeled_get(Request &req, Response &res) {
+        static const char* device_names[11] = {
+            "p1_foot_up",
+            "p1_foot_right",
+            "p1_foot_left",
+            "p1_foot_down",
+            "p2_foot_up",
+            "p2_foot_right",
+            "p2_foot_left",
+            "p2_foot_down",
+            "top_panel",
+            "monitor_left",
+            "monitor_right"
+        };
+
+        Value response_object(kObjectType);
+
+        // Iterate through each device and dump its lights data into the response
+        for (size_t device = 0; device < 11; device++) {
+            size_t num_leds = 25;
+            if (device > 7)
+                num_leds = 50;
+
+            Value light_state(kArrayType);
+            light_state.Reserve(num_leds * 3, res.doc()->GetAllocator());
+            for (size_t led = 0; led < num_leds; led++) {
+                light_state.PushBack(games::ddr::DDR_TAPELEDS[device][led][0], res.doc()->GetAllocator());
+                light_state.PushBack(games::ddr::DDR_TAPELEDS[device][led][1], res.doc()->GetAllocator());
+                light_state.PushBack(games::ddr::DDR_TAPELEDS[device][led][2], res.doc()->GetAllocator());
+            }
+
+            response_object.AddMember(StringRef(device_names[device]), light_state, res.doc()->GetAllocator());
+        }
+
+        res.add_data(response_object);
+    }
+}

src/spice2x/api/modules/ddr.h

@@ -1,17 +1,17 @@
-#pragma once
-
-#include <vector>
-#include "api/module.h"
-#include "api/request.h"
-
-namespace api::modules {
-
-    class DDR : public Module {
-    public:
-        DDR();
-
-    private:
-        // function definitions
-        void tapeled_get(Request &req, Response &res);
-    };
-}
+#pragma once
+
+#include <vector>
+#include "api/module.h"
+#include "api/request.h"
+
+namespace api::modules {
+
+    class DDR : public Module {
+    public:
+        DDR();
+
+    private:
+        // function definitions
+        void tapeled_get(Request &req, Response &res);
+    };
+}

src/spice2x/api/modules/iidx.cpp

@@ -106,14 +106,16 @@ namespace api::modules {
     void IIDX::copy_tapeled_data(Response &res, Value &response_object, const tapeledutils::tape_led &mapping) {
         // Create an array for the light state
         Value light_state(kArrayType);
-        light_state.Reserve(mapping.data.capacity() * 3, res.doc()->GetAllocator());
+        light_state.Reserve(
+            static_cast<SizeType>(mapping.data.size() * 3),
+            res.doc()->GetAllocator());
         for (const auto [r, g, b] : mapping.data) {
             light_state.PushBack(r, res.doc()->GetAllocator());
             light_state.PushBack(g, res.doc()->GetAllocator());
             light_state.PushBack(b, res.doc()->GetAllocator());
         }
 
-        // Can't use StringRef here, turns some strings partially into null bytes for some reason
+        // can't use StringRef here, turns some strings partially into null bytes for some reason
         Value light_name(mapping.lightName.c_str(), res.doc()->GetAllocator());
         response_object.AddMember(light_name, light_state, res.doc()->GetAllocator());
     }

src/spice2x/api/modules/keypads.cpp

@@ -1,13 +1,14 @@
 #include "keypads.h"
 
+#include <chrono>
 #include <functional>
+#include <thread>
 
 #include <windows.h>
 
 #include "avs/game.h"
 #include "external/rapidjson/document.h"
 #include "misc/eamuse.h"
-#include "util/precise_timer.h"
 
 using namespace std::placeholders;
 using namespace rapidjson;
@@ -59,7 +60,6 @@ namespace api::modules {
         // get params
         auto keypad = req.params[0].GetUint();
         auto input = std::string(req.params[1].GetString());
-        timeutils::PreciseSleepTimer timer;
 
         // process all chars
         for (auto c : input) {
@@ -93,11 +93,11 @@ namespace api::modules {
 
             // set
             eamuse_set_keypad_overrides(keypad, state);
-            timer.sleep(sleep_time);
+            std::this_thread::sleep_for(std::chrono::milliseconds(sleep_time));
 
             // unset
             eamuse_set_keypad_overrides(keypad, 0);
-            timer.sleep(sleep_time);
+            std::this_thread::sleep_for(std::chrono::milliseconds(sleep_time));
         }
     }
 

src/spice2x/api/modules/sdvx.cpp

@@ -0,0 +1,67 @@
+#include "sdvx.h"
+
+#include <functional>
+
+using namespace std::placeholders;
+using namespace rapidjson;
+
+namespace api::modules {
+
+    SDVX::SDVX() : Module("sdvx") {
+        functions["tapeled_get"] = std::bind(&SDVX::tapeled_get, this, _1, _2);
+
+        for (auto &light : games::sdvx::TAPELED_MAPPING) {
+            lights_by_names.emplace(light.lightName, light);
+        }
+    }
+
+    /**
+     * tapeled_get()
+     * tapeled_get(name: str, ...)
+     */
+    void SDVX::tapeled_get(Request &req, Response &res) {
+        Value response_object(kObjectType);
+
+        // all tape leds
+        if (req.params.Size() == 0) {
+            // iterate through each device and dump its lights data into the response
+            for (const auto &mapping : games::sdvx::TAPELED_MAPPING) {
+                copy_tapeled_data(res, response_object, mapping);
+            }
+        } else {
+            // specified light names
+            for (Value &param : req.params.GetArray()) {
+                // check params
+                if (!param.IsString()) {
+                    error_type(res, "name", "string");
+                    return;
+                }
+
+                const auto name = param.GetString();
+                if (const auto &it = lights_by_names.find(name); it != lights_by_names.end()) {
+                    copy_tapeled_data(res, response_object, it->second.get());
+                }
+            }
+        }
+
+        res.add_data(response_object);
+    }
+
+    void SDVX::copy_tapeled_data(Response &res, Value &response_object,
+            const tapeledutils::tape_led &mapping)
+    {
+        Value light_state(kArrayType);
+        light_state.Reserve(
+            static_cast<SizeType>(mapping.data.size() * 3),
+            res.doc()->GetAllocator());
+        for (const auto [r, g, b] : mapping.data) {
+            light_state.PushBack(r, res.doc()->GetAllocator());
+            light_state.PushBack(g, res.doc()->GetAllocator());
+            light_state.PushBack(b, res.doc()->GetAllocator());
+        }
+
+        // can't use StringRef here, turns some strings partially into null bytes for some reason
+        Value light_name(mapping.lightName.c_str(), res.doc()->GetAllocator());
+        response_object.AddMember(light_name, light_state, res.doc()->GetAllocator());
+    }
+}

src/spice2x/api/modules/sdvx.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <functional>
+#include <string>
+
+#include "api/module.h"
+#include "api/request.h"
+#include "external/robin_hood.h"
+#include "games/sdvx/sdvx.h"
+
+namespace api::modules {
+
+    class SDVX : public Module {
+    public:
+        SDVX();
+
+    private:
+        robin_hood::unordered_map<std::string, std::reference_wrapper<tapeledutils::tape_led>> lights_by_names;
+
+        void tapeled_get(Request &req, Response &res);
+        void copy_tapeled_data(Response &res, rapidjson::Value &response_object,
+                const tapeledutils::tape_led &mapping);
+    };
+}

src/spice2x/api/modules/touch.cpp

@@ -1,5 +1,7 @@
 #include "touch.h"
 
+#include <algorithm>
+#include <cstdint>
 #include <functional>
 
 #include "external/rapidjson/document.h"
@@ -8,7 +10,11 @@
 #include "misc/eamuse.h"
 #include "launcher/launcher.h"
 #include "touch/touch.h"
+#include "touch/native/inject.h"
+#include "touch/native/nativetouchhook.h"
+#include "touch/native/transform.h"
 #include "util/utils.h"
+#include "games/gitadora/gitadora.h"
 #include "games/iidx/iidx.h"
 
 using namespace std::placeholders;
@@ -17,6 +23,54 @@ using namespace rapidjson;
 
 namespace api::modules {
 
+    static bool inject_native_touch(
+            const std::vector<TouchPoint> &touch_points, int canvas_w, int canvas_h) {
+        if (touch_points.empty()) {
+            // no active touches remain; release the synthetic contact
+            return nativetouch::inject::inject_synthetic_touch({ 0, 0 }, false);
+        }
+
+        // only a single synthetic contact is supported, so just use the first touch point
+        const auto &touch = touch_points.front();
+        POINT position { touch.x, touch.y };
+        if (canvas_w > 0 && canvas_h > 0) {
+            return nativetouch::inject::inject_synthetic_touch_from_canvas(
+                position,
+                { canvas_w, canvas_h },
+                true);
+        }
+        return nativetouch::inject::inject_synthetic_touch(position, true);
+    }
+
+    // map API coordinates onto the touch space SDVX reads, which depends on how it is displayed
+    static void sdvx_touch_errata(
+            int &x, int &y, bool use_native, int canvas_w, int canvas_h) {
+
+        // windowed coordinates already match the sub screen window they land on
+        if (GRAPHICS_WINDOWED) {
+            return;
+        }
+
+        // landscape mode: native injection hands the game these coordinates
+        // unchanged, so apply the rotation the touchscreen gets, while wintouchemu instead
+        // rotates them later through the subscreen overlay
+        if (GRAPHICS_FS_ORIENTATION_SWAP) {
+            if (use_native) {
+                POINT position { x, y };
+                if (nativetouch::transform::sdvx_landscape_rotate(&position, canvas_w, canvas_h)) {
+                    x = position.x;
+                    y = position.y;
+                }
+            }
+            return;
+        }
+
+        // rotate into the portrait touch space
+        const int x_raw = x;
+        x = canvas_w - y;
+        y = x_raw;
+    }
+
     Touch::Touch() : Module("touch") {
         is_sdvx = avs::game::is_model("KFC");
 
@@ -26,6 +80,32 @@ namespace api::modules {
             is_tdj_fhd = false;
         }
 
+        use_native = nativetouch::is_hooked();
+
+        // resolution the API/companion sends native touch coordinates in (after errata)
+        native_canvas_w = 0;
+        native_canvas_h = 0;
+        if (is_sdvx) {
+            // windowed API coordinates land on the sub screen window as-is; fullscreen
+            // coordinates are rotated into the game's touch space by apply_touch_errata
+            const bool landscape_coordinates =
+                GRAPHICS_WINDOWED || GRAPHICS_FS_ORIENTATION_SWAP;
+            native_canvas_w = landscape_coordinates ? 1920 : 1080;
+            native_canvas_h = landscape_coordinates ? 1080 : 1920;
+        } else if (avs::game::is_model("LDJ")) {
+            // TDJ subscreen; FHD models are upscaled to 1080p by apply_touch_errata
+            native_canvas_w = is_tdj_fhd ? 1920 : 1280;
+            native_canvas_h = is_tdj_fhd ? 1080 : 720;
+        } else if (avs::game::is_model("M39")) {
+            // pop'n music API touch surface
+            native_canvas_w = 1280;
+            native_canvas_h = 800;
+        } else if (games::gitadora::is_arena_model()) {
+            // GITADORA arena SMALL subscreen, either in its own window or in the overlay
+            native_canvas_w = games::gitadora::ARENA_SUBSCREEN_WIDTH;
+            native_canvas_h = games::gitadora::ARENA_SUBSCREEN_HEIGHT;
+        }
+
         functions["read"] = std::bind(&Touch::read, this, _1, _2);
         functions["write"] = std::bind(&Touch::write, this, _1, _2);
         functions["write_reset"] = std::bind(&Touch::write_reset, this, _1, _2);
@@ -99,7 +179,11 @@ namespace api::modules {
         }
 
         // apply touch points
-        touch_write_points(&touch_points);
+        if (use_native) {
+            write_native(touch_points);
+        } else {
+            touch_write_points(&touch_points);
+        }
     }
 
     /**
@@ -123,23 +207,54 @@ namespace api::modules {
         }
 
         // remove all IDs
-        touch_remove_points(&touch_point_ids);
+        if (use_native) {
+            write_reset_native(touch_point_ids);
+        } else {
+            touch_remove_points(&touch_point_ids);
+        }
+    }
+
+    void Touch::write_native(const std::vector<TouchPoint> &touch_points) {
+        if (touch_points.empty()) {
+            return;
+        }
+
+        std::lock_guard<std::mutex> lock(native_touch_mutex);
+        const auto touch_id = touch_points.front().id;
+        if (native_touch_id && *native_touch_id != touch_id) {
+            if (!inject_native_touch({}, native_canvas_w, native_canvas_h)) {
+                return;
+            }
+            native_touch_id.reset();
+        }
+        if (inject_native_touch(touch_points, native_canvas_w, native_canvas_h)) {
+            native_touch_id = touch_id;
+        }
+    }
+
+    void Touch::write_reset_native(const std::vector<DWORD> &touch_point_ids) {
+        std::lock_guard<std::mutex> lock(native_touch_mutex);
+        if (!native_touch_id ||
+                std::find(
+                    touch_point_ids.begin(),
+                    touch_point_ids.end(),
+                    *native_touch_id) == touch_point_ids.end()) {
+            return;
+        }
+        if (inject_native_touch({}, native_canvas_w, native_canvas_h)) {
+            native_touch_id.reset();
+        }
     }
 
     void Touch::apply_touch_errata(int &x, int &y) {
-        int x_raw = x;
-        int y_raw = y;
-
         if (is_tdj_fhd) {
             // deal with TDJ FHD resolution mismatch (upgrade 720p to 1080p)
             // we don't know what screen is being shown on the companion and the API doesn't specify
             // the target of the touch events so just assume it's the sub screen
-            x = x_raw * 1920 / 1280;
-            y = y_raw * 1080 / 720;
+            x = x * 1920 / 1280;
+            y = y * 1080 / 720;
         } else if (is_sdvx) {
-            // for exceed gear, they are both 1080p screens, but need to apply transformation
-            x = 1080 - y_raw;
-            y = x_raw;
+            sdvx_touch_errata(x, y, use_native, native_canvas_w, native_canvas_h);
         }
     }
 }

src/spice2x/api/modules/touch.h

@@ -1,8 +1,12 @@
 #pragma once
 
+#include <cstdint>
+#include <mutex>
+#include <optional>
 #include <vector>
 #include "api/module.h"
 #include "api/request.h"
+#include "touch/touch.h"
 
 namespace api::modules {
 
@@ -13,11 +17,21 @@ namespace api::modules {
     private:
         bool is_sdvx;
         bool is_tdj_fhd;
+        bool use_native;
+        std::mutex native_touch_mutex;
+        std::optional<uint32_t> native_touch_id;
+
+        // resolution the API/companion sends native touch coordinates in (after errata);
+        // used to normalize before mapping into the native injection window
+        int native_canvas_w;
+        int native_canvas_h;
 
         // function definitions
         void read(Request &req, Response &res);
         void write(Request &req, Response &res);
         void write_reset(Request &req, Response &res);
+        void write_native(const std::vector<TouchPoint> &touch_points);
+        void write_reset_native(const std::vector<DWORD> &touch_point_ids);
         void apply_touch_errata(int &x, int &y);
 
     };

src/spice2x/api/resources/python/spiceapi/__init__.py

@@ -7,6 +7,7 @@ from .coin import *
 from .control import *
 from .exceptions import *
 from .iidx import *
+from .sdvx import *
 from .info import *
 from .keypads import *
 from .lights import *

src/spice2x/api/resources/python/spiceapi/sdvx.py

@@ -0,0 +1,12 @@
+from .connection import Connection
+from .request import Request
+
+
+def sdvx_tapeled_get(con: Connection, *light_names):
+    req = Request("sdvx", "tapeled_get")
+
+    for light_name in light_names:
+        req.add_param(light_name)
+
+    res = con.request(req)
+    return res.get_data()

src/spice2x/api/serial.cpp

@@ -1,11 +1,12 @@
 #include "controller.h"
 #include "serial.h"
 
+#include <chrono>
 #include <string>
+#include <thread>
 #include <utility>
 
 #include "util/logging.h"
-#include "util/precise_timer.h"
 #include "util/utils.h"
 
 
@@ -17,7 +18,6 @@ namespace api {
         controller->init_state(this->state);
         this->thread = new std::thread([this] () {
             log_warning("api::serial", "listening on {} (baud: {})", this->port, this->baud);
-            timeutils::PreciseSleepTimer timer;
 
             // read buffer
             uint8_t read_buffer[16*1024];
@@ -162,7 +162,7 @@ namespace api {
 
                 // slow down on reconnect
                 if (this->running) {
-                    timer.sleep(retry_time);
+                    std::this_thread::sleep_for(std::chrono::milliseconds(retry_time));
                 }
             }
         });

src/spice2x/avs/core.cpp

@@ -1114,6 +1114,7 @@ namespace avs {
 #endif
             // jubeat
             {"jubeat.dll", 0x2000000},
+            {"jubeat2019.dll", 0x10000000},
 
             // MUSECA
             {"museca.dll", 0xC000000},
@@ -1924,7 +1925,7 @@ namespace avs {
 #if !SPICE64
             // sdvx4 bad log config fix
             if (avs::game::DLL_NAME == "soundvoltex.dll" &&  // it's too early for avs::game::is_model
-                property_search_safe(config, config_node, "/log/enable_console")) {
+                property_search(config, config_node, "/log/enable_console")) {
                 log_info("avs-core", "applying SDVX4 avs-config.xml fix for <log><enable_console>");
                 property_search_remove_safe(config, config_node, "/log/enable_console");
             }

src/spice2x/avs/ea3.cpp

@@ -591,6 +591,7 @@ namespace avs {
             // for proper reporting of Omnimix and other song packs
             if (_stricmp(EA3_MODEL, "LDJ") == 0 ||
                 _stricmp(EA3_MODEL, "L44") == 0 ||
+                _stricmp(EA3_MODEL, "T44") == 0 ||
                 _stricmp(EA3_MODEL, "M39") == 0 ||
                 _stricmp(EA3_MODEL, "KFC") == 0)
             {

src/spice2x/build/manifest.manifest

@@ -6,6 +6,7 @@
         <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
             <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
             <dpiAware>true</dpiAware>
+            <activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">Legacy</activeCodePage>
         </asmv3:windowsSettings>
     </asmv3:application>
     <dependency>

src/spice2x/build_all.sh

@@ -214,6 +214,19 @@ time (
 	echo "==========================="
 )
 
+echo ""
+echo "Checking Win7 compatibility..."
+echo "============================="
+if ! command -v windows_dll_compat_checker &> /dev/null; then
+	echo "WARNING: windows_dll_compat_checker not found, skipping Win7 compatibility check"
+else
+	windows_dll_compat_checker -s PREMADE/konami_win7_museca_x86_64.ini \
+		${BUILDDIR_64}/spicetools/64/spice64.exe
+	windows_dll_compat_checker -s PREMADE/konami_win7_museca_x86_64_32bit_dlls.ini \
+		${BUILDDIR_32}/spicetools/spicecfg.exe \
+		${BUILDDIR_32}/spicetools/32/spice.exe
+fi
+
 if ((BUILD_XP_32 > 0)) || ((BUILD_XP_64 > 0))
 then
 	echo ""
@@ -229,7 +242,7 @@ then
 		fi
 		if ((BUILD_XP_32 > 0))
 		then
-			windows_dll_compat_checker -s PREMADE/winxp_x86_64_32bit_dlls.ini \
+			windows_dll_compat_checker -s PREMADE/konami_winxp_jubeat_i686.ini \
 				${BUILDDIR_WINXP_32}/spicetools/spicecfg.exe \
 				${BUILDDIR_WINXP_32}/spicetools/32/spice.exe
 		fi
@@ -294,6 +307,7 @@ mkdir -p ${OUTDIR_EXTRAS}/largeaddressaware
 mkdir -p ${OUTDIR_EXTRAS}/linux
 mkdir -p ${OUTDIR_EXTRAS}/sdk/samples/32
 mkdir -p ${OUTDIR_EXTRAS}/sdk/samples/64
+mkdir -p ${OUTDIR_EXTRAS}/updater
 if ((BUILD_XP_32 > 0)) || ((BUILD_XP_64 > 0))
 then
 mkdir -p ${OUTDIR_EXTRAS}/winxp
@@ -354,6 +368,9 @@ mkdir ${OUTDIR_EXTRAS}/api
 find ./api/resources/python -name "__pycache__" -exec rm -rf {} +
 cp -r ./api/resources/* ${OUTDIR_EXTRAS}/api
 
+# generate the standalone updater scripts from the shared template and drop them
+bash ./build_updaters.sh ${OUTDIR_EXTRAS}/updater
+
 # build distribution archive
 if ((DIST_ENABLE > 0))
 then

src/spice2x/build_updaters.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+
+# builds the standalone updater scripts from the shared PowerShell logic in
+# update_spice.ps1. each output is a self-contained polyglot .bat: a small batch
+# header (with the release channel baked in) followed by the shared PowerShell
+# body after the marker line.
+#
+# usage: build_updaters.sh OUT_DIR
+#   OUT_DIR  directory to write the generated .bat files into
+
+set -eu
+
+if [ $# -lt 1 ]; then
+	echo "usage: build_updaters.sh OUT_DIR" >&2
+	exit 1
+fi
+
+SRC_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PS_BODY="${SRC_DIR}/update_spice.ps1"
+OUT_DIR="$1"
+
+[ -f "$PS_BODY" ] || { echo "error: $PS_BODY not found" >&2; exit 1; }
+
+MARKER='#___PS___'
+
+gen() {
+	channel="$1"; label="$2"; out="$3"
+	{
+		cat <<HEADER
+@echo off
+setlocal
+REM ============================================================================
+REM  spice2x updater  -  updates spice.exe, spice64.exe and spicecfg.exe in
+REM  this folder to the latest spice2x release from GitHub.
+REM
+REM  release channel: ${label}
+REM  make sure spice/spicecfg are NOT running before updating.
+REM ============================================================================
+
+REM expose the script folder + channel to the embedded PowerShell, then run the
+REM PowerShell part: re-read this file and execute everything after the marker.
+set "SPICE_DIR=%~dp0"
+set "SPICE_CHANNEL=${channel}"
+powershell -NoProfile -ExecutionPolicy Bypass -Command "\$m='#___'+'PS'+'___'; \$code=((Get-Content -LiteralPath '%~f0' -Raw) -split \$m)[-1]; Invoke-Expression \$code"
+set "RC=%ERRORLEVEL%"
+endlocal & exit /b %RC%
+
+${MARKER}
+HEADER
+		cat "$PS_BODY"
+	} | sed -e 's/\r$//' -e 's/$/\r/' > "${OUT_DIR}/${out}"
+	echo "  generated ${OUT_DIR}/${out}"
+}
+
+echo "Generating updater scripts from $(basename "$PS_BODY")..."
+gen "" "stable (pre-releases excluded)" "update_spice.bat"
+gen "beta" "beta (newest, pre-releases included)" "update_spice_beta.bat"

src/spice2x/cfg/api.cpp

@@ -3,7 +3,9 @@
 #include <cassert>
 #include <optional>
 
+#include "games/io.h"
 #include "launcher/superexit.h"
+#include "misc/eamuse.h"
 #include "rawinput/rawinput.h"
 #include "rawinput/piuio.h"
 #include "util/time.h"
@@ -62,7 +64,43 @@ std::vector<Button> GameAPI::Buttons::sortButtons(
     return sorted;
 }
 
-GameAPI::Buttons::State GameAPI::Buttons::getState(rawinput::RawInputManager *manager, Button &_button, bool check_alts) {
+namespace GameAPI::Buttons {
+    static State get_button_state(
+        rawinput::RawInputManager *manager,
+        Button &button,
+        bool check_alts,
+        bool check_modifiers);
+
+    static bool modifiers_pressed(rawinput::RawInputManager *manager, Button &button);
+}
+
+bool GameAPI::Buttons::modifiers_pressed(rawinput::RawInputManager *manager, Button &button) {
+    const auto modifier_mask = button.getModifierMask();
+    if (modifier_mask == 0) {
+        return true;
+    }
+
+    auto *modifier_buttons = games::get_buttons_modifiers(eamuse_get_game());
+    if (!modifier_buttons) {
+        return false;
+    }
+
+    for (uint8_t index = 0; index < games::ModifierButtons::Size; index++) {
+        if ((modifier_mask & (UINT8_C(1) << index)) != 0 &&
+            (index >= modifier_buttons->size() ||
+             get_button_state(manager, modifier_buttons->at(index), true, false) !=
+                 GameAPI::Buttons::BUTTON_PRESSED)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+GameAPI::Buttons::State GameAPI::Buttons::get_button_state(
+        rawinput::RawInputManager *manager,
+        Button &_button,
+        bool check_alts,
+        bool check_modifiers) {
 
     // check override
     if (_button.override_enabled) {
@@ -76,6 +114,23 @@ GameAPI::Buttons::State GameAPI::Buttons::getState(rawinput::RawInputManager *ma
     std::optional<bool> window_has_focus;
     while (true) {
 
+        // skip bindings whose required modifiers are not held
+        //
+        // note that modifiers cannot process MIDI as the logic is written
+        // below, since MIDI buttons are event-based (on event, off event, etc)
+        // and cannot be correctly handled by a simple early return
+        // there is no explicit check for MIDI here, but the UI should have
+        // prevented it
+        if (check_modifiers && !modifiers_pressed(manager, *current_button)) {
+            button_count++;
+            if (!alternatives || alternatives->empty() ||
+                button_count - 1 >= alternatives->size()) {
+                return BUTTON_NOT_PRESSED;
+            }
+            current_button = &alternatives->at(button_count - 1);
+            continue;
+        }
+
         // naive behavior
         if (current_button->isNaive()) {
             GameAPI::Buttons::State state;
@@ -411,6 +466,12 @@ GameAPI::Buttons::State GameAPI::Buttons::getState(rawinput::RawInputManager *ma
                         BUTTON_PRESSED : BUTTON_NOT_PRESSED;
                     break;
                 }
+                case rawinput::DESTROYED:
+                    // device was unplugged. release the button instead of leaving
+                    // state at getLastState(), which would latch a held button on
+                    // forever (e.g. a MIDI note held while the device is removed)
+                    state = BUTTON_NOT_PRESSED;
+                    break;
                 default:
                     break;
             }
@@ -463,6 +524,10 @@ GameAPI::Buttons::State GameAPI::Buttons::getState(rawinput::RawInputManager *ma
     }
 }
 
+Buttons::State Buttons::getState(rawinput::RawInputManager *manager, Button &button, bool check_alts) {
+    return get_button_state(manager, button, check_alts, true);
+}
+
 Buttons::State Buttons::getState(std::unique_ptr<rawinput::RawInputManager> &manager, Button &button, bool check_alts) {
     if (manager) {
         return getState(manager.get(), button, check_alts);
@@ -478,17 +543,13 @@ static float getVelocityHelper(rawinput::RawInputManager *manager, Button &butto
         return button.override_velocity;
     }
 
-    // naive behavior
-    if (button.isNaive()) {
-        if (button.getInvert()) {
-            return (GetAsyncKeyState(button.getVKey()) & 0x8000) ? 0.f : 1.f;
-        } else {
-            return (GetAsyncKeyState(button.getVKey()) & 0x8000) ? 1.f : 0.f;
-        }
-    }
-
     // get button state
-    Buttons::State button_state = Buttons::getState(manager, button, false);
+    const auto button_state = Buttons::getState(manager, button, false);
+
+    // naive bindings report their digital state as full or zero velocity
+    if (button.isNaive()) {
+        return button_state == Buttons::BUTTON_PRESSED ? 1.f : 0.f;
+    }
 
     // check if button isn't being pressed
     if (button_state != Buttons::BUTTON_PRESSED) {

src/spice2x/cfg/button.cpp

@@ -299,7 +299,27 @@ std::string Button::getMidiNoteString() {
     return fmt::format("{}{}", note_names[index % 12], ((index / 12) - 1));
 }
 
-std::string Button::getDisplayString(rawinput::RawInputManager* manager) {
+std::string Button::getDisplayString(rawinput::RawInputManager *manager) {
+    auto binding_display = this->getBindingDisplayString(manager);
+    auto modifiers = this->getModifierMask();
+    if (binding_display.empty() || modifiers == 0) {
+        return binding_display;
+    }
+
+    std::string modifier_display;
+    for (unsigned int index = 1; modifiers != 0; index++, modifiers >>= 1) {
+        if ((modifiers & UINT8_C(1)) == 0) {
+            continue;
+        }
+        if (!modifier_display.empty()) {
+            modifier_display += "+";
+        }
+        modifier_display += fmt::format("Mod{}", index);
+    }
+    return modifier_display + "+" + binding_display;
+}
+
+std::string Button::getBindingDisplayString(rawinput::RawInputManager *manager) {
 
     // get VKey string
     auto vKey = (uint16_t) this->getVKey();

src/spice2x/cfg/button.h

@@ -49,6 +49,7 @@ private:
     std::string name;
     std::string device_identifier = "";
     unsigned short vKey = INVALID_VKEY;
+    uint8_t modifier_mask = 0;
 
     // default bindings are always naive
     unsigned short vKey_default = INVALID_VKEY;
@@ -65,6 +66,7 @@ private:
     unsigned short velocity_threshold = 0;
 
     std::string getMidiNoteString();
+    std::string getBindingDisplayString(rawinput::RawInputManager *manager);
 
 public:
     std::string getVKeyString();
@@ -111,6 +113,7 @@ public:
         device_identifier = "";
         analog_type = BAT_NONE;
         bat_threshold = 0;
+        modifier_mask = 0;
     }
 
     std::string getDisplayString(rawinput::RawInputManager* manager);
@@ -123,6 +126,14 @@ public:
         return this->name;
     }
 
+    inline uint8_t getModifierMask() const {
+        return this->modifier_mask;
+    }
+
+    inline void setModifierMask(uint8_t new_modifier_mask) {
+        this->modifier_mask = new_modifier_mask & UINT8_C(0x0F);
+    }
+
     inline const std::string &getDeviceIdentifier() const {
         return this->device_identifier;
     }

src/spice2x/cfg/config.cpp

@@ -165,6 +165,7 @@ bool Config::addGame(Game &game, bool save) {
                     int bat_threshold = 0;
                     int velocity_threshold = 0;
                     bool invert = false;
+                    unsigned int modifier_mask = 0;
                     tinyxml2::XMLError attrError = gameButtonNode->QueryIntAttribute("vkey", &vKey);
                     const char *devid = gameButtonNode->Attribute("devid");
                     gameButtonNode->QueryIntAttribute("analogtype", &analogType);
@@ -173,6 +174,7 @@ bool Config::addGame(Game &game, bool save) {
                     gameButtonNode->QueryIntAttribute("bat_threshold", &bat_threshold);
                     gameButtonNode->QueryIntAttribute("velocity_threshold", &velocity_threshold);
                     gameButtonNode->QueryBoolAttribute("invert", &invert);
+                    gameButtonNode->QueryUnsignedAttribute("modifiers", &modifier_mask);
                     if (attrError != tinyxml2::XMLError::XML_SUCCESS) {
                         gameButtonsNode->DeleteChild(gameButtonNode);
                         gameButtonNode = this->configFile.NewElement("button");
@@ -185,6 +187,7 @@ bool Config::addGame(Game &game, bool save) {
                         gameButtonNode->SetAttribute("bat_threshold", bat_threshold);
                         gameButtonNode->SetAttribute("velocity_threshold", velocity_threshold);
                         gameButtonNode->SetAttribute("invert", invert);
+                        gameButtonNode->SetAttribute("modifiers", button->getModifierMask());
                         gameButtonsNode->InsertEndChild(gameButtonNode);
                     } else {
                         button->setVKey(static_cast<unsigned short int>(vKey));
@@ -194,6 +197,7 @@ bool Config::addGame(Game &game, bool save) {
                         button->setBatThreshold(bat_threshold);
                         button->setVelocityThreshold(velocity_threshold);
                         button->setInvert(invert);
+                        button->setModifierMask(static_cast<uint8_t>(modifier_mask));
                         if (devid) {
                             button->setDeviceIdentifier(devid);
                         }
@@ -214,6 +218,7 @@ bool Config::addGame(Game &game, bool save) {
                 gameButtonNode->SetAttribute("bat_threshold", it.getBatThreshold());
                 gameButtonNode->SetAttribute("velocity_threshold", it.getVelocityThreshold());
                 gameButtonNode->SetAttribute("invert", it.getInvert());
+                gameButtonNode->SetAttribute("modifiers", it.getModifierMask());
                 gameButtonNode->SetAttribute("devid", it.getDeviceIdentifier().c_str());
                 gameButtonsNode->InsertEndChild(gameButtonNode);
             }
@@ -440,6 +445,7 @@ bool Config::addGame(Game &game, bool save) {
             gameButtonNode->SetAttribute("bat_threshold", it.getBatThreshold());
             gameButtonNode->SetAttribute("velocity_threshold", it.getVelocityThreshold());
             gameButtonNode->SetAttribute("invert", it.getInvert());
+            gameButtonNode->SetAttribute("modifiers", it.getModifierMask());
             gameButtonNode->SetAttribute("devid", it.getDeviceIdentifier().c_str());
             gameButtonsNode->InsertEndChild(gameButtonNode);
         }
@@ -552,6 +558,7 @@ bool Config::updateBinding(const Game &game, const Button &button, int alternati
                 gameButtonNode->SetAttribute("velocity_threshold", button.getVelocityThreshold());
                 gameButtonNode->SetAttribute("invert", button.getInvert());
                 gameButtonNode->SetAttribute("devid", button.getDeviceIdentifier().c_str());
+                gameButtonNode->SetAttribute("modifiers", button.getModifierMask());
                 break;
             }
         }
@@ -569,6 +576,7 @@ bool Config::updateBinding(const Game &game, const Button &button, int alternati
             gameButtonNode->SetAttribute("velocity_threshold", 0);
             gameButtonNode->SetAttribute("invert", false);
             gameButtonNode->SetAttribute("devid", "");
+            gameButtonNode->SetAttribute("modifiers", 0);
             gameButtonsNode->InsertEndChild(gameButtonNode);
         }
     }
@@ -964,6 +972,7 @@ std::vector<Button> Config::getButtons(const std::string &gameName) {
                 int bat_threshold = 0;
                 int velocity_threshold = 0;
                 bool invert = false;
+                unsigned int modifier_mask = 0;
                 gameButtonNode->QueryIntAttribute("vkey", &vKey);
                 gameButtonNode->QueryIntAttribute("analogtype", &analogType);
                 gameButtonNode->QueryDoubleAttribute("debounce_up", &debounce_up);
@@ -971,6 +980,7 @@ std::vector<Button> Config::getButtons(const std::string &gameName) {
                 gameButtonNode->QueryIntAttribute("bat_threshold", &bat_threshold);
                 gameButtonNode->QueryIntAttribute("velocity_threshold", &velocity_threshold);
                 gameButtonNode->QueryBoolAttribute("invert", &invert);
+                gameButtonNode->QueryUnsignedAttribute("modifiers", &modifier_mask);
                 const char *devid = gameButtonNode->Attribute("devid");
 
                 // find alternative
@@ -986,6 +996,7 @@ std::vector<Button> Config::getButtons(const std::string &gameName) {
                         alt.setBatThreshold(bat_threshold);
                         alt.setVelocityThreshold(velocity_threshold);
                         alt.setInvert(invert);
+                        alt.setModifierMask(static_cast<uint8_t>(modifier_mask));
                         if (devid) {
                             alt.setDeviceIdentifier(std::string(devid));
                         }
@@ -1005,6 +1016,7 @@ std::vector<Button> Config::getButtons(const std::string &gameName) {
                     button.setBatThreshold(bat_threshold);
                     button.setVelocityThreshold(velocity_threshold);
                     button.setInvert(invert);
+                    button.setModifierMask(static_cast<uint8_t>(modifier_mask));
                     if (devid) {
                         button.setDeviceIdentifier(devid);
                     }

src/spice2x/cfg/configurator.cpp

@@ -3,6 +3,7 @@
 #include <d3d9.h>
 
 #include "overlay/overlay.h"
+#include "util/libutils.h"
 #include "util/logging.h"
 
 namespace cfg {
@@ -35,7 +36,26 @@ namespace cfg {
             return false;
         }
 
-        IDirect3D9 *d3d = Direct3DCreate9(D3D_SDK_VERSION);
+        // load d3d9.dll dynamically rather than linking against it statically.
+        // a static import would force the system d3d9.dll to load at process
+        // startup for the main spice executable too (this file is shared with
+        // spice.exe), which loads system32\d3d9.dll before the modules directory
+        // is added to the DLL search path - preventing a user-supplied DXVK
+        // d3d9.dll in modules from ever loading for the game.
+        typedef IDirect3D9 *(WINAPI *Direct3DCreate9_t)(UINT);
+        HMODULE d3d9_module = libutils::try_library("d3d9.dll");
+        if (d3d9_module == nullptr) {
+            log_warning("configurator", "could not load d3d9.dll, falling back to software renderer");
+            return false;
+        }
+        auto Direct3DCreate9_fn =
+                reinterpret_cast<Direct3DCreate9_t>(libutils::try_proc(d3d9_module, "Direct3DCreate9"));
+        if (Direct3DCreate9_fn == nullptr) {
+            log_warning("configurator", "could not find Direct3DCreate9, falling back to software renderer");
+            return false;
+        }
+
+        IDirect3D9 *d3d = Direct3DCreate9_fn(D3D_SDK_VERSION);
         if (d3d == nullptr) {
             log_warning("configurator", "Direct3DCreate9 returned NULL, falling back to software renderer");
             return false;

src/spice2x/cfg/controller_presets.cpp

@@ -26,6 +26,7 @@ namespace overlay::windows {
         el->SetAttribute("debounce_down", entry.debounce_down);
         el->SetAttribute("bat_threshold", entry.bat_threshold);
         el->SetAttribute("velocity_threshold", entry.velocity_threshold);
+        el->SetAttribute("modifiers", entry.modifier_mask);
         parent->InsertEndChild(el);
     }
 
@@ -54,6 +55,10 @@ namespace overlay::windows {
         el->QueryIntAttribute("bat_threshold", &bat);
         entry.bat_threshold = bat;
 
+        unsigned int modifier_mask = 0;
+        el->QueryUnsignedAttribute("modifiers", &modifier_mask);
+        entry.modifier_mask = static_cast<uint8_t>(modifier_mask & UINT8_C(0x0F));
+
         return entry;
     }
 
@@ -160,6 +165,28 @@ namespace overlay::windows {
                 }
             }
 
+            // modifier buttons
+            auto *mod_el = tmpl_el->FirstChildElement("modifier_buttons");
+            if (mod_el) {
+                auto *btn_el = mod_el->FirstChildElement("button");
+                while (btn_el) {
+                    const char *btn_name = btn_el->Attribute("name");
+                    std::string btn_name_str = btn_name ? btn_name : "";
+
+                    TemplateButtonBinding *binding = nullptr;
+                    for (auto &b : tmpl.modifier_buttons) {
+                        if (b.name == btn_name_str) { binding = &b; break; }
+                    }
+                    if (!binding) {
+                        tmpl.modifier_buttons.push_back(
+                            {btn_name_str, read_button_entry(btn_el), {}});
+                    } else {
+                        binding->alternatives.push_back(read_button_entry(btn_el));
+                    }
+                    btn_el = btn_el->NextSiblingElement("button");
+                }
+            }
+
             // keypad buttons
             auto *kp_el = tmpl_el->FirstChildElement("keypad_buttons");
             if (kp_el) {
@@ -244,6 +271,7 @@ namespace overlay::windows {
     bool save_user_template(
         const ControllerTemplate &tmpl,
         const bool save_buttons,
+        const bool save_modifiers,
         const bool save_keypads,
         const bool save_analogs,
         const bool save_lights) {
@@ -300,6 +328,24 @@ namespace overlay::windows {
         }
         tmpl_el->InsertEndChild(buttons_el);
 
+        // modifier buttons - skip unbound entries
+        if (!tmpl.modifier_buttons.empty()) {
+            auto *mod_el = doc.NewElement("modifier_buttons");
+            if (save_modifiers) {
+                for (auto &btn : tmpl.modifier_buttons) {
+                    if (!btn.primary.is_unbound()) {
+                        write_button_entry(doc, mod_el, btn.name, btn.primary);
+                    }
+                    for (auto &alt : btn.alternatives) {
+                        if (!alt.is_unbound()) {
+                            write_button_entry(doc, mod_el, btn.name, alt);
+                        }
+                    }
+                }
+            }
+            tmpl_el->InsertEndChild(mod_el);
+        }
+
         // keypad buttons — skip unbound entries
         if (!tmpl.keypad_buttons.empty()) {
             auto *kp_el = doc.NewElement("keypad_buttons");

src/spice2x/cmake/check_no_static_dll_imports.cmake

@@ -0,0 +1,72 @@
+# fails the build if a PE binary statically imports a forbidden DLL.
+#
+# some DLLs must never end up in spice's static import table, for two reasons:
+#
+#  1. user-overridable DLLs (e.g. DXVK's d3d9.dll): users drop their own copy
+#     into the modules directory to replace the system one. a static import
+#     forces the loader to load the SYSTEM copy at process startup - before the
+#     modules directory is added to the DLL search path and before the game DLL
+#     loads - so the user-supplied override never takes effect (see issue #779).
+#
+#  2. DLLs that break games when present (e.g. Media Foundation: mf/mfplat/
+#     mfreadwrite): a static import loads them eagerly and breaks Unity games.
+#
+# in both cases the DLL must instead be loaded dynamically (libutils::try_library
+# / GetProcAddress / delay load) so it is only pulled in when actually needed.
+#
+# invoked via `cmake -P` from a POST_BUILD step. required -D variables:
+#   OBJDUMP     - path to objdump (CMAKE_OBJDUMP)
+#   TARGET_FILE - path to the PE binary to inspect
+#   FORBIDDEN   - semicolon-separated list of lowercase DLL names to reject
+
+if(NOT OBJDUMP OR NOT EXISTS "${OBJDUMP}")
+    message(WARNING
+        "check_no_static_dll_imports: objdump not found, skipping import check for ${TARGET_FILE}")
+    return()
+endif()
+
+execute_process(
+    COMMAND "${OBJDUMP}" -p "${TARGET_FILE}"
+    OUTPUT_VARIABLE dump_output
+    RESULT_VARIABLE dump_result
+    ERROR_VARIABLE dump_error)
+
+if(NOT dump_result EQUAL 0)
+    message(WARNING
+        "check_no_static_dll_imports: objdump failed for ${TARGET_FILE}: ${dump_error}")
+    return()
+endif()
+
+# both GNU objdump and llvm-objdump print one "DLL Name: <name>" line per
+# statically imported DLL in their PE private-header dump.
+string(REGEX MATCHALL "DLL Name:[ \t]*[^\n\r]+" dll_lines "${dump_output}")
+
+set(violations "")
+foreach(line IN LISTS dll_lines)
+    string(REGEX REPLACE "DLL Name:[ \t]*" "" dll_name "${line}")
+    string(STRIP "${dll_name}" dll_name)
+    string(TOLOWER "${dll_name}" dll_name_lower)
+    if(dll_name_lower IN_LIST FORBIDDEN)
+        list(APPEND violations "${dll_name}")
+    endif()
+endforeach()
+
+if(violations)
+    list(REMOVE_DUPLICATES violations)
+    string(REPLACE ";" ", " violations_str "${violations}")
+    message(FATAL_ERROR
+        "static DLL import check FAILED for ${TARGET_FILE}\n"
+        "  forbidden static imports found: ${violations_str}\n"
+        "\n"
+        "  these DLLs must never be statically imported by spice:\n"
+        "    * user-overridable DLLs (e.g. DXVK d3d9.dll) - a static import loads the\n"
+        "      system copy at startup and preempts the modules override (issue #779).\n"
+        "    * Media Foundation DLLs (mf/mfplat/mfreadwrite) - a static import breaks\n"
+        "      Unity games.\n"
+        "\n"
+        "  fix: load the DLL dynamically instead - replace the direct API call with a\n"
+        "  libutils::try_library() + libutils::try_proc() lookup (or a delay load), then\n"
+        "  call through the resolved function pointer.")
+endif()
+
+message(STATUS "static DLL import check passed for ${TARGET_FILE}")

src/spice2x/external/dseg/DSEG-LICENSE.txt

@@ -1,95 +1,95 @@
-Copyright (c) 2017, keshikan (http://www.keshikan.net),
-with Reserved Font Name "DSEG".
-
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
-
-
------------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
------------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.
+Copyright (c) 2017, keshikan (http://www.keshikan.net),
+with Reserved Font Name "DSEG".
+
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

src/spice2x/external/easywsclient/easywsclient.cpp

@@ -0,0 +1,552 @@
+// This code comes from:
+// https://github.com/dhbaird/easywsclient
+//
+// To get the latest version:
+// wget https://raw.github.com/dhbaird/easywsclient/master/easywsclient.hpp
+// wget https://raw.github.com/dhbaird/easywsclient/master/easywsclient.cpp
+
+#include "easywsclient.hpp"
+
+#ifdef _WIN32
+    #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+    #endif
+    #include <winsock2.h>
+    #include <ws2tcpip.h>
+    #pragma comment( lib, "ws2_32" )
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <vector>
+    #include <string>
+    typedef SOCKET socket_t;
+    #ifndef _SSIZE_T_DEFINED
+        typedef int ssize_t;
+        #define _SSIZE_T_DEFINED
+    #endif
+    #ifndef _SOCKET_T_DEFINED
+        typedef SOCKET socket_t;
+        #define _SOCKET_T_DEFINED
+    #endif
+    #if defined(_MSC_VER) && !defined(snprintf)
+        #define snprintf _snprintf_s
+    #endif
+    #include <stdint.h>
+    #define socketerrno WSAGetLastError()
+    #define SOCKET_EAGAIN_EINPROGRESS WSAEINPROGRESS
+    #define SOCKET_EWOULDBLOCK WSAEWOULDBLOCK
+#else
+    #include <fcntl.h>
+    #include <netdb.h>
+    #include <netinet/tcp.h>
+    #include <stdint.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <sys/socket.h>
+    #include <sys/time.h>
+    #include <sys/types.h>
+    #include <unistd.h>
+    #include <string>
+    #include <vector>
+    #include <errno.h>
+    typedef int socket_t;
+    #ifndef INVALID_SOCKET
+        #define INVALID_SOCKET (-1)
+    #endif
+    #ifndef SOCKET_ERROR
+        #define SOCKET_ERROR (-1)
+    #endif
+    #define closesocket(s) ::close(s)
+    #include <errno.h>
+    #define socketerrno errno
+    #define SOCKET_EAGAIN_EINPROGRESS EAGAIN
+    #define SOCKET_EWOULDBLOCK EWOULDBLOCK
+#endif
+
+#include <vector>
+#include <string>
+
+#include <stdarg.h>
+
+#include "util/logging.h"
+
+// When false, easywsclient's diagnostics are suppressed. The host application
+// opts in by setting this flag (see obs_websocket.cpp).
+bool EASYWSCLIENT_LOGGING_ENABLED = false;
+
+// Route easywsclient's diagnostic output through the project logger instead of
+// writing to stderr, without editing the upstream source lines below: these two
+// macros redirect fprintf(stderr, ...) / fputs(..., stderr) to log_misc.
+// Only emitted when EASYWSCLIENT_LOGGING_ENABLED is set.
+static inline void easywsclient_logf(const char *fmt, ...) {
+    if (!EASYWSCLIENT_LOGGING_ENABLED) {
+        return;
+    }
+    char buf[1024];
+    va_list args;
+    va_start(args, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, args);
+    va_end(args);
+    // trim trailing newline(s); the logger appends its own
+    size_t len = strlen(buf);
+    while (len > 0 && (buf[len - 1] == '\n' || buf[len - 1] == '\r')) {
+        buf[--len] = '\0';
+    }
+    log_misc("easywsclient", "{}", buf);
+}
+#define fprintf(stream, ...) easywsclient_logf(__VA_ARGS__)
+#define fputs(str, stream) easywsclient_logf("%s", str)
+
+using namespace easywsclient;
+
+namespace { // private module-only namespace
+
+socket_t hostname_connect(const std::string& hostname, int port) {
+    struct addrinfo hints;
+    struct addrinfo *result;
+    struct addrinfo *p;
+    int ret;
+    socket_t sockfd = INVALID_SOCKET;
+    char sport[16];
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+    snprintf(sport, 16, "%d", port);
+    if ((ret = getaddrinfo(hostname.c_str(), sport, &hints, &result)) != 0)
+    {
+      fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(ret));
+      return 1;
+    }
+    for(p = result; p != NULL; p = p->ai_next)
+    {
+        sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
+        if (sockfd == INVALID_SOCKET) { continue; }
+        if (connect(sockfd, p->ai_addr, p->ai_addrlen) != SOCKET_ERROR) {
+            break;
+        }
+        closesocket(sockfd);
+        sockfd = INVALID_SOCKET;
+    }
+    freeaddrinfo(result);
+    return sockfd;
+}
+
+
+class _DummyWebSocket : public easywsclient::WebSocket
+{
+  public:
+    void poll(int timeout) { }
+    void send(const std::string& message) { }
+    void sendBinary(const std::string& message) { }
+    void sendBinary(const std::vector<uint8_t>& message) { }
+    void sendPing() { }
+    void close() { }
+    readyStateValues getReadyState() const { return CLOSED; }
+    void _dispatch(Callback_Imp & callable) { }
+    void _dispatchBinary(BytesCallback_Imp& callable) { }
+};
+
+
+class _RealWebSocket : public easywsclient::WebSocket
+{
+  public:
+    // http://tools.ietf.org/html/rfc6455#section-5.2  Base Framing Protocol
+    //
+    //  0                   1                   2                   3
+    //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+    // +-+-+-+-+-------+-+-------------+-------------------------------+
+    // |F|R|R|R| opcode|M| Payload len |    Extended payload length    |
+    // |I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
+    // |N|V|V|V|       |S|             |   (if payload len==126/127)   |
+    // | |1|2|3|       |K|             |                               |
+    // +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
+    // |     Extended payload length continued, if payload len == 127  |
+    // + - - - - - - - - - - - - - - - +-------------------------------+
+    // |                               |Masking-key, if MASK set to 1  |
+    // +-------------------------------+-------------------------------+
+    // | Masking-key (continued)       |          Payload Data         |
+    // +-------------------------------- - - - - - - - - - - - - - - - +
+    // :                     Payload Data continued ...                :
+    // + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
+    // |                     Payload Data continued ...                |
+    // +---------------------------------------------------------------+
+
+    struct wsheader_type {
+        unsigned header_size;
+        bool fin;
+        bool mask;
+        enum opcode_type {
+            CONTINUATION = 0x0,
+            TEXT_FRAME = 0x1,
+            BINARY_FRAME = 0x2,
+            CLOSE = 8,
+            PING = 9,
+            PONG = 0xa,
+        } opcode;
+        int N0;
+        uint64_t N;
+        uint8_t masking_key[4];
+    };
+
+    std::vector<uint8_t> rxbuf;
+    std::vector<uint8_t> txbuf;
+    std::vector<uint8_t> receivedData;
+
+    socket_t sockfd;
+    readyStateValues readyState;
+    bool useMask;
+    bool isRxBad;
+
+    _RealWebSocket(socket_t sockfd, bool useMask) : sockfd(sockfd), readyState(OPEN), useMask(useMask), isRxBad(false) {
+    }
+
+    readyStateValues getReadyState() const {
+      return readyState;
+    }
+
+    void poll(int timeout) { // timeout in milliseconds
+        if (readyState == CLOSED) {
+            if (timeout > 0) {
+                timeval tv = { timeout/1000, (timeout%1000) * 1000 };
+                select(0, NULL, NULL, NULL, &tv);
+            }
+            return;
+        }
+        if (timeout != 0) {
+            fd_set rfds;
+            fd_set wfds;
+            timeval tv = { timeout/1000, (timeout%1000) * 1000 };
+            FD_ZERO(&rfds);
+            FD_ZERO(&wfds);
+            FD_SET(sockfd, &rfds);
+            if (txbuf.size()) { FD_SET(sockfd, &wfds); }
+            select(sockfd + 1, &rfds, &wfds, NULL, timeout > 0 ? &tv : NULL);
+        }
+        while (true) {
+            // FD_ISSET(0, &rfds) will be true
+            int N = rxbuf.size();
+            ssize_t ret;
+            rxbuf.resize(N + 1500);
+            ret = recv(sockfd, (char*)&rxbuf[0] + N, 1500, 0);
+            if (false) { }
+            else if (ret < 0 && (socketerrno == SOCKET_EWOULDBLOCK || socketerrno == SOCKET_EAGAIN_EINPROGRESS)) {
+                rxbuf.resize(N);
+                break;
+            }
+            else if (ret <= 0) {
+                rxbuf.resize(N);
+                closesocket(sockfd);
+                readyState = CLOSED;
+                fputs(ret < 0 ? "Connection error!\n" : "Connection closed!\n", stderr);
+                break;
+            }
+            else {
+                rxbuf.resize(N + ret);
+            }
+        }
+        while (txbuf.size()) {
+            int ret = ::send(sockfd, (char*)&txbuf[0], txbuf.size(), 0);
+            if (false) { } // ??
+            else if (ret < 0 && (socketerrno == SOCKET_EWOULDBLOCK || socketerrno == SOCKET_EAGAIN_EINPROGRESS)) {
+                break;
+            }
+            else if (ret <= 0) {
+                closesocket(sockfd);
+                readyState = CLOSED;
+                fputs(ret < 0 ? "Connection error!\n" : "Connection closed!\n", stderr);
+                break;
+            }
+            else {
+                txbuf.erase(txbuf.begin(), txbuf.begin() + ret);
+            }
+        }
+        if (!txbuf.size() && readyState == CLOSING) {
+            closesocket(sockfd);
+            readyState = CLOSED;
+        }
+    }
+
+    virtual void _dispatch(Callback_Imp & callable) {
+        struct CallbackAdapter : public BytesCallback_Imp
+            // Adapt void(const std::string<uint8_t>&) to void(const std::string&)
+        {
+            Callback_Imp& callable;
+            CallbackAdapter(Callback_Imp& callable) : callable(callable) { }
+            void operator()(const std::vector<uint8_t>& message) {
+                std::string stringMessage(message.begin(), message.end());
+                callable(stringMessage);
+            }
+        };
+        CallbackAdapter bytesCallback(callable);
+        _dispatchBinary(bytesCallback);
+    }
+
+    virtual void _dispatchBinary(BytesCallback_Imp& callable) {
+        // TODO: consider acquiring a lock on rxbuf...
+        while (true) {
+            wsheader_type ws;
+            if (rxbuf.size() < 2) { return; /* Need at least 2 */ }
+            const uint8_t * data = (uint8_t *) &rxbuf[0]; // peek, but don't consume
+            ws.fin = (data[0] & 0x80) == 0x80;
+            ws.opcode = (wsheader_type::opcode_type) (data[0] & 0x0f);
+            ws.mask = (data[1] & 0x80) == 0x80;
+            ws.N0 = (data[1] & 0x7f);
+            ws.header_size = 2 + (ws.N0 == 126? 2 : 0) + (ws.N0 == 127? 8 : 0) + (ws.mask? 4 : 0);
+            if (rxbuf.size() < ws.header_size) { return; /* Need: ws.header_size - rxbuf.size() */ }
+            int i = 0;
+            if (ws.N0 < 126) {
+                ws.N = ws.N0;
+                i = 2;
+            }
+            else if (ws.N0 == 126) {
+                ws.N = 0;
+                ws.N |= ((uint64_t) data[2]) << 8;
+                ws.N |= ((uint64_t) data[3]) << 0;
+                i = 4;
+            }
+            else if (ws.N0 == 127) {
+                ws.N = 0;
+                ws.N |= ((uint64_t) data[2]) << 56;
+                ws.N |= ((uint64_t) data[3]) << 48;
+                ws.N |= ((uint64_t) data[4]) << 40;
+                ws.N |= ((uint64_t) data[5]) << 32;
+                ws.N |= ((uint64_t) data[6]) << 24;
+                ws.N |= ((uint64_t) data[7]) << 16;
+                ws.N |= ((uint64_t) data[8]) << 8;
+                ws.N |= ((uint64_t) data[9]) << 0;
+                i = 10;
+            }
+            if (ws.mask) {
+                ws.masking_key[0] = ((uint8_t) data[i+0]) << 0;
+                ws.masking_key[1] = ((uint8_t) data[i+1]) << 0;
+                ws.masking_key[2] = ((uint8_t) data[i+2]) << 0;
+                ws.masking_key[3] = ((uint8_t) data[i+3]) << 0;
+            }
+            else {
+                ws.masking_key[0] = 0;
+                ws.masking_key[1] = 0;
+                ws.masking_key[2] = 0;
+                ws.masking_key[3] = 0;
+            }
+
+            // Note: The checks above should hopefully ensure this addition
+            //       cannot overflow:
+            if (rxbuf.size() < ws.header_size+ws.N) { return; /* Need: ws.header_size+ws.N - rxbuf.size() */ }
+
+            // We got a whole message, now do something with it:
+            if (false) { }
+            else if (
+                   ws.opcode == wsheader_type::TEXT_FRAME
+                || ws.opcode == wsheader_type::BINARY_FRAME
+                || ws.opcode == wsheader_type::CONTINUATION
+            ) {
+                if (ws.mask) { for (size_t i = 0; i != ws.N; ++i) { rxbuf[i+ws.header_size] ^= ws.masking_key[i&0x3]; } }
+                receivedData.insert(receivedData.end(), rxbuf.begin()+ws.header_size, rxbuf.begin()+ws.header_size+(size_t)ws.N);// just feed
+                if (ws.fin) {
+                    callable((const std::vector<uint8_t>) receivedData);
+                    receivedData.erase(receivedData.begin(), receivedData.end());
+                    std::vector<uint8_t> ().swap(receivedData);// free memory
+                }
+            }
+            else if (ws.opcode == wsheader_type::PING) {
+                if (ws.mask) { for (size_t i = 0; i != ws.N; ++i) { rxbuf[i+ws.header_size] ^= ws.masking_key[i&0x3]; } }
+                std::string data(rxbuf.begin()+ws.header_size, rxbuf.begin()+ws.header_size+(size_t)ws.N);
+                sendData(wsheader_type::PONG, data.size(), data.begin(), data.end());
+            }
+            else if (ws.opcode == wsheader_type::PONG) { }
+            else if (ws.opcode == wsheader_type::CLOSE) { close(); }
+            else { fprintf(stderr, "ERROR: Got unexpected WebSocket message.\n"); close(); }
+
+            rxbuf.erase(rxbuf.begin(), rxbuf.begin() + ws.header_size+(size_t)ws.N);
+        }
+    }
+
+    void sendPing() {
+        std::string empty;
+        sendData(wsheader_type::PING, empty.size(), empty.begin(), empty.end());
+    }
+
+    void send(const std::string& message) {
+        sendData(wsheader_type::TEXT_FRAME, message.size(), message.begin(), message.end());
+    }
+
+    void sendBinary(const std::string& message) {
+        sendData(wsheader_type::BINARY_FRAME, message.size(), message.begin(), message.end());
+    }
+
+    void sendBinary(const std::vector<uint8_t>& message) {
+        sendData(wsheader_type::BINARY_FRAME, message.size(), message.begin(), message.end());
+    }
+
+    template<class Iterator>
+    void sendData(wsheader_type::opcode_type type, uint64_t message_size, Iterator message_begin, Iterator message_end) {
+        // TODO:
+        // Masking key should (must) be derived from a high quality random
+        // number generator, to mitigate attacks on non-WebSocket friendly
+        // middleware:
+        const uint8_t masking_key[4] = { 0x12, 0x34, 0x56, 0x78 };
+        // TODO: consider acquiring a lock on txbuf...
+        if (readyState == CLOSING || readyState == CLOSED) { return; }
+        std::vector<uint8_t> header;
+        header.assign(2 + (message_size >= 126 ? 2 : 0) + (message_size >= 65536 ? 6 : 0) + (useMask ? 4 : 0), 0);
+        header[0] = 0x80 | type;
+        if (false) { }
+        else if (message_size < 126) {
+            header[1] = (message_size & 0xff) | (useMask ? 0x80 : 0);
+            if (useMask) {
+                header[2] = masking_key[0];
+                header[3] = masking_key[1];
+                header[4] = masking_key[2];
+                header[5] = masking_key[3];
+            }
+        }
+        else if (message_size < 65536) {
+            header[1] = 126 | (useMask ? 0x80 : 0);
+            header[2] = (message_size >> 8) & 0xff;
+            header[3] = (message_size >> 0) & 0xff;
+            if (useMask) {
+                header[4] = masking_key[0];
+                header[5] = masking_key[1];
+                header[6] = masking_key[2];
+                header[7] = masking_key[3];
+            }
+        }
+        else { // TODO: run coverage testing here
+            header[1] = 127 | (useMask ? 0x80 : 0);
+            header[2] = (message_size >> 56) & 0xff;
+            header[3] = (message_size >> 48) & 0xff;
+            header[4] = (message_size >> 40) & 0xff;
+            header[5] = (message_size >> 32) & 0xff;
+            header[6] = (message_size >> 24) & 0xff;
+            header[7] = (message_size >> 16) & 0xff;
+            header[8] = (message_size >>  8) & 0xff;
+            header[9] = (message_size >>  0) & 0xff;
+            if (useMask) {
+                header[10] = masking_key[0];
+                header[11] = masking_key[1];
+                header[12] = masking_key[2];
+                header[13] = masking_key[3];
+            }
+        }
+        // N.B. - txbuf will keep growing until it can be transmitted over the socket:
+        txbuf.insert(txbuf.end(), header.begin(), header.end());
+        txbuf.insert(txbuf.end(), message_begin, message_end);
+        if (useMask) {
+            size_t message_offset = txbuf.size() - message_size;
+            for (size_t i = 0; i != message_size; ++i) {
+                txbuf[message_offset + i] ^= masking_key[i&0x3];
+            }
+        }
+    }
+
+    void close() {
+        if(readyState == CLOSING || readyState == CLOSED) { return; }
+        readyState = CLOSING;
+        uint8_t closeFrame[6] = {0x88, 0x80, 0x00, 0x00, 0x00, 0x00}; // last 4 bytes are a masking key
+        std::vector<uint8_t> header(closeFrame, closeFrame+6);
+        txbuf.insert(txbuf.end(), header.begin(), header.end());
+    }
+
+};
+
+
+easywsclient::WebSocket::pointer from_url(const std::string& url, bool useMask, const std::string& origin) {
+    char host[512];
+    int port;
+    char path[512];
+    if (url.size() >= 512) {
+      fprintf(stderr, "ERROR: url size limit exceeded: %s\n", url.c_str());
+      return NULL;
+    }
+    if (origin.size() >= 200) {
+      fprintf(stderr, "ERROR: origin size limit exceeded: %s\n", origin.c_str());
+      return NULL;
+    }
+    if (false) { }
+    else if (sscanf(url.c_str(), "ws://%[^:/]:%d/%s", host, &port, path) == 3) {
+    }
+    else if (sscanf(url.c_str(), "ws://%[^:/]/%s", host, path) == 2) {
+        port = 80;
+    }
+    else if (sscanf(url.c_str(), "ws://%[^:/]:%d", host, &port) == 2) {
+        path[0] = '\0';
+    }
+    else if (sscanf(url.c_str(), "ws://%[^:/]", host) == 1) {
+        port = 80;
+        path[0] = '\0';
+    }
+    else {
+        fprintf(stderr, "ERROR: Could not parse WebSocket url: %s\n", url.c_str());
+        return NULL;
+    }
+    //fprintf(stderr, "easywsclient: connecting: host=%s port=%d path=/%s\n", host, port, path);
+    socket_t sockfd = hostname_connect(host, port);
+    if (sockfd == INVALID_SOCKET) {
+        fprintf(stderr, "Unable to connect to %s:%d\n", host, port);
+        return NULL;
+    }
+    {
+        // XXX: this should be done non-blocking,
+        char line[1024];
+        int status;
+        int i;
+        snprintf(line, 1024, "GET /%s HTTP/1.1\r\n", path); ::send(sockfd, line, strlen(line), 0);
+        if (port == 80) {
+            snprintf(line, 1024, "Host: %s\r\n", host); ::send(sockfd, line, strlen(line), 0);
+        }
+        else {
+            snprintf(line, 1024, "Host: %s:%d\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
+        }
+        snprintf(line, 1024, "Upgrade: websocket\r\n"); ::send(sockfd, line, strlen(line), 0);
+        snprintf(line, 1024, "Connection: Upgrade\r\n"); ::send(sockfd, line, strlen(line), 0);
+        if (!origin.empty()) {
+            snprintf(line, 1024, "Origin: %s\r\n", origin.c_str()); ::send(sockfd, line, strlen(line), 0);
+        }
+        snprintf(line, 1024, "Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n"); ::send(sockfd, line, strlen(line), 0);
+        snprintf(line, 1024, "Sec-WebSocket-Version: 13\r\n"); ::send(sockfd, line, strlen(line), 0);
+        snprintf(line, 1024, "\r\n"); ::send(sockfd, line, strlen(line), 0);
+        for (i = 0; i < 2 || (i < 1023 && line[i-2] != '\r' && line[i-1] != '\n'); ++i) { if (recv(sockfd, line+i, 1, 0) == 0) { return NULL; } }
+        line[i] = 0;
+        if (i == 1023) { fprintf(stderr, "ERROR: Got invalid status line connecting to: %s\n", url.c_str()); return NULL; }
+        if (sscanf(line, "HTTP/1.1 %d", &status) != 1 || status != 101) { fprintf(stderr, "ERROR: Got bad status connecting to %s: %s", url.c_str(), line); return NULL; }
+        // TODO: verify response headers,
+        while (true) {
+            for (i = 0; i < 2 || (i < 1023 && line[i-2] != '\r' && line[i-1] != '\n'); ++i) { if (recv(sockfd, line+i, 1, 0) == 0) { return NULL; } }
+            if (line[0] == '\r' && line[1] == '\n') { break; }
+        }
+    }
+    int flag = 1;
+    setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char*) &flag, sizeof(flag)); // Disable Nagle's algorithm
+#ifdef _WIN32
+    u_long on = 1;
+    ioctlsocket(sockfd, FIONBIO, &on);
+#else
+    fcntl(sockfd, F_SETFL, O_NONBLOCK);
+#endif
+    //fprintf(stderr, "Connected to: %s\n", url.c_str());
+    return easywsclient::WebSocket::pointer(new _RealWebSocket(sockfd, useMask));
+}
+
+} // end of module-only namespace
+
+
+
+namespace easywsclient {
+
+WebSocket::pointer WebSocket::create_dummy() {
+    static pointer dummy = pointer(new _DummyWebSocket);
+    return dummy;
+}
+
+
+WebSocket::pointer WebSocket::from_url(const std::string& url, const std::string& origin) {
+    return ::from_url(url, true, origin);
+}
+
+WebSocket::pointer WebSocket::from_url_no_mask(const std::string& url, const std::string& origin) {
+    return ::from_url(url, false, origin);
+}
+
+
+} // namespace easywsclient

src/spice2x/external/easywsclient/easywsclient.hpp

@@ -0,0 +1,73 @@
+#ifndef EASYWSCLIENT_HPP_20120819_MIOFVASDTNUASZDQPLFD
+#define EASYWSCLIENT_HPP_20120819_MIOFVASDTNUASZDQPLFD
+
+// This code comes from:
+// https://github.com/dhbaird/easywsclient
+//
+// To get the latest version:
+// wget https://raw.github.com/dhbaird/easywsclient/master/easywsclient.hpp
+// wget https://raw.github.com/dhbaird/easywsclient/master/easywsclient.cpp
+
+#include <string>
+#include <vector>
+#include <cstdint>
+
+namespace easywsclient {
+
+struct Callback_Imp { virtual void operator()(const std::string& message) = 0; };
+struct BytesCallback_Imp { virtual void operator()(const std::vector<uint8_t>& message) = 0; };
+
+class WebSocket {
+  public:
+    typedef WebSocket * pointer;
+    typedef enum readyStateValues { CLOSING, CLOSED, CONNECTING, OPEN } readyStateValues;
+
+    // Factories:
+    static pointer create_dummy();
+    static pointer from_url(const std::string& url, const std::string& origin = std::string());
+    static pointer from_url_no_mask(const std::string& url, const std::string& origin = std::string());
+
+    // Interfaces:
+    virtual ~WebSocket() { }
+    virtual void poll(int timeout = 0) = 0; // timeout in milliseconds
+    virtual void send(const std::string& message) = 0;
+    virtual void sendBinary(const std::string& message) = 0;
+    virtual void sendBinary(const std::vector<uint8_t>& message) = 0;
+    virtual void sendPing() = 0;
+    virtual void close() = 0;
+    virtual readyStateValues getReadyState() const = 0;
+
+    template<class Callable>
+    void dispatch(Callable callable)
+        // For callbacks that accept a string argument.
+    { // N.B. this is compatible with both C++11 lambdas, functors and C function pointers
+        struct _Callback : public Callback_Imp {
+            Callable& callable;
+            _Callback(Callable& callable) : callable(callable) { }
+            void operator()(const std::string& message) { callable(message); }
+        };
+        _Callback callback(callable);
+        _dispatch(callback);
+    }
+
+    template<class Callable>
+    void dispatchBinary(Callable callable)
+        // For callbacks that accept a std::vector<uint8_t> argument.
+    { // N.B. this is compatible with both C++11 lambdas, functors and C function pointers
+        struct _Callback : public BytesCallback_Imp {
+            Callable& callable;
+            _Callback(Callable& callable) : callable(callable) { }
+            void operator()(const std::vector<uint8_t>& message) { callable(message); }
+        };
+        _Callback callback(callable);
+        _dispatchBinary(callback);
+    }
+
+  protected:
+    virtual void _dispatch(Callback_Imp& callable) = 0;
+    virtual void _dispatchBinary(BytesCallback_Imp& callable) = 0;
+};
+
+} // namespace easywsclient
+
+#endif /* EASYWSCLIENT_HPP_20120819_MIOFVASDTNUASZDQPLFD */

src/spice2x/external/imgui/imgui_filebrowser.h

@@ -878,7 +878,15 @@ inline void ImGui::FileBrowser::UpdateFileRecords()
 
 inline void ImGui::FileBrowser::SetPwdUncatched(const std::filesystem::path &pwd)
 {
-    pwd_ = absolute(pwd);
+    // spice2x
+    // avoid MinGW std::filesystem::absolute() duplicating UNC server/share
+    // prefixes, which makes directory_iterator() throw during startup
+    // spice2x
+    const auto &nativePwd = pwd.native();
+    const bool hasUncPrefix = nativePwd.size() >= 2 &&
+        (nativePwd[0] == '\\' || nativePwd[0] == '/') &&
+        (nativePwd[1] == '\\' || nativePwd[1] == '/');
+    pwd_ = hasUncPrefix ? pwd : absolute(pwd);
     UpdateFileRecords();
     selectedFilenames_.clear();
     (*inputNameBuf_)[0] = '\0';

src/spice2x/games/ccj/ccj.cpp

@@ -7,7 +7,6 @@
 #include "util/utils.h"
 #include "util/detour.h"
 #include "acioemu/handle.h"
-#include "misc/wintouchemu.h"
 #include "hooks/graphics/graphics.h"
 #include "bi2x_hook.h"
 #include "trackball.h"

src/spice2x/games/ccj/trackball.cpp

@@ -33,13 +33,14 @@ namespace games::ccj {
     static UINT WINAPI GetRawInputDeviceList_hook(PRAWINPUTDEVICELIST pRawInputDeviceList, PUINT puiNumDevices,
                                                   UINT cbSize) {
         auto result = GetRawInputDeviceList_orig(pRawInputDeviceList, puiNumDevices, cbSize);
-        if (result == 0xFFFFFFFF)
+        if (result == 0xFFFFFFFF) {
             return result;
+        }
 
         if (pRawInputDeviceList == NULL) {
             (*puiNumDevices)++;
         } else if (result < *puiNumDevices) {
-            pRawInputDeviceList[result] = {fakeHandle, 0};
+            pRawInputDeviceList[result] = { fakeHandle, 0 };
             result++;
         }
 
@@ -47,8 +48,9 @@ namespace games::ccj {
     }
 
     static UINT WINAPI GetRawInputDeviceInfoW_hook(HANDLE hDevice, UINT uiCommand, LPVOID pData, PUINT pcbSize) {
-        if (hDevice != fakeHandle || uiCommand != RIDI_DEVICENAME)
+        if (hDevice != fakeHandle || uiCommand != RIDI_DEVICENAME) {
             return GetRawInputDeviceInfoW_orig(hDevice, uiCommand, pData, pcbSize);
+        }
 
         const auto requiredLen = (wcslen(fakeDeviceName) + 1) * sizeof(wchar_t);
 
@@ -68,23 +70,157 @@ namespace games::ccj {
 
     static LONG_PTR WINAPI SetWindowLongPtrW_hook(HWND _hWnd, int nIndex, LONG_PTR dwNewLong) {
         wchar_t buffer[256];
-        if (nIndex != GWLP_WNDPROC || GetWindowTextW(_hWnd, buffer, 256) == 0 || !wcswcs(buffer, windowName))
+        if (nIndex != GWLP_WNDPROC || GetWindowTextW(_hWnd, buffer, 256) == 0 || !wcswcs(buffer, windowName)) {
             return SetWindowLongPtrW_orig(_hWnd, nIndex, dwNewLong);
+        }
 
         hWnd = _hWnd;
         wndProc = (WNDPROC)dwNewLong;
         return SetWindowLongPtrW_orig(_hWnd, nIndex, dwNewLong);
     }
 
+    // compute the cursor wrap region in client coordinates. The cursor is confined to the
+    // monitor, so if the window's client area extends past a screen edge (window larger than /
+    // offset off the monitor) the cursor can never reach that far client edge. Clamp the region
+    // to the on-screen portion of the client area so the right/bottom edges wrap as reliably as
+    // the left/top edges.
+    static RECT trackball_wrap_bounds(HWND wnd, const RECT &client) {
+        RECT bounds = client;
+
+        POINT origin = { 0, 0 };
+        ClientToScreen(wnd, &origin);
+        RECT clientScreen = {
+            origin.x,
+            origin.y,
+            origin.x + client.right,
+            origin.y + client.bottom
+        };
+
+        MONITORINFO mi = {};
+        mi.cbSize = sizeof(mi);
+        RECT usable;
+        if (GetMonitorInfo(MonitorFromWindow(wnd, MONITOR_DEFAULTTONEAREST), &mi)
+            && IntersectRect(&usable, &clientScreen, &mi.rcMonitor)) {
+            bounds.left = usable.left - origin.x;
+            bounds.top = usable.top - origin.y;
+            bounds.right = usable.right - origin.x;
+            bounds.bottom = usable.bottom - origin.y;
+        }
+
+        return bounds;
+    }
+
+    // drive the trackball from the physical mouse cursor, wrapping it at the window edges so it
+    // can spin indefinitely. gated by the secondary-mouse button (hold or debounced toggle).
+    static void trackball_mouse_input(RAWMOUSE &rawMouse) {
+        static bool active = false;
+        static bool lastState = false;
+        static std::chrono::steady_clock::time_point lastModified = std::chrono::steady_clock::now();
+        static const std::chrono::milliseconds debounceDuration(100);
+
+        const auto currentTime = std::chrono::steady_clock::now();
+        const bool pressed = get_async_secondary_mouse();
+        const bool focused = GetForegroundWindow() == hWnd;
+
+        if (focused && MOUSE_TRACKBALL_USE_TOGGLE && pressed && (currentTime - lastModified > debounceDuration)) {
+            active = !active;
+            lastModified = currentTime;
+        }
+
+        const bool engaged = focused
+            && ((MOUSE_TRACKBALL_USE_TOGGLE && active) || (!MOUSE_TRACKBALL_USE_TOGGLE && pressed));
+        if (!engaged) {
+            if (lastState && !active) {
+                lastState = false;
+            }
+            return;
+        }
+
+        POINT cursor;
+        RECT client;
+        GetClientRect(hWnd, &client);
+        GetCursorPos(&cursor);
+        ScreenToClient(hWnd, &cursor);
+
+        const RECT bounds = trackball_wrap_bounds(hWnd, client);
+
+        static int lastX = cursor.x;
+        static int lastY = cursor.y;
+        if (!lastState) {
+            lastX = cursor.x;
+            lastY = cursor.y;
+            lastState = true;
+        }
+
+        rawMouse.usFlags = MOUSE_MOVE_RELATIVE;
+        rawMouse.lLastX = (int)((float)(cursor.x - lastX) * (float)TRACKBALL_SENSITIVITY / 20.0f);
+        rawMouse.lLastY = (int)((float)(lastY - cursor.y) * (float)TRACKBALL_SENSITIVITY / 20.0f);
+
+        // wrap the cursor to the opposite edge once it reaches a boundary, so the trackball
+        // can keep spinning past the screen edge.
+        bool updateCursor = false;
+        auto wrap = [&updateCursor](LONG value, LONG lo, LONG hi) -> LONG {
+            if (value <= lo) {
+                updateCursor = true;
+                return hi - 5;
+            }
+            if (value >= hi - 1) {
+                updateCursor = true;
+                return lo + 5;
+            }
+            return value;
+        };
+
+        cursor.x = wrap(cursor.x, bounds.left, bounds.right);
+        cursor.y = wrap(cursor.y, bounds.top, bounds.bottom);
+
+        lastX = cursor.x;
+        lastY = cursor.y;
+
+        if (updateCursor) {
+            ClientToScreen(hWnd, &cursor);
+            SetCursorPos(cursor.x, cursor.y);
+        }
+    }
+
+    // drive the trackball from the configured analog axes / direction buttons.
+    static void trackball_mapped_input(RAWMOUSE &rawMouse) {
+        rawMouse.usFlags = MOUSE_MOVE_RELATIVE;
+
+        auto &analogs = get_analogs();
+        if (analogs[Analogs::Trackball_DX].isSet() || analogs[Analogs::Trackball_DY].isSet()) {
+            float x = GameAPI::Analogs::getState(RI_MGR, analogs[Analogs::Trackball_DX]) * 2.0f - 1.0f;
+            float y = GameAPI::Analogs::getState(RI_MGR, analogs[Analogs::Trackball_DY]) * 2.0f - 1.0f;
+            rawMouse.lLastX = (long) (x * (float) TRACKBALL_SENSITIVITY);
+            rawMouse.lLastY = (long) (-y * (float) TRACKBALL_SENSITIVITY);
+        }
+
+        auto &buttons = get_buttons();
+        if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Trackball_Up])) {
+            rawMouse.lLastY = TRACKBALL_SENSITIVITY;
+        }
+        if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Trackball_Down])) {
+            rawMouse.lLastY = -TRACKBALL_SENSITIVITY;
+        }
+        if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Trackball_Left])) {
+            rawMouse.lLastX = -TRACKBALL_SENSITIVITY;
+        }
+        if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Trackball_Right])) {
+            rawMouse.lLastX = TRACKBALL_SENSITIVITY;
+        }
+    }
+
     static UINT WINAPI GetRawInputData_hook(HRAWINPUT hRawInput, UINT uiCommand, LPVOID pData, PUINT pcbSize, UINT cbSizeHeader) {
-        if (hRawInput != fakeHandle)
+        if (hRawInput != fakeHandle) {
             return GetRawInputData_orig(hRawInput, uiCommand, pData, pcbSize, cbSizeHeader);
+        }
 
         if (pData == NULL) {
-            if (uiCommand == RID_HEADER)
+            if (uiCommand == RID_HEADER) {
                 *pcbSize = sizeof(RAWINPUTHEADER);
-            else
+            } else {
                 *pcbSize = sizeof(RAWINPUT);
+            }
             return 0;
         }
 
@@ -107,92 +243,9 @@ namespace games::ccj {
             RAWMOUSE rawMouse {};
 
             if (MOUSE_TRACKBALL) {
-                static bool active = false;
-                static bool lastState = false;
-
-                static std::chrono::time_point<std::chrono::steady_clock> lastModified = std::chrono::steady_clock::now();
-                static std::chrono::milliseconds debounceDuration(100);
-                auto currentTime = std::chrono::steady_clock::now();
-                bool pressed = get_async_secondary_mouse();
-                bool focused = GetForegroundWindow() == hWnd;
-
-                if (focused && MOUSE_TRACKBALL_USE_TOGGLE && pressed && (currentTime - lastModified > debounceDuration)) {
-                    active = !active;
-                    lastModified = currentTime;
-                }
-
-                if (focused && ((MOUSE_TRACKBALL_USE_TOGGLE && active) || (!MOUSE_TRACKBALL_USE_TOGGLE && pressed))) {
-                    POINT cursor;
-                    RECT client;
-
-                    GetClientRect(hWnd, &client);
-                    int sx = client.right - client.left;
-                    int sy = client.bottom - client.top;
-
-                    GetCursorPos(&cursor);
-                    ScreenToClient(hWnd, &cursor);
-
-                    static int lastX = cursor.x;
-                    static int lastY = cursor.y;
-
-                    if (!lastState) {
-                        lastX = cursor.x;
-                        lastY = cursor.y;
-                        lastState = true;
-                    }
-
-                    rawMouse.usFlags = MOUSE_MOVE_RELATIVE;
-                    rawMouse.lLastX = (int)((float)(cursor.x - lastX) * (float)TRACKBALL_SENSITIVITY / 20.0f);
-                    rawMouse.lLastY = (int)((float)(lastY - cursor.y) * (float)TRACKBALL_SENSITIVITY / 20.0f);
-
-                    bool updateCursor = false;
-
-                    if (cursor.x <= 0) {
-                        updateCursor = true;
-                        cursor.x = sx - 5;
-                    } else if (cursor.x >= sx - 1) {
-                        updateCursor = true;
-                        cursor.x = 5;
-                    }
-
-                    if (cursor.y <= 0) {
-                        updateCursor = true;
-                        cursor.y = sy - 5;
-                    } else if (cursor.y >= sy - 1) {
-                        updateCursor = true;
-                        cursor.y = 5;
-                    }
-
-                    lastX = cursor.x;
-                    lastY = cursor.y;
-
-                    if (updateCursor) {
-                        ClientToScreen(hWnd, &cursor);
-                        SetCursorPos(cursor.x, cursor.y);
-                    }
-                } else if (lastState && !active) {
-                    lastState = false;
-                }
+                trackball_mouse_input(rawMouse);
             } else {
-                rawMouse.usFlags = MOUSE_MOVE_RELATIVE;
-
-                auto &analogs = get_analogs();
-                if (analogs[Analogs::Trackball_DX].isSet() || analogs[Analogs::Trackball_DY].isSet()) {
-                    float x = GameAPI::Analogs::getState(RI_MGR, analogs[Analogs::Trackball_DX]) * 2.0f - 1.0f;
-                    float y = GameAPI::Analogs::getState(RI_MGR, analogs[Analogs::Trackball_DY]) * 2.0f - 1.0f;
-                    rawMouse.lLastX = (long) (x * (float) TRACKBALL_SENSITIVITY);
-                    rawMouse.lLastY = (long) (-y * (float) TRACKBALL_SENSITIVITY);
-                }
-
-                auto &buttons = get_buttons();
-                if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Trackball_Up]))
-                    rawMouse.lLastY = TRACKBALL_SENSITIVITY;
-                if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Trackball_Down]))
-                    rawMouse.lLastY = -TRACKBALL_SENSITIVITY;
-                if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Trackball_Left]))
-                    rawMouse.lLastX = -TRACKBALL_SENSITIVITY;
-                if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Trackball_Right]))
-                    rawMouse.lLastX = TRACKBALL_SENSITIVITY;
+                trackball_mapped_input(rawMouse);
             }
 
             *((RAWINPUT*)pData) = { header, { rawMouse } };
@@ -224,9 +277,8 @@ namespace games::ccj {
         static bool initialized = false;
         if (initialized) {
             return;
-        } else {
-            initialized = true;
         }
+        initialized = true;
 
         // announce
         log_info("trackball", "init");
@@ -246,8 +298,6 @@ namespace games::ccj {
     }
 
     void trackball_thread_start() {
-        using namespace std::chrono_literals;
-
         tbThreadRunning = true;
 
         log_info("trackball", "thread start, use mouse: {}, toggle: {}", MOUSE_TRACKBALL, MOUSE_TRACKBALL_USE_TOGGLE);
@@ -259,8 +309,9 @@ namespace games::ccj {
                     wndProc(hWnd, WM_INPUT, RIM_INPUT, (LPARAM)fakeHandle);
                 }
 
-                if (!tbThreadRunning)
+                if (!tbThreadRunning) {
                     break;
+                }
 
                 timer.sleep(10);
             }
@@ -269,8 +320,9 @@ namespace games::ccj {
 
     void trackball_thread_stop() {
         tbThreadRunning = false;
-        if (tbThread)
+        if (tbThread) {
             tbThread->join();
+        }
 
         log_info("trackball", "thread stop");
 

src/spice2x/games/gitadora/asio.cpp

@@ -1,171 +1,171 @@
-#include "asio.h"
-
-#include <windows.h>
-#include <cstring>
-
-#include "avs/game.h"
-#include "gitadora.h"
-#include "util/detour.h"
-#include "util/logging.h"
-
-namespace games::gitadora {
-
-    // Redirects the game's hard-coded "XONAR" ASIO driver lookup to the
-    // driver name in ASIO_DRIVER by intercepting registry calls to
-    // HKLM\SOFTWARE\ASIO. Sentinel HKEY values mark the redirected handles
-    // so we can recognise them on subsequent reg* calls.
-
-    static const HKEY PARENT_ASIO_REG_HANDLE = reinterpret_cast<HKEY>(0x4001);
-    static const HKEY DEVICE_ASIO_REG_HANDLE = reinterpret_cast<HKEY>(0x4002);
-    static const char *FAKE_ASIO_DEVICE_NAME = "XONAR";
-
-    static decltype(RegCloseKey) *RegCloseKey_orig = nullptr;
-    static decltype(RegEnumKeyA) *RegEnumKeyA_orig = nullptr;
-    static decltype(RegOpenKeyA) *RegOpenKeyA_orig = nullptr;
-    static decltype(RegOpenKeyExA) *RegOpenKeyExA_orig = nullptr;
-    static decltype(RegQueryValueExA) *RegQueryValueExA_orig = nullptr;
-
-    static HKEY real_asio_reg_handle = nullptr;
-    static HKEY real_asio_device_reg_handle = nullptr;
-
-    static LONG WINAPI RegOpenKeyExA_hook(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGSAM samDesired,
-            PHKEY phkResult)
-    {
-        if (ASIO_DRIVER.has_value() &&
-            lpSubKey != nullptr &&
-            phkResult != nullptr &&
-            hKey == PARENT_ASIO_REG_HANDLE &&
-            _stricmp(lpSubKey, FAKE_ASIO_DEVICE_NAME) == 0) {
-
-            *phkResult = DEVICE_ASIO_REG_HANDLE;
-
-            log_info("gitadora::asio", "replacing '{}' with '{}'", lpSubKey, ASIO_DRIVER.value());
-            const auto result = RegOpenKeyExA_orig(
-                    real_asio_reg_handle,
-                    ASIO_DRIVER.value().c_str(),
-                    ulOptions,
-                    samDesired,
-                    &real_asio_device_reg_handle);
-
-            if (result != ERROR_SUCCESS) {
-                log_warning(
-                    "gitadora::asio",
-                    "failed to open registry subkey '{}', error=0x{:x}",
-                    ASIO_DRIVER.value(), result);
-                log_warning(
-                    "gitadora::asio",
-                    "due to improper ASIO setting, audio init will fail");
-            }
-
-            return result;
-        }
-
-        return RegOpenKeyExA_orig(hKey, lpSubKey, ulOptions, samDesired, phkResult);
-    }
-
-    static LONG WINAPI RegOpenKeyA_hook(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult) {
-        if (ASIO_DRIVER.has_value() &&
-            lpSubKey != nullptr &&
-            phkResult != nullptr &&
-            hKey == HKEY_LOCAL_MACHINE &&
-            _stricmp(lpSubKey, "software\\asio") == 0)
-        {
-            *phkResult = PARENT_ASIO_REG_HANDLE;
-            return RegOpenKeyA_orig(hKey, lpSubKey, &real_asio_reg_handle);
-        }
-
-        return RegOpenKeyA_orig(hKey, lpSubKey, phkResult);
-    }
-
-    static LONG WINAPI RegEnumKeyA_hook(HKEY hKey, DWORD dwIndex, LPSTR lpName, DWORD cchName) {
-        if (hKey == PARENT_ASIO_REG_HANDLE && ASIO_DRIVER.has_value()) {
-            if (dwIndex == 0) {
-                // forward to real handle just to verify the key exists; we
-                // overwrite the name with our fake driver string regardless
-                auto ret = RegEnumKeyA_orig(real_asio_reg_handle, dwIndex, lpName, cchName);
-                if (ret == ERROR_SUCCESS && lpName != nullptr && cchName > 0) {
-                    log_info("gitadora::asio", "stubbing '{}' with '{}'", lpName, FAKE_ASIO_DEVICE_NAME);
-                    strncpy(lpName, FAKE_ASIO_DEVICE_NAME, cchName);
-                    lpName[cchName - 1] = '\0';
-                }
-                return ret;
-            } else {
-                return ERROR_NO_MORE_ITEMS;
-            }
-        }
-
-        return RegEnumKeyA_orig(hKey, dwIndex, lpName, cchName);
-    }
-
-    static LONG WINAPI RegQueryValueExA_hook(HKEY hKey, LPCSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType,
-            LPBYTE lpData, LPDWORD lpcbData)
-    {
-        HKEY target = hKey;
-
-        if (ASIO_DRIVER.has_value() &&
-            lpValueName != nullptr &&
-            lpData != nullptr &&
-            lpcbData != nullptr &&
-            hKey == DEVICE_ASIO_REG_HANDLE) {
-            if (_stricmp(lpValueName, "Description") == 0) {
-                // engine may verify the driver name after open; ensure it still
-                // sees something containing "XONAR" so the substring check passes
-                const size_t len = strlen(FAKE_ASIO_DEVICE_NAME) + 1;
-                if (*lpcbData < len) {
-                    *lpcbData = static_cast<DWORD>(len);
-                    return ERROR_MORE_DATA;
-                }
-                memcpy(lpData, FAKE_ASIO_DEVICE_NAME, len);
-                *lpcbData = static_cast<DWORD>(len);
-                if (lpType != nullptr) {
-                    *lpType = REG_SZ;
-                }
-                return ERROR_SUCCESS;
-            }
-
-            // for everything else (CLSID etc.) defer to the real driver subkey
-            target = real_asio_device_reg_handle;
-        }
-
-        return RegQueryValueExA_orig(target, lpValueName, lpReserved, lpType, lpData, lpcbData);
-    }
-
-    static LONG WINAPI RegCloseKey_hook(HKEY hKey) {
-        if (hKey == PARENT_ASIO_REG_HANDLE) {
-            if (real_asio_reg_handle != nullptr) {
-                RegCloseKey_orig(real_asio_reg_handle);
-                real_asio_reg_handle = nullptr;
-            }
-            return ERROR_SUCCESS;
-        }
-
-        if (hKey == DEVICE_ASIO_REG_HANDLE) {
-            if (real_asio_device_reg_handle != nullptr) {
-                RegCloseKey_orig(real_asio_device_reg_handle);
-                real_asio_device_reg_handle = nullptr;
-            }
-            return ERROR_SUCCESS;
-        }
-
-        return RegCloseKey_orig(hKey);
-    }
-
-    void asio_hook_init() {
-        if (!ASIO_DRIVER.has_value()) {
-            return;
-        }
-
-        log_info("gitadora::asio", "installing ASIO driver redirect: XONAR -> {}", ASIO_DRIVER.value());
-
-        RegCloseKey_orig = detour::iat_try(
-                "RegCloseKey", RegCloseKey_hook, avs::game::DLL_INSTANCE);
-        RegEnumKeyA_orig = detour::iat_try(
-                "RegEnumKeyA", RegEnumKeyA_hook, avs::game::DLL_INSTANCE);
-        RegOpenKeyA_orig = detour::iat_try(
-                "RegOpenKeyA", RegOpenKeyA_hook, avs::game::DLL_INSTANCE);
-        RegOpenKeyExA_orig = detour::iat_try(
-                "RegOpenKeyExA", RegOpenKeyExA_hook, avs::game::DLL_INSTANCE);
-        RegQueryValueExA_orig = detour::iat_try(
-                "RegQueryValueExA", RegQueryValueExA_hook, avs::game::DLL_INSTANCE);
-    }
-}
+#include "asio.h"
+
+#include <windows.h>
+#include <cstring>
+
+#include "avs/game.h"
+#include "gitadora.h"
+#include "util/detour.h"
+#include "util/logging.h"
+
+namespace games::gitadora {
+
+    // Redirects the game's hard-coded "XONAR" ASIO driver lookup to the
+    // driver name in ASIO_DRIVER by intercepting registry calls to
+    // HKLM\SOFTWARE\ASIO. Sentinel HKEY values mark the redirected handles
+    // so we can recognise them on subsequent reg* calls.
+
+    static const HKEY PARENT_ASIO_REG_HANDLE = reinterpret_cast<HKEY>(0x4001);
+    static const HKEY DEVICE_ASIO_REG_HANDLE = reinterpret_cast<HKEY>(0x4002);
+    static const char *FAKE_ASIO_DEVICE_NAME = "XONAR";
+
+    static decltype(RegCloseKey) *RegCloseKey_orig = nullptr;
+    static decltype(RegEnumKeyA) *RegEnumKeyA_orig = nullptr;
+    static decltype(RegOpenKeyA) *RegOpenKeyA_orig = nullptr;
+    static decltype(RegOpenKeyExA) *RegOpenKeyExA_orig = nullptr;
+    static decltype(RegQueryValueExA) *RegQueryValueExA_orig = nullptr;
+
+    static HKEY real_asio_reg_handle = nullptr;
+    static HKEY real_asio_device_reg_handle = nullptr;
+
+    static LONG WINAPI RegOpenKeyExA_hook(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGSAM samDesired,
+            PHKEY phkResult)
+    {
+        if (ASIO_DRIVER.has_value() &&
+            lpSubKey != nullptr &&
+            phkResult != nullptr &&
+            hKey == PARENT_ASIO_REG_HANDLE &&
+            _stricmp(lpSubKey, FAKE_ASIO_DEVICE_NAME) == 0) {
+
+            *phkResult = DEVICE_ASIO_REG_HANDLE;
+
+            log_info("gitadora::asio", "replacing '{}' with '{}'", lpSubKey, ASIO_DRIVER.value());
+            const auto result = RegOpenKeyExA_orig(
+                    real_asio_reg_handle,
+                    ASIO_DRIVER.value().c_str(),
+                    ulOptions,
+                    samDesired,
+                    &real_asio_device_reg_handle);
+
+            if (result != ERROR_SUCCESS) {
+                log_warning(
+                    "gitadora::asio",
+                    "failed to open registry subkey '{}', error=0x{:x}",
+                    ASIO_DRIVER.value(), result);
+                log_warning(
+                    "gitadora::asio",
+                    "due to improper ASIO setting, audio init will fail");
+            }
+
+            return result;
+        }
+
+        return RegOpenKeyExA_orig(hKey, lpSubKey, ulOptions, samDesired, phkResult);
+    }
+
+    static LONG WINAPI RegOpenKeyA_hook(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult) {
+        if (ASIO_DRIVER.has_value() &&
+            lpSubKey != nullptr &&
+            phkResult != nullptr &&
+            hKey == HKEY_LOCAL_MACHINE &&
+            _stricmp(lpSubKey, "software\\asio") == 0)
+        {
+            *phkResult = PARENT_ASIO_REG_HANDLE;
+            return RegOpenKeyA_orig(hKey, lpSubKey, &real_asio_reg_handle);
+        }
+
+        return RegOpenKeyA_orig(hKey, lpSubKey, phkResult);
+    }
+
+    static LONG WINAPI RegEnumKeyA_hook(HKEY hKey, DWORD dwIndex, LPSTR lpName, DWORD cchName) {
+        if (hKey == PARENT_ASIO_REG_HANDLE && ASIO_DRIVER.has_value()) {
+            if (dwIndex == 0) {
+                // forward to real handle just to verify the key exists; we
+                // overwrite the name with our fake driver string regardless
+                auto ret = RegEnumKeyA_orig(real_asio_reg_handle, dwIndex, lpName, cchName);
+                if (ret == ERROR_SUCCESS && lpName != nullptr && cchName > 0) {
+                    log_info("gitadora::asio", "stubbing '{}' with '{}'", lpName, FAKE_ASIO_DEVICE_NAME);
+                    strncpy(lpName, FAKE_ASIO_DEVICE_NAME, cchName);
+                    lpName[cchName - 1] = '\0';
+                }
+                return ret;
+            } else {
+                return ERROR_NO_MORE_ITEMS;
+            }
+        }
+
+        return RegEnumKeyA_orig(hKey, dwIndex, lpName, cchName);
+    }
+
+    static LONG WINAPI RegQueryValueExA_hook(HKEY hKey, LPCSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType,
+            LPBYTE lpData, LPDWORD lpcbData)
+    {
+        HKEY target = hKey;
+
+        if (ASIO_DRIVER.has_value() &&
+            lpValueName != nullptr &&
+            lpData != nullptr &&
+            lpcbData != nullptr &&
+            hKey == DEVICE_ASIO_REG_HANDLE) {
+            if (_stricmp(lpValueName, "Description") == 0) {
+                // engine may verify the driver name after open; ensure it still
+                // sees something containing "XONAR" so the substring check passes
+                const size_t len = strlen(FAKE_ASIO_DEVICE_NAME) + 1;
+                if (*lpcbData < len) {
+                    *lpcbData = static_cast<DWORD>(len);
+                    return ERROR_MORE_DATA;
+                }
+                memcpy(lpData, FAKE_ASIO_DEVICE_NAME, len);
+                *lpcbData = static_cast<DWORD>(len);
+                if (lpType != nullptr) {
+                    *lpType = REG_SZ;
+                }
+                return ERROR_SUCCESS;
+            }
+
+            // for everything else (CLSID etc.) defer to the real driver subkey
+            target = real_asio_device_reg_handle;
+        }
+
+        return RegQueryValueExA_orig(target, lpValueName, lpReserved, lpType, lpData, lpcbData);
+    }
+
+    static LONG WINAPI RegCloseKey_hook(HKEY hKey) {
+        if (hKey == PARENT_ASIO_REG_HANDLE) {
+            if (real_asio_reg_handle != nullptr) {
+                RegCloseKey_orig(real_asio_reg_handle);
+                real_asio_reg_handle = nullptr;
+            }
+            return ERROR_SUCCESS;
+        }
+
+        if (hKey == DEVICE_ASIO_REG_HANDLE) {
+            if (real_asio_device_reg_handle != nullptr) {
+                RegCloseKey_orig(real_asio_device_reg_handle);
+                real_asio_device_reg_handle = nullptr;
+            }
+            return ERROR_SUCCESS;
+        }
+
+        return RegCloseKey_orig(hKey);
+    }
+
+    void asio_hook_init() {
+        if (!ASIO_DRIVER.has_value()) {
+            return;
+        }
+
+        log_info("gitadora::asio", "installing ASIO driver redirect: XONAR -> {}", ASIO_DRIVER.value());
+
+        RegCloseKey_orig = detour::iat_try(
+                "RegCloseKey", RegCloseKey_hook, avs::game::DLL_INSTANCE);
+        RegEnumKeyA_orig = detour::iat_try(
+                "RegEnumKeyA", RegEnumKeyA_hook, avs::game::DLL_INSTANCE);
+        RegOpenKeyA_orig = detour::iat_try(
+                "RegOpenKeyA", RegOpenKeyA_hook, avs::game::DLL_INSTANCE);
+        RegOpenKeyExA_orig = detour::iat_try(
+                "RegOpenKeyExA", RegOpenKeyExA_hook, avs::game::DLL_INSTANCE);
+        RegQueryValueExA_orig = detour::iat_try(
+                "RegQueryValueExA", RegQueryValueExA_hook, avs::game::DLL_INSTANCE);
+    }
+}

src/spice2x/games/gitadora/asio.h

@@ -1,12 +1,12 @@
-#pragma once
-
-namespace games::gitadora {
-
-    // installs IAT registry hooks in gfdm.dll that redirect the game's
-    // ASIO driver lookup (hard-coded "XONAR" substring) to a user-chosen
-    // driver name read from games::gitadora::ASIO_DRIVER.
-    //
-    // safe to call unconditionally; if ASIO_DRIVER is unset the hooks
-    // forward every call straight through to advapi32.
-    void asio_hook_init();
-}
+#pragma once
+
+namespace games::gitadora {
+
+    // installs IAT registry hooks in gfdm.dll that redirect the game's
+    // ASIO driver lookup (hard-coded "XONAR" substring) to a user-chosen
+    // driver name read from games::gitadora::ASIO_DRIVER.
+    //
+    // safe to call unconditionally; if ASIO_DRIVER is unset the hooks
+    // forward every call straight through to advapi32.
+    void asio_hook_init();
+}

src/spice2x/games/gitadora/gitadora.cpp

@@ -2,17 +2,20 @@
 #include "asio.h"
 #include "handle.h"
 #include "bi2x_hook.h"
+#include <span>
 #include <unordered_map>
 
+#include "cfg/configurator.h"
+#include "cfg/screen_resize.h"
+
 #include <ks.h>
 #include <ksmedia.h>
-
-#include "cfg/configurator.h"
 #include "hooks/audio/audio.h"
 #include "hooks/audio/mme.h"
 #include "hooks/graphics/graphics.h"
 #include "misc/wintouchemu.h"
 #include "overlay/overlay.h"
+#include "touch/native/nativetouchhook.h"
 #include "util/cpuutils.h"
 #include "util/deferlog.h"
 #include "util/detour.h"
@@ -28,14 +31,17 @@ namespace games::gitadora {
 
     // settings
     bool TWOCHANNEL = false;
+    bool DISABLE_FRAME_LIMITER = false;
     std::optional<unsigned int> CAB_TYPE = std::nullopt;
     bool P1_LEFTY = false;
     bool P2_LEFTY = false;
     std::optional<std::string> SUBSCREEN_OVERLAY_SIZE;
     std::optional<socd::SocdAlgorithm> PICK_ALGO = socd::SocdAlgorithm::PreferRecent;
     std::optional<uint8_t> ARENA_WINDOW_COUNT = std::nullopt;
+    bool ARENA_TWO_HEAD_EXCLUSIVE = false;
     std::optional<std::string> ASIO_DRIVER = std::nullopt;
     bool ALLOW_REALTEK_AUDIO = false;
+    bool NATIVE_TOUCH = false;
 
     /*
      * Prevent GitaDora from creating folders on F drive
@@ -61,6 +67,46 @@ namespace games::gitadora {
 
         return CreateDirectoryA(lpPathName, lpSecurityAttributes);
     }
+
+    // libshare-pj paces mainloop with separate 12 ms and 16 ms waits. these waits
+    // interfere with the game's normal display synchronization on modern Windows
+    // and can hold a nominal 60 FPS game near 58 FPS. locate the instruction
+    // sequences at runtime so the fix does not depend on per-version file offsets.
+    static void disable_mainloop_frame_limiter(HMODULE sharepj_module) {
+        if (!sharepj_module) {
+            return;
+        }
+
+        // both limiters have the same shape, only the millisecond target xx differs
+        // (0Ch for the 12 ms limiter, 10h for the 16 ms one):
+        //
+        // 48 83 F8 xx:     cmp rax, xx;   compare elapsed frame time with the target
+        // 73 10:           jae +10h;      skip the wait once the target has elapsed
+        // B9 xx 00 00 00:  mov ecx, xx;   load the target
+        // 48 2B C8:        sub rcx, rax;  calculate the remaining wait time
+        // 74 06:           je +6h;        skip the following six-byte Sleep call if no wait remains
+        //
+        // changing jae (73h) to jmp (EBh) makes each block always take its existing
+        // skip path, which bypasses only the associated Sleep call and leaves the 10h
+        // branch displacement and every other wait untouched.
+        const auto limiter_12ms_disabled = replace_pattern(
+                sharepj_module,
+                "4883F80C7310B90C000000482BC87406",
+                "????????EB??????????????????????", 0, 0);
+        const auto limiter_16ms_disabled = replace_pattern(
+                sharepj_module,
+                "4883F8107310B910000000482BC87406",
+                "????????EB??????????????????????", 0, 0);
+
+        if (!limiter_12ms_disabled || !limiter_16ms_disabled) {
+            log_fatal(
+                "gitadora",
+                "failed to disable libshare-pj mainloop frame limiter (-gdnoframelimiter), ensure patch is not already applied");
+            return;
+        }
+
+        log_info("gitadora", "successfully disabled libshare-pj mainloop frame limiter (-gdnoframelimiter)");
+    }
 #endif
 
     /*
@@ -270,9 +316,21 @@ namespace games::gitadora {
                         break;
                     case 2:
                         if (!GRAPHICS_WINDOWED) {
-                            log_fatal(
+                            if (D3D9_ADAPTER.has_value()) {
+                                log_fatal(
+                                    "gitadora",
+                                    "arena model: fullscreen two-window mode cannot use -monitor; "
+                                    "use -w for borderless windows instead");
+                            }
+                            ARENA_TWO_HEAD_EXCLUSIVE = true;
+                            log_info(
                                 "gitadora",
-                                "arena model: 2-window mode is not supported in fullscreen, choose 1 or 4");
+                                "arena model: native two-head fullscreen adapter-group mode "
+                                "(MAIN + SMALL; LEFT/RIGHT are virtual)");
+                        } else {
+                            log_info(
+                                "gitadora",
+                                "arena model: two-window mode uses windowed rendering");
                         }
                         log_info("gitadora", "arena model: two-window mode");
                         GRAPHICS_GITADORA_HIDE_SIDE_WINDOWS = true;
@@ -298,10 +356,18 @@ namespace games::gitadora {
     static decltype(QueryDisplayConfig) *QueryDisplayConfig_orig = nullptr;
     static decltype(DisplayConfigGetDeviceInfo) *DisplayConfigGetDeviceInfo_orig = nullptr;
 
-    // cached primary real monitor: its path + source/target mode entries.
-    // modeInfoIdx values on the path are renumbered to 0 / 1 so the cache is self-contained.
+    // Cached real monitor paths and their source/target mode entries. modeInfoIdx values are
+    // renumbered so the cache is self-contained. The normal single-head emulation keeps only
+    // MAIN; the two-head adapter-group mode keeps MAIN and SMALL as real heads.
     static DISPLAYCONFIG_PATH_INFO real_primary_path = {};
     static DISPLAYCONFIG_MODE_INFO real_primary_modes[2] = {}; // [0]=source, [1]=target
+    static DISPLAYCONFIG_PATH_INFO real_small_path = {};
+    static DISPLAYCONFIG_MODE_INFO real_small_modes[2] = {}; // [0]=source, [1]=target
+    static bool real_small_path_available = false;
+
+    static bool is_two_head_exclusive() {
+        return ARENA_TWO_HEAD_EXCLUSIVE && !GRAPHICS_WINDOWED;
+    }
 
     // fake monitors appended after the real ones. the game classifies monitors
     // by outputTechnology + connectorInstance:
@@ -325,12 +391,31 @@ namespace games::gitadora {
     // adapter to a swap chain role via its DisplayConfig connector instance,
     // so the entries here must be listed in the same order the wrapper enumerates
     // them: id=1 -> adapter 1 -> left, id=2 -> adapter 2 -> right, id=3 -> adapter 3 -> small.
-    static constexpr FakeMonitor FAKE_MONITORS[] = {
+    // Normal single-head emulation: every non-MAIN role is fake.
+    static constexpr FakeMonitor FAKE_MONITORS_SINGLE_HEAD[] = {
         { 1, 1080, 1920, -100000, -100000, 0 }, // left  (DP connector instance 0)
         { 2, 1080, 1920, -200000, -200000, 1 }, // right (DP connector instance 1)
         { 3,  800, 1280, -300000, -300000, 2 }, // small (DP connector instance 2, touch)
     };
-    static constexpr UINT32 FAKE_MONITOR_COUNT = static_cast<UINT32>(std::size(FAKE_MONITORS));
+
+    // Two-head fullscreen: adapters 0/1 are the real MAIN/SMALL group heads.
+    // Keep only LEFT/RIGHT fake, with their adapter ids matching the D3D9 wrapper.
+    static constexpr FakeMonitor FAKE_MONITORS_TWO_HEAD[] = {
+        { 2, 1080, 1920, -200000, -200000, 0 }, // left  (DP connector instance 0)
+        { 3, 1080, 1920, -300000, -300000, 1 }, // right (DP connector instance 1)
+    };
+
+    static std::span<const FakeMonitor> get_fake_monitors() {
+        if (is_two_head_exclusive()) {
+            return FAKE_MONITORS_TWO_HEAD;
+        }
+
+        return FAKE_MONITORS_SINGLE_HEAD;
+    }
+
+    static UINT32 real_monitor_count() {
+        return is_two_head_exclusive() ? 2 : 1;
+    }
 
     // call QueryDisplayConfig once, keep only the primary monitor's path and its
     // two referenced modes (source + target). modeInfoIdx values are rewritten to
@@ -368,13 +453,55 @@ namespace games::gitadora {
             log_fatal("gitadora", "cache_primary_monitor_info: no primary monitor found");
         }
 
+        if (primary->targetInfo.modeInfoIdx >= all_modes.size()) {
+            log_fatal("gitadora", "cache_primary_monitor_info: primary target mode is missing");
+        }
+
         real_primary_modes[0] = all_modes[primary->sourceInfo.modeInfoIdx];
         real_primary_modes[1] = all_modes[primary->targetInfo.modeInfoIdx];
         real_primary_path = *primary;
         real_primary_path.sourceInfo.modeInfoIdx = 0;
         real_primary_path.targetInfo.modeInfoIdx = 1;
 
-        log_info("gitadora", "cache_primary_monitor_info: cached primary monitor");
+        real_small_path_available = false;
+        if (is_two_head_exclusive()) {
+            if (all_paths.size() != 2) {
+                log_fatal(
+                    "gitadora",
+                    "two-head fullscreen mode requires exactly two active display paths, found {}",
+                    all_paths.size());
+            }
+
+            const auto secondary = std::find_if(all_paths.begin(), all_paths.end(),
+                [&](const auto &p) {
+                    return &p != &*primary;
+                });
+            if (secondary == all_paths.end() ||
+                    secondary->sourceInfo.modeInfoIdx >= all_modes.size() ||
+                    secondary->targetInfo.modeInfoIdx >= all_modes.size()) {
+                log_fatal("gitadora", "could not identify the physical SMALL monitor");
+            }
+            const LUID primary_adapter = primary->sourceInfo.adapterId;
+            const LUID secondary_adapter = secondary->sourceInfo.adapterId;
+            const bool same_adapter = primary_adapter.HighPart == secondary_adapter.HighPart &&
+                primary_adapter.LowPart == secondary_adapter.LowPart;
+            if (!same_adapter) {
+                log_fatal(
+                    "gitadora",
+                    "MAIN and SMALL must use the same display adapter");
+            }
+
+            real_small_modes[0] = all_modes[secondary->sourceInfo.modeInfoIdx];
+            real_small_modes[1] = all_modes[secondary->targetInfo.modeInfoIdx];
+            real_small_path = *secondary;
+            real_small_path.sourceInfo.modeInfoIdx = 2;
+            real_small_path.targetInfo.modeInfoIdx = 3;
+            real_small_path_available = true;
+
+            log_info("gitadora", "cache_primary_monitor_info: cached real MAIN and SMALL monitors");
+        } else {
+            log_info("gitadora", "cache_primary_monitor_info: cached primary monitor");
+        }
     }
 
     static
@@ -389,33 +516,36 @@ namespace games::gitadora {
         static std::once_flag populate_once;
         std::call_once(populate_once, cache_primary_monitor_info);
 
-        // always report exactly 1 real + N fake monitors
-        *pNumPathArrayElements = 1 + FAKE_MONITOR_COUNT;
-        *pNumModeInfoArrayElements = 2 + FAKE_MONITOR_COUNT * 2;
+        const auto fake_monitors = get_fake_monitors();
+        const auto fake_count = static_cast<UINT32>(fake_monitors.size());
+        const UINT32 real_count = real_monitor_count();
+        *pNumPathArrayElements = real_count + fake_count;
+        *pNumModeInfoArrayElements = (real_count + fake_count) * 2;
 
         log_info(
             "gitadora",
-            "GetDisplayConfigBufferSizes: 1 real path + {} fake monitor(s)",
-            FAKE_MONITOR_COUNT);
+            "GetDisplayConfigBufferSizes: {} real path(s) + {} fake monitor(s)",
+            real_count,
+            fake_count);
 
         return ERROR_SUCCESS;
     }
 
-    // write fake monitor i into the caller's path/mode arrays. layout (single-monitor
-    // assumption): index 0 in both arrays holds the cached primary real monitor, so
-    // fake i occupies path slot (1 + i) and mode slots (2 + i*2) / (2 + i*2 + 1).
+    // Write a fake monitor after the real paths. The cache is packed as [source, target]
+    // mode pairs, so each path consumes two mode entries.
     static void insert_fake_monitor(
         DISPLAYCONFIG_PATH_INFO *paths,
         DISPLAYCONFIG_MODE_INFO *modes,
-        UINT32 i)
+        const FakeMonitor &m,
+        UINT32 path_index,
+        UINT32 source_mode_index)
     {
-        const FakeMonitor &m = FAKE_MONITORS[i];
-        const UINT32 src_idx = 2 + i * 2;
+        const UINT32 src_idx = source_mode_index;
         const UINT32 tgt_idx = src_idx + 1;
         const LUID adapter_id { .LowPart = static_cast<DWORD>(-m.id), .HighPart = -m.id };
         const UINT32 uid = static_cast<UINT32>(-m.id);
 
-        paths[1 + i] = {
+        paths[path_index] = {
             .sourceInfo = {
                 .adapterId = adapter_id,
                 .id = uid,
@@ -473,21 +603,35 @@ namespace games::gitadora {
         DISPLAYCONFIG_MODE_INFO* modeInfoArray,
         DISPLAYCONFIG_TOPOLOGY_ID* currentTopologyId)
     {
-        // copy cached primary real monitor into caller buffers at index 0
+        // Copy cached real monitor paths into the caller buffers.
         pathArray[0] = real_primary_path;
         modeInfoArray[0] = real_primary_modes[0];
         modeInfoArray[1] = real_primary_modes[1];
-        *numPathArrayElements = 1 + FAKE_MONITOR_COUNT;
-        *numModeInfoArrayElements = 2 + FAKE_MONITOR_COUNT * 2;
+        if (is_two_head_exclusive() && real_small_path_available) {
+            pathArray[1] = real_small_path;
+            modeInfoArray[2] = real_small_modes[0];
+            modeInfoArray[3] = real_small_modes[1];
+        }
+
+        const auto fake_monitors = get_fake_monitors();
+        const auto fake_count = static_cast<UINT32>(fake_monitors.size());
+        const UINT32 real_count = real_monitor_count();
+        *numPathArrayElements = real_count + fake_count;
+        *numModeInfoArrayElements = (real_count + fake_count) * 2;
         if (currentTopologyId != nullptr) {
             *currentTopologyId = DISPLAYCONFIG_TOPOLOGY_EXTEND;
         }
 
         log_misc("gitadora", "QueryDisplayConfig returning fake monitor paths and modes");
 
-        // append fake monitors after the real one
-        for (UINT32 i = 0; i < FAKE_MONITOR_COUNT; i++) {
-            insert_fake_monitor(pathArray, modeInfoArray, i);
+        // Append fake monitors after the real path(s).
+        for (UINT32 i = 0; i < fake_count; i++) {
+            insert_fake_monitor(
+                pathArray,
+                modeInfoArray,
+                fake_monitors[i],
+                real_count + i,
+                real_count * 2 + i * 2);
         }
 
         return ERROR_SUCCESS;
@@ -518,7 +662,8 @@ namespace games::gitadora {
                 const auto targetName = reinterpret_cast<DISPLAYCONFIG_TARGET_DEVICE_NAME*>(requestPacket);
                 const LONG fake_id = -id;
                 UINT32 conn_inst = 0xff;
-                for (const auto& f : FAKE_MONITORS) {
+                const auto fake_monitors = get_fake_monitors();
+                for (const auto &f : fake_monitors) {
                     if (f.id == fake_id) {
                         conn_inst = f.connector_instance;
                         break;
@@ -541,18 +686,27 @@ namespace games::gitadora {
             return ret;
         }
 
-        // override the cached primary real monitor target info to look like HDMI/0
+        // Override MAIN to HDMI/0 and retag the real second head as the DP/2 SMALL
+        // display expected by the cabinet software in two-head fullscreen mode.
         const auto targetName = reinterpret_cast<DISPLAYCONFIG_TARGET_DEVICE_NAME*>(requestPacket);
-        const auto& target = real_primary_path.targetInfo;
-        if (target.id == targetName->header.id &&
-            target.adapterId.HighPart == targetName->header.adapterId.HighPart &&
-            target.adapterId.LowPart == targetName->header.adapterId.LowPart)
-        {
+        const auto target_matches = [&](const DISPLAYCONFIG_PATH_TARGET_INFO &target) {
+            return target.id == targetName->header.id &&
+                target.adapterId.HighPart == targetName->header.adapterId.HighPart &&
+                target.adapterId.LowPart == targetName->header.adapterId.LowPart;
+        };
+        if (target_matches(real_primary_path.targetInfo)) {
             targetName->outputTechnology = DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI;
             targetName->connectorInstance = 0;
             log_info("gitadora",
                 "overriding primary monitor (id={}) to pretend to be HDMI",
                 targetName->header.id);
+        } else if (is_two_head_exclusive() && real_small_path_available &&
+                target_matches(real_small_path.targetInfo)) {
+            targetName->outputTechnology = DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL;
+            targetName->connectorInstance = 2;
+            log_info("gitadora",
+                "overriding secondary monitor (id={}) to pretend to be SMALL DP/2",
+                targetName->header.id);
         }
         return ret;
     }
@@ -575,6 +729,12 @@ namespace games::gitadora {
         HMODULE system_module = libutils::try_module("libsystem.dll");
 
         // patches
+#ifdef SPICE64
+        if (DISABLE_FRAME_LIMITER && !is_arena_model()) {
+            disable_mainloop_frame_limiter(sharepj_module);
+        }
+#endif
+
         detour::inline_hook((void *) eam_network_detected_ip_change, libutils::try_proc(
                 sharepj_module, "eam_network_detected_ip_change"));
         detour::inline_hook((void *) eam_network_settings_conflict, libutils::try_proc(
@@ -650,31 +810,38 @@ namespace games::gitadora {
                 hooks::audio::INJECT_FAKE_REALTEK_AUDIO = true;
             }
 
-            // monitor/touch hooks (windowed or full screen)
-            if (GRAPHICS_PREVENT_SECONDARY_WINDOWS) {
-                // enable touch hook for subscreen overlay
+            // touch injection drives mouse-as-touch and API touch for the subscreen,
+            // no matter whether it is drawn by the overlay (single-window mode) or by
+            // the dedicated SMALL window
+            NATIVE_TOUCH = !wintouchemu::FORCE &&
+                nativetouch::hook(avs::game::DLL_INSTANCE);
+            if (!NATIVE_TOUCH && GRAPHICS_PREVENT_SECONDARY_WINDOWS) {
+                // the legacy fallback can only feed the subscreen overlay
                 wintouchemu::FORCE = true;
                 wintouchemu::INJECT_MOUSE_AS_WM_TOUCH = true;
                 wintouchemu::hook("GITADORA", avs::game::DLL_INSTANCE);
+            }
 
 #if !SPICE_XP
 
-                if (!GRAPHICS_WINDOWED) {
-                    // monitor hook: always pretend to have 1 primary real monitor + 3 fake monitors
-                    // (LEFT / RIGHT / SMALL) so the game accepts the arena cab topology
-                    GetDisplayConfigBufferSizes_orig =
-                        detour::iat_try("GetDisplayConfigBufferSizes",
-                            GetDisplayConfigBufferSizes_hook, avs::game::DLL_INSTANCE);
-                    QueryDisplayConfig_orig =
-                        detour::iat_try("QueryDisplayConfig",
-                            QueryDisplayConfig_hook, avs::game::DLL_INSTANCE);
-                    DisplayConfigGetDeviceInfo_orig =
-                        detour::iat_try("DisplayConfigGetDeviceInfo",
-                            DisplayConfigGetDeviceInfo_hook, avs::game::DLL_INSTANCE);
+            if (!GRAPHICS_WINDOWED &&
+                    (GRAPHICS_PREVENT_SECONDARY_WINDOWS || ARENA_TWO_HEAD_EXCLUSIVE)) {
+                if (ARENA_TWO_HEAD_EXCLUSIVE) {
+                    log_info(
+                        "gitadora",
+                        "exposing physical MAIN/SMALL and virtual LEFT/RIGHT");
                 }
-#endif
-
+                GetDisplayConfigBufferSizes_orig =
+                    detour::iat_try("GetDisplayConfigBufferSizes",
+                        GetDisplayConfigBufferSizes_hook, avs::game::DLL_INSTANCE);
+                QueryDisplayConfig_orig =
+                    detour::iat_try("QueryDisplayConfig",
+                        QueryDisplayConfig_hook, avs::game::DLL_INSTANCE);
+                DisplayConfigGetDeviceInfo_orig =
+                    detour::iat_try("DisplayConfigGetDeviceInfo",
+                        DisplayConfigGetDeviceInfo_hook, avs::game::DLL_INSTANCE);
             }
+#endif
         }
 
         // window patch

src/spice2x/games/gitadora/gitadora.h

@@ -13,14 +13,21 @@ namespace games::gitadora {
 
     // settings
     extern bool TWOCHANNEL;
+    extern bool DISABLE_FRAME_LIMITER;
     extern std::optional<unsigned int> CAB_TYPE;
     extern bool P1_LEFTY;
     extern bool P2_LEFTY;
     extern std::optional<std::string> SUBSCREEN_OVERLAY_SIZE;
     extern std::optional<socd::SocdAlgorithm> PICK_ALGO;
     extern std::optional<uint8_t> ARENA_WINDOW_COUNT;
+    extern bool ARENA_TWO_HEAD_EXCLUSIVE;
     extern std::optional<std::string> ASIO_DRIVER;
     extern bool ALLOW_REALTEK_AUDIO;
+    extern bool NATIVE_TOUCH;
+
+    // arena SMALL subscreen (touch panel) resolution
+    static constexpr int ARENA_SUBSCREEN_WIDTH = 800;
+    static constexpr int ARENA_SUBSCREEN_HEIGHT = 1280;
 
     class GitaDoraGame : public games::Game {
     public:

src/spice2x/games/iidx/bi2x_hook.cpp

@@ -3,6 +3,7 @@
 #if SPICE64
 
 #include <cstdint>
+#include "api/client.h"
 #include "util/detour.h"
 #include "util/logging.h"
 #include "util/utils.h"
@@ -443,10 +444,12 @@ namespace games::iidx {
             GameAPI::Lights::writeLight(RI_MGR, lights[map.index_g], rgb.g);
             GameAPI::Lights::writeLight(RI_MGR, lights[map.index_b], rgb.b);
 
-            for (unsigned int i = 0; i < data_size; ++i) {
-                map.data[i].r = data[i * 3];
-                map.data[i].g = data[i * 3 + 1];
-                map.data[i].b = data[i * 3 + 2];
+            if (api::has_clients()) {
+                for (size_t i = 0; i < data_size; ++i) {
+                    map.data[i].r = data[i * 3];
+                    map.data[i].g = data[i * 3 + 1];
+                    map.data[i].b = data[i * 3 + 2];
+                }
             }
         }
 

src/spice2x/games/iidx/camera.cpp

@@ -534,7 +534,7 @@ namespace games::iidx {
                         if (mediaTypePointer && mediaTypePointer->IsString()) {
                             std::string mediaType = mediaTypePointer->GetString();
                             if (mediaType.length() > 0) {
-                                camera->m_selectedMediaTypeDescription = mediaType;
+                                camera->SetSelectedMediaTypeDescription(mediaType);
                                 camera->m_useAutoMediaType = false;
                             } else {
                                 camera->m_useAutoMediaType = true;
@@ -547,7 +547,7 @@ namespace games::iidx {
                             std::string drawModeString = drawModePointer->GetString();
                             for (int j = 0; j < DRAW_MODE_SIZE; j++) {
                                 if (DRAW_MODE_LABELS[j].compare(drawModeString) == 0) {
-                                    camera->m_drawMode = (LocalCameraDrawMode) j;
+                                    camera->m_drawMode.store((LocalCameraDrawMode) j);
                                     break;
                                 }
                             }
@@ -556,12 +556,12 @@ namespace games::iidx {
                         // Flip
                         auto flipHorizontalPointer = rapidjson::Pointer(root + "/" + symLink + "/FlipHorizontal").Get(doc);
                         if (flipHorizontalPointer && flipHorizontalPointer->IsBool()) {
-                            camera->m_flipHorizontal = flipHorizontalPointer->GetBool();
+                            camera->m_flipHorizontal.store(flipHorizontalPointer->GetBool());
                         }
 
                         auto flipVerticalPointer = rapidjson::Pointer(root + "/" + symLink + "/FlipVertical").Get(doc);
                         if (flipVerticalPointer && flipVerticalPointer->IsBool()) {
-                            camera->m_flipVertical = flipVerticalPointer->GetBool();
+                            camera->m_flipVertical.store(flipVerticalPointer->GetBool());
                         }
 
                         // Allow manual control
@@ -625,15 +625,17 @@ namespace games::iidx {
             if (camera->m_useAutoMediaType) {
                 rapidjson::Pointer(root + "MediaType").Set(doc, "");
             } else {
-                rapidjson::Pointer(root + "MediaType").Set(doc, camera->m_selectedMediaTypeDescription);
+                const auto mediaTypeDescription = camera->GetSelectedMediaTypeDescription();
+                rapidjson::Pointer(root + "MediaType").Set(doc, mediaTypeDescription);
             }
 
             // Draw Mode
-            rapidjson::Pointer(root + "DrawMode").Set(doc, DRAW_MODE_LABELS[camera->m_drawMode]);
+            const auto drawMode = camera->m_drawMode.load();
+            rapidjson::Pointer(root + "DrawMode").Set(doc, DRAW_MODE_LABELS[drawMode]);
 
             // Flip
-            rapidjson::Pointer(root + "FlipHorizontal").Set(doc, camera->m_flipHorizontal);
-            rapidjson::Pointer(root + "FlipVertical").Set(doc, camera->m_flipVertical);
+            rapidjson::Pointer(root + "FlipHorizontal").Set(doc, camera->m_flipHorizontal.load());
+            rapidjson::Pointer(root + "FlipVertical").Set(doc, camera->m_flipVertical.load());
 
             // Manual control
             rapidjson::Pointer(root + "AllowManualControl").Set(doc, camera->m_allowManualControl);

src/spice2x/games/iidx/iidx.cpp

@@ -20,9 +20,9 @@
 #include "hooks/sleephook.h"
 #include "launcher/options.h"
 #include "touch/touch.h"
-#include "misc/nativetouchhook.h"
-#include "misc/wintouchemu.h"
+#include "touch/native/nativetouchhook.h"
 #include "misc/eamuse.h"
+#include "misc/wintouchemu.h"
 #include "util/detour.h"
 #include "util/deferlog.h"
 #include "util/fileutils.h"
@@ -41,6 +41,7 @@
 #include "bi2x_hook.h"
 #include "ezusb.h"
 #include "io.h"
+#include "poke.h"
 
 static decltype(RegCloseKey) *RegCloseKey_orig = nullptr;
 static decltype(RegEnumKeyA) *RegEnumKeyA_orig = nullptr;
@@ -57,13 +58,14 @@ namespace games::iidx {
 
     // settings
     bool FLIP_CAMS = false;
-    std::optional<bool> DISABLE_CAMS;
+    cab_camera_access_mode CAB_CAMERA_ACCESS = cab_camera_access_mode::automatic;
     bool TDJ_CAMERA = false;
     bool TDJ_CAMERA_PREFER_16_9 = true;
     bool TDJ_MODE = false;
     bool FORCE_720P = false;
     bool DISABLE_ESPEC_IO = false;
-    bool NATIVE_TOUCH = false;
+    bool NATIVE_TOUCH = true;
+    bool ENABLE_POKE = false;
     std::optional<std::string> SOUND_OUTPUT_DEVICE = std::nullopt;
     std::optional<std::string> SOUND_OUTPUT_DEVICE_IN_EFFECT = std::nullopt;
     std::optional<std::string> ASIO_DRIVER = std::nullopt;
@@ -350,12 +352,15 @@ namespace games::iidx {
                 // need to hook `avs2-core.dll` so AVS win32fs operations go through rom hook
                 devicehook_init(avs::core::DLL_INSTANCE);
 
-                if (NATIVE_TOUCH) {
-                    nativetouchhook::hook(avs::game::DLL_INSTANCE);
-                } else {
+                NATIVE_TOUCH = !wintouchemu::FORCE &&
+                    nativetouch::hook(avs::game::DLL_INSTANCE);
+                if (!NATIVE_TOUCH) {
                     wintouchemu::FORCE = true;
                     wintouchemu::INJECT_MOUSE_AS_WM_TOUCH = true;
-                    wintouchemu::hook_title_ends("beatmania IIDX", "main", avs::game::DLL_INSTANCE);
+                    wintouchemu::hook_title_ends(
+                        "beatmania IIDX",
+                        "main",
+                        avs::game::DLL_INSTANCE);
                 }
             }
 
@@ -419,10 +424,7 @@ namespace games::iidx {
                 "RegQueryValueExA", RegQueryValueExA_hook, avs::game::DLL_INSTANCE);
 
         // check if cam hook should be enabled
-        if (!DISABLE_CAMS.has_value()) {
-            log_fatal("iidx", "assertion failure - DISABLE_CAMS not set during attach");
-        }
-        if (!DISABLE_CAMS.value()) {
+        if (CAB_CAMERA_ACCESS == cab_camera_access_mode::legacy) {
             init_legacy_camera_hook(FLIP_CAMS);
         }
 
@@ -449,19 +451,10 @@ namespace games::iidx {
             SetEnvironmentVariable("SCREEN_MODE", SCREEN_MODE.value().c_str());
         }
 
-        // check for cab camera access for the second time (first time was in launcher.cpp)
-        // this time, we are inside -iidx module hook, which means the user is likely NOT on a cab
-        // therefore, start with cams OFF by default, and allow user to forcibly override to ON
-        if (!games::iidx::DISABLE_CAMS.has_value()) {
-            games::iidx::DISABLE_CAMS = true;
-            if (options->at(launcher::Options::IIDXCabCamAccess).is_active() &&
-                options->at(launcher::Options::IIDXCabCamAccess).value_text() == "on") {
-                games::iidx::DISABLE_CAMS = false;
-            }
-            if (games::iidx::DISABLE_CAMS.value()) {
-                log_misc("iidx", "CONNECT_CAMERA env var set to 0");
-                SetEnvironmentVariable("CONNECT_CAMERA", "0");
-            }
+        // auto with iidx module means turn off camera (non-cab use)
+        if (CAB_CAMERA_ACCESS == cab_camera_access_mode::automatic) {
+            log_misc("iidx", "CONNECT_CAMERA env var set to 0");
+            SetEnvironmentVariable("CONNECT_CAMERA", "0");
         }
 
         // windowed subscreen, enabled by default, unless turned off by user
@@ -533,6 +526,12 @@ namespace games::iidx {
         }
     }
 
+    void IIDXGame::post_attach() {
+        if (ENABLE_POKE) {
+            poke::enable();
+        }
+    }
+
     void IIDXGame::detach() {
         Game::detach();
 

src/spice2x/games/iidx/iidx.h

@@ -11,6 +11,13 @@
 
 namespace games::iidx {
 
+    enum class cab_camera_access_mode {
+        automatic,
+        off,
+        on,
+        legacy,
+    };
+
     enum class iidx_aio_emulation_state {
         unknown,
         bi2a_com2,
@@ -20,7 +27,7 @@ namespace games::iidx {
     // settings
 
     extern bool FLIP_CAMS;
-    extern std::optional<bool> DISABLE_CAMS;
+    extern cab_camera_access_mode CAB_CAMERA_ACCESS;
     extern bool TDJ_CAMERA;
     extern bool TDJ_CAMERA_PREFER_16_9;
     extern std::optional<std::string> TDJ_CAMERA_OVERRIDE;
@@ -29,6 +36,7 @@ namespace games::iidx {
     extern bool FORCE_720P;
     extern bool DISABLE_ESPEC_IO;
     extern bool NATIVE_TOUCH;
+    extern bool ENABLE_POKE;
     extern std::optional<std::string> SOUND_OUTPUT_DEVICE;
     extern std::optional<std::string> ASIO_DRIVER;
     extern uint8_t DIGITAL_TT_SENS;
@@ -53,6 +61,7 @@ namespace games::iidx {
 
         virtual void attach() override;
         virtual void pre_attach() override;
+        virtual void post_attach() override;
         virtual void detach() override;
 
     private:

src/spice2x/games/iidx/local_camera.h

@@ -2,6 +2,7 @@
 
 #if SPICE64 && !SPICE_XP
 
+#include <atomic>
 #include <d3d9.h>
 #include <dxva2api.h>
 #include <mutex>
@@ -66,6 +67,8 @@ extern std::string CAMERA_CONTROL_LABELS[];
 extern std::string DRAW_MODE_LABELS[];
 
 namespace games::iidx {
+    class IIDXCameraSourceReaderCallback;
+
     namespace Camera {
         struct PlayVideoCamera {
             IDirect3DTexture9** d3d9_texture(const uintptr_t offset) {
@@ -87,7 +90,7 @@ namespace games::iidx {
 
     class IIDXLocalCamera {
     protected:
-        virtual ~IIDXLocalCamera() {};
+        virtual ~IIDXLocalCamera();
 
         LONG m_nRefCount;
         CRITICAL_SECTION m_critsec;
@@ -101,9 +104,14 @@ namespace games::iidx {
         // For reading frames from Camera
         IMFMediaSource *m_pSource = nullptr;
         IMFSourceReader *m_pSourceReader = nullptr;
+        IMFSourceReaderEx *m_pSourceReaderEx = nullptr;
+        IIDXCameraSourceReaderCallback *m_pSourceReaderCallback = nullptr;
+        std::mutex m_mediaTypeMutex;
+        IMFMediaType *m_pendingMediaType = nullptr;
+        int m_selectedMediaTypeIndex = 0;
+        std::string m_selectedMediaTypeDescription = "";
 
         // Camera Format information
-        double                  m_frameRate = 0;
         LONG                    m_cameraWidth;
         LONG                    m_cameraHeight;
 
@@ -129,6 +137,12 @@ namespace games::iidx {
         LPDIRECT3DTEXTURE9 m_conversionTexture = nullptr;
         IDirect3DSurface9 *m_pConversionSurf = nullptr;
 
+        // upload surface for decoded camera frames returned in system memory
+        IDirect3DSurface9 *m_pDecodedSurf = nullptr;
+        GUID m_decodedSubtype = GUID_NULL;
+        GUID m_outputSubtype = GUID_NULL;
+        bool m_drawErrorLogged = false;
+
         // Texture for custom transform (e.g. horizontal flip)
         LPDIRECT3DTEXTURE9 m_transformTexture = nullptr;
         IDirect3DSurface9 *m_pTransformSurf = nullptr;
@@ -153,21 +167,19 @@ namespace games::iidx {
         BOOL m_initialized = false;
 
         // True if all the setup steps succeeded
-        BOOL m_active = false;
+        std::atomic_bool m_active = false;
 
         // Media type select
         std::vector<MediaTypeInfo> m_mediaTypeInfos = {};
-        int m_selectedMediaTypeIndex = 0;
         bool m_useAutoMediaType = true;
         IMFMediaType *m_pAutoMediaType = nullptr;
-        std::string m_selectedMediaTypeDescription = "";
         bool m_allowManualControl = false;
 
-        LocalCameraDrawMode m_drawMode = DrawModeCrop4_3;
+        std::atomic<LocalCameraDrawMode> m_drawMode = DrawModeCrop4_3;
 
         // Render processing
-        bool m_flipHorizontal = false;
-        bool m_flipVertical = false;
+        std::atomic_bool m_flipHorizontal = false;
+        std::atomic_bool m_flipVertical = false;
 
         IIDXLocalCamera(
             std::string name,
@@ -184,11 +196,14 @@ namespace games::iidx {
         HRESULT GetCameraControlProp(int index, CameraControlProp *pProp);
         HRESULT SetCameraControlProp(int index, long value, long flags);
         HRESULT ResetCameraControlProps();
-        HRESULT FlushDrawCommands();
         std::string GetName();
         std::string GetFriendlyName();
         std::string GetSymLink();
+        int GetSelectedMediaTypeIndex();
+        std::string GetSelectedMediaTypeDescription();
+        void SetSelectedMediaTypeDescription(const std::string &description);
         HRESULT ChangeMediaType(IMFMediaType *pType);
+        void RequestMediaType(IMFMediaType *pType);
         HRESULT StartCapture();
         void UpdateDrawRect();
 
@@ -197,12 +212,22 @@ namespace games::iidx {
         void CreateThread();
         MediaTypeInfo GetMediaTypeInfo(IMFMediaType *pType);
         std::string GetVideoFormatName(GUID subtype);
-        HRESULT TryMediaType(IMFMediaType *pType, UINT32 *pBestWidth, double *pBestFrameRate);
+        static bool CompareMediaTypes(const MediaTypeInfo &a, const MediaTypeInfo &b);
+        bool MatchesPreferredAspect(const MediaTypeInfo &info) const;
+        static bool IsBetterAutoType(const MediaTypeInfo &candidate, const MediaTypeInfo &current);
+        IMFMediaType *FindBestNativeAutoType(bool requirePreferredAspect) const;
+        IMFMediaType *FindBestAutoType(const GUID &subtype, bool requirePreferredAspect) const;
+        HRESULT ValidateMediaType(IMFMediaType *pType);
         HRESULT InitTargetTexture();
+        HRESULT EnsureTransformTextures();
         HRESULT InitCameraControl();
+        void SetSelectedMediaType(int index, const std::string &description);
+        bool HasPendingMediaType();
+        HRESULT ApplyPendingMediaType();
+        HRESULT UploadDecodedSample(IMFMediaBuffer *pSrcBuffer);
         HRESULT DrawSample(IMFMediaBuffer *pSrcBuffer);
         HRESULT ReadSample();
-        LPDIRECT3DTEXTURE9 Render();
+        HRESULT Render();
     };
 }
 

src/spice2x/games/iidx/mf_wrappers.cpp

@@ -1,116 +1,132 @@
-#include "mf_wrappers.h"
-#include "util/libutils.h"
-#include "util/logging.h"
-
-namespace games::iidx {
-
-    static bool INITIALIZED = false;
-
-    static HMODULE mf_dll = nullptr;
-    static HMODULE mfreadwrite_dll = nullptr;
-    static HMODULE mfplat_dll = nullptr;
-
-    typedef HRESULT (__stdcall * MFCreateAttributes_t)(
-        _Out_ IMFAttributes** ppMFAttributes,
-        _In_ UINT32 cInitialSize
-        );
-
-    typedef HRESULT (__stdcall * MFEnumDeviceSources_t)(
-        _In_ IMFAttributes* pAttributes,
-        _Outptr_result_buffer_(*pcSourceActivate) IMFActivate*** pppSourceActivate,
-        _Out_ UINT32* pcSourceActivate
-        );
-
-    typedef HRESULT (__stdcall * MFCreateSourceReaderFromMediaSource_t)(
-        _In_ IMFMediaSource *pMediaSource,
-        _In_opt_ IMFAttributes *pAttributes,
-        _Out_ IMFSourceReader **ppSourceReader
-        );
-
-    typedef HRESULT (__stdcall * MFGetService_t)(
-        IUnknown* punkObject,
-        REFGUID guidService,
-        REFIID riid,
-        _Outptr_ LPVOID* ppvObject
-        );
-
-    static MFCreateAttributes_t MFCreateAttributes = nullptr;
-    static MFEnumDeviceSources_t MFEnumDeviceSources = nullptr;
-    static MFCreateSourceReaderFromMediaSource_t MFCreateSourceReaderFromMediaSource = nullptr;
-    static MFGetService_t MFGetService = nullptr;
-
-    void init_mf_library() {
-
-        // why was all of this needed?
-        //
-        // when iidx camhook was initially implemented, we linked to mf.lib, mfreadwrite.lib, and mfplat.lib
-        // this made Unity-based really unhappy, causing them to skip over the logic that loads mf library
-        // causing videos to not play ("Initializing Microsoft Media Foundation failed." in the cmd prompt)
-        //
-        // as a result, the static linking to mf libs were removed, and we are now doing the mess that is this file
-
-        if (INITIALIZED) {
-            return;
-        }
-        INITIALIZED = true;
-
-        log_misc("mf_wrappers", "creating delay-loaded wrappers for MF routines - BEGIN");
-
-        mf_dll = libutils::load_library("mf.dll", true);
-        mfreadwrite_dll = libutils::load_library("mfreadwrite.dll", true);
-        mfplat_dll = libutils::load_library("mfplat.dll", true);
-
-        MFCreateAttributes = (MFCreateAttributes_t)
-            libutils::get_proc(mfplat_dll, "MFCreateAttributes");
-        if (!MFCreateAttributes) {
-            log_fatal("mf_wrappers", "MFCreateAttributes failed to hook");
-        }
-
-        MFEnumDeviceSources = (MFEnumDeviceSources_t)
-            libutils::get_proc(mf_dll, "MFEnumDeviceSources");
-        if (!MFEnumDeviceSources) {
-            log_fatal("mf_wrappers", "MFEnumDeviceSources failed to hook");
-        }
-
-        MFCreateSourceReaderFromMediaSource = (MFCreateSourceReaderFromMediaSource_t)
-            libutils::get_proc(mfreadwrite_dll, "MFCreateSourceReaderFromMediaSource");
-        if (!MFCreateSourceReaderFromMediaSource) {
-            log_fatal("mf_wrappers", "MFCreateSourceReaderFromMediaSource failed to hook");
-        }
-
-        MFGetService = (MFGetService_t)libutils::get_proc(mf_dll, "MFGetService");
-        if (!MFGetService) {
-            log_fatal("mf_wrappers", "MFGetService failed to hook");
-        }
-
-        log_misc("mf_wrappers", "creating delay-loaded wrappers for MF routines - DONE");
-    }
-
-    HRESULT WrappedMFCreateAttributes (
-        _Out_ IMFAttributes** ppMFAttributes,
-        _In_ UINT32 cInitialSize) {
-        return MFCreateAttributes(ppMFAttributes, cInitialSize);
-    }
-
-    HRESULT WrappedMFEnumDeviceSources (
-        _In_ IMFAttributes* pAttributes,
-        _Outptr_result_buffer_(*pcSourceActivate) IMFActivate*** pppSourceActivate,
-        _Out_ UINT32* pcSourceActivate) {
-        return MFEnumDeviceSources(pAttributes, pppSourceActivate, pcSourceActivate);
-    }
-
-    HRESULT WrappedMFCreateSourceReaderFromMediaSource (
-        _In_ IMFMediaSource *pMediaSource,
-        _In_opt_ IMFAttributes *pAttributes,
-        _Out_ IMFSourceReader **ppSourceReader) {
-        return MFCreateSourceReaderFromMediaSource(pMediaSource, pAttributes, ppSourceReader);
-    }
-
-    HRESULT WrappedMFGetService (
-        IUnknown* punkObject,
-        REFGUID guidService,
-        REFIID riid,
-        _Outptr_ LPVOID* ppvObject) {
-        return MFGetService(punkObject, guidService, riid, ppvObject);
-    }
+#include "mf_wrappers.h"
+#include "util/libutils.h"
+#include "util/logging.h"
+
+namespace games::iidx {
+
+    static bool INITIALIZED = false;
+
+    static HMODULE mf_dll = nullptr;
+    static HMODULE mfreadwrite_dll = nullptr;
+    static HMODULE mfplat_dll = nullptr;
+
+    typedef HRESULT (__stdcall * MFCreateAttributes_t)(
+        _Out_ IMFAttributes** ppMFAttributes,
+        _In_ UINT32 cInitialSize
+        );
+
+    typedef HRESULT (__stdcall * MFCreateMediaType_t)(
+        _Out_ IMFMediaType** ppMFType
+        );
+
+    typedef HRESULT (__stdcall * MFEnumDeviceSources_t)(
+        _In_ IMFAttributes* pAttributes,
+        _Outptr_result_buffer_(*pcSourceActivate) IMFActivate*** pppSourceActivate,
+        _Out_ UINT32* pcSourceActivate
+        );
+
+    typedef HRESULT (__stdcall * MFCreateSourceReaderFromMediaSource_t)(
+        _In_ IMFMediaSource *pMediaSource,
+        _In_opt_ IMFAttributes *pAttributes,
+        _Out_ IMFSourceReader **ppSourceReader
+        );
+
+    typedef HRESULT (__stdcall * MFGetService_t)(
+        IUnknown* punkObject,
+        REFGUID guidService,
+        REFIID riid,
+        _Outptr_ LPVOID* ppvObject
+        );
+
+    static MFCreateAttributes_t MFCreateAttributes = nullptr;
+    static MFCreateMediaType_t MFCreateMediaType = nullptr;
+    static MFEnumDeviceSources_t MFEnumDeviceSources = nullptr;
+    static MFCreateSourceReaderFromMediaSource_t MFCreateSourceReaderFromMediaSource = nullptr;
+    static MFGetService_t MFGetService = nullptr;
+
+    void init_mf_library() {
+
+        // why was all of this needed?
+        //
+        // when iidx camhook was initially implemented, we linked to mf.lib, mfreadwrite.lib, and mfplat.lib
+        // this made Unity-based really unhappy, causing them to skip over the logic that loads mf library
+        // causing videos to not play ("Initializing Microsoft Media Foundation failed." in the cmd prompt)
+        //
+        // as a result, the static linking to mf libs were removed, and we are now doing the mess that is this file
+
+        if (INITIALIZED) {
+            return;
+        }
+        INITIALIZED = true;
+
+        log_misc("mf_wrappers", "creating delay-loaded wrappers for MF routines - BEGIN");
+
+        mf_dll = libutils::load_library("mf.dll", true);
+        mfreadwrite_dll = libutils::load_library("mfreadwrite.dll", true);
+        mfplat_dll = libutils::load_library("mfplat.dll", true);
+
+        MFCreateAttributes = (MFCreateAttributes_t)
+            libutils::get_proc(mfplat_dll, "MFCreateAttributes");
+        if (!MFCreateAttributes) {
+            log_fatal("mf_wrappers", "MFCreateAttributes failed to hook");
+        }
+
+        MFCreateMediaType = (MFCreateMediaType_t)
+            libutils::get_proc(mfplat_dll, "MFCreateMediaType");
+        if (!MFCreateMediaType) {
+            log_fatal("mf_wrappers", "MFCreateMediaType failed to hook");
+        }
+
+        MFEnumDeviceSources = (MFEnumDeviceSources_t)
+            libutils::get_proc(mf_dll, "MFEnumDeviceSources");
+        if (!MFEnumDeviceSources) {
+            log_fatal("mf_wrappers", "MFEnumDeviceSources failed to hook");
+        }
+
+        MFCreateSourceReaderFromMediaSource = (MFCreateSourceReaderFromMediaSource_t)
+            libutils::get_proc(mfreadwrite_dll, "MFCreateSourceReaderFromMediaSource");
+        if (!MFCreateSourceReaderFromMediaSource) {
+            log_fatal("mf_wrappers", "MFCreateSourceReaderFromMediaSource failed to hook");
+        }
+
+        MFGetService = (MFGetService_t)libutils::get_proc(mf_dll, "MFGetService");
+        if (!MFGetService) {
+            log_fatal("mf_wrappers", "MFGetService failed to hook");
+        }
+
+        log_misc("mf_wrappers", "creating delay-loaded wrappers for MF routines - DONE");
+    }
+
+    HRESULT WrappedMFCreateAttributes (
+        _Out_ IMFAttributes** ppMFAttributes,
+        _In_ UINT32 cInitialSize) {
+        return MFCreateAttributes(ppMFAttributes, cInitialSize);
+    }
+
+    HRESULT WrappedMFCreateMediaType (
+        _Out_ IMFMediaType** ppMFType) {
+        return MFCreateMediaType(ppMFType);
+    }
+
+    HRESULT WrappedMFEnumDeviceSources (
+        _In_ IMFAttributes* pAttributes,
+        _Outptr_result_buffer_(*pcSourceActivate) IMFActivate*** pppSourceActivate,
+        _Out_ UINT32* pcSourceActivate) {
+        return MFEnumDeviceSources(pAttributes, pppSourceActivate, pcSourceActivate);
+    }
+
+    HRESULT WrappedMFCreateSourceReaderFromMediaSource (
+        _In_ IMFMediaSource *pMediaSource,
+        _In_opt_ IMFAttributes *pAttributes,
+        _Out_ IMFSourceReader **ppSourceReader) {
+        return MFCreateSourceReaderFromMediaSource(pMediaSource, pAttributes, ppSourceReader);
+    }
+
+    HRESULT WrappedMFGetService (
+        IUnknown* punkObject,
+        REFGUID guidService,
+        REFIID riid,
+        _Outptr_ LPVOID* ppvObject) {
+        return MFGetService(punkObject, guidService, riid, ppvObject);
+    }
 }

src/spice2x/games/iidx/mf_wrappers.h

@@ -1,30 +1,33 @@
-#include <mfapi.h>
-#include <mfidl.h>
-#include <mfreadwrite.h>
-#include <mfobjects.h>
-
-#pragma once
-
-namespace games::iidx {
-    void init_mf_library();
-
-    HRESULT WrappedMFCreateAttributes (
-        _Out_ IMFAttributes** ppMFAttributes,
-        _In_ UINT32 cInitialSize);
-
-    HRESULT WrappedMFEnumDeviceSources (
-        _In_ IMFAttributes* pAttributes,
-        _Outptr_result_buffer_(*pcSourceActivate) IMFActivate*** pppSourceActivate,
-        _Out_ UINT32* pcSourceActivate);
-
-    HRESULT WrappedMFCreateSourceReaderFromMediaSource (
-        _In_ IMFMediaSource *pMediaSource,
-        _In_opt_ IMFAttributes *pAttributes,
-        _Out_ IMFSourceReader **ppSourceReader);
-
-    HRESULT WrappedMFGetService (
-        IUnknown* punkObject,
-        REFGUID guidService,
-        REFIID riid,
-        _Outptr_ LPVOID* ppvObject);
+#include <mfapi.h>
+#include <mfidl.h>
+#include <mfreadwrite.h>
+#include <mfobjects.h>
+
+#pragma once
+
+namespace games::iidx {
+    void init_mf_library();
+
+    HRESULT WrappedMFCreateAttributes (
+        _Out_ IMFAttributes** ppMFAttributes,
+        _In_ UINT32 cInitialSize);
+
+    HRESULT WrappedMFCreateMediaType (
+        _Out_ IMFMediaType** ppMFType);
+
+    HRESULT WrappedMFEnumDeviceSources (
+        _In_ IMFAttributes* pAttributes,
+        _Outptr_result_buffer_(*pcSourceActivate) IMFActivate*** pppSourceActivate,
+        _Out_ UINT32* pcSourceActivate);
+
+    HRESULT WrappedMFCreateSourceReaderFromMediaSource (
+        _In_ IMFMediaSource *pMediaSource,
+        _In_opt_ IMFAttributes *pAttributes,
+        _Out_ IMFSourceReader **ppSourceReader);
+
+    HRESULT WrappedMFGetService (
+        IUnknown* punkObject,
+        REFGUID guidService,
+        REFIID riid,
+        _Outptr_ LPVOID* ppvObject);
 }

src/spice2x/games/iidx/poke.cpp

@@ -1,31 +1,17 @@
 #include "poke.h"
 
+#include <chrono>
 #include <thread>
 
 #include "windows.h"
-#include "cfg/screen_resize.h"
 #include "games/io.h"
 #include "games/iidx/iidx.h"
 #include "hooks/graphics/graphics.h"
 #include "launcher/shutdown.h"
 #include "misc/eamuse.h"
-#include "overlay/overlay.h"
-#include "overlay/windows/generic_sub.h"
-#include "rawinput/rawinput.h"
+#include "touch/native/inject.h"
 #include "touch/touch.h"
-#include "util/libutils.h"
 #include "util/logging.h"
-#include "util/precise_timer.h"
-
-#define POKE_NATIVE_TOUCH 0
-
-#if POKE_NATIVE_TOUCH
-static HINSTANCE USER32_INSTANCE = nullptr;
-typedef BOOL (WINAPI *InitializeTouchInjection_t)(UINT32, DWORD);
-typedef BOOL (WINAPI *InjectTouchInput_t)(UINT32, POINTER_TOUCH_INFO*);
-static InitializeTouchInjection_t pInitializeTouchInjection = nullptr;
-static InjectTouchInput_t pInjectTouchInput = nullptr;
-#endif
 
 namespace games::iidx::poke {
 
@@ -116,93 +102,29 @@ namespace games::iidx::poke {
         {"1/D", 50},
     };
 
-#if POKE_NATIVE_TOUCH
-    void initialize_native_touch_library() {
-        if (USER32_INSTANCE == nullptr) {
-            USER32_INSTANCE = libutils::load_library("user32.dll");
-        }
-
-        pInitializeTouchInjection = libutils::try_proc<InitializeTouchInjection_t>(
-                USER32_INSTANCE, "InitializeTouchInjection");
-        pInjectTouchInput = libutils::try_proc<InjectTouchInput_t>(
-                USER32_INSTANCE, "InjectTouchInput");
-    }
-
-    void emulate_native_touch(TouchPoint tp, bool is_down) {
-        if (pInjectTouchInput == nullptr) {
+    static void inject_native_touch_points(const std::vector<TouchPoint> &touch_points, bool down) {
+        if (touch_points.empty()) {
             return;
         }
 
-        POINTER_TOUCH_INFO contact;
-        BOOL bRet = TRUE;
-        const int contact_offset = 2;
-
-        memset(&contact, 0, sizeof(POINTER_TOUCH_INFO));
-
-        contact.pointerInfo.pointerType = PT_TOUCH;
-        contact.pointerInfo.pointerId = 0;
-        contact.pointerInfo.ptPixelLocation.x = tp.x;
-        contact.pointerInfo.ptPixelLocation.y = tp.y;
-        if (is_down) {
-            contact.pointerInfo.pointerFlags = POINTER_FLAG_DOWN | POINTER_FLAG_INRANGE | POINTER_FLAG_INCONTACT;
-        } else {
-            contact.pointerInfo.pointerFlags = POINTER_FLAG_UP;
-        }
-
-        contact.pointerInfo.dwTime = 0;
-        contact.pointerInfo.PerformanceCount = 0;
-
-        contact.touchFlags = TOUCH_FLAG_NONE;
-        contact.touchMask = TOUCH_MASK_CONTACTAREA | TOUCH_MASK_ORIENTATION | TOUCH_MASK_PRESSURE;
-        contact.orientation = 0;
-        contact.pressure = 1024;
-
-        contact.rcContact.top = tp.y - contact_offset;
-        contact.rcContact.bottom = tp.y + contact_offset;
-        contact.rcContact.left = tp.x - contact_offset;
-        contact.rcContact.right = tp.x + contact_offset;
-
-        bRet = InjectTouchInput(1, &contact);
-        if (!bRet) {
-            log_warning("poke", "error injecting native touch {}: ({}, {}) error: {}", is_down ? "down" : "up", tp.x, tp.y, GetLastError());
-        }
+        const auto &touch = touch_points.front();
+        nativetouch::inject::inject_synthetic_touch({ touch.x, touch.y }, down);
     }
-
-    void emulate_native_touch_points(std::vector<TouchPoint> *touch_points) {
-        int i = 0;
-        for (auto &touch : *touch_points) {
-            emulate_native_touch(touch, true);
-        }
-    }
-
-    void clear_native_touch_points(std::vector<TouchPoint> *touch_points) {
-        for (auto &touch : *touch_points) {
-            emulate_native_touch(touch, false);
-        }
-        touch_points->clear();
-    }
-#endif
     
-    void clear_touch_points(std::vector<TouchPoint> *touch_points) {
-        std::vector<DWORD> touch_ids;
-        for (auto &touch : *touch_points) {
-            touch_ids.emplace_back(touch.id);
-        }
-        touch_remove_points(&touch_ids);
-        touch_points->clear();
-    }
-
     void enable() {
 
         // check if already running
         if (THREAD)
             return;
 
+        if (!games::iidx::NATIVE_TOUCH) {
+            log_warning("poke", "keypad touch emulation requires native touch; disabled");
+            return;
+        }
+
         // create new thread
         THREAD_RUNNING = true;
         THREAD = new std::thread([] {
-            timeutils::PreciseSleepTimer timer;
-
             // log
             log_info("poke", "enabled");
 
@@ -210,35 +132,13 @@ namespace games::iidx::poke {
             std::vector<TouchPoint> touch_points;
             std::vector<uint16_t> last_keypad_state = {0, 0};
 
-#if POKE_NATIVE_TOUCH
-            bool use_native = games::iidx::NATIVE_TOUCH;
-
-            if (use_native) {
-                initialize_native_touch_library();
-                
-                if (pInitializeTouchInjection != nullptr) {
-                    pInitializeTouchInjection(1, TOUCH_FEEDBACK_NONE);
-                }
-            }
-
-#else 
-            bool use_native = false;
-#endif
-
             // set variable to false to stop
             while (THREAD_RUNNING) {
 
                 // clean up touch from last frame
                 if (touch_points.size() > 0) {
-#if POKE_NATIVE_TOUCH
-                    if (use_native) {
-                        clear_native_touch_points(&touch_points);
-                    } else {
-                        clear_touch_points(&touch_points);
-                    }
-#else
-                    clear_touch_points(&touch_points);
-#endif
+                    inject_native_touch_points(touch_points, false);
+                    touch_points.clear();
                 }
 
                 for (int unit = 0; unit < 2; unit++) {
@@ -263,32 +163,15 @@ namespace games::iidx::poke {
 
                                     float x = x_iter->second / 1920.0;
                                     float y = y_iter->second / 1080.0;
-                                    if (use_native) {
-                                        x *= rawinput::TOUCHSCREEN_RANGE_X;
-                                        y *= rawinput::TOUCHSCREEN_RANGE_Y;
-                                    } else if (GRAPHICS_IIDX_WSUB) {
-                                        // Scale to windowed subscreen
-                                        x *= GRAPHICS_WSUB_WIDTH;
-                                        y *= GRAPHICS_WSUB_HEIGHT;
-                                    } else if (GENERIC_SUB_WINDOW_FULLSIZE || !overlay::OVERLAY->get_active()) {
-                                        // Overlay is not present, scale to main screen
-                                        if (GRAPHICS_WINDOWED) {
-                                            x *= SPICETOUCH_TOUCH_WIDTH;
-                                            y *= SPICETOUCH_TOUCH_HEIGHT;
-                                        } else {
-                                            x *= ImGui::GetIO().DisplaySize.x;
-                                            y *= ImGui::GetIO().DisplaySize.y;
+                                    if (GRAPHICS_WINDOWED) {
+                                        if (SPICETOUCH_TOUCH_WIDTH <= 0 || SPICETOUCH_TOUCH_HEIGHT <= 0) {
+                                            continue;
                                         }
+                                        x = SPICETOUCH_TOUCH_X + x * SPICETOUCH_TOUCH_WIDTH;
+                                        y = SPICETOUCH_TOUCH_Y + y * SPICETOUCH_TOUCH_HEIGHT;
                                     } else {
-                                        // Overlay subscreen
-                                        x = (GENERIC_SUB_WINDOW_X + x * GENERIC_SUB_WINDOW_WIDTH);
-                                        y = (GENERIC_SUB_WINDOW_Y + y * GENERIC_SUB_WINDOW_HEIGHT);
-
-                                        // Scale to window size ratio
-                                        if (GRAPHICS_WINDOWED) {
-                                            x *= SPICETOUCH_TOUCH_WIDTH / ImGui::GetIO().DisplaySize.x;
-                                            y *= SPICETOUCH_TOUCH_HEIGHT / ImGui::GetIO().DisplaySize.y;
-                                        }
+                                        x = x_iter->second;
+                                        y = y_iter->second;
                                     }
 
                                     TouchPoint tp {
@@ -309,19 +192,15 @@ namespace games::iidx::poke {
                 } // for all units
 
                 if (touch_points.size() > 0) {
-#if POKE_NATIVE_TOUCH
-                    if (use_native) {
-                        emulate_native_touch_points(&touch_points);
-                    } else {
-                        touch_write_points(&touch_points);
-                    }
-#else
-                    touch_write_points(&touch_points);
-#endif
+                    inject_native_touch_points(touch_points, true);
                 }
 
                 // slow down
-                timer.sleep(50);
+                std::this_thread::sleep_for(std::chrono::milliseconds(50));
+            }
+
+            if (!touch_points.empty()) {
+                inject_native_touch_points(touch_points, false);
             }
 
             return nullptr;

src/spice2x/games/io.cpp

@@ -44,6 +44,7 @@ namespace games {
     static bool IO_INITIALIZED = false;
     static std::vector<std::string> games;
     static robin_hood::unordered_map<std::string, std::vector<Button> &> buttons;
+    static robin_hood::unordered_map<std::string, std::vector<Button>> buttons_modifiers;
     static robin_hood::unordered_map<std::string, std::vector<Button>> buttons_keypads;
     static robin_hood::unordered_map<std::string, std::vector<Button>> buttons_overlay;
     static robin_hood::unordered_map<std::string, std::string> buttons_help;
@@ -132,6 +133,7 @@ namespace games {
         buttons_help.insert({ jb, jb::get_buttons_help() });
         lights.insert({ jb, jb::get_lights() });
         file_hints[jb].push_back({"jubeat.dll"});
+        file_hints[jb].push_back({"jubeat2019.dll"});
 
         // mga
         const std::string mga("Metal Gear");
@@ -365,6 +367,37 @@ namespace games {
         return it->second;
     }
 
+    static std::vector<Button> gen_buttons_modifiers(const std::string &game) {
+        auto modifier_buttons = GameAPI::Buttons::getButtons(game);
+        const std::vector<std::string> names {
+            "Modifier 1",
+            "Modifier 2",
+            "Modifier 3",
+            "Modifier 4",
+        };
+        modifier_buttons = GameAPI::Buttons::sortButtons(modifier_buttons, names);
+        for (auto &modifier : modifier_buttons) {
+            modifier.setModifierMask(0);
+            for (auto &alternative : modifier.getAlternatives()) {
+                alternative.setModifierMask(0);
+            }
+        }
+        return modifier_buttons;
+    }
+
+    std::vector<Button> *get_buttons_modifiers(const std::string &game) {
+        initialize();
+        auto it = buttons_modifiers.find(game);
+        if (it == buttons_modifiers.end()) {
+            if (game.empty()) {
+                return nullptr;
+            }
+            buttons_modifiers[game] = gen_buttons_modifiers(game);
+            return &buttons_modifiers[game];
+        }
+        return &it->second;
+    }
+
     static std::vector<Button> gen_buttons_keypads(const std::string &game) {
         auto buttons = GameAPI::Buttons::getButtons(game);
         std::vector<std::string> names;
@@ -474,6 +507,8 @@ namespace games {
         vkey_defaults.push_back(VK_F12);
         names.emplace_back("Toggle Camera Control");
         vkey_defaults.push_back(0xFF);
+        names.emplace_back("Toggle OBS Control");
+        vkey_defaults.push_back(0xFF);
         names.emplace_back("Player 1 PIN Macro");
         vkey_defaults.push_back(0xFF);
         names.emplace_back("Player 2 PIN Macro");

src/spice2x/games/io.h

@@ -5,6 +5,16 @@
 
 namespace games {
 
+    namespace ModifierButtons {
+        enum {
+            Modifier1,
+            Modifier2,
+            Modifier3,
+            Modifier4,
+            Size,
+        };
+    }
+
     namespace OverlayButtons {
         enum {
             Screenshot,
@@ -23,6 +33,7 @@ namespace games {
             ToggleScreenResize,
             ToggleFps,
             ToggleCameraControl,
+            ToggleOBSControl,
             TriggerPinMacroP1,
             TriggerPinMacroP2,
             ScreenResize,
@@ -58,6 +69,7 @@ namespace games {
 
     const std::vector<std::string> &get_games();
     std::vector<Button> *get_buttons(const std::string &game);
+    std::vector<Button> *get_buttons_modifiers(const std::string &game);
     std::string get_buttons_help(const std::string &game);
     std::string get_analogs_help(const std::string &game);
     std::vector<Button> *get_buttons_keypads(const std::string &game);

src/spice2x/games/jb/bi2x_hook.cpp

@@ -0,0 +1,336 @@
+#include "bi2x_hook.h"
+
+#if SPICE64
+
+#include <array>
+#include <cstdint>
+#include <cstring>
+
+#include "games/io.h"
+#include "games/jb/jb_touch.h"
+#include "io.h"
+#include "misc/eamuse.h"
+#include "rawinput/rawinput.h"
+#include "util/detour.h"
+#include "util/logging.h"
+
+namespace games::jb {
+
+    struct AIO_SCI_COMM {
+        std::array<uint8_t, 0x100> data;
+    };
+
+    struct AIO_NMGR_IOB2;
+
+    struct AIO_NMGR_IOB2_VTABLE {
+        std::array<void *, 10> unused;
+        void (__fastcall *begin_manage)(AIO_NMGR_IOB2 *node_mgr);
+    };
+
+    struct AIO_NMGR_IOB2 {
+        AIO_NMGR_IOB2_VTABLE *vtable;
+        std::array<uint8_t, 0x78> data;
+    };
+
+    struct AIO_IOB2_BI2X_T44 {
+        std::array<uint8_t, 0x80> data;
+    };
+
+    struct AIO_IOB2_BI2X_T44_DEVSTATUS {
+        std::array<uint8_t, 0x140> data;
+    };
+
+    struct AIO_IOB2_BI2X_WRFIRM {
+        uint8_t data;
+    };
+
+    static_assert(sizeof(AIO_NMGR_IOB2) == 0x80);
+    static_assert(sizeof(AIO_IOB2_BI2X_T44_DEVSTATUS) == 0x140);
+
+    using aioIob2Bi2xT44_Create_t = AIO_IOB2_BI2X_T44 *(__fastcall *)(AIO_NMGR_IOB2 *node_mgr,
+            uint32_t device_id);
+    using aioIob2Bi2xT44_GetDeviceStatus_t = void (__fastcall *)(AIO_IOB2_BI2X_T44 *node,
+            AIO_IOB2_BI2X_T44_DEVSTATUS *status);
+    using aioIob2Bi2xT44_IoReset_t = void (__fastcall *)(AIO_IOB2_BI2X_T44 *node, uint32_t reset);
+    using aioIob2Bi2xT44_SetWatchDogTimer_t = void (__fastcall *)(AIO_IOB2_BI2X_T44 *node, uint8_t count);
+    using aioIob2Bi2xT44_ControlCoinBlocker_t = void (__fastcall *)(AIO_IOB2_BI2X_T44 *node,
+            uint32_t slot, bool open);
+    using aioIob2Bi2xT44_AddCounter_t = void (__fastcall *)(AIO_IOB2_BI2X_T44 *node,
+            uint32_t counter, uint32_t count);
+    using aioIob2Bi2xT44_SetIccrLed_t = void (__fastcall *)(AIO_IOB2_BI2X_T44 *node, uint32_t color);
+    using aioIob2Bi2xT44_SetTapeLedData_t = void (__fastcall *)(AIO_IOB2_BI2X_T44 *node,
+            uint32_t tape, const void *data);
+    using aioIob2Bi2x_OpenSciUsbCdc_t = AIO_SCI_COMM *(__fastcall *)(uint32_t serial_number);
+    using aioIob2Bi2x_CreateWriteFirmContext_t = AIO_IOB2_BI2X_WRFIRM *(__fastcall *)(
+            uint32_t serial_number, uint32_t iob_mask);
+    using aioIob2Bi2x_DestroyWriteFirmContext_t = void (__fastcall *)(AIO_IOB2_BI2X_WRFIRM *context);
+    using aioIob2Bi2x_WriteFirmGetState_t = int32_t (__fastcall *)(AIO_IOB2_BI2X_WRFIRM *context);
+    using aioIob2Bi2x_WriteFirmIsCompleted_t = bool (__fastcall *)(int32_t state);
+    using aioIob2Bi2x_WriteFirmIsError_t = bool (__fastcall *)(int32_t state);
+    using aioNMgrIob2_Create_t = AIO_NMGR_IOB2 *(__fastcall *)(AIO_SCI_COMM *sci, uint32_t mode);
+    using aioSci_Destroy_t = void (__fastcall *)(AIO_SCI_COMM *sci);
+    using aioNodeMgr_Destroy_t = void (__fastcall *)(AIO_NMGR_IOB2 *node_mgr);
+    using aioNodeCtl_Destroy_t = void (__fastcall *)(AIO_IOB2_BI2X_T44 *node);
+    using aioNodeCtl_UpdateDevicesStatus_t = void (__fastcall *)();
+
+    static aioIob2Bi2xT44_Create_t aioIob2Bi2xT44_Create_orig = nullptr;
+    static aioIob2Bi2xT44_GetDeviceStatus_t aioIob2Bi2xT44_GetDeviceStatus_orig = nullptr;
+    static aioIob2Bi2xT44_IoReset_t aioIob2Bi2xT44_IoReset_orig = nullptr;
+    static aioIob2Bi2xT44_SetWatchDogTimer_t aioIob2Bi2xT44_SetWatchDogTimer_orig = nullptr;
+    static aioIob2Bi2xT44_ControlCoinBlocker_t aioIob2Bi2xT44_ControlCoinBlocker_orig = nullptr;
+    static aioIob2Bi2xT44_AddCounter_t aioIob2Bi2xT44_AddCounter_orig = nullptr;
+    static aioIob2Bi2xT44_SetIccrLed_t aioIob2Bi2xT44_SetIccrLed_orig = nullptr;
+    static aioIob2Bi2xT44_SetTapeLedData_t aioIob2Bi2xT44_SetTapeLedData_orig = nullptr;
+    static aioIob2Bi2x_OpenSciUsbCdc_t aioIob2Bi2x_OpenSciUsbCdc_orig = nullptr;
+    static aioIob2Bi2x_CreateWriteFirmContext_t aioIob2Bi2x_CreateWriteFirmContext_orig = nullptr;
+    static aioIob2Bi2x_DestroyWriteFirmContext_t aioIob2Bi2x_DestroyWriteFirmContext_orig = nullptr;
+    static aioIob2Bi2x_WriteFirmGetState_t aioIob2Bi2x_WriteFirmGetState_orig = nullptr;
+    static aioIob2Bi2x_WriteFirmIsCompleted_t aioIob2Bi2x_WriteFirmIsCompleted_orig = nullptr;
+    static aioIob2Bi2x_WriteFirmIsError_t aioIob2Bi2x_WriteFirmIsError_orig = nullptr;
+    static aioNMgrIob2_Create_t aioNMgrIob2_Create_orig = nullptr;
+    static aioSci_Destroy_t aioSci_Destroy_orig = nullptr;
+    static aioNodeMgr_Destroy_t aioNodeMgr_Destroy_orig = nullptr;
+    static aioNodeCtl_Destroy_t aioNodeCtl_Destroy_orig = nullptr;
+    static aioNodeCtl_UpdateDevicesStatus_t aioNodeCtl_UpdateDevicesStatus_orig = nullptr;
+
+    static AIO_SCI_COMM *aio_sci_comm = nullptr;
+    static AIO_NMGR_IOB2 *aio_node_mgr = nullptr;
+    static AIO_IOB2_BI2X_T44 *aio_t44 = nullptr;
+    static AIO_IOB2_BI2X_WRFIRM *aio_write_firm = nullptr;
+    static uint8_t input_counter = 0;
+
+    static void __fastcall aioNMgrIob_BeginManage(AIO_NMGR_IOB2 *) {
+    }
+
+    static AIO_NMGR_IOB2_VTABLE aio_node_mgr_vtable {
+        {},
+        aioNMgrIob_BeginManage,
+    };
+
+    static AIO_SCI_COMM *__fastcall aioIob2Bi2x_OpenSciUsbCdc(uint32_t) {
+        aio_sci_comm = new AIO_SCI_COMM {};
+        return aio_sci_comm;
+    }
+
+    static AIO_NMGR_IOB2 *__fastcall aioNMgrIob2_Create(AIO_SCI_COMM *sci, uint32_t mode) {
+        if (sci != aio_sci_comm) {
+            return aioNMgrIob2_Create_orig(sci, mode);
+        }
+
+        aio_node_mgr = new AIO_NMGR_IOB2 {};
+        aio_node_mgr->vtable = &aio_node_mgr_vtable;
+        return aio_node_mgr;
+    }
+
+    static AIO_IOB2_BI2X_T44 *__fastcall aioIob2Bi2xT44_Create(
+            AIO_NMGR_IOB2 *node_mgr, uint32_t device_id) {
+        if (node_mgr != aio_node_mgr) {
+            return aioIob2Bi2xT44_Create_orig(node_mgr, device_id);
+        }
+
+        log_info("jb::bi2x", "T44 node created");
+        aio_t44 = new AIO_IOB2_BI2X_T44 {};
+        return aio_t44;
+    }
+
+    static void __fastcall aioIob2Bi2xT44_GetDeviceStatus(
+            AIO_IOB2_BI2X_T44 *node, AIO_IOB2_BI2X_T44_DEVSTATUS *status) {
+        if (node != aio_t44) {
+            return aioIob2Bi2xT44_GetDeviceStatus_orig(node, status);
+        }
+
+        RI_MGR->devices_flush_output();
+        std::memset(status, 0, sizeof(*status));
+
+        status->data[0x00] = input_counter;
+        status->data[0x03] = input_counter++;
+        status->data[0x0A] = static_cast<uint8_t>(eamuse_coin_get_stock());
+
+        games::jb::touch_update();
+        const auto touched = games::jb::touch_state();
+        auto &buttons = get_buttons();
+
+        status->data[0x04] = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Test]) ? 0xFF : 0;
+        status->data[0x05] = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Service]) ? 0xFF : 0;
+        status->data[0x06] = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::CoinMech]) ? 0xFF : 0;
+
+        static constexpr size_t PANEL_ORDER[16] = {
+            3, 7, 11, 15,
+            2, 6, 10, 14,
+            1, 5, 9, 13,
+            0, 4, 8, 12,
+        };
+        for (size_t status_index = 0; status_index < std::size(PANEL_ORDER); status_index++) {
+            const auto panel_index = PANEL_ORDER[status_index];
+            if (touched[panel_index] || GameAPI::Buttons::getState(
+                    RI_MGR, buttons[Buttons::Button1 + panel_index])) {
+                status->data[0x0F + status_index] = 0xFF;
+            }
+        }
+    }
+
+    static void __fastcall aioIob2Bi2xT44_IoReset(AIO_IOB2_BI2X_T44 *node, uint32_t reset) {
+        if (node != aio_t44) {
+            return aioIob2Bi2xT44_IoReset_orig(node, reset);
+        }
+    }
+
+    static void __fastcall aioIob2Bi2xT44_SetWatchDogTimer(AIO_IOB2_BI2X_T44 *node, uint8_t count) {
+        if (node != aio_t44) {
+            return aioIob2Bi2xT44_SetWatchDogTimer_orig(node, count);
+        }
+    }
+
+    static void __fastcall aioIob2Bi2xT44_ControlCoinBlocker(
+            AIO_IOB2_BI2X_T44 *node, uint32_t slot, bool open) {
+        if (node != aio_t44) {
+            return aioIob2Bi2xT44_ControlCoinBlocker_orig(node, slot, open);
+        }
+
+        eamuse_coin_set_block(!open);
+    }
+
+    static void __fastcall aioIob2Bi2xT44_AddCounter(
+            AIO_IOB2_BI2X_T44 *node, uint32_t counter, uint32_t count) {
+        if (node != aio_t44) {
+            return aioIob2Bi2xT44_AddCounter_orig(node, counter, count);
+        }
+    }
+
+    static void __fastcall aioIob2Bi2xT44_SetIccrLed(AIO_IOB2_BI2X_T44 *node, uint32_t color) {
+        if (node != aio_t44) {
+            return aioIob2Bi2xT44_SetIccrLed_orig(node, color);
+        }
+    }
+
+    static void __fastcall aioIob2Bi2xT44_SetTapeLedData(
+            AIO_IOB2_BI2X_T44 *node, uint32_t tape, const void *data) {
+        if (node != aio_t44) {
+            return aioIob2Bi2xT44_SetTapeLedData_orig(node, tape, data);
+        }
+    }
+
+    static AIO_IOB2_BI2X_WRFIRM *__fastcall aioIob2Bi2x_CreateWriteFirmContext(uint32_t, uint32_t) {
+        aio_write_firm = new AIO_IOB2_BI2X_WRFIRM {};
+        return aio_write_firm;
+    }
+
+    static void __fastcall aioIob2Bi2x_DestroyWriteFirmContext(AIO_IOB2_BI2X_WRFIRM *context) {
+        if (context != aio_write_firm) {
+            return aioIob2Bi2x_DestroyWriteFirmContext_orig(context);
+        }
+
+        delete aio_write_firm;
+        aio_write_firm = nullptr;
+    }
+
+    static int32_t __fastcall aioIob2Bi2x_WriteFirmGetState(AIO_IOB2_BI2X_WRFIRM *context) {
+        if (context != aio_write_firm) {
+            return aioIob2Bi2x_WriteFirmGetState_orig(context);
+        }
+        return 8;
+    }
+
+    static bool __fastcall aioIob2Bi2x_WriteFirmIsCompleted(int32_t state) {
+        if (aio_write_firm) {
+            return true;
+        }
+        return aioIob2Bi2x_WriteFirmIsCompleted_orig(state);
+    }
+
+    static bool __fastcall aioIob2Bi2x_WriteFirmIsError(int32_t state) {
+        if (aio_write_firm) {
+            return false;
+        }
+        return aioIob2Bi2x_WriteFirmIsError_orig(state);
+    }
+
+    static void __fastcall aioSci_Destroy(AIO_SCI_COMM *sci) {
+        if (sci != aio_sci_comm) {
+            return aioSci_Destroy_orig(sci);
+        }
+
+        delete aio_sci_comm;
+        aio_sci_comm = nullptr;
+    }
+
+    static void __fastcall aioNodeMgr_Destroy(AIO_NMGR_IOB2 *node_mgr) {
+        if (node_mgr != aio_node_mgr) {
+            return aioNodeMgr_Destroy_orig(node_mgr);
+        }
+
+        delete aio_node_mgr;
+        aio_node_mgr = nullptr;
+    }
+
+    static void __fastcall aioNodeCtl_Destroy(AIO_IOB2_BI2X_T44 *node) {
+        if (node != aio_t44) {
+            return aioNodeCtl_Destroy_orig(node);
+        }
+
+        delete aio_t44;
+        aio_t44 = nullptr;
+    }
+
+    static void __fastcall aioNodeCtl_UpdateDevicesStatus() {
+    }
+
+    void bi2x_hook_init() {
+        static bool initialized = false;
+        if (initialized) {
+            return;
+        }
+        initialized = true;
+
+        log_info("jb::bi2x", "initializing T44 hooks");
+
+        const auto libaio_iob2_video = "libaio-iob2_video.dll";
+        detour::trampoline_try(libaio_iob2_video, "aioIob2Bi2xT44_Create",
+                aioIob2Bi2xT44_Create, &aioIob2Bi2xT44_Create_orig);
+        detour::trampoline_try(libaio_iob2_video,
+                "?GetDeviceStatus@AIO_IOB2_BI2X_T44@@QEBAXAEAUDEVSTATUS@1@@Z",
+                aioIob2Bi2xT44_GetDeviceStatus, &aioIob2Bi2xT44_GetDeviceStatus_orig);
+        detour::trampoline_try(libaio_iob2_video, "?IoReset@AIO_IOB2_BI2X_T44@@QEAAXI@Z",
+                aioIob2Bi2xT44_IoReset, &aioIob2Bi2xT44_IoReset_orig);
+        detour::trampoline_try(libaio_iob2_video,
+                "?SetWatchDogTimer@AIO_IOB2_BI2X_T44@@QEAAXE@Z",
+                aioIob2Bi2xT44_SetWatchDogTimer, &aioIob2Bi2xT44_SetWatchDogTimer_orig);
+        detour::trampoline_try(libaio_iob2_video,
+                "?ControlCoinBlocker@AIO_IOB2_BI2X_T44@@QEAAXI_N@Z",
+                aioIob2Bi2xT44_ControlCoinBlocker, &aioIob2Bi2xT44_ControlCoinBlocker_orig);
+        detour::trampoline_try(libaio_iob2_video, "?AddCounter@AIO_IOB2_BI2X_T44@@QEAAXII@Z",
+                aioIob2Bi2xT44_AddCounter, &aioIob2Bi2xT44_AddCounter_orig);
+        detour::trampoline_try(libaio_iob2_video, "?SetIccrLed@AIO_IOB2_BI2X_T44@@QEAAXI@Z",
+                aioIob2Bi2xT44_SetIccrLed, &aioIob2Bi2xT44_SetIccrLed_orig);
+        detour::trampoline_try(libaio_iob2_video,
+                "?SetTapeLedData@AIO_IOB2_BI2X_T44@@QEAAXIPEBX@Z",
+                aioIob2Bi2xT44_SetTapeLedData, &aioIob2Bi2xT44_SetTapeLedData_orig);
+
+        const auto libaio_iob = "libaio-iob.dll";
+        detour::trampoline_try(libaio_iob, "aioIob2Bi2x_OpenSciUsbCdc",
+                aioIob2Bi2x_OpenSciUsbCdc, &aioIob2Bi2x_OpenSciUsbCdc_orig);
+        detour::trampoline_try(libaio_iob, "aioIob2Bi2x_CreateWriteFirmContext",
+                aioIob2Bi2x_CreateWriteFirmContext, &aioIob2Bi2x_CreateWriteFirmContext_orig);
+        detour::trampoline_try(libaio_iob, "aioIob2Bi2x_DestroyWriteFirmContext",
+                aioIob2Bi2x_DestroyWriteFirmContext, &aioIob2Bi2x_DestroyWriteFirmContext_orig);
+        detour::trampoline_try(libaio_iob, "aioIob2Bi2x_WriteFirmGetState",
+                aioIob2Bi2x_WriteFirmGetState, &aioIob2Bi2x_WriteFirmGetState_orig);
+        detour::trampoline_try(libaio_iob, "aioIob2Bi2x_WriteFirmIsCompleted",
+                aioIob2Bi2x_WriteFirmIsCompleted, &aioIob2Bi2x_WriteFirmIsCompleted_orig);
+        detour::trampoline_try(libaio_iob, "aioIob2Bi2x_WriteFirmIsError",
+                aioIob2Bi2x_WriteFirmIsError, &aioIob2Bi2x_WriteFirmIsError_orig);
+        detour::trampoline_try(libaio_iob, "aioNMgrIob2_Create",
+                aioNMgrIob2_Create, &aioNMgrIob2_Create_orig);
+
+        const auto libaio = "libaio.dll";
+        detour::trampoline_try(libaio, "aioSci_Destroy", aioSci_Destroy, &aioSci_Destroy_orig);
+        detour::trampoline_try(libaio, "aioNodeMgr_Destroy",
+                aioNodeMgr_Destroy, &aioNodeMgr_Destroy_orig);
+        detour::trampoline_try(libaio, "aioNodeCtl_Destroy",
+                aioNodeCtl_Destroy, &aioNodeCtl_Destroy_orig);
+        detour::trampoline_try(libaio, "aioNodeCtl_UpdateDevicesStatus",
+                aioNodeCtl_UpdateDevicesStatus, &aioNodeCtl_UpdateDevicesStatus_orig);
+    }
+}
+
+#endif

src/spice2x/games/jb/bi2x_hook.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#if SPICE64
+
+namespace games::jb {
+    void bi2x_hook_init();
+}
+
+#endif

src/spice2x/games/jb/jb.cpp

@@ -4,211 +4,27 @@
 #include <filesystem>
 
 #include "avs/game.h"
+#include "bi2x_hook.h"
 #include "cfg/configurator.h"
-#include "hooks/graphics/graphics.h"
-#include "touch/touch.h"
 #include "util/logging.h"
-#include "util/utils.h"
 #include "util/detour.h"
 #include "util/libutils.h"
 
-#define JB_BUTTON_SIZE 160
-#define JB_BUTTON_GAP 37
-#define JB_BUTTON_HITBOX (JB_BUTTON_SIZE + JB_BUTTON_GAP)
-
 namespace games::jb {
 
-    // touch stuff
-    JubeatTouchAlgorithm TOUCH_ALGORITHM = Improved;
-    static bool TOUCH_ENABLE = false;
-    static bool TOUCH_ATTACHED = false;
-    static bool IS_PORTRAIT = true;
-    static std::vector<TouchPoint> TOUCH_POINTS;
-    bool TOUCH_STATE[16];
+#if !SPICE64
 
-    void touch_update() {
-
-        // check if touch enabled
-        if (!TOUCH_ENABLE) {
-            return;
-        }
-
-        // attach touch module
-        if (!TOUCH_ATTACHED) {
-
-            /*
-             * Find the game window.
-             * We check the foreground window first, then fall back to searching for the window title
-             * All game versions seem to have their model first in the window title
-             */
-            HWND wnd = GetForegroundWindow();
-            if (!string_begins_with(GetActiveWindowTitle(), avs::game::MODEL)) {
-                wnd = FindWindowBeginsWith(avs::game::MODEL);
-            }
-
-            // check if we have a window handle
-            if (!wnd) {
-                log_warning("jubeat", "could not find window handle for touch");
-                TOUCH_ENABLE = false;
-                return;
-            }
-
-            // attach touch hook
-            log_info("jubeat", "using window handle for touch: {}", fmt::ptr(wnd));
-            touch_create_wnd(wnd, true);
-
-            // show cursor
-            if (GRAPHICS_SHOW_CURSOR) {
-                ShowCursor(TRUE);
-            }
-
-            // earlier games use a different screen orientation
-            if (!avs::game::is_model("L44")) {
-                IS_PORTRAIT = false;
-            }
-
-            // set attached
-            TOUCH_ATTACHED = true;
-        }
-
-        // reset touch state
-        memset(TOUCH_STATE, 0, sizeof(TOUCH_STATE));
-
-        // check touch points
-        // note that the IO code in device.cpp will correctly compensate for orientation, depending on the model.
-        TOUCH_POINTS.clear();
-        touch_get_points(TOUCH_POINTS);
-        if (TOUCH_ALGORITHM == Legacy) {
-            auto offset = IS_PORTRAIT ? 580 : 0;
-            for (auto &tp : TOUCH_POINTS) {
-
-                // get grid coordinates
-                int x = tp.x * 4 / 768;
-                int y = (tp.y - offset) * 4 / (1360 - 580);
-
-                // set the corresponding state
-                int index = y * 4 + x;
-                if (index >= 0 && index < 16) {
-                    TOUCH_STATE[index] = true;
-                }
-            }
-        } else {
-            for (auto &tp : TOUCH_POINTS) {
-                // check window out of bounds
-                if (IS_PORTRAIT) {
-                    if (tp.x > 768 || tp.y > 1360) {
-                        continue;
-                    }
-                } else {
-                    if (tp.x > 1360 || tp.y > 768) {
-                        continue;
-                    }
-                }
-
-                int x_relative = tp.x;
-                int y_relative = tp.y;
-
-                // x_relative and y_relative are relative to the top-left pixel of the first button
-                if (IS_PORTRAIT) {
-                    // which is at (8, 602) in portrait:
-                    //   X: [8...759] (752 pixels wide)
-                    //   Y: [602...1353] (752 pixels high)
-                    x_relative -= 8;
-                    y_relative -= 602;
-                } else {
-                    // and at (8, 8) in landscape
-                    x_relative -= 8;
-                    y_relative -= 8;
-                }
-
-                int x_index = -1;
-                int x_hitbox = 0;
-                int y_index = -1;
-                int y_hitbox = 0;
-
-                // x_hitbox and y_hitbox is relative to top-left pixel of each button
-                if (x_relative >= 0) {
-                    x_index = x_relative / JB_BUTTON_HITBOX;
-                    x_hitbox = x_relative % JB_BUTTON_HITBOX;
-                }
-                if (y_relative >= 0) {
-                    y_index = y_relative / JB_BUTTON_HITBOX;
-                    y_hitbox = y_relative % JB_BUTTON_HITBOX;
-                }
-
-                // log_info("jb", "raw={}, idx={}, hitbox={}", tp.x, x_index, x_hitbox);
-
-                if (TOUCH_ALGORITHM == Improved) {
-                    if (IS_PORTRAIT) {
-                        // extend to left border
-                        if (x_relative < 0) {
-                            x_index = 0;
-                        }
-                        // right and bottom borders are covered by the hit box
-                    } else {
-                        // extend to top border
-                        if (y_relative < 0) {
-                            y_index = 0;
-                        }
-                        // extend to left border
-                        if (x_relative < 0) {
-                            x_index = 0;
-                        }
-                        // bottom border is covered by the hit box
-                        // rightmost edge - ignore them entirely
-                        if (x_index == 3 && JB_BUTTON_SIZE < x_hitbox) {
-                            continue;
-                        }
-                    }
-                }
-
-                if (x_index < 0 || y_index < 0 || x_index > 3 || y_index > 3) {
-                    continue;
-                }
-
-                // check if the gap was touched
-                if (TOUCH_ALGORITHM == AcAccurate) {
-                    // in ac-accurate mode, touching the gap is ignored
-                    if (x_hitbox > JB_BUTTON_SIZE || y_hitbox > JB_BUTTON_SIZE) {
-                        continue;
-                    }
-
-                } else if (TOUCH_ALGORITHM == Improved) {
-                    // in improved mode, touching the gap triggers the closest button
-                    if (x_index <= 2 && (JB_BUTTON_SIZE + JB_BUTTON_GAP / 2) < x_hitbox) {
-                        x_index++;
-                    }
-                    if (y_index <= 2 && (JB_BUTTON_SIZE + JB_BUTTON_GAP / 2) < y_hitbox) {
-                        y_index++;
-                    }
-                }
-
-                // set the corresponding state
-                int index = y_index * 4 + x_index;
-                if (0 <= index && index < 16) {
-                    TOUCH_STATE[index] = true;
-                }
-            }
-        }
-    }
-
-    /*
-     * to fix "IP ADDR CHANGE" errors on boot and in-game when using weird network setups such as a VPN
-     */
+    // fixes "IP ADDR CHANGE" errors with unusual network setups (e.g. a VPN)
     static BOOL __stdcall network_addr_is_changed() {
         return 0;
     }
 
-    /*
-     * to fix lag spikes when game tries to ping "eamuse.konami.fun" every few minutes
-     */
+    // fixes lag spikes from the periodic ping to "eamuse.konami.fun"
     static BOOL __stdcall network_get_network_check_info() {
         return 0;
     }
 
-    /*
-     * to fix network error on non DHCP interfaces
-     */
+    // fixes network errors on non-DHCP interfaces
     static BOOL __cdecl network_get_dhcp_result() {
         return 1;
     }
@@ -219,6 +35,8 @@ namespace games::jb {
         return 0;
     }
 
+#endif
+
     JBGame::JBGame() : Game("Jubeat") {
     }
 
@@ -248,24 +66,18 @@ namespace games::jb {
     void JBGame::attach() {
         Game::attach();
 
-        // enable touch
-        TOUCH_ENABLE = true;
-
-        switch (TOUCH_ALGORITHM) {
-            case Legacy:
-                log_info("jubeat", "using 'legacy' touch targets");
-                break;
-            case Improved:
-                log_info("jubeat", "using 'improved' touch targets");
-                break;
-            case AcAccurate:
-                log_info("jubeat", "using 'ac accurate' touch targets");
-                break;
-            default:
-                log_fatal("jubeat", "unknown touch algo detected in touch_update, this is a bug");
-                break;
+#if SPICE64
+        if (avs::game::DLL_NAME == "jubeat2019.dll") {
+            libutils::load_library("libaio.dll");
+            libutils::load_library("libaio-iob.dll");
+            libutils::load_library("libaio-iob2_video.dll");
+            bi2x_hook_init();
         }
+#endif
 
+        touch_attach();
+
+#if !SPICE64
         // enable debug logging of gftools
         HMODULE gftools = libutils::try_module("gftools.dll");
         detour::inline_hook((void *) GFDbgSetReportFunc, libutils::try_proc(
@@ -279,12 +91,13 @@ namespace games::jb {
                 network, "network_get_network_check_info"));
         detour::inline_hook((void *) network_get_dhcp_result, libutils::try_proc(
                 network, "network_get_dhcp_result"));
+#endif
+
     }
 
     void JBGame::detach() {
         Game::detach();
 
-        // disable touch
-        TOUCH_ENABLE = false;
+        touch_detach();
     }
 }

src/spice2x/games/jb/jb.h

@@ -1,20 +1,10 @@
 #pragma once
 
 #include "games/game.h"
+#include "games/jb/jb_touch.h"
 
 namespace games::jb {
 
-    enum JubeatTouchAlgorithm {
-        Legacy,
-        Improved,
-        AcAccurate
-    };
-
-    // touch stuff
-    extern JubeatTouchAlgorithm TOUCH_ALGORITHM;
-    extern bool TOUCH_STATE[16];
-    void touch_update();
-
     class JBGame : public games::Game {
     public:
         JBGame();

src/spice2x/games/jb/jb_touch.cpp

@@ -0,0 +1,485 @@
+#include "jb_touch.h"
+
+#include <windows.h>
+#include <atomic>
+#include <cmath>
+#include <limits>
+#include <vector>
+
+#include "avs/game.h"
+#include "hooks/graphics/graphics.h"
+#include "launcher/launcher.h"
+#include "touch/touch.h"
+#include "rawinput/touch.h"
+#include "util/logging.h"
+#include "util/time.h"
+#include "util/utils.h"
+
+// touch layout: a 4x4 grid of 160px buttons separated by 37 / 38 / 37 px gaps
+// (752px across). the first button's top-left is at (8, 602) in portrait and
+// (6, 8) in landscape.
+#define JB_BUTTON_SIZE 160
+#define JB_MAX_BUTTON_GAP 38
+#define JB_T44_BUTTON_SIZE 224
+#define JB_T44_BUTTON_GAP 33
+
+// improved and plus modes use this reach around each button. must be >= the
+// diagonal half of the widest gap (~27px) so the grid centre still reaches a button.
+#define JB_TOUCH_RADIUS 38
+
+namespace games::jb {
+
+    static_assert(std::atomic_bool::is_always_lock_free);
+    static_assert(std::atomic_uint16_t::is_always_lock_free);
+    static_assert(std::atomic<POINT>::is_always_lock_free);
+    static constexpr int JB_MAX_GAP_DISTANCE = (JB_MAX_BUTTON_GAP + 1) / 2;
+    static_assert(JB_TOUCH_RADIUS * JB_TOUCH_RADIUS >=
+                  2 * JB_MAX_GAP_DISTANCE * JB_MAX_GAP_DISTANCE);
+
+    // touch state
+    JubeatTouchAlgorithm TOUCH_ALGORITHM = Improved;
+    JubeatTouchDebugMode TOUCH_DEBUG_OVERLAY = JbTouchDebugAuto;
+    uint32_t TOUCH_DEBOUNCE_MS = 0;
+    static std::atomic_bool TOUCH_ENABLE = false;
+    static bool TOUCH_ATTACHED = false;
+    static bool IS_PORTRAIT = true;
+    static bool IS_T44 = false;
+    static std::atomic_uint16_t TOUCH_STATE = 0;
+
+    // fixed-size contact view used by the debug overlay
+    static const size_t JB_MAX_TOUCH_POINTS = 16;
+    static constexpr LONG JB_INVALID_TOUCH_COORD = std::numeric_limits<LONG>::max();
+    static constexpr POINT JB_INVALID_TOUCH_POINT {
+        JB_INVALID_TOUCH_COORD,
+        JB_INVALID_TOUCH_COORD
+    };
+    static std::atomic<POINT> TOUCH_POINTS[JB_MAX_TOUCH_POINTS] {};
+
+    static void clear_touch_points() {
+        for (auto &point : TOUCH_POINTS) {
+            point.store(JB_INVALID_TOUCH_POINT, std::memory_order_release);
+        }
+    }
+
+    // false when a contact is younger than the debounce window and should be ignored
+    static bool touch_matured(const TouchPoint &tp, double now_ms, double threshold_ms) {
+        return now_ms - tp.down_ms >= threshold_ms;
+    }
+
+    // snapshot for the debug overlay: each slot atomically holds one matured contact or
+    // the invalid sentinel. immature and absent contacts are published as invalid, so the
+    // overlay never shows a suppressed tap and a single atomic per slot cannot tear
+    static void publish_touch_points(const std::vector<TouchPoint> &touch_points,
+                                     double now_ms, double threshold_ms) {
+        size_t count = touch_points.size();
+        if (count > JB_MAX_TOUCH_POINTS) {
+            count = JB_MAX_TOUCH_POINTS;
+        }
+
+        for (size_t i = 0; i < JB_MAX_TOUCH_POINTS; i++) {
+            POINT point = JB_INVALID_TOUCH_POINT;
+            if (i < count && touch_matured(touch_points[i], now_ms, threshold_ms)) {
+                point = { touch_points[i].x, touch_points[i].y };
+            }
+            TOUCH_POINTS[i].store(point, std::memory_order_release);
+        }
+    }
+
+    // --- touch geometry ------------------------------------------------------
+    // gaps between the four buttons along one axis (the middle gap is 1px wider)
+    static const int JB_BUTTON_GAPS[3] = { 37, JB_MAX_BUTTON_GAP, 37 };
+    static const int JB_T44_BUTTON_GAPS[3] = {
+        JB_T44_BUTTON_GAP,
+        JB_T44_BUTTON_GAP,
+        JB_T44_BUTTON_GAP,
+    };
+
+    struct AxisGeometry {
+        int size;
+        int button[4]; // left/top edge of each button
+    };
+
+    // left/top edges of the four buttons along one axis, starting at `first`
+    static AxisGeometry axis_geometry(int first, int size, const int gaps[3]) {
+        AxisGeometry g {};
+        g.size = size;
+        g.button[0] = first;
+        for (int i = 1; i < 4; i++) {
+            g.button[i] = g.button[i - 1] + size + gaps[i - 1];
+        }
+        return g;
+    }
+
+    // button edges for the current orientation
+    static void touch_geometry(AxisGeometry &gx, AxisGeometry &gy) {
+        if (IS_T44) {
+            gx = axis_geometry(37, JB_T44_BUTTON_SIZE, JB_T44_BUTTON_GAPS);
+            gy = axis_geometry(864, JB_T44_BUTTON_SIZE, JB_T44_BUTTON_GAPS);
+        } else if (IS_PORTRAIT) {
+            gx = axis_geometry(8, JB_BUTTON_SIZE, JB_BUTTON_GAPS);
+            gy = axis_geometry(602, JB_BUTTON_SIZE, JB_BUTTON_GAPS);
+        } else {
+            gx = axis_geometry(6, JB_BUTTON_SIZE, JB_BUTTON_GAPS);
+            gy = axis_geometry(8, JB_BUTTON_SIZE, JB_BUTTON_GAPS);
+        }
+    }
+
+    // distance from `p` to a button along one axis (0 when inside)
+    static int axis_distance(int p, int button, int size) {
+        int end = button + size - 1;
+        if (p < button) {
+            return button - p;
+        }
+        if (p > end) {
+            return p - end;
+        }
+        return 0;
+    }
+
+    // index (0..15) of the nearest button to (px, py) within `radius`, or -1 if none;
+    // shared by detection and the debug overlay so both agree which button a touch hits
+    static int nearest_button(
+            int px, int py, const AxisGeometry &gx, const AxisGeometry &gy, int radius) {
+        int best_index = -1;
+        int best_dist = 0;
+        for (int r = 0; r < 4; r++) {
+            for (int c = 0; c < 4; c++) {
+                int dx = axis_distance(px, gx.button[c], gx.size);
+                int dy = axis_distance(py, gy.button[r], gy.size);
+                int dist = dx * dx + dy * dy;
+                if (dist <= radius * radius && (best_index < 0 || dist < best_dist)) {
+                    best_dist = dist;
+                    best_index = r * 4 + c;
+                }
+            }
+        }
+        return best_index;
+    }
+
+    // detection reach for the current algorithm (0 = register only inside a button)
+    static int touch_radius() {
+        return TOUCH_ALGORITHM == AcAccurate || (IS_T44 && TOUCH_ALGORITHM == Legacy) ?
+            0 : JB_TOUCH_RADIUS;
+    }
+
+    // mark the buttons a touch at (px, py) hits: only the nearest within `radius`, or
+    // every button within `radius` when `multi` (edge/gap presses trigger several)
+    static void mark_buttons(uint16_t &state, int px, int py,
+                             const AxisGeometry &gx, const AxisGeometry &gy,
+                             int radius, bool multi) {
+        if (!multi) {
+            int index = nearest_button(px, py, gx, gy, radius);
+            if (index >= 0) {
+                state |= uint16_t(1) << index;
+            }
+            return;
+        }
+        for (int r = 0; r < 4; r++) {
+            for (int c = 0; c < 4; c++) {
+                int dx = axis_distance(px, gx.button[c], gx.size);
+                int dy = axis_distance(py, gy.button[r], gy.size);
+                if (dx * dx + dy * dy <= radius * radius) {
+                    state |= uint16_t(1) << (r * 4 + c);
+                }
+            }
+        }
+    }
+
+    std::bitset<16> touch_state() {
+        return std::bitset<16>(TOUCH_STATE.load(std::memory_order_acquire));
+    }
+
+    void touch_update() {
+
+        if (!TOUCH_ENABLE.load(std::memory_order_acquire)) {
+            return;
+        }
+
+        // one-time touch window attach
+        if (!TOUCH_ATTACHED) {
+
+            IS_T44 = avs::game::is_model("T44");
+            IS_PORTRAIT = IS_T44 || avs::game::is_model("L44");
+
+            // find the game window: prefer the foreground window, else search by
+            // title (T44 uses a fixed title instead of the model prefix)
+            const char *window_title = IS_T44 ? "jubeat 10 main" : avs::game::MODEL;
+            HWND wnd = GetForegroundWindow();
+            if (!string_begins_with(GetActiveWindowTitle(), window_title)) {
+                wnd = FindWindowBeginsWith(window_title);
+            }
+            if (!wnd) {
+                log_warning("jubeat", "could not find window handle for touch");
+                TOUCH_ENABLE.store(false, std::memory_order_release);
+                TOUCH_STATE.store(0, std::memory_order_release);
+                return;
+            }
+
+            log_info("jubeat", "using window handle for touch: {}", fmt::ptr(wnd));
+
+            // let the rawinput stack correct the aspect ratio
+            ::rawinput::touch::ASPECT_COMPENSATION_GAME = true;
+
+            touch_create_wnd(wnd, true);
+
+            if (GRAPHICS_SHOW_CURSOR) {
+                ShowCursor(TRUE);
+            }
+
+            TOUCH_ATTACHED = true;
+        }
+
+        // calculate the next state locally and publish it after processing every touch
+        uint16_t next_state = 0;
+        std::vector<TouchPoint> touch_points;
+        touch_get_points(touch_points);
+
+        // debounce: the landing time is stamped by the touch layer, so this is
+        // independent of how often the game polls for input (0 = off)
+        double now_ms = get_performance_milliseconds();
+        double threshold_ms = TOUCH_DEBOUNCE_MS;
+
+        // publish every raw contact (with its maturity) for the debug overlay, then drop
+        // the ones still inside the debounce window so no algorithm sees them
+        publish_touch_points(touch_points, now_ms, threshold_ms);
+        std::erase_if(touch_points, [&](const TouchPoint &tp) {
+            return !touch_matured(tp, now_ms, threshold_ms);
+        });
+
+        if (TOUCH_ALGORITHM == Legacy && !IS_T44) {
+
+            // legacy: evenly divide the play area into a 4x4 grid
+            auto offset = IS_PORTRAIT ? 580 : 0;
+            for (auto &tp : touch_points) {
+                int x = tp.x * 4 / 768;
+                int y = (tp.y - offset) * 4 / (1360 - 580);
+                int index = y * 4 + x;
+                if (index >= 0 && index < 16) {
+                    next_state |= uint16_t(1) << index;
+                }
+            }
+        } else {
+
+            // accurate registers only a touch inside a button; improved snaps each touch
+            // to the single nearest button within reach (so a gap or centre touch still
+            // triggers exactly one button); plus marks every button within the same reach,
+            // so an edge or gap touch can trigger several at once (like the mobile game)
+            AxisGeometry gx, gy;
+            touch_geometry(gx, gy);
+            int radius = touch_radius();
+            bool multi = (TOUCH_ALGORITHM == Plus);
+            for (auto &tp : touch_points) {
+                mark_buttons(next_state, tp.x, tp.y, gx, gy, radius, multi);
+            }
+        }
+
+        TOUCH_STATE.store(next_state, std::memory_order_release);
+    }
+
+    // true when any supported touch handler detects a touchscreen (checked once)
+    static bool touchscreen_detected() {
+        static const bool detected = is_touch_available("jubeat touch debug overlay");
+        return detected;
+    }
+
+    // auto draws the boxes only when a touch screen is present
+    static bool debug_show_boxes() {
+        switch (TOUCH_DEBUG_OVERLAY) {
+            case JbTouchDebugBox:
+            case JbTouchDebugAll:
+                return true;
+            case JbTouchDebugAuto:
+                return touchscreen_detected();
+            default:
+                return false;
+        }
+    }
+
+    static bool debug_show_taps() {
+        return TOUCH_DEBUG_OVERLAY == JbTouchDebugAll;
+    }
+
+    bool touch_debug_overlay_enabled() {
+        return TOUCH_ENABLE.load(std::memory_order_acquire) &&
+               (debug_show_boxes() || debug_show_taps());
+    }
+
+    // the 16 boundary rects: legacy divides the area evenly, others use button squares
+    static void debug_cells(
+            bool legacy, const AxisGeometry &gx, const AxisGeometry &gy, RECT cells[16]) {
+        if (legacy) {
+            int offset = IS_PORTRAIT ? 580 : 0;
+            int x_edges[5];
+            int y_edges[5];
+            for (int i = 0; i <= 4; i++) {
+                x_edges[i] = i * 768 / 4;
+                y_edges[i] = offset + i * (1360 - 580) / 4;
+            }
+            for (int r = 0; r < 4; r++) {
+                for (int c = 0; c < 4; c++) {
+                    cells[r * 4 + c] = { x_edges[c], y_edges[r], x_edges[c + 1], y_edges[r + 1] };
+                }
+            }
+        } else {
+            for (int r = 0; r < 4; r++) {
+                for (int c = 0; c < 4; c++) {
+                    cells[r * 4 + c] = {
+                        gx.button[c], gy.button[r],
+                        gx.button[c] + gx.size, gy.button[r] + gy.size
+                    };
+                }
+            }
+        }
+    }
+
+    // hollow box outlines: grey idle, thick green when pressed (PS_INSIDEFRAME stays inside)
+    static void draw_debug_boxes(
+            HDC hdc, bool legacy, const AxisGeometry &gx, const AxisGeometry &gy) {
+        RECT cells[16];
+        debug_cells(legacy, gx, gy, cells);
+
+        HPEN pen_idle = CreatePen(PS_SOLID, 1, RGB(160, 160, 160));
+        HPEN pen_active = CreatePen(PS_INSIDEFRAME, 4, RGB(0, 200, 0));
+        auto state = touch_state();
+        for (int i = 0; i < 16; i++) {
+            HGDIOBJ old_pen = SelectObject(hdc, state[i] ? pen_active : pen_idle);
+            Rectangle(hdc, cells[i].left, cells[i].top, cells[i].right, cells[i].bottom);
+            SelectObject(hdc, old_pen);
+        }
+        DeleteObject(pen_idle);
+        DeleteObject(pen_active);
+    }
+
+    // whether a touch at (px, py) presses at least one button: legacy has no gaps, plus
+    // reaches across gaps to nearby buttons, and the others only fire inside a button square
+    static bool touch_presses_button(int px, int py, const AxisGeometry &gx, const AxisGeometry &gy,
+                                     bool legacy, int radius) {
+        if (legacy) {
+            return true;
+        }
+        int reach = (TOUCH_ALGORITHM == Plus) ? radius : 0;
+        return nearest_button(px, py, gx, gy, reach) >= 0;
+    }
+
+    // 90-degree arc on the circle rim facing the centre of button `index`
+    static void draw_tap_arc(HDC hdc, int px, int py, int index,
+                             const AxisGeometry &gx, const AxisGeometry &gy, int arc_radius) {
+        int c = index % 4;
+        int r = index / 4;
+        double mid = std::atan2((gy.button[r] + gy.size / 2) - py,
+                    (gx.button[c] + gx.size / 2) - px);
+        const double quarter = 3.14159265358979323846 / 2.0;
+        const int segments = 16;
+        POINT arc[segments + 1];
+        for (int i = 0; i <= segments; i++) {
+            double a = mid - quarter / 2.0 + quarter * i / segments;
+            arc[i].x = px + static_cast<LONG>(std::lround(arc_radius * std::cos(a)));
+            arc[i].y = py + static_cast<LONG>(std::lround(arc_radius * std::sin(a)));
+        }
+        Polyline(hdc, arc, segments + 1);
+    }
+
+    // circle at each touch: white when it presses a button, grey otherwise; in single-button
+    // modes a gap touch also gets a white arc facing the button it snapped to (skipped in
+    // plus, where a touch can trigger several buttons at once)
+    static void draw_debug_taps(
+            HDC hdc, bool legacy, const AxisGeometry &gx, const AxisGeometry &gy) {
+        // PS_INSIDEFRAME keeps the stroke inside the circle radius
+        const int stroke = 4;
+        HPEN pen_white = CreatePen(PS_INSIDEFRAME, stroke, RGB(255, 255, 255));
+        HPEN pen_gray = CreatePen(PS_INSIDEFRAME, stroke, RGB(128, 128, 128));
+        HGDIOBJ old_pen = SelectObject(hdc, pen_white);
+
+        // accurate has no reach, so fall back to a visible marker size when drawing the circle
+        int radius = touch_radius();
+        int draw_radius = radius > 0 ? radius : JB_TOUCH_RADIUS;
+
+        // each slot holds a matured contact or the invalid sentinel; immature and absent
+        // contacts were already filtered out by publish_touch_points
+        for (auto &touch_point : TOUCH_POINTS) {
+            POINT point = touch_point.load(std::memory_order_acquire);
+            if (point.x == JB_INVALID_TOUCH_COORD) {
+                continue;
+            }
+
+            bool pressed = touch_presses_button(point.x, point.y, gx, gy, legacy, radius);
+
+            SelectObject(hdc, pressed ? pen_white : pen_gray);
+            Ellipse(hdc, point.x - draw_radius, point.y - draw_radius,
+                         point.x + draw_radius, point.y + draw_radius);
+
+            // the arc points at a single snapped-to button; plus can trigger several at
+            // once, so skip it there
+            if (pressed || TOUCH_ALGORITHM == Plus) {
+                continue;
+            }
+            int index = nearest_button(point.x, point.y, gx, gy, radius);
+            if (index >= 0) {
+                SelectObject(hdc, pen_white);
+                draw_tap_arc(hdc, point.x, point.y, index, gx, gy, draw_radius - stroke / 2);
+            }
+        }
+
+        SelectObject(hdc, old_pen);
+        DeleteObject(pen_white);
+        DeleteObject(pen_gray);
+    }
+
+    void touch_draw_debug_overlay(HDC hdc) {
+
+        // only draw while touch is active
+        if (!TOUCH_ENABLE.load(std::memory_order_acquire)) {
+            return;
+        }
+
+        bool show_boxes = debug_show_boxes();
+        bool show_taps = debug_show_taps();
+        if (!show_boxes && !show_taps) {
+            return;
+        }
+
+        // legacy divides the field evenly; the other algorithms use button squares
+        bool legacy = TOUCH_ALGORITHM == Legacy && !IS_T44;
+        AxisGeometry gx {}, gy {};
+        if (!legacy) {
+            touch_geometry(gx, gy);
+        }
+
+        HGDIOBJ old_brush = SelectObject(hdc, GetStockObject(NULL_BRUSH));
+        if (show_boxes) {
+            draw_debug_boxes(hdc, legacy, gx, gy);
+        }
+        if (show_taps) {
+            draw_debug_taps(hdc, legacy, gx, gy);
+        }
+        SelectObject(hdc, old_brush);
+    }
+
+    void touch_attach() {
+        clear_touch_points();
+        TOUCH_ENABLE.store(true, std::memory_order_release);
+
+        switch (TOUCH_ALGORITHM) {
+            case Legacy:
+                log_info("jubeat", "using 'legacy' touch targets");
+                break;
+            case Improved:
+                log_info("jubeat", "using 'improved' touch targets");
+                break;
+            case Plus:
+                log_info("jubeat", "using 'plus' touch targets");
+                break;
+            case AcAccurate:
+                log_info("jubeat", "using 'ac accurate' touch targets");
+                break;
+            default:
+                log_fatal("jubeat", "unknown touch algo, this is a bug");
+                break;
+        }
+    }
+
+    void touch_detach() {
+        TOUCH_ENABLE.store(false, std::memory_order_release);
+        TOUCH_STATE.store(0, std::memory_order_release);
+    }
+}

src/spice2x/games/jb/jb_touch.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <bitset>
+#include <cstdint>
+#include <windows.h>
+
+namespace games::jb {
+
+    // touch detection algorithm
+    enum JubeatTouchAlgorithm {
+        Legacy,
+        Improved,
+        Plus,
+        AcAccurate
+    };
+
+    // debug touch overlay mode
+    enum JubeatTouchDebugMode {
+        JbTouchDebugAuto,   // boundary boxes when a touch screen is detected, else nothing
+        JbTouchDebugNone,   // draw nothing
+        JbTouchDebugBox,    // boundary boxes
+        JbTouchDebugAll,    // boundary boxes and touch circles
+    };
+
+    // selected algorithm and debug mode (set from the launcher options)
+    extern JubeatTouchAlgorithm TOUCH_ALGORITHM;
+    extern JubeatTouchDebugMode TOUCH_DEBUG_OVERLAY;
+
+    // minimum contact age in milliseconds before a touch registers (0 = off);
+    // filters momentary phantom touches from noisy panels
+    extern uint32_t TOUCH_DEBOUNCE_MS;
+
+    // atomically published panel state, read by the I/O layer
+    std::bitset<16> touch_state();
+
+    // read the current touch points and refresh the panel state
+    void touch_update();
+
+    // enable/disable touch handling on game attach/detach
+    void touch_attach();
+    void touch_detach();
+
+    // whether the debug overlay should currently draw anything
+    bool touch_debug_overlay_enabled();
+
+    // draw the debug touch overlay (boundary boxes and/or touch circles per the
+    // selected mode) onto the spice touch overlay window's device context
+    void touch_draw_debug_overlay(HDC hdc);
+}

src/spice2x/games/mfg/mfg.cpp

@@ -6,7 +6,6 @@
 #include "util/utils.h"
 #include "util/execexe.h"
 #include "acioemu/handle.h"
-#include "misc/wintouchemu.h"
 #include "hooks/graphics/graphics.h"
 #include "bi2a_hook.h"
 

src/spice2x/games/nost/nost.cpp

@@ -1,16 +1,15 @@
-// enable touch functions - set version to windows 7
-// mingw otherwise doesn't load touch stuff
-#define _WIN32_WINNT 0x0601
-
 #include "nost.h"
 #include "poke.h"
+#include "touch_mode.h"
 #include "hooks/setupapihook.h"
 #include "misc/wintouchemu.h"
+#include "touch/native/nativetouchhook.h"
 #include "avs/game.h"
 
 namespace games::nost {
 
     bool ENABLE_POKE = false;
+    bool ENABLE_TOUCH_MODE = false;
 
     NostGame::NostGame() : Game("Nostalgia") {
     }
@@ -43,9 +42,16 @@ namespace games::nost {
         setupapihook_init(avs::game::DLL_INSTANCE);
         setupapihook_add(touch_settings);
 
-        // custom touch
-        // nostalgia crashes if you inject touch events too early
-        wintouchemu::hook("nostalgia", avs::game::DLL_INSTANCE, 20);
+        const auto native_touch_ready = !wintouchemu::FORCE &&
+            nativetouch::hook(avs::game::DLL_INSTANCE);
+        if (!native_touch_ready) {
+            wintouchemu::FORCE = true;
+            wintouchemu::hook("nostalgia", avs::game::DLL_INSTANCE, 20);
+        } else {
+            if (ENABLE_TOUCH_MODE) {
+                touch_mode::enable();
+            }
+        }
     }
 
     void NostGame::post_attach() {
@@ -55,6 +61,9 @@ namespace games::nost {
     }
 
     void NostGame::detach() {
+        if (ENABLE_TOUCH_MODE) {
+            touch_mode::disable();
+        }
         if (ENABLE_POKE) {
             poke::disable();
         }

src/spice2x/games/nost/nost.h

@@ -5,6 +5,7 @@
 namespace games::nost {
 
     extern bool ENABLE_POKE;
+    extern bool ENABLE_TOUCH_MODE;
 
     class NostGame : public games::Game {
     public:

src/spice2x/games/nost/poke.cpp

@@ -1,22 +1,25 @@
 #include "poke.h"
 
-#include <thread>
+#include <atomic>
+#include <chrono>
 #include <optional>
+#include <thread>
 
 #include "games/nost/io.h"
 #include "cfg/api.h"
 #include "rawinput/rawinput.h"
 #include "misc/eamuse.h"
-#include "touch/touch.h"
+#include "touch/native/inject.h"
+#include "touch/native/nativetouchhook.h"
 #include "util/logging.h"
-#include "util/precise_timer.h"
 
 namespace games::nost::poke {
 
     static std::thread *THREAD = nullptr;
-    static volatile bool THREAD_RUNNING = false;
-    
-    static const std::unordered_map<int, std::pair<LONG, LONG>> NOST_POKE_NUM {
+    static std::atomic<bool> THREAD_RUNNING { false };
+
+    // positions use game-client pixels, matching the legacy client-sized touch window
+    static const std::unordered_map<int, std::pair<LONG, LONG>> NOST_POKE_KEYPAD {
         {EAM_IO_KEYPAD_0, {760, 440}},
         {EAM_IO_KEYPAD_1, {760, 385}},
         {EAM_IO_KEYPAD_2, {820, 385}},
@@ -31,7 +34,8 @@ namespace games::nost::poke {
         {EAM_IO_KEYPAD_DECIMAL, {880, 440}} // also erase button
     };
 
-    static const std::unordered_map<games::nost::Buttons::Button, std::pair<LONG, LONG>> NOST_POKE {
+    static const std::unordered_map<
+        games::nost::Buttons::Button, std::pair<LONG, LONG>> NOST_POKE_BUTTONS {
         {games::nost::Buttons::Button::PokeConfirm, {1100, 525}},
         {games::nost::Buttons::Button::PokeBack, {340, 100}},
         {games::nost::Buttons::Button::PokeSong1, {450, 190}},
@@ -46,13 +50,8 @@ namespace games::nost::poke {
         {games::nost::Buttons::Button::PokeDifficulty4, {820, 490}},
     };
 
-    void clear_touch_points(std::vector<TouchPoint> *touch_points) {
-        std::vector<DWORD> touch_ids;
-        for (auto &touch : *touch_points) {
-            touch_ids.emplace_back(touch.id);
-        }
-        touch_remove_points(&touch_ids);
-        touch_points->clear();
+    static bool inject_poke_position(POINT position, bool down) {
+        return nativetouch::inject::inject_synthetic_touch(position, down);
     }
 
     void enable() {
@@ -61,126 +60,143 @@ namespace games::nost::poke {
             return;
         }
 
+        if (!nativetouch::is_hooked()) {
+            log_warning("poke", "Nostalgia poke requires native touch; disabled");
+            return;
+        }
+
         // create new thread
         THREAD_RUNNING = true;
         THREAD = new std::thread([] {
-            timeutils::PreciseSleepTimer timer;
-            const DWORD touch_id = (DWORD)(0xFFFFFFFE);
-
             const int swipe_anim_total_frames = 6;
             const int swipe_anim_y = 300;
 
             const int swipe_next_page_x_begin = 1120;
-            const int swipe_next_page_x_end = 1120-120;
+            const int swipe_next_page_x_end = 1120 - 120;
 
-            const int swipe_prev_page_x_begin = 280-120;
+            const int swipe_prev_page_x_begin = 280 - 120;
             const int swipe_prev_page_x_end = 280;
 
             int next_page_anim_index = -1;
             int prev_page_anim_index = -1;
-            std::vector<TouchPoint> touch_points;
-
-            bool touch_release = false;
+            bool contact_active = false;
+            bool release_pending = false;
+            POINT last_position {};
+            std::unordered_map<games::nost::Buttons::Button, bool> button_states;
+            uint16_t last_keypad_state = 0;
 
             // log
             log_info("poke", "enabled");
 
             // set variable to false to stop
             while (THREAD_RUNNING) {
-                // clean up touch from last frame
-                if (!touch_points.empty()) {
-                    if (touch_release) {
-                        clear_touch_points(&touch_points);
-                        touch_release = false;
-                    } else {
-                        touch_points.clear();
+                if (release_pending) {
+                    if (contact_active) {
+                        inject_poke_position(last_position, false);
                     }
+                    contact_active = false;
+                    release_pending = false;
                 }
 
                 auto &buttons = games::nost::get_buttons();
+                std::optional<POINT> touch_position;
+                bool release_after_touch = false;
+
+                const auto button_triggered = [&](games::nost::Buttons::Button button) {
+                    const auto pressed =
+                        GameAPI::Buttons::getState(RI_MGR, buttons.at(button));
+                    const auto triggered = pressed && !button_states[button];
+                    button_states[button] = pressed;
+                    return triggered;
+                };
+
+                std::optional<POINT> triggered_touch_position;
+                for (const auto& it : NOST_POKE_BUTTONS) {
+                    if (button_triggered(it.first) && !triggered_touch_position.has_value()) {
+                        triggered_touch_position = POINT {
+                            it.second.first,
+                            it.second.second,
+                        };
+                    }
+                }
+
+                const auto next_triggered =
+                    button_triggered(games::nost::Buttons::PokeNextPage);
+                const auto prev_triggered =
+                    button_triggered(games::nost::Buttons::PokePrevPage);
+
+                const auto keypad_state = eamuse_get_keypad_state(0);
+                if (!triggered_touch_position.has_value()) {
+                    for (const auto& it : NOST_POKE_KEYPAD) {
+                        const auto mask = static_cast<uint16_t>(1 << it.first);
+                        if ((keypad_state & mask) && !(last_keypad_state & mask)) {
+                            triggered_touch_position = POINT {
+                                it.second.first,
+                                it.second.second,
+                            };
+                            break;
+                        }
+                    }
+                }
+                last_keypad_state = keypad_state;
 
                 if (0 <= next_page_anim_index) {
                     const auto delta =
                         (swipe_next_page_x_end - swipe_next_page_x_begin)
                         * (swipe_anim_total_frames - next_page_anim_index) / swipe_anim_total_frames;
 
-                    TouchPoint tp {
-                        .id = touch_id,
-                        .x = (LONG)swipe_next_page_x_begin + delta,
-                        .y = (LONG)swipe_anim_y,
-                        .mouse = true,
+                    touch_position = POINT {
+                        swipe_next_page_x_begin + delta,
+                        swipe_anim_y,
                     };
-                    touch_points.emplace_back(tp);
                     next_page_anim_index--;
                     if (next_page_anim_index < 0) {
-                        touch_release = true;
+                        release_after_touch = true;
                     }
                 } else if (0 <= prev_page_anim_index) {
                     const auto delta =
                         (swipe_prev_page_x_end - swipe_prev_page_x_begin)
                         * (swipe_anim_total_frames - prev_page_anim_index) / swipe_anim_total_frames;
 
-                    TouchPoint tp {
-                        .id = touch_id,
-                        .x = (LONG)swipe_prev_page_x_begin + delta,
-                        .y = (LONG)swipe_anim_y,
-                        .mouse = true,
+                    touch_position = POINT {
+                        swipe_prev_page_x_begin + delta,
+                        swipe_anim_y,
                     };
-                    touch_points.emplace_back(tp);
                     prev_page_anim_index--;
                     if (prev_page_anim_index < 0) {
-                        touch_release = true;
+                        release_after_touch = true;
                     }
                 } else {
-                    for (const auto& it : NOST_POKE) {
-                        if (GameAPI::Buttons::getState(RI_MGR, buttons.at(it.first))) {
-                            TouchPoint tp {
-                                .id = touch_id,
-                                .x = it.second.first,
-                                .y = it.second.second,
-                                .mouse = true,
-                            };
-                            touch_points.emplace_back(tp);
-                            touch_release = true;
-                            break;
-                        }
-                    }
-                    if (!touch_release) {
-                        const auto state = eamuse_get_keypad_state(0);
-                        if (state) {
-                            for (const auto& it : NOST_POKE_NUM) {
-                                if (state & (1 << it.first)) {
-                                    TouchPoint tp {
-                                        .id = touch_id,
-                                        .x = it.second.first,
-                                        .y = it.second.second,
-                                        .mouse = true,
-                                    };
-                                    touch_points.emplace_back(tp);
-                                    touch_release = true;
-                                    break;
-                                }
-                            }
-                        }
-                    }
+                    touch_position = triggered_touch_position;
+                    release_after_touch = touch_position.has_value();
 
                     // start animations for next frame
-                    if (!touch_release) {
-                        if (GameAPI::Buttons::getState(RI_MGR, buttons.at(games::nost::Buttons::PokeNextPage))) {
+                    if (!touch_position.has_value()) {
+                        if (next_triggered) {
                             next_page_anim_index = swipe_anim_total_frames;
                         }
-                        if (GameAPI::Buttons::getState(RI_MGR, buttons.at(games::nost::Buttons::PokePrevPage))) {
+
+                        if (prev_triggered) {
                             prev_page_anim_index = swipe_anim_total_frames;
                         }
                     }
                 }
 
-                if (!touch_points.empty()) {
-                    touch_write_points(&touch_points);
+                if (touch_position.has_value() &&
+                    inject_poke_position(*touch_position, true)) {
+                    contact_active = true;
+                    last_position = *touch_position;
+                }
+                if (release_after_touch && contact_active) {
+                    release_pending = true;
                 }
 
                 // slow down
-                timer.sleep(30);
+                std::this_thread::sleep_for(std::chrono::milliseconds(30));
+            }
+
+            if (contact_active) {
+                inject_poke_position(last_position, false);
             }
 
             return nullptr;

src/spice2x/games/nost/touch_mode.cpp

@@ -0,0 +1,233 @@
+#include "touch_mode.h"
+
+#include <atomic>
+#include <mutex>
+#include <unordered_map>
+
+#include "touch/native/nativetouchhook.h"
+#include "util/logging.h"
+
+namespace games::nost::touch_mode {
+
+    // native contact positions feed piano input directly. native events reach the game
+    // in nav mode and are suppressed in piano mode. mode-button contacts are always
+    // suppressed and change that routing after release.
+    static constexpr LONG PIANO_LEFT_GAP = 11;
+    static constexpr LONG PIANO_RIGHT_GAP = 10;
+    static constexpr uint32_t PIANO_KEY_COUNT = 28;
+
+    struct TouchGeometry {
+        HWND window = nullptr;
+        RECT mode_button {};
+        LONG client_width = 0;
+        LONG client_height = 0;
+
+        bool valid() const {
+            return window != nullptr && client_width > 0 && client_height > 0;
+        }
+    };
+
+    struct NativeContact {
+        POINT position {};
+
+        // position contains game-client coordinates
+        bool client_position_valid = false;
+
+        // down began on the mode switch button; remains true through up
+        bool mode_button = false;
+    };
+
+    static std::atomic_bool accept_events { false };
+    static std::atomic<Mode> current_mode_state { Mode::Nav };
+    static std::mutex state_mutex;
+    static TouchGeometry touch_geometry;
+
+    // native contacts are kept by ID so each contact contributes exactly one position
+    static std::unordered_map<DWORD, NativeContact> active_contacts;
+
+    // a hardware button release requests one change after all contacts are released
+    static bool mode_change_pending = false;
+
+    static void reset_state_locked() {
+        current_mode_state.store(Mode::Nav, std::memory_order_release);
+        touch_geometry = {};
+        active_contacts.clear();
+        mode_change_pending = false;
+    }
+
+    // hardware contacts arrive in screen coordinates
+    static bool native_touch_in_button(const nativetouch::NativeTouchEvent &event) {
+        if (!touch_geometry.valid()) {
+            return false;
+        }
+
+        POINT position { event.x, event.y };
+        if (!ScreenToClient(touch_geometry.window, &position)) {
+            return false;
+        }
+        return PtInRect(&touch_geometry.mode_button, position) != FALSE;
+    }
+
+    static bool update_touch_state(const nativetouch::NativeTouchEvent &event) {
+        std::lock_guard<std::mutex> lock(state_mutex);
+
+        // first, process down / move events
+        if (event.down || event.move) {
+            auto contact = active_contacts.try_emplace(event.id).first;
+
+            // keep track of IDs that began as a down on the mode switch button
+            if (event.down) {
+                contact->second.mode_button = native_touch_in_button(event);
+            }
+
+            // check for valid position
+            POINT position { event.x, event.y };
+            if (touch_geometry.window != nullptr &&
+                ScreenToClient(touch_geometry.window, &position)) {
+                contact->second.position = position;
+                contact->second.client_position_valid = true;
+            }
+        }
+
+        const auto contact = active_contacts.find(event.id);
+        const bool mode_button_contact = contact != active_contacts.end() &&
+            contact->second.mode_button;
+
+        // process up events
+        if (event.up) {
+            active_contacts.erase(event.id);
+
+            // if a contact that began down event on the mode switch button has
+            // been released, a mode switch is now pending
+            if (mode_button_contact) {
+                mode_change_pending = true;
+            }
+
+            // apply the change on the final hardware up. switching earlier would
+            // split another contact's down and up events across different modes
+            if (mode_change_pending && active_contacts.empty()) {
+                mode_change_pending = false;
+                const auto next_mode = current_mode() == Mode::Nav ? Mode::Piano : Mode::Nav;
+                current_mode_state.store(next_mode, std::memory_order_release);
+            }
+        }
+        return mode_button_contact;
+    }
+
+    // install the Nostalgia-specific native touch interception
+    void enable() {
+        if (accept_events.exchange(true, std::memory_order_acq_rel)) {
+            return;
+        }
+
+        {
+            std::lock_guard<std::mutex> lock(state_mutex);
+            reset_state_locked();
+        }
+
+        nativetouch::set_input_filter(filter_native_touch);
+        log_info("nost::touch", "enabled");
+    }
+
+    void disable() {
+        if (!accept_events.exchange(false, std::memory_order_acq_rel)) {
+            return;
+        }
+
+        nativetouch::set_input_filter(nullptr);
+
+        std::lock_guard<std::mutex> lock(state_mutex);
+        reset_state_locked();
+    }
+
+    bool enabled() {
+        return accept_events.load(std::memory_order_acquire);
+    }
+
+    Mode current_mode() {
+        return current_mode_state.load(std::memory_order_acquire);
+    }
+
+    // publish the rendered overlay button rectangle in game-client pixels
+    void publish_button_bounds(HWND window, const RECT &client_bounds) {
+        TouchGeometry next {};
+        RECT client_rect {};
+        if (window != nullptr && GetClientRect(window, &client_rect) &&
+            client_rect.right > 0 && client_rect.bottom > 0) {
+            next.window = window;
+            next.mode_button = client_bounds;
+            next.client_width = client_rect.right;
+            next.client_height = client_rect.bottom;
+        }
+
+        std::lock_guard<std::mutex> lock(state_mutex);
+        touch_geometry = next;
+    }
+
+    // return the active 28-key piano bitfield for the PANB input update
+    uint32_t piano_key_state() {
+        if (!enabled() || current_mode() != Mode::Piano) {
+            return 0;
+        }
+
+        std::lock_guard<std::mutex> lock(state_mutex);
+        if (current_mode() != Mode::Piano || !touch_geometry.valid()) {
+            return 0;
+        }
+
+        uint32_t state = 0;
+        for (const auto &contact : active_contacts) {
+            // invalid position or mode-button contact; ignore these contacts
+            if (!contact.second.client_position_valid || contact.second.mode_button) {
+                continue;
+            }
+
+            const auto &position = contact.second.position;
+
+            // outside the client area or on the mode button; ignore these contacts
+            if (position.x < 0 || position.x >= touch_geometry.client_width ||
+                position.y < 0 || position.y >= touch_geometry.client_height ||
+                PtInRect(&touch_geometry.mode_button, position)) {
+                continue;
+            }
+
+            // divide the inset width evenly; touches in either side gap clamp to
+            // the nearest outer key so the physical screen edges remain playable
+            const auto piano_width =
+                touch_geometry.client_width - PIANO_LEFT_GAP - PIANO_RIGHT_GAP;
+            uint32_t key = 0;
+            if (position.x >= touch_geometry.client_width - PIANO_RIGHT_GAP) {
+                key = PIANO_KEY_COUNT - 1;
+            } else if (position.x >= PIANO_LEFT_GAP && piano_width > 0) {
+                key = static_cast<uint32_t>(
+                    (position.x - PIANO_LEFT_GAP) * PIANO_KEY_COUNT / piano_width);
+            }
+            state |= UINT32_C(1) << key;
+        }
+
+        return state;
+    }
+
+    // update native contacts and report whether this event should be hidden from the game
+    bool filter_native_touch(const nativetouch::NativeTouchEvent &event) {
+        // synthetic events are outside this hardware-only feature
+        if (!enabled() || event.synthetic) {
+            // false leaves the event visible to the game
+            return false;
+        }
+
+        // snapshot routing before an up event can commit a pending mode switch
+        const bool piano_mode_before_update = current_mode() == Mode::Piano;
+
+        // update the contact lifetime and commit any pending switch when safe
+        const bool mode_button_contact = update_touch_state(event);
+
+        // hide every event in a contact that began on the mode switch button
+        if (mode_button_contact) {
+            return true;
+        }
+
+        // piano mode consumes hardware events; nav mode forwards them to the game
+        return piano_mode_before_update;
+    }
+}

src/spice2x/games/nost/touch_mode.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <cstdint>
+#include <windows.h>
+
+#include "touch/native/nativetouchhook.h"
+
+namespace games::nost::touch_mode {
+
+    // nav mode forwards contacts to the game; piano mode converts them into piano keys
+    enum class Mode {
+        Nav,
+        Piano,
+    };
+
+    void enable();
+    void disable();
+    bool enabled();
+
+    Mode current_mode();
+
+    void publish_button_bounds(HWND window, const RECT &client_bounds);
+
+    uint32_t piano_key_state();
+
+    bool filter_native_touch(const nativetouch::NativeTouchEvent &event);
+}

src/spice2x/games/pc/pc.cpp

@@ -12,7 +12,6 @@
 #include "util/unity_player.h"
 #include "util/execexe.h"
 #include "acioemu/handle.h"
-#include "misc/wintouchemu.h"
 #include "hooks/graphics/graphics.h"
 #include "rawinput/rawinput.h"
 #include "util/socd_cleaner.h"

src/spice2x/games/pcm/pcm.cpp

@@ -2,7 +2,6 @@
 
 #include "acio/icca/icca.h"
 #include "io.h"
-#include "misc/wintouchemu.h"
 #include "util/detour.h"
 #include "util/utils.h"
 #include "util/libutils.h"

src/spice2x/games/popn/popn.cpp

@@ -16,16 +16,16 @@
 #include "launcher/launcher.h"
 #include "launcher/logger.h"
 #include "misc/eamuse.h"
+#include "misc/wintouchemu.h"
 #include "util/sysutils.h"
 #include "io.h"
 #include "util/deferlog.h"
-#include "misc/nativetouchhook.h"
-#include "misc/wintouchemu.h"
+#include "touch/native/nativetouchhook.h"
 
 namespace games::popn {
 
     bool SHOW_PIKA_MONITOR_WARNING = false;
-    bool NATIVE_TOUCH = false;
+    bool NATIVE_TOUCH = true;
     
 #if SPICE64 && !SPICE_XP
 
@@ -715,13 +715,16 @@ namespace games::popn {
         //       00000100 0000000B 00000001  (button 9)
         //       set third column to 0 and it will work with BIO2
         
-        if (!GRAPHICS_WINDOWED) {
-            if (NATIVE_TOUCH) {
-                nativetouchhook::hook(avs::game::DLL_INSTANCE);
-            } else {
-                wintouchemu::FORCE = true;
+        NATIVE_TOUCH = !wintouchemu::FORCE &&
+            nativetouch::hook(avs::game::DLL_INSTANCE);
+        if (!NATIVE_TOUCH) {
+            wintouchemu::FORCE = true;
+            if (!GRAPHICS_WINDOWED || GRAPHICS_PREVENT_SECONDARY_WINDOWS) {
                 wintouchemu::INJECT_MOUSE_AS_WM_TOUCH = true;
-                wintouchemu::hook_title_ends("", "Main Screen", avs::game::DLL_INSTANCE);
+                wintouchemu::hook_title_ends(
+                    "",
+                    "Main Screen",
+                    avs::game::DLL_INSTANCE);
             }
         }
 

src/spice2x/games/rb/rb.cpp

@@ -41,7 +41,7 @@ void games::rb::RBGame::attach() {
     Game::attach();
 
     if (1000 < games::rb::TOUCH_POLL_RATE) {
-        log_fatal("rb", "-rbtouchsize is set too high; cannot exceed 1000");
+        log_fatal("rb", "-rbtouchhz is set too high; cannot exceed 1000");
     }
 
     // init stuff
@@ -60,7 +60,7 @@ void games::rb::RBGame::attach() {
         log_info("rb", "force increasing touch poll rate by hooking SleepEx ({}Hz)", TOUCH_POLL_RATE);
         SleepEx_orig = detour::iat_try("SleepEx", SleepEx_hook, avs::game::DLL_INSTANCE);
     } else {
-        log_info("rb", "not changing touch poll rate (120Hz by default)");
+        log_info("rb", "not changing touch poll rate (~125Hz by default)");
     }
 }
 

src/spice2x/games/rb/rb.h

@@ -7,7 +7,6 @@
 namespace games::rb {
 
     extern uint16_t TOUCH_SCALING;
-    extern uint8_t TOUCH_SIZE;
     extern uint16_t TOUCH_POLL_RATE;
 
     class RBGame : public games::Game {

src/spice2x/games/rb/touch.cpp

@@ -4,7 +4,10 @@
 
 #include "avs/game.h"
 #include "hooks/graphics/graphics.h"
+#include "rawinput/touch.h"
 #include "touch/touch.h"
+#include "touch_debug.h"
+#include "touch_defs.h"
 #include "util/logging.h"
 #include "util/time.h"
 #include "util/utils.h"
@@ -12,28 +15,38 @@
 static std::string WINDOW_TITLE = "REFLEC BEAT";
 
 namespace games::rb {
-    uint16_t TOUCH_SCALING = 1000;
-    uint8_t TOUCH_SIZE = 1;
+    static constexpr double TOUCH_POINT_OFFSET_DIVISOR = 3.0;
+    static constexpr double X_INPUT_COORDINATE_COUNT = 54.0;
+
+    uint16_t TOUCH_SCALING = TOUCH_SCALE_DEFAULT;
+
+    static void packet_set_bit(unsigned char *packet, int bit) {
+        packet[TOUCH_PACKET_DATA_OFFSET + bit / 8] |=
+            static_cast<unsigned char>(1u << (bit % 8));
+    }
 }
 
-games::rb::ReflecBeatTouchDeviceHandle::ReflecBeatTouchDeviceHandle(bool log_fps) {
-    this->log_fps = log_fps;
+games::rb::ReflecBeatTouchDeviceHandle::ReflecBeatTouchDeviceHandle(bool log_fps) : log_fps(log_fps) {
 }
 
 void games::rb::ReflecBeatTouchDeviceHandle::grid_insert(unsigned char *data, int cursor_x, int cursor_y) {
 
-    // scale to grid position - there are 48 columns and 76 rows of IR sensors.
-    // for whatever reason, the last y row (#75) results in weird input few rows above; just drop it
-    int grid_x = CLAMP((cursor_x * 48) / window_width, 0, 47);
-    int grid_y = CLAMP((cursor_y * 76) / window_height, 0, 74);
+    // read() contracts X uniformly so screen edges land within usable sensors 2..45
+    int grid_x = CLAMP(
+        (cursor_x * X_SENSOR_COUNT) / window_width,
+        0,
+        X_SENSOR_COUNT - 1);
+    int grid_y = CLAMP(
+        (cursor_y * Y_SENSOR_COUNT) / window_height,
+        0,
+        Y_SENSOR_COUNT - 1);
 
     // get bit positions
-    int bit_x = 88 + grid_x;
-    int bit_y = 74 - grid_y;
+    int bit_x = X_SENSOR_FIRST_BIT + grid_x;
+    int bit_y = Y_SENSOR_FIRST_BIT - grid_y;
 
-    // insert bits
-    data[3 + bit_x / 8] |= (char) 1 << (bit_x % 8);
-    data[3 + bit_y / 8] |= (char) 1 << (bit_y % 8);
+    packet_set_bit(data, bit_x);
+    packet_set_bit(data, bit_y);
 }
 
 bool games::rb::ReflecBeatTouchDeviceHandle::open(LPCWSTR lpFileName) {
@@ -49,6 +62,9 @@ bool games::rb::ReflecBeatTouchDeviceHandle::open(LPCWSTR lpFileName) {
 
     if (wnd != nullptr) {
 
+        // cache the game window so read() can size against it regardless of focus
+        this->game_hwnd = wnd;
+
         // reset window process to make the game not crash
         SetWindowLongPtr(wnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(DefWindowProc));
 
@@ -68,18 +84,19 @@ bool games::rb::ReflecBeatTouchDeviceHandle::open(LPCWSTR lpFileName) {
             // update window
             SetWindowPos(wnd, nullptr, 0, 0, 0, 0,
                          SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER);
+        }
 
-            // create touch window
-            touch_create_wnd(wnd);
+        // request automatic aspect ratio fixes
+        ::rawinput::touch::ASPECT_COMPENSATION_GAME = true;
 
-        } else {
+        // create touch window
+        touch_create_wnd(wnd);
 
-            // create touch window
-            touch_create_wnd(wnd);
-
-            // show game window because it lost focus
+        // show fullscreen game window because it lost focus
+        if (!GRAPHICS_WINDOWED) {
             ShowWindow(wnd, SW_SHOW);
         }
+
     } else {
 
         // fallback to dx hook
@@ -91,18 +108,21 @@ bool games::rb::ReflecBeatTouchDeviceHandle::open(LPCWSTR lpFileName) {
         ShowCursor(TRUE);
     }
 
+    touch_debug_attach();
+
     return true;
 }
 
 int games::rb::ReflecBeatTouchDeviceHandle::read(LPVOID lpBuffer, DWORD nNumberOfBytesToRead) {
 
     // check buffer size
-    if (nNumberOfBytesToRead < 20) {
+    if (nNumberOfBytesToRead < TOUCH_PACKET_SIZE) {
         return 0;
     }
 
-    // get window
-    HWND window = GetForegroundWindow();
+    // size against the game window cached in open() (not GetForegroundWindow), so
+    // touch stays correctly scaled and keeps working when the game loses focus
+    HWND window = this->game_hwnd;
     if (window == nullptr) {
         return 0;
     }
@@ -122,17 +142,17 @@ int games::rb::ReflecBeatTouchDeviceHandle::read(LPVOID lpBuffer, DWORD nNumberO
     }
 
     // create data
-    unsigned char data[20] {};
+    unsigned char data[TOUCH_PACKET_SIZE] {};
 
     // data header
     data[0] = 0x55;
     data[2] = 0x4C;
    
-    const auto SCALE_FACTOR = games::rb::TOUCH_SCALING / 1000.f;
+    const float scale_factor = games::rb::TOUCH_SCALING / (float) games::rb::TOUCH_SCALE_DEFAULT;
 
     // iterate all touch points
-    auto offset_x = (int) (window_width / 48.0 / 3.0);
-    auto offset_y = (int) (window_height / 76.0 / 3.0);
+    int offset_x = (int) (window_width / (double) X_SENSOR_COUNT / TOUCH_POINT_OFFSET_DIVISOR);
+    int offset_y = (int) (window_height / (double) Y_SENSOR_COUNT / TOUCH_POINT_OFFSET_DIVISOR);
     std::vector<TouchPoint> touch_points;
     touch_get_points(touch_points);
     for (auto &point : touch_points) {
@@ -148,37 +168,44 @@ int games::rb::ReflecBeatTouchDeviceHandle::read(LPVOID lpBuffer, DWORD nNumberO
         }
 
         // apply scaling
-        x = x - (window_width * (1.f - SCALE_FACTOR) / 2);
-        x = x / SCALE_FACTOR;
-        y = y - (window_height * (1.f - SCALE_FACTOR) / 2);
-        y = y / SCALE_FACTOR;
+        x = x - (window_width * (1.f - scale_factor) / 2);
+        x = x / scale_factor;
+        y = y - (window_height * (1.f - scale_factor) / 2);
+        y = y / scale_factor;
 
         if (x < 0 || window_width <= x || y < 0 || window_height <= y) {
             continue;
         }
 
-        // point scaling
-        const auto point_x = (int) ((x - window_width / 2.0) * 48.0 / 54.0 + window_width / 2.0);
-        const auto point_y = (int) (y - window_height / 76);
+        // point coordinates
+        // keep the verified left edge fixed while adding up to one-third of a beam
+        // at the right edge, preventing the finger footprint from including sensor 44
+        const auto point_x = (int) (
+            (x - window_width / 2.0) * X_SENSOR_COUNT / X_INPUT_COORDINATE_COUNT +
+            window_width / 2.0 +
+            x / (X_SENSOR_COUNT * TOUCH_POINT_OFFSET_DIVISOR));
+        const auto point_y = (int) y;
 
-        // center
-        grid_insert(data, point_x, point_y);
-
-        // surrounding points
-        if (games::rb::TOUCH_SIZE == 3) {
-            grid_insert(data, point_x - offset_x, point_y);            // west
-            grid_insert(data, point_x - offset_x, point_y - offset_y); // northwest
-            grid_insert(data, point_x - offset_x, point_y + offset_y); // southwest
-            grid_insert(data, point_x + offset_x, point_y);            // east
-            grid_insert(data, point_x + offset_x, point_y + offset_y); // southeast
-            grid_insert(data, point_x + offset_x, point_y - offset_y); // northeast
-            grid_insert(data, point_x, point_y - offset_y);            // north
-            grid_insert(data, point_x, point_y + offset_y);            // south
-        }
+        // model a finger as a 3x3 block of IR sensors around the touch point
+        // this gives better accuracy (than just 1x1) since the logic below
+        // can toggle anywhere from 1x1 to 2x2, and the game engine calculates
+        // the center point, which means by inserting up to 8 extra blocks
+        // we are emulating a sub-"pixel" resolution
+        grid_insert(data, point_x, point_y);                       // center
+        grid_insert(data, point_x - offset_x, point_y);            // west
+        grid_insert(data, point_x - offset_x, point_y - offset_y); // northwest
+        grid_insert(data, point_x - offset_x, point_y + offset_y); // southwest
+        grid_insert(data, point_x + offset_x, point_y);            // east
+        grid_insert(data, point_x + offset_x, point_y + offset_y); // southeast
+        grid_insert(data, point_x + offset_x, point_y - offset_y); // northeast
+        grid_insert(data, point_x, point_y - offset_y);            // north
+        grid_insert(data, point_x, point_y + offset_y);            // south
     }
 
+    touch_debug_publish(data, is_landscape);
+
     // copy data to buffer
-    memcpy(lpBuffer, data, 20);
+    memcpy(lpBuffer, data, TOUCH_PACKET_SIZE);
 
     // update frame logging
     if (log_fps) {
@@ -193,7 +220,7 @@ int games::rb::ReflecBeatTouchDeviceHandle::read(LPVOID lpBuffer, DWORD nNumberO
     }
 
     // return amount of bytes written
-    return 20;
+    return TOUCH_PACKET_SIZE;
 }
 
 int games::rb::ReflecBeatTouchDeviceHandle::write(LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite) {
@@ -207,6 +234,8 @@ int games::rb::ReflecBeatTouchDeviceHandle::device_io(DWORD dwIoControlCode, LPV
 
 bool games::rb::ReflecBeatTouchDeviceHandle::close() {
 
+    touch_debug_detach();
+
     // detach touch module
     touch_detach();
 

src/spice2x/games/rb/touch.h

@@ -12,6 +12,12 @@ namespace games::rb {
         int window_width = 1080;
         int window_height = 1920;
 
+        // game window resolved in open(); read() sizes against this instead of the
+        // foreground window so touch stays correctly scaled and keeps working when
+        // the game is not the foreground window (rawinput delivers touch regardless
+        // of focus)
+        HWND game_hwnd = nullptr;
+
         // logging
         bool log_fps = false;
         uint64_t log_time = 0;

src/spice2x/games/rb/touch_debug.cpp

@@ -0,0 +1,143 @@
+#include "touch_debug.h"
+
+#include <array>
+#include <atomic>
+#include <cstring>
+#include <mutex>
+
+#include "external/imgui/imgui.h"
+#include "games/rb/rb.h"
+#include "games/rb/touch_defs.h"
+
+namespace games::rb {
+
+    struct TouchDebugState {
+        std::array<unsigned char, TOUCH_PACKET_SIZE> packet {};
+        bool is_landscape = false;
+    };
+
+    std::atomic_bool TOUCH_DEBUG_OVERLAY = false;
+    static std::atomic_bool TOUCH_ACTIVE = false;
+    static std::mutex TOUCH_DEBUG_STATE_M;
+    static TouchDebugState TOUCH_DEBUG_STATE;
+
+    static float touch_scale_factor() {
+        return TOUCH_SCALING / (float) TOUCH_SCALE_DEFAULT;
+    }
+
+    static void clear_touch_debug_state() {
+        std::lock_guard<std::mutex> lock(TOUCH_DEBUG_STATE_M);
+        TOUCH_DEBUG_STATE = {};
+    }
+
+    static TouchDebugState get_touch_debug_state() {
+        std::lock_guard<std::mutex> lock(TOUCH_DEBUG_STATE_M);
+        return TOUCH_DEBUG_STATE;
+    }
+
+    static bool packet_bit_active(
+            const std::array<unsigned char, TOUCH_PACKET_SIZE> &packet, int bit) {
+        return (packet[TOUCH_PACKET_DATA_OFFSET + bit / 8] & (1u << (bit % 8))) != 0;
+    }
+
+    static int sensor_center(int sensor, int sensor_count, int extent) {
+        return ((sensor * 2 + 1) * extent) / (sensor_count * 2);
+    }
+
+    static float sensor_span_position(int sensor, int sensor_count, int extent) {
+        return sensor * (extent - 1) / (float) (sensor_count - 1);
+    }
+
+    bool touch_debug_overlay_enabled() {
+        return TOUCH_DEBUG_OVERLAY && TOUCH_ACTIVE.load(std::memory_order_acquire);
+    }
+
+    void touch_draw_debug_overlay() {
+        if (!touch_debug_overlay_enabled()) {
+            return;
+        }
+
+        const auto &io = ImGui::GetIO();
+        int width = static_cast<int>(io.DisplaySize.x);
+        int height = static_cast<int>(io.DisplaySize.y);
+        if (width <= 0 || height <= 0) {
+            return;
+        }
+
+        const float scale_factor = touch_scale_factor();
+        const float left = width * (1.f - scale_factor) / 2.f;
+        const float top = height * (1.f - scale_factor) / 2.f;
+        const float right = width - left;
+        const float bottom = height - top;
+
+        TouchDebugState state = get_touch_debug_state();
+        ImDrawList *draw_list = ImGui::GetBackgroundDrawList();
+        auto draw_line = [&](float x1, float y1, float x2, float y2) {
+            draw_list->AddLine(
+                ImVec2(x1, y1), ImVec2(x2, y2),
+                IM_COL32(0, 255, 64, 255), 2.f);
+        };
+
+        // show the valid input area when touch scaling restricts it
+        if (TOUCH_SCALING != TOUCH_SCALE_DEFAULT) {
+            draw_list->AddRect(
+                ImVec2(left, top), ImVec2(right, bottom),
+                IM_COL32(255, 255, 255, 255), 0.f, 0, 2.f);
+        }
+
+        // spread the usable X sensors 2..45 from edge to edge
+        for (int sensor = X_SENSOR_FIRST_ACTIVE; sensor <= X_SENSOR_LAST_ACTIVE; sensor++) {
+            if (!packet_bit_active(state.packet, X_SENSOR_FIRST_BIT + sensor)) {
+                continue;
+            }
+
+            float position = sensor_span_position(
+                sensor - X_SENSOR_FIRST_ACTIVE, X_SENSOR_ACTIVE_COUNT,
+                state.is_landscape ? height : width);
+            if (state.is_landscape) {
+                float y = top + position * scale_factor;
+                draw_line(left, y, right, y);
+            } else {
+                float x = left + position * scale_factor;
+                draw_line(x, top, x, bottom);
+            }
+        }
+
+        for (int sensor = 0; sensor < Y_SENSOR_COUNT; sensor++) {
+            if (!packet_bit_active(state.packet, Y_SENSOR_FIRST_BIT - sensor)) {
+                continue;
+            }
+
+            int position = sensor_center(
+                sensor, Y_SENSOR_COUNT,
+                state.is_landscape ? width : height);
+            if (state.is_landscape) {
+                float x = right - position * scale_factor;
+                draw_line(x, top, x, bottom);
+            } else {
+                float y = top + position * scale_factor;
+                draw_line(left, y, right, y);
+            }
+        }
+    }
+
+    void touch_debug_attach() {
+        clear_touch_debug_state();
+        TOUCH_ACTIVE.store(true, std::memory_order_release);
+    }
+
+    void touch_debug_detach() {
+        TOUCH_ACTIVE.store(false, std::memory_order_release);
+        clear_touch_debug_state();
+    }
+
+    void touch_debug_publish(const unsigned char *data, bool is_landscape) {
+        if (!TOUCH_DEBUG_OVERLAY) {
+            return;
+        }
+
+        std::lock_guard<std::mutex> lock(TOUCH_DEBUG_STATE_M);
+        memcpy(TOUCH_DEBUG_STATE.packet.data(), data, TOUCH_PACKET_SIZE);
+        TOUCH_DEBUG_STATE.is_landscape = is_landscape;
+    }
+}

src/spice2x/games/rb/touch_debug.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <atomic>
+
+namespace games::rb {
+    extern std::atomic_bool TOUCH_DEBUG_OVERLAY;
+
+    bool touch_debug_overlay_enabled();
+    void touch_draw_debug_overlay();
+
+    void touch_debug_attach();
+    void touch_debug_detach();
+    void touch_debug_publish(const unsigned char *data, bool is_landscape);
+}

src/spice2x/games/rb/touch_defs.h

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace games::rb {
+    inline constexpr int TOUCH_SCALE_DEFAULT = 1000;
+    inline constexpr int TOUCH_PACKET_SIZE = 20;
+    inline constexpr int TOUCH_PACKET_DATA_OFFSET = 3;
+
+    inline constexpr int X_SENSOR_COUNT = 48;
+    inline constexpr int X_SENSOR_FIRST_ACTIVE = 2;
+    inline constexpr int X_SENSOR_LAST_ACTIVE = 45;
+    inline constexpr int X_SENSOR_ACTIVE_COUNT =
+        X_SENSOR_LAST_ACTIVE - X_SENSOR_FIRST_ACTIVE + 1;
+    inline constexpr int X_SENSOR_FIRST_BIT = 88;
+
+    inline constexpr int Y_SENSOR_COUNT = 76;
+    inline constexpr int Y_SENSOR_FIRST_BIT = 75;
+}

src/spice2x/games/sdvx/bi2x_hook.cpp

@@ -3,6 +3,7 @@
 #if SPICE64
 
 #include <cstdint>
+#include "api/client.h"
 #include "util/detour.h"
 #include "util/logging.h"
 #include "util/utils.h"
@@ -349,43 +350,29 @@ namespace games::sdvx {
          * 9 - v unit - 258 bytes - 86 colors
          *
          * data is stored in RGB order, 3 bytes per color
-         *
-         * TODO: expose this data via API
          */
 
-        // data mapping
-        static struct TapeLedMapping {
-            size_t data_size;
-            int index_r, index_g, index_b;
-
-            TapeLedMapping(size_t data_size, int index_r, int index_g, int index_b)
-                    : data_size(data_size), index_r(index_r), index_g(index_g), index_b(index_b) {}
-
-        } mapping[] = {
-                { 74, Lights::TITLE_AVG_R, Lights::TITLE_AVG_G, Lights::TITLE_AVG_B },
-                { 12, Lights::UPPER_LEFT_SPEAKER_AVG_R, Lights::UPPER_LEFT_SPEAKER_AVG_G, Lights::UPPER_LEFT_SPEAKER_AVG_B },
-                { 12, Lights::UPPER_RIGHT_SPEAKER_AVG_R, Lights::UPPER_RIGHT_SPEAKER_AVG_G, Lights::UPPER_RIGHT_SPEAKER_AVG_B },
-                { 56, Lights::LEFT_WING_AVG_R, Lights::LEFT_WING_AVG_G, Lights::LEFT_WING_AVG_B },
-                { 56, Lights::RIGHT_WING_AVG_R, Lights::RIGHT_WING_AVG_G, Lights::RIGHT_WING_AVG_B },
-                { 94, Lights::CONTROL_PANEL_AVG_R, Lights::CONTROL_PANEL_AVG_G, Lights::CONTROL_PANEL_AVG_B },
-                { 12, Lights::LOWER_LEFT_SPEAKER_AVG_R, Lights::LOWER_LEFT_SPEAKER_AVG_G, Lights::LOWER_LEFT_SPEAKER_AVG_B },
-                { 12, Lights::LOWER_RIGHT_SPEAKER_AVG_R, Lights::LOWER_RIGHT_SPEAKER_AVG_G, Lights::LOWER_RIGHT_SPEAKER_AVG_B },
-                { 14, Lights::WOOFER_AVG_R, Lights::WOOFER_AVG_G, Lights::WOOFER_AVG_B },
-                { 86, Lights::V_UNIT_AVG_R, Lights::V_UNIT_AVG_G, Lights::V_UNIT_AVG_B },
-        };
-
         // check index bounds
-        if (tapeledutils::is_enabled() && index < std::size(mapping)) {
-            auto &map = mapping[index];
+        if (tapeledutils::is_enabled() && index < std::size(TAPELED_MAPPING)) {
+            auto &map = TAPELED_MAPPING[index];
+            const auto data_size = map.data.size();
 
             // pick a color to use
-            const auto rgb = tapeledutils::pick_color_from_led_tape(data, map.data_size);
+            const auto rgb = tapeledutils::pick_color_from_led_tape(data, data_size);
 
             // program the lights into API
             auto &lights = get_lights();
             GameAPI::Lights::writeLight(RI_MGR, lights[map.index_r], rgb.r);
             GameAPI::Lights::writeLight(RI_MGR, lights[map.index_g], rgb.g);
             GameAPI::Lights::writeLight(RI_MGR, lights[map.index_b], rgb.b);
+
+            if (api::has_clients()) {
+                for (size_t i = 0; i < data_size; ++i) {
+                    map.data[i].r = data[i * 3];
+                    map.data[i].g = data[i * 3 + 1];
+                    map.data[i].b = data[i * 3 + 2];
+                }
+            }
         }
 
         if (This != custom_node) {

src/spice2x/games/sdvx/sdvx.cpp

@@ -8,6 +8,9 @@
 #include "hooks/graphics/graphics.h"
 #include "hooks/devicehook.h"
 #include "hooks/libraryhook.h"
+#ifdef SPICE64
+#include "hooks/graphics/nvapi_impl.h"
+#endif
 #include "hooks/graphics/nvapi_hook.h"
 #include "hooks/powrprof.h"
 #include "hooks/sleephook.h"
@@ -23,8 +26,8 @@
 #include "util/libutils.h"
 #include "util/sysutils.h"
 #include "misc/eamuse.h"
-#include "misc/nativetouchhook.h"
 #include "misc/wintouchemu.h"
+#include "touch/native/nativetouchhook.h"
 #include "bi2x_hook.h"
 #include "camera.h"
 #include "io.h"
@@ -46,7 +49,6 @@ namespace games::sdvx {
     const char *ORIGINAL_ASIO_DEVICE_NAME = "XONAR SOUND CARD(64)";
 
     // settings
-    bool NATIVETOUCH = false;
     uint8_t DIGITAL_KNOB_SENS = 16;
     SdvxOverlayPosition OVERLAY_POS = SDVX_OVERLAY_BOTTOM;
     bool ENABLE_COM_PORT_SCAN_HOOK = false;
@@ -59,6 +61,19 @@ namespace games::sdvx {
     static HKEY real_asio_reg_handle = nullptr;
     static HKEY real_asio_device_reg_handle = nullptr;
 
+    tapeledutils::tape_led TAPELED_MAPPING[SDVX_TAPELED_TOTAL] = {
+        { 74, Lights::TITLE_AVG_R, Lights::TITLE_AVG_G, Lights::TITLE_AVG_B, "Title" },
+        { 12, Lights::UPPER_LEFT_SPEAKER_AVG_R, Lights::UPPER_LEFT_SPEAKER_AVG_G, Lights::UPPER_LEFT_SPEAKER_AVG_B, "Upper Left Speaker" },
+        { 12, Lights::UPPER_RIGHT_SPEAKER_AVG_R, Lights::UPPER_RIGHT_SPEAKER_AVG_G, Lights::UPPER_RIGHT_SPEAKER_AVG_B, "Upper Right Speaker" },
+        { 56, Lights::LEFT_WING_AVG_R, Lights::LEFT_WING_AVG_G, Lights::LEFT_WING_AVG_B, "Left Wing" },
+        { 56, Lights::RIGHT_WING_AVG_R, Lights::RIGHT_WING_AVG_G, Lights::RIGHT_WING_AVG_B, "Right Wing" },
+        { 94, Lights::CONTROL_PANEL_AVG_R, Lights::CONTROL_PANEL_AVG_G, Lights::CONTROL_PANEL_AVG_B, "Control Panel" },
+        { 12, Lights::LOWER_LEFT_SPEAKER_AVG_R, Lights::LOWER_LEFT_SPEAKER_AVG_G, Lights::LOWER_LEFT_SPEAKER_AVG_B, "Lower Left Speaker" },
+        { 12, Lights::LOWER_RIGHT_SPEAKER_AVG_R, Lights::LOWER_RIGHT_SPEAKER_AVG_G, Lights::LOWER_RIGHT_SPEAKER_AVG_B, "Lower Right Speaker" },
+        { 14, Lights::WOOFER_AVG_R, Lights::WOOFER_AVG_G, Lights::WOOFER_AVG_B, "Woofer" },
+        { 86, Lights::V_UNIT_AVG_R, Lights::V_UNIT_AVG_G, Lights::V_UNIT_AVG_B, "V Unit" },
+    };
+
     static LONG WINAPI RegOpenKeyA_hook(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult) {
         if (lpSubKey != nullptr &&
             phkResult != nullptr &&
@@ -428,28 +443,41 @@ namespace games::sdvx {
         if (aio != nullptr) {
 
             // enable 9on12 for AMD
-            if (!libutils::try_library("nvapi64.dll")) {
+            const auto nvapi = libutils::try_library("nvapi64.dll");
+            if (nvapi == nullptr) {
                 log_info(
                     "sdvx",
                     "nvapi64.dll not found; for non-NVIDIA GPUs, requesting 9on12 to be enabled");
                 GRAPHICS_9_ON_12_REQUESTED_BY_GAME = true;
+            }
+
+            if (nvapi_hook::BYPASS_NVAPI || nvapi == nullptr) {
+                const uint32_t main_refresh_hz = GRAPHICS_FORCE_REFRESH > 0 ?
+                    GRAPHICS_FORCE_REFRESH : (is_valkyrie_model() ? 120 : 60);
+                const uint32_t sub_refresh_hz = GRAPHICS_FORCE_REFRESH_SUB.value_or(60);
+                if (!nvapi_impl::initialize(
+                        avs::game::DLL_INSTANCE,
+                        main_refresh_hz,
+                        sub_refresh_hz)) {
+                    log_warning("sdvx", "failed to initialize synthetic NVAPI");
+                }
             } else {
                 // don't let nvapi mess with display settings
                 nvapi_hook::initialize(avs::game::DLL_INSTANCE);
             }
 
             if (is_valkyrie_model()) {
-                if (NATIVETOUCH) {
-                    nativetouchhook::hook(avs::game::DLL_INSTANCE);
-                } else if (!NATIVETOUCH && !GRAPHICS_WINDOWED) {
-                    // hook touch window
-                    // in windowed mode, game can accept mouse input on the second screen
+                const auto native_touch_ready = !wintouchemu::FORCE &&
+                    nativetouch::hook(avs::game::DLL_INSTANCE);
+                if (!native_touch_ready) {
                     wintouchemu::FORCE = true;
-                    wintouchemu::INJECT_MOUSE_AS_WM_TOUCH = true;
-                    wintouchemu::hook_title_ends(
+                    if (!GRAPHICS_WINDOWED) {
+                        wintouchemu::INJECT_MOUSE_AS_WM_TOUCH = true;
+                        wintouchemu::hook_title_ends(
                             "SOUND VOLTEX",
                             "Main Screen",
                             avs::game::DLL_INSTANCE);
+                    }
                 }
 
                 // insert BI2X hooks

src/spice2x/games/sdvx/sdvx.h

@@ -6,6 +6,7 @@
 
 #include "avs/game.h"
 #include "games/game.h"
+#include "util/tapeled.h"
 
 namespace games::sdvx {
 
@@ -18,7 +19,6 @@ namespace games::sdvx {
     };
 
     // settings
-    extern bool NATIVETOUCH;
     extern uint8_t DIGITAL_KNOB_SENS;
     extern std::optional<std::string> ASIO_DRIVER;
     extern SdvxOverlayPosition OVERLAY_POS;
@@ -26,6 +26,9 @@ namespace games::sdvx {
     // states
     extern bool SHOW_VM_MONITOR_WARNING;
 
+    constexpr int SDVX_TAPELED_TOTAL = 10;
+    extern tapeledutils::tape_led TAPELED_MAPPING[SDVX_TAPELED_TOTAL];
+
     static inline bool is_valkyrie_model() {
         return (
             avs::game::is_model("KFC") &&

src/spice2x/games/sdvx/sdvx_live2d.cpp

@@ -0,0 +1,72 @@
+#include "sdvx_live2d.h"
+
+// only the Live2D-capable SDVX versions are 64-bit, so the whole feature is
+// compiled out of 32-bit builds.
+#ifdef SPICE64
+
+#include <string>
+
+#include "hooks/graphics/graphics.h"
+#include "launcher/logger.h"
+#include "util/logging.h"
+
+namespace games::sdvx {
+
+    // Live2D in-game scene detection (for the -sdvxnolive2d "ingame" option).
+    //
+    // the game logs scene transitions as "I:Attach: in <SCENE>" / "I:Detach: in
+    // <SCENE>". several scenes correspond to in-song gameplay (with the heavy
+    // Live2D rendering); we watch those log lines and keep the shared flag
+    // the d3d9 backend reads up to date. the hook never alters the log output
+    // (always returns false).
+    static bool live2d_scene_log_hook(
+            void *user, const std::string &data, logger::Style style, std::string &out) {
+        // any of these scenes counts as in-song gameplay (different play modes)
+        static const char *const gameplay_scenes[] = {
+            "in ALTERNATIVE_GAME_SCENE",
+            "in MEGAMIX_GAME_SCENE",
+            "in MEGAMIX_BATTLE",
+            "in BATTLE_GAME_SCENE",
+            "in AUTOMATION_GAME_SCENE",
+            "in ARENA_GAME_SCENE",
+        };
+        bool in_gameplay_scene = false;
+        for (const auto *scene : gameplay_scenes) {
+            if (data.find(scene) != std::string::npos) {
+                in_gameplay_scene = true;
+                break;
+            }
+        }
+        if (!in_gameplay_scene) {
+            return false;
+        }
+        // note: log messages here must NOT contain any matched scene token, else
+        // this hook would re-enter itself when the message is pushed.
+        if (data.find("I:Attach: in ") != std::string::npos) {
+            if (!GRAPHICS_SDVX_LIVE2D_IN_GAMEPLAY.exchange(true, std::memory_order_relaxed)) {
+                log_info("sdvx", "Live2D skip: entering gameplay");
+            }
+        } else if (data.find("I:Detach: in ") != std::string::npos) {
+            if (GRAPHICS_SDVX_LIVE2D_IN_GAMEPLAY.exchange(false, std::memory_order_relaxed)) {
+                log_info("sdvx", "Live2D skip: leaving gameplay");
+            }
+        }
+        return false;
+    }
+
+    void live2d_scene_detection_init() {
+        static bool installed = false;
+        if (installed) {
+            return;
+        }
+        installed = true;
+        // the logger's hook list is a persistent static, so registering here is
+        // safe even though this runs before logger::start(). we intentionally do
+        // NOT log a confirmation now: at this point the log file isn't open yet
+        // and the message would be dropped. the entering/leaving-gameplay lines
+        // above provide runtime confirmation once the logger is running.
+        logger::hook_add(live2d_scene_log_hook, nullptr);
+    }
+}
+
+#endif // SPICE64

src/spice2x/games/sdvx/sdvx_live2d.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace games::sdvx {
+
+#ifdef SPICE64
+    // installs the Live2D in-game scene-detection log hook used by the
+    // -sdvxnolive2d "ingame" option. does not require the SDVX game module to
+    // be attached, so it can be enabled purely from the launcher option.
+    // only the Live2D-capable SDVX versions are 64-bit, so this is compiled out
+    // of 32-bit builds.
+    void live2d_scene_detection_init();
+#endif
+
+}

src/spice2x/hooks/audio/asio_driver_scan.cpp

@@ -1,74 +1,84 @@
-#include "asio_driver_scan.h"
-
-#include <algorithm>
-
-#include <windows.h>
-
-#include "util/utils.h"
-
-namespace hooks::audio {
-
-    static constexpr char ASIO_REG_PATH[] = "software\\asio";
-    static constexpr char ASIO_REG_DESC[] = "description";
-
-    // enumerate a single registry view, appending to entries while merging
-    // duplicates discovered in another view. Drivers are matched by name (not
-    // CLSID): the game's ASIO loader selects drivers by name, and some vendors
-    // register the same CLSID under different 32-bit/64-bit names (e.g. "XONAR
-    // SOUND CARD" vs "XONAR SOUND CARD(64)"), which are distinct user choices.
-    static void scan_view(
-            REGSAM wow64_flag,
-            bool is_64bit,
-            std::vector<AsioDriverScanEntry> &entries) {
-
-        HKEY hkEnum = nullptr;
-        if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, ASIO_REG_PATH, 0,
-                KEY_READ | wow64_flag, &hkEnum) != ERROR_SUCCESS) {
-            return;
-        }
-
-        char key_name[256];
-        for (DWORD index = 0;
-             RegEnumKeyA(hkEnum, index, key_name, sizeof(key_name)) == ERROR_SUCCESS;
-             index++) {
-
-            // read description (display name), fall back to the key name
-            char desc[256] = { 0 };
-            DWORD size = sizeof(desc);
-            std::string name = key_name;
-            if (RegGetValueA(hkEnum,
-                             key_name,
-                             ASIO_REG_DESC,
-                             RRF_RT_REG_SZ | wow64_flag,
-                             nullptr,
-                             desc,
-                             &size) == ERROR_SUCCESS && desc[0]) {
-                name = desc;
-            }
-
-            // merge with an existing entry from the other view (match by name)
-            const std::string name_lower = strtolower(name);
-            auto it = std::find_if(entries.begin(), entries.end(), [&](const auto &e) {
-                return strtolower(e.name) == name_lower;
-            });
-            if (it == entries.end()) {
-                entries.push_back({ name });
-                it = entries.end() - 1;
-            }
-            it->found_32bit |= !is_64bit;
-            it->found_64bit |= is_64bit;
-        }
-
-        RegCloseKey(hkEnum);
-    }
-
-    std::vector<AsioDriverScanEntry> scan_asio_drivers() {
-        std::vector<AsioDriverScanEntry> entries;
-
-        // 64-bit view first so it wins ordering when present in both
-        scan_view(KEY_WOW64_64KEY, true, entries);
-        scan_view(KEY_WOW64_32KEY, false, entries);
-
-        return entries;
-    }
-}
+#include "asio_driver_scan.h"
+
+#include <algorithm>
+
+#include <windows.h>
+
+#include "util/utils.h"
+
+namespace hooks::audio {
+
+    static constexpr char ASIO_REG_PATH[] = "software\\asio";
+    static constexpr char ASIO_REG_DESC[] = "description";
+
+    // enumerate a single registry view, appending to entries while merging
+    // duplicates discovered in another view. Drivers are matched by name (not
+    // CLSID): the game's ASIO loader selects drivers by name, and some vendors
+    // register the same CLSID under different 32-bit/64-bit names (e.g. "XONAR
+    // SOUND CARD" vs "XONAR SOUND CARD(64)"), which are distinct user choices.
+    static void scan_view(
+            REGSAM wow64_flag,
+            bool is_64bit,
+            std::vector<AsioDriverScanEntry> &entries) {
+
+        HKEY hkEnum = nullptr;
+        if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, ASIO_REG_PATH, 0,
+                KEY_READ | wow64_flag, &hkEnum) != ERROR_SUCCESS) {
+            return;
+        }
+
+        char key_name[256];
+        for (DWORD index = 0;
+             RegEnumKeyA(hkEnum, index, key_name, sizeof(key_name)) == ERROR_SUCCESS;
+             index++) {
+
+            // read description (display name), fall back to the key name.
+            // RegOpenKeyExA + RegQueryValueExA is used instead of RegGetValueA
+            // because the latter is unavailable on Windows XP.
+            char desc[256] = { 0 };
+            DWORD size = sizeof(desc);
+            std::string name = key_name;
+            HKEY hkDriver = nullptr;
+            if (RegOpenKeyExA(hkEnum, key_name, 0,
+                    KEY_QUERY_VALUE | wow64_flag, &hkDriver) == ERROR_SUCCESS) {
+                DWORD type = 0;
+                if (RegQueryValueExA(hkDriver,
+                                     ASIO_REG_DESC,
+                                     nullptr,
+                                     &type,
+                                     reinterpret_cast<LPBYTE>(desc),
+                                     &size) == ERROR_SUCCESS
+                        && type == REG_SZ && desc[0]) {
+                    // ensure null termination
+                    desc[sizeof(desc) - 1] = '\0';
+                    name = desc;
+                }
+                RegCloseKey(hkDriver);
+            }
+
+            // merge with an existing entry from the other view (match by name)
+            const std::string name_lower = strtolower(name);
+            auto it = std::find_if(entries.begin(), entries.end(), [&](const auto &e) {
+                return strtolower(e.name) == name_lower;
+            });
+            if (it == entries.end()) {
+                entries.push_back({ name });
+                it = entries.end() - 1;
+            }
+            it->found_32bit |= !is_64bit;
+            it->found_64bit |= is_64bit;
+        }
+
+        RegCloseKey(hkEnum);
+    }
+
+    std::vector<AsioDriverScanEntry> scan_asio_drivers() {
+        std::vector<AsioDriverScanEntry> entries;
+
+        // 64-bit view first so it wins ordering when present in both
+        scan_view(KEY_WOW64_64KEY, true, entries);
+        scan_view(KEY_WOW64_32KEY, false, entries);
+
+        return entries;
+    }
+}

src/spice2x/hooks/audio/asio_driver_scan.h

@@ -1,15 +1,15 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace hooks::audio {
-
-    struct AsioDriverScanEntry {
-        std::string name;
-        bool found_32bit = false;
-        bool found_64bit = false;
-    };
-
-    std::vector<AsioDriverScanEntry> scan_asio_drivers();
-}
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace hooks::audio {
+
+    struct AsioDriverScanEntry {
+        std::string name;
+        bool found_32bit = false;
+        bool found_64bit = false;
+    };
+
+    std::vector<AsioDriverScanEntry> scan_asio_drivers();
+}

src/spice2x/hooks/audio/asio_proxy.h

@@ -1,216 +1,240 @@
-#pragma once
-
-#include <atomic>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <windows.h>
-
-#include "external/asio/asio.h"
-#include "external/asio/iasiodrv.h"
-
-namespace hooks::audio::asio {
-
-    // returns true if a CoCreateInstance call is instantiating a registered ASIO driver.
-    // ASIO hosts pass the driver CLSID as both class id and interface id; we also validate
-    // it against the system's registered ASIO drivers to avoid false positives
-    bool is_asio_creation(REFCLSID rclsid, REFIID riid);
-
-    // wrap a real ASIO driver instance, taking ownership of the supplied reference, and
-    // return a proxy that forwards every call to it
-    IUnknown *wrap(REFCLSID clsid, void *real);
-}
-
-// transparent proxy around a real ASIO driver; a single place to intercept ASIO traffic
-struct WrappedAsio final : IAsio {
-    WrappedAsio(IAsio *real, REFCLSID clsid, std::string name)
-        : pReal(real), clsid(clsid), driver_name(std::move(name)) {
-    }
-
-    WrappedAsio(const WrappedAsio &) = delete;
-    WrappedAsio &operator=(const WrappedAsio &) = delete;
-
-    virtual ~WrappedAsio();
-
-    // selects which source channel pair of a multichannel ASIO output reaches the device's
-    // 2.0 front pair. when not None, the proxy presents the game's expected multichannel
-    // layout to the host so it proceeds to create_buffers, then opens only a two-channel
-    // stream on the real device and routes the selected pair onto it (see create_buffers).
-    // Front is the plain "force two channel" case (forward the device's own front pair);
-    // the others copy a different pair onto 0/1. assumes a standard 7.1 layout (0-indexed).
-    // set once at boot, before any wrapper exists, so it needs no synchronization
-    enum class StereoDownmix {
-        None,   // feature disabled - full multichannel passthrough
-        Front,  // channels 0/1 - the device front pair is forwarded as-is (no copy)
-        Center, // channel 2 duplicated to both 0 and 1
-        Rear,   // channels 4/5 -> 0/1
-        Side,   // channels 6/7 -> 0/1
-    };
-    static StereoDownmix STEREO_DOWNMIX;
-
-    // true when a stereo extraction is configured, i.e. the real device should open a 2.0
-    // stream and only the selected pair should reach it. the former standalone
-    // FORCE_TWO_CHANNELS flag is now just the Front case of this
-    static bool force_two_channels() {
-        return STEREO_DOWNMIX != StereoDownmix::None;
-    }
-
-    // some games hardcode a multichannel ASIO output and bail before create_buffers if
-    // get_channels reports fewer, so we report at least this many output channels when a
-    // stereo extraction is active
-    static constexpr long FORCED_OUTPUT_CHANNELS = 8;
-
-    // maps an option string ("front", "center", "rear", "side") to a StereoDownmix value,
-    // returning None for anything unrecognized
-    static StereoDownmix name_to_stereo_downmix(const char *name);
-
-#pragma region IUnknown
-    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppv) override;
-    ULONG STDMETHODCALLTYPE AddRef() override;
-    ULONG STDMETHODCALLTYPE Release() override;
-#pragma endregion
-
-#pragma region IAsio
-    AsioBool __thiscall init(void *sys_handle) override;
-    void __thiscall get_driver_name(char *name) override;
-    long __thiscall get_driver_version() override;
-    void __thiscall get_error_message(char *string) override;
-    AsioError __thiscall start() override;
-    AsioError __thiscall stop() override;
-    AsioError __thiscall get_channels(long *num_input_channels, long *num_output_channels) override;
-    AsioError __thiscall get_latencies(long *input_latency, long *output_latency) override;
-    AsioError __thiscall get_buffer_size(
-        long *min_size,
-        long *max_size,
-        long *preferred_size,
-        long *granularity) override;
-    AsioError __thiscall can_sample_rate(AsioSampleRate sample_rate) override;
-    AsioError __thiscall get_sample_rate(AsioSampleRate *sample_rate) override;
-    AsioError __thiscall set_sample_rate(AsioSampleRate sample_rate) override;
-    AsioError __thiscall get_clock_sources(ASIOClockSource *clocks, long *num_sources) override;
-    AsioError __thiscall set_clock_source(long reference) override;
-    AsioError __thiscall get_sample_position(ASIOSamples *s_pos, ASIOTimeStamp *t_stamp) override;
-    AsioError __thiscall get_channel_info(AsioChannelInfo *info) override;
-    AsioError __thiscall create_buffers(
-        AsioBufferInfo *buffer_infos,
-        long num_channels,
-        long buffer_size,
-        AsioCallbacks *callbacks) override;
-    AsioError __thiscall dispose_buffers() override;
-    AsioError __thiscall control_panel() override;
-    AsioError __thiscall future(long selector, void *opt) override;
-    AsioError __thiscall output_ready() override;
-#pragma endregion
-
-private:
-    // create_buffers implementation used when a stereo extraction is active: forwards only
-    // the channels the real device has and hands the game throwaway buffers for the rest
-    AsioError create_buffers_front_pair(
-        AsioBufferInfo *buffer_infos,
-        long num_channels,
-        long buffer_size,
-        AsioCallbacks *callbacks);
-
-    // if any post-processing effect (volume boost or stereo downmix) is active, saves the
-    // game's callbacks and returns a proxy callback set (our buffer-switch trampolines) to
-    // hand the real driver instead, so we can rework its output buffers after the game
-    // fills them. otherwise returns the game's callbacks unchanged. called at create_buffers
-    // time, before the stream starts
-    AsioCallbacks *install_proxy_callbacks(AsioCallbacks *game_callbacks);
-
-    // records a device output channel whose buffers we scale by the volume boost. queries
-    // the real driver for the channel's sample format. called at create_buffers time
-    void record_volume_output_channel(const AsioBufferInfo &info);
-
-    // the real device's output sample format, queried from its first output channel. all
-    // output channels of a device share one format, so this characterizes them all. returns
-    // ASIOSTLastEntry if the device has no output channels or the query fails
-    AsioSampleType device_output_sample_type();
-
-    // locates the destination pair (device channels 0/1) and the configured source channels
-    // in the game's buffer set so the realtime path can copy the selected pair onto 0/1.
-    // a no-op unless STEREO_DOWNMIX selects a non-front pair. called at create_buffers time
-    void record_downmix_channels(AsioBufferInfo *buffer_infos, long num_channels, long buffer_size);
-
-    // publishes the captured post-process state to the realtime thread once the buffers
-    // exist, making our trampolines start reworking output. called at the end of either
-    // create_buffers path
-    void publish_post_process(long buffer_size);
-
-    // detaches this instance from the realtime trampolines so they stop touching its
-    // buffers. called from dispose_buffers and the destructor
-    void detach_post_process();
-
-    // multiplies every recorded output channel's buffer for the given double-buffer index
-    // by the volume boost. runs on the driver's realtime thread from our buffer switch
-    void apply_output_volume(long double_buffer_index);
-
-    // copies the configured source channel pair onto device channels 0/1 for the given
-    // double-buffer index. runs on the driver's realtime thread from our buffer switch
-    void apply_downmix(long double_buffer_index);
-
-    // realtime-thread trampolines for the buffer-switch callbacks, handed to the real
-    // driver in place of the game's; ASIO callbacks carry no user data, so they reach the
-    // active wrapper through active_instance, call the game's original, then rework output.
-    // the other two callbacks (sample_rate_did_change, asio_message) are forwarded as the
-    // game's own pointers, so they need no trampoline
-    static void __cdecl proxy_buffer_switch(long double_buffer_index, AsioBool direct_process);
-    static AsioTime * __cdecl proxy_buffer_switch_time_info(
-        AsioTime *params, long double_buffer_index, AsioBool direct_process);
-
-    // the single wrapper whose proxy callbacks are installed (ASIO is single-instance with
-    // one running stream); read by the static trampolines to reach the right wrapper
-    static std::atomic<WrappedAsio *> active_instance;
-
-    IAsio *const pReal;
-    const CLSID clsid;
-
-    // registry name of the driver (not get_driver_name), used in our logs as a single
-    // unambiguous name; constant for our lifetime
-    std::string driver_name;
-
-    // our own reference count; we hold one reference on pReal and release it when this
-    // drops to zero
-    std::atomic<ULONG> ref_count {1};
-
-    // throwaway double buffers handed to the channels we discard when a stereo extraction
-    // is active (see create_buffers). owned for the lifetime of the buffer set and freed
-    // in dispose_buffers; only read by the game from its own bufferSwitch, never by us
-    std::vector<std::unique_ptr<uint8_t[]>> dummy_buffers;
-
-    // one device output channel scaled by the volume boost in our buffer switch
-    struct VolumeOutputChannel {
-        void *buffers[2];
-        AsioSampleType type;
-    };
-
-    // the game's original callbacks (captured when we install our proxy set) and the proxy
-    // set we hand the real driver; the realtime trampolines reach the game's buffer_switch
-    // through game_callbacks regardless of which effect is active
-    AsioCallbacks game_callbacks {};
-    AsioCallbacks proxy_callbacks {};
-
-    // volume boost state, captured at create_buffers time and published to the realtime
-    // thread via active_instance once fully built; untouched while the stream runs.
-    // volume_active gates whether the realtime path scales any buffers
-    bool volume_active = false;
-    float volume_gain = 1.0f;
-    long volume_buffer_size = 0;
-    std::vector<VolumeOutputChannel> volume_channels;
-
-    // one device channel (0 or 1) fed by a source channel during stereo downmix; both
-    // buffer pointers are indexed by the ASIO double-buffer index, the same as the channels
-    struct DownmixCopy {
-        void *dst[2];
-        void *src[2];
-    };
-
-    // stereo downmix state, captured at create_buffers time and published alongside the
-    // volume state; untouched while the stream runs. downmix_active gates whether the
-    // realtime path copies the selected source pair onto device channels 0/1. copies[0]
-    // feeds device channel 0, copies[1] feeds device channel 1
-    bool downmix_active = false;
-    DownmixCopy downmix_copies[2] {};
-    size_t downmix_bytes = 0;
-};
+#pragma once
+
+#include <atomic>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <windows.h>
+
+#include "external/asio/asio.h"
+#include "external/asio/iasiodrv.h"
+
+namespace hooks::audio::asio {
+
+    // returns true if a CoCreateInstance call is instantiating a registered ASIO driver.
+    // ASIO hosts pass the driver CLSID as both class id and interface id; we also validate
+    // it against the system's registered ASIO drivers to avoid false positives
+    bool is_asio_creation(REFCLSID rclsid, REFIID riid);
+
+    // wrap a real ASIO driver instance, taking ownership of the supplied reference, and
+    // return a proxy that forwards every call to it. also records it as the cached
+    // instance for its CLSID so later CoCreate calls can reuse it (see wrap_existing)
+    IUnknown *wrap(REFCLSID clsid, void *real);
+
+    // if a cached wrapper already exists for this CLSID, return it (with an added
+    // reference); otherwise nullptr to signal the caller to create the real driver and
+    // wrap it. lets the host reuse one driver instance instead of re-instantiating it
+    IUnknown *wrap_existing(REFCLSID clsid);
+
+    // drop the process-lifetime references taken by wrap() so cached drivers can be released
+    // at shutdown. only relinquishes our pin, so a real driver is torn down once the host
+    // has released its own references too. call from a controlled shutdown point, never from
+    // a static destructor (the driver DLL may already be unloaded)
+    void release_all_wrappers();
+}
+
+// transparent proxy around a real ASIO driver; a single place to intercept ASIO traffic
+struct WrappedAsio final : IAsio {
+    WrappedAsio(IAsio *real, REFCLSID clsid, std::string name)
+        : pReal(real), clsid(clsid), driver_name(std::move(name)) {
+    }
+
+    WrappedAsio(const WrappedAsio &) = delete;
+    WrappedAsio &operator=(const WrappedAsio &) = delete;
+
+    virtual ~WrappedAsio();
+
+    // selects which source channel pair of a multichannel ASIO output reaches the device's
+    // 2.0 front pair. when not None, the proxy presents the game's expected multichannel
+    // layout to the host so it proceeds to create_buffers, then opens only a two-channel
+    // stream on the real device and routes the selected pair onto it (see create_buffers).
+    // Front is the plain "force two channel" case (forward the device's own front pair);
+    // the others copy a different pair onto 0/1. assumes a standard 7.1 layout (0-indexed).
+    // set once at boot, before any wrapper exists, so it needs no synchronization
+    enum class StereoDownmix {
+        None,   // feature disabled - full multichannel passthrough
+        Front,  // channels 0/1 - the device front pair is forwarded as-is (no copy)
+        Center, // channel 2 duplicated to both 0 and 1
+        Rear,   // channels 4/5 -> 0/1
+        Side,   // channels 6/7 -> 0/1
+    };
+    static StereoDownmix STEREO_DOWNMIX;
+
+    // true when a stereo extraction is configured, i.e. the real device should open a 2.0
+    // stream and only the selected pair should reach it. the former standalone
+    // FORCE_TWO_CHANNELS flag is now just the Front case of this
+    static bool force_two_channels() {
+        return STEREO_DOWNMIX != StereoDownmix::None;
+    }
+
+    // some games hardcode a multichannel ASIO output and bail before create_buffers if
+    // get_channels reports fewer, so we report at least this many output channels when a
+    // stereo extraction is active
+    static constexpr long FORCED_OUTPUT_CHANNELS = 8;
+
+    // maps an option string ("front", "center", "rear", "side") to a StereoDownmix value,
+    // returning None for anything unrecognized
+    static StereoDownmix name_to_stereo_downmix(const char *name);
+
+#pragma region IUnknown
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppv) override;
+    ULONG STDMETHODCALLTYPE AddRef() override;
+    ULONG STDMETHODCALLTYPE Release() override;
+#pragma endregion
+
+#pragma region IAsio
+    AsioBool __thiscall init(void *sys_handle) override;
+    void __thiscall get_driver_name(char *name) override;
+    long __thiscall get_driver_version() override;
+    void __thiscall get_error_message(char *string) override;
+    AsioError __thiscall start() override;
+    AsioError __thiscall stop() override;
+    AsioError __thiscall get_channels(long *num_input_channels, long *num_output_channels) override;
+    AsioError __thiscall get_latencies(long *input_latency, long *output_latency) override;
+    AsioError __thiscall get_buffer_size(
+        long *min_size,
+        long *max_size,
+        long *preferred_size,
+        long *granularity) override;
+    AsioError __thiscall can_sample_rate(AsioSampleRate sample_rate) override;
+    AsioError __thiscall get_sample_rate(AsioSampleRate *sample_rate) override;
+    AsioError __thiscall set_sample_rate(AsioSampleRate sample_rate) override;
+    AsioError __thiscall get_clock_sources(ASIOClockSource *clocks, long *num_sources) override;
+    AsioError __thiscall set_clock_source(long reference) override;
+    AsioError __thiscall get_sample_position(ASIOSamples *s_pos, ASIOTimeStamp *t_stamp) override;
+    AsioError __thiscall get_channel_info(AsioChannelInfo *info) override;
+    AsioError __thiscall create_buffers(
+        AsioBufferInfo *buffer_infos,
+        long num_channels,
+        long buffer_size,
+        AsioCallbacks *callbacks) override;
+    AsioError __thiscall dispose_buffers() override;
+    AsioError __thiscall control_panel() override;
+    AsioError __thiscall future(long selector, void *opt) override;
+    AsioError __thiscall output_ready() override;
+#pragma endregion
+
+    // quiesces any leftover stream/buffer state before the cached wrapper is handed back
+    // for reuse, without destroying the real driver (see wrap_existing)
+    void quiesce_for_reuse();
+
+private:
+    // create_buffers implementation used when a stereo extraction is active: forwards only
+    // the channels the real device has and hands the game throwaway buffers for the rest
+    AsioError create_buffers_front_pair(
+        AsioBufferInfo *buffer_infos,
+        long num_channels,
+        long buffer_size,
+        AsioCallbacks *callbacks);
+
+    // if any post-processing effect (volume boost or stereo downmix) is active, saves the
+    // game's callbacks and returns a proxy callback set (our buffer-switch trampolines) to
+    // hand the real driver instead, so we can rework its output buffers after the game
+    // fills them. otherwise returns the game's callbacks unchanged. called at create_buffers
+    // time, before the stream starts
+    AsioCallbacks *install_proxy_callbacks(AsioCallbacks *game_callbacks);
+
+    // records a device output channel whose buffers we scale by the volume boost. queries
+    // the real driver for the channel's sample format. called at create_buffers time
+    void record_volume_output_channel(const AsioBufferInfo &info);
+
+    // the real device's output sample format, queried from its first output channel. all
+    // output channels of a device share one format, so this characterizes them all. returns
+    // ASIOSTLastEntry if the device has no output channels or the query fails
+    AsioSampleType device_output_sample_type();
+
+    // locates the destination pair (device channels 0/1) and the configured source channels
+    // in the game's buffer set so the realtime path can copy the selected pair onto 0/1.
+    // a no-op unless STEREO_DOWNMIX selects a non-front pair. called at create_buffers time
+    void record_downmix_channels(AsioBufferInfo *buffer_infos, long num_channels, long buffer_size);
+
+    // publishes the captured post-process state to the realtime thread once the buffers
+    // exist, making our trampolines start reworking output. called at the end of either
+    // create_buffers path
+    void publish_post_process(long buffer_size);
+
+    // detaches this instance from the realtime trampolines so they stop touching its
+    // buffers. called from dispose_buffers and the destructor
+    void detach_post_process();
+
+    // multiplies every recorded output channel's buffer for the given double-buffer index
+    // by the volume boost. runs on the driver's realtime thread from our buffer switch
+    void apply_output_volume(long double_buffer_index);
+
+    // copies the configured source channel pair onto device channels 0/1 for the given
+    // double-buffer index. runs on the driver's realtime thread from our buffer switch
+    void apply_downmix(long double_buffer_index);
+
+    // realtime-thread trampolines for the buffer-switch callbacks, handed to the real
+    // driver in place of the game's; ASIO callbacks carry no user data, so they reach the
+    // active wrapper through active_instance, call the game's original, then rework output.
+    // the other two callbacks (sample_rate_did_change, asio_message) are forwarded as the
+    // game's own pointers, so they need no trampoline
+    static void __cdecl proxy_buffer_switch(long double_buffer_index, AsioBool direct_process);
+    static AsioTime * __cdecl proxy_buffer_switch_time_info(
+        AsioTime *params, long double_buffer_index, AsioBool direct_process);
+
+    // the single wrapper whose proxy callbacks are installed (ASIO is single-instance with
+    // one running stream); read by the static trampolines to reach the right wrapper
+    static std::atomic<WrappedAsio *> active_instance;
+
+    IAsio *const pReal;
+    const CLSID clsid;
+
+    // registry name of the driver (not get_driver_name), used in our logs as a single
+    // unambiguous name; constant for our lifetime
+    std::string driver_name;
+
+    // the real driver is initialized exactly once; repeat init() calls are a no-op success
+    bool initialized = false;
+
+    // whether the real driver currently has a buffer set / running stream. used to quiesce
+    // leftover state when the cached wrapper is reused (see quiesce_for_reuse)
+    bool buffers_created = false;
+    bool started = false;
+
+    // our own reference count; we hold one reference on pReal and release it when this
+    // drops to zero
+    std::atomic<ULONG> ref_count {1};
+
+    // throwaway double buffers handed to the channels we discard when a stereo extraction
+    // is active (see create_buffers). owned for the lifetime of the buffer set and freed
+    // in dispose_buffers; only read by the game from its own bufferSwitch, never by us
+    std::vector<std::unique_ptr<uint8_t[]>> dummy_buffers;
+
+    // one device output channel scaled by the volume boost in our buffer switch
+    struct VolumeOutputChannel {
+        void *buffers[2];
+        AsioSampleType type;
+    };
+
+    // the game's original callbacks (captured when we install our proxy set) and the proxy
+    // set we hand the real driver; the realtime trampolines reach the game's buffer_switch
+    // through game_callbacks regardless of which effect is active
+    AsioCallbacks game_callbacks {};
+    AsioCallbacks proxy_callbacks {};
+
+    // volume boost state, captured at create_buffers time and published to the realtime
+    // thread via active_instance once fully built; untouched while the stream runs.
+    // volume_active gates whether the realtime path scales any buffers
+    bool volume_active = false;
+    float volume_gain = 1.0f;
+    long volume_buffer_size = 0;
+    std::vector<VolumeOutputChannel> volume_channels;
+
+    // one device channel (0 or 1) fed by a source channel during stereo downmix; both
+    // buffer pointers are indexed by the ASIO double-buffer index, the same as the channels
+    struct DownmixCopy {
+        void *dst[2];
+        void *src[2];
+    };
+
+    // stereo downmix state, captured at create_buffers time and published alongside the
+    // volume state; untouched while the stream runs. downmix_active gates whether the
+    // realtime path copies the selected source pair onto device channels 0/1. copies[0]
+    // feeds device channel 0, copies[1] feeds device channel 1
+    bool downmix_active = false;
+    DownmixCopy downmix_copies[2] {};
+    size_t downmix_bytes = 0;
+};

src/spice2x/hooks/audio/audio.cpp

@@ -7,6 +7,7 @@
 #include <audioclient.h>
 #include <mmdeviceapi.h>
 
+#include "avs/game.h"
 #include "hooks/audio/backends/mmdevice/device_enumerator.h"
 #include "util/detour.h"
 #include "util/logging.h"
@@ -15,6 +16,7 @@
 #include "audio_private.h"
 #include "acm.h"
 #include "asio_proxy.h"
+#include "xact.h"
 
 #ifdef _MSC_VER
 DEFINE_GUID(CLSID_MMDeviceEnumerator,
@@ -53,9 +55,39 @@ namespace hooks::audio {
     std::string ASIO_DRIVER_NAME = "";
     bool ASIO_FORCE_UNLOAD_ON_STOP = false;
 
-    // private globals
-    IAudioClient *CLIENT = nullptr;
     std::mutex INITIALIZE_LOCK; // for asio
+
+    IAudioClient *CLIENT = nullptr;
+    static std::mutex CLIENT_LOCK;
+    static bool CLIENT_STOPPING = false;
+
+    void set_active_client(IAudioClient *client, const char *source) {
+        IAudioClient *previous_client = nullptr;
+        {
+            std::lock_guard lock(CLIENT_LOCK);
+
+            if (CLIENT_STOPPING || CLIENT == client) {
+                return;
+            }
+            if (client) {
+                client->AddRef();
+            }
+
+            previous_client = CLIENT;
+            CLIENT = client;
+        }
+
+        if (previous_client) {
+            previous_client->Release();
+        }
+
+        if (client) {
+            log_info(
+                "audio",
+                "active client selected by {} after successful initialization",
+                source);
+        }
+    }
 }
 
 static HRESULT STDAPICALLTYPE CoCreateInstance_hook(
@@ -68,6 +100,15 @@ static HRESULT STDAPICALLTYPE CoCreateInstance_hook(
 
     HRESULT ret;
 
+    // ASIO: if we already hold a cached instance for this CLSID, hand back a fresh
+    // wrapper over it instead of re-creating the real driver (see asio_proxy.cpp)
+    if (ppv != nullptr && hooks::audio::asio::is_asio_creation(rclsid, riid)) {
+        if (IUnknown *reused = hooks::audio::asio::wrap_existing(rclsid)) {
+            *ppv = reused;
+            return S_OK;
+        }
+    }
+
     // call original
     ret = CoCreateInstance_orig(rclsid, pUnkOuter, dwClsContext, riid, ppv);
     if (FAILED(ret)) {
@@ -120,15 +161,28 @@ namespace hooks::audio {
 
         // general hooks
         CoCreateInstance_orig = detour::iat_try("CoCreateInstance", CoCreateInstance_hook);
+        if (avs::game::is_model("PAN")) {
+            hooks::audio::xact::init();
+        }
     }
 
     void stop() {
         log_info("audio", "stopping");
-        if (CLIENT) {
-            CLIENT->Stop();
-            CLIENT->Release();
+        IAudioClient *client = nullptr;
+        {
+            std::lock_guard lock(CLIENT_LOCK);
+            CLIENT_STOPPING = true;
+            client = CLIENT;
             CLIENT = nullptr;
         }
+        if (client) {
+            client->Stop();
+            client->Release();
+        }
         stop_low_latency();
+
+        // release the ASIO drivers we kept pinned for the process lifetime now that we are
+        // at a controlled shutdown point (see asio_proxy.cpp)
+        hooks::audio::asio::release_all_wrappers();
     }
 }

src/spice2x/hooks/audio/audio_private.h

@@ -14,4 +14,6 @@ namespace hooks::audio {
     extern std::mutex INITIALIZE_LOCK;
     extern bool VOLUME_HOOK_ENABLED;
     extern LowLatencyAudioClient *LOW_LATENCY_CLIENT;
+
+    void set_active_client(IAudioClient *client, const char *source);
 }

src/spice2x/hooks/audio/backends/mmdevice/audio_endpoint_volume.h

@@ -1,43 +1,43 @@
-#pragma once
-
-#include <stdint.h>
-#include <endpointvolume.h>
-
-struct WrappedIAudioEndpointVolume : IAudioEndpointVolume {
-    explicit WrappedIAudioEndpointVolume(IAudioEndpointVolume *orig) : pReal(orig) {}
-
-    WrappedIAudioEndpointVolume(const WrappedIAudioEndpointVolume &) = delete;
-    WrappedIAudioEndpointVolume &operator=(const WrappedIAudioEndpointVolume &) = delete;
-
-    virtual ~WrappedIAudioEndpointVolume() = default;
-
-#pragma region IUnknown
-    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObj) override;
-    ULONG STDMETHODCALLTYPE AddRef() override;
-    ULONG STDMETHODCALLTYPE Release() override;
-#pragma endregion
-
-#pragma region IAudioEndpointVolume
-    HRESULT STDMETHODCALLTYPE RegisterControlChangeNotify(IAudioEndpointVolumeCallback *pNotify) override;
-    HRESULT STDMETHODCALLTYPE UnregisterControlChangeNotify(IAudioEndpointVolumeCallback *pNotify) override;
-    HRESULT STDMETHODCALLTYPE GetChannelCount(uint32_t *pnChannelCount) override;
-    HRESULT STDMETHODCALLTYPE SetMasterVolumeLevel(float fLevelDB, LPCGUID pguidEventContext) override;
-    HRESULT STDMETHODCALLTYPE SetMasterVolumeLevelScalar(float fLevel, LPCGUID pguidEventContext) override;
-    HRESULT STDMETHODCALLTYPE GetMasterVolumeLevel(float *fLevelDB) override;
-    HRESULT STDMETHODCALLTYPE GetMasterVolumeLevelScalar(float *fLevel) override;
-    HRESULT STDMETHODCALLTYPE SetChannelVolumeLevel(uint32_t nChannel, float fLevelDB, LPCGUID pguidEventContext) override;
-    HRESULT STDMETHODCALLTYPE SetChannelVolumeLevelScalar(uint32_t nChannel, float fLevel, LPCGUID pguidEventContext) override;
-    HRESULT STDMETHODCALLTYPE GetChannelVolumeLevel(uint32_t nChannel, float *fLevelDB) override;
-    HRESULT STDMETHODCALLTYPE GetChannelVolumeLevelScalar(uint32_t nChannel, float *fLevel) override;
-    HRESULT STDMETHODCALLTYPE SetMute(WINBOOL bMute, LPCGUID pguidEventContext) override;
-    HRESULT STDMETHODCALLTYPE GetMute(WINBOOL *bMute) override;
-    HRESULT STDMETHODCALLTYPE GetVolumeStepInfo(uint32_t *pnStep, uint32_t *pnStepCount) override;
-    HRESULT STDMETHODCALLTYPE VolumeStepUp(LPCGUID pguidEventContext) override;
-    HRESULT STDMETHODCALLTYPE VolumeStepDown(LPCGUID pguidEventContext) override;
-    HRESULT STDMETHODCALLTYPE QueryHardwareSupport(DWORD *pdwHardwareSupportMask) override;
-    HRESULT STDMETHODCALLTYPE GetVolumeRange(float *pflVolumeMindB, float *pflVolumeMaxdB, float *pflVolumeIncrementdB) override;
-#pragma endregion
-
-private:
-    IAudioEndpointVolume *const pReal;
+#pragma once
+
+#include <stdint.h>
+#include <endpointvolume.h>
+
+struct WrappedIAudioEndpointVolume : IAudioEndpointVolume {
+    explicit WrappedIAudioEndpointVolume(IAudioEndpointVolume *orig) : pReal(orig) {}
+
+    WrappedIAudioEndpointVolume(const WrappedIAudioEndpointVolume &) = delete;
+    WrappedIAudioEndpointVolume &operator=(const WrappedIAudioEndpointVolume &) = delete;
+
+    virtual ~WrappedIAudioEndpointVolume() = default;
+
+#pragma region IUnknown
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObj) override;
+    ULONG STDMETHODCALLTYPE AddRef() override;
+    ULONG STDMETHODCALLTYPE Release() override;
+#pragma endregion
+
+#pragma region IAudioEndpointVolume
+    HRESULT STDMETHODCALLTYPE RegisterControlChangeNotify(IAudioEndpointVolumeCallback *pNotify) override;
+    HRESULT STDMETHODCALLTYPE UnregisterControlChangeNotify(IAudioEndpointVolumeCallback *pNotify) override;
+    HRESULT STDMETHODCALLTYPE GetChannelCount(uint32_t *pnChannelCount) override;
+    HRESULT STDMETHODCALLTYPE SetMasterVolumeLevel(float fLevelDB, LPCGUID pguidEventContext) override;
+    HRESULT STDMETHODCALLTYPE SetMasterVolumeLevelScalar(float fLevel, LPCGUID pguidEventContext) override;
+    HRESULT STDMETHODCALLTYPE GetMasterVolumeLevel(float *fLevelDB) override;
+    HRESULT STDMETHODCALLTYPE GetMasterVolumeLevelScalar(float *fLevel) override;
+    HRESULT STDMETHODCALLTYPE SetChannelVolumeLevel(uint32_t nChannel, float fLevelDB, LPCGUID pguidEventContext) override;
+    HRESULT STDMETHODCALLTYPE SetChannelVolumeLevelScalar(uint32_t nChannel, float fLevel, LPCGUID pguidEventContext) override;
+    HRESULT STDMETHODCALLTYPE GetChannelVolumeLevel(uint32_t nChannel, float *fLevelDB) override;
+    HRESULT STDMETHODCALLTYPE GetChannelVolumeLevelScalar(uint32_t nChannel, float *fLevel) override;
+    HRESULT STDMETHODCALLTYPE SetMute(WINBOOL bMute, LPCGUID pguidEventContext) override;
+    HRESULT STDMETHODCALLTYPE GetMute(WINBOOL *bMute) override;
+    HRESULT STDMETHODCALLTYPE GetVolumeStepInfo(uint32_t *pnStep, uint32_t *pnStepCount) override;
+    HRESULT STDMETHODCALLTYPE VolumeStepUp(LPCGUID pguidEventContext) override;
+    HRESULT STDMETHODCALLTYPE VolumeStepDown(LPCGUID pguidEventContext) override;
+    HRESULT STDMETHODCALLTYPE QueryHardwareSupport(DWORD *pdwHardwareSupportMask) override;
+    HRESULT STDMETHODCALLTYPE GetVolumeRange(float *pflVolumeMindB, float *pflVolumeMaxdB, float *pflVolumeIncrementdB) override;
+#pragma endregion
+
+private:
+    IAudioEndpointVolume *const pReal;
 };

src/spice2x/hooks/audio/backends/mmdevice/device.cpp

@@ -95,11 +95,6 @@ HRESULT STDMETHODCALLTYPE WrappedIMMDevice::Activate(
         }
         std::lock_guard initialize_guard(hooks::audio::INITIALIZE_LOCK, std::adopt_lock);
 
-        // release old audio client if initialized
-        if (hooks::audio::CLIENT) {
-            hooks::audio::CLIENT->Release();
-        }
-
         IAudioClient *client = nullptr;
         if (iid == IID_IAudioClient) {
             client = wrap_audio_client(reinterpret_cast<IAudioClient *>(*ppInterface));
@@ -107,9 +102,6 @@ HRESULT STDMETHODCALLTYPE WrappedIMMDevice::Activate(
             client = wrap_audio_client3(reinterpret_cast<IAudioClient3 *>(*ppInterface));
         }
         *ppInterface = client;
-        // persist the audio client
-        hooks::audio::CLIENT = client;
-        hooks::audio::CLIENT->AddRef();
 
     } else if (iid == __uuidof(IAudioEndpointVolume) && hooks::audio::VOLUME_HOOK_ENABLED) {
         *ppInterface = new WrappedIAudioEndpointVolume(reinterpret_cast<IAudioEndpointVolume *>(*ppInterface));

src/spice2x/hooks/audio/backends/mmdevice/null_device.cpp

@@ -1,195 +1,185 @@
-#include "null_device.h"
-
-#include <atomic>
-#include <cstring>
-
-#include <audioclient.h>
-
-#include "hooks/audio/audio.h"
-#include "hooks/audio/audio_private.h"
-#include "hooks/audio/backends/wasapi/dummy_audio_client.h"
-#include "util/logging.h"
-#include "util/utils.h"
-
-#include "null_discard_backend.h"
-
-// friendly name reported by the synthetic device. must contain "Realtek" so the
-// gitadora arena device search matches it.
-static const wchar_t NULL_DEVICE_FRIENDLY_NAME[] = L"Realtek High Definition Audio";
-
-// arbitrary identifier reported by the synthetic device.
-static const wchar_t NULL_DEVICE_ID[] = L"{spice2x-null-render-device}";
-
-// PKEY_Device_FriendlyName, hardcoded to avoid pulling in functiondiscoverykeys_devpkey.h
-static const PROPERTYKEY PKEY_DEVICE_FRIENDLY_NAME_LOCAL = {
-    { 0xa45c254e, 0xdf1c, 0x4efd, { 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0 } },
-    14
-};
-
-bool null_render_device_enabled() {
-    return hooks::audio::INJECT_FAKE_REALTEK_AUDIO;
-}
-
-// duplicate a wide string into CoTaskMem so the caller can free it with
-// CoTaskMemFree / PropVariantClear as the COM API contract requires.
-static LPWSTR co_task_wcsdup(const wchar_t *src) {
-    const size_t bytes = (wcslen(src) + 1) * sizeof(wchar_t);
-    auto *dst = static_cast<LPWSTR>(CoTaskMemAlloc(bytes));
-    if (dst != nullptr) {
-        memcpy(dst, src, bytes);
-    }
-    return dst;
-}
-
-namespace {
-
-    // minimal IPropertyStore that only answers PKEY_Device_FriendlyName.
-    struct NullPropertyStore : IPropertyStore {
-        std::atomic<ULONG> ref_cnt = 1;
-
-        virtual ~NullPropertyStore() = default;
-
-        HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObj) override {
-            if (ppvObj == nullptr) {
-                return E_POINTER;
-            }
-            if (riid == __uuidof(IUnknown) || riid == __uuidof(IPropertyStore)) {
-                this->AddRef();
-                *ppvObj = this;
-                return S_OK;
-            }
-            *ppvObj = nullptr;
-            return E_NOINTERFACE;
-        }
-        ULONG STDMETHODCALLTYPE AddRef() override {
-            return ++this->ref_cnt;
-        }
-        ULONG STDMETHODCALLTYPE Release() override {
-            const ULONG refs = --this->ref_cnt;
-            if (refs == 0) {
-                delete this;
-            }
-            return refs;
-        }
-        HRESULT STDMETHODCALLTYPE GetCount(DWORD *cProps) override {
-            if (cProps == nullptr) {
-                return E_POINTER;
-            }
-            *cProps = 1;
-            return S_OK;
-        }
-        HRESULT STDMETHODCALLTYPE GetAt(DWORD iProp, PROPERTYKEY *pkey) override {
-            if (pkey == nullptr) {
-                return E_POINTER;
-            }
-            if (iProp != 0) {
-                return E_INVALIDARG;
-            }
-            *pkey = PKEY_DEVICE_FRIENDLY_NAME_LOCAL;
-            return S_OK;
-        }
-        HRESULT STDMETHODCALLTYPE GetValue(REFPROPERTYKEY key, PROPVARIANT *pv) override {
-            if (pv == nullptr) {
-                return E_POINTER;
-            }
-            PropVariantInit(pv);
-            if (key.fmtid == PKEY_DEVICE_FRIENDLY_NAME_LOCAL.fmtid
-                    && key.pid == PKEY_DEVICE_FRIENDLY_NAME_LOCAL.pid) {
-                pv->pwszVal = co_task_wcsdup(NULL_DEVICE_FRIENDLY_NAME);
-                if (pv->pwszVal == nullptr) {
-                    return E_OUTOFMEMORY;
-                }
-                pv->vt = VT_LPWSTR;
-            }
-            // unknown keys are returned as VT_EMPTY / S_OK
-            return S_OK;
-        }
-        HRESULT STDMETHODCALLTYPE SetValue(REFPROPERTYKEY, REFPROPVARIANT) override {
-            return STG_E_ACCESSDENIED;
-        }
-        HRESULT STDMETHODCALLTYPE Commit() override {
-            return S_OK;
-        }
-    };
-}
-
-#pragma region IUnknown
-HRESULT STDMETHODCALLTYPE NullMMDevice::QueryInterface(REFIID riid, void **ppvObj) {
-    if (ppvObj == nullptr) {
-        return E_POINTER;
-    }
-    if (riid == __uuidof(IUnknown) || riid == __uuidof(IMMDevice)) {
-        this->AddRef();
-        *ppvObj = this;
-        return S_OK;
-    }
-    *ppvObj = nullptr;
-    return E_NOINTERFACE;
-}
-ULONG STDMETHODCALLTYPE NullMMDevice::AddRef() {
-    return ++this->ref_cnt;
-}
-ULONG STDMETHODCALLTYPE NullMMDevice::Release() {
-    const ULONG refs = --this->ref_cnt;
-    if (refs == 0) {
-        delete this;
-    }
-    return refs;
-}
-#pragma endregion
-
-#pragma region IMMDevice
-HRESULT STDMETHODCALLTYPE NullMMDevice::Activate(
-    REFIID iid,
-    DWORD,
-    PROPVARIANT *,
-    void **ppInterface)
-{
-    if (ppInterface == nullptr) {
-        return E_POINTER;
-    }
-    *ppInterface = nullptr;
-
-    log_info("audio::null", "NullMMDevice::Activate {}", guid2s(iid));
-
-    if (iid == IID_IAudioClient) {
-
-        // release any previously persisted client
-        if (hooks::audio::CLIENT != nullptr) {
-            hooks::audio::CLIENT->Release();
-        }
-
-        auto *client = static_cast<IAudioClient *>(new DummyIAudioClient(new NullDiscardBackend()));
-        *ppInterface = client;
-
-        // persist the audio client
-        hooks::audio::CLIENT = client;
-        hooks::audio::CLIENT->AddRef();
-
-        return S_OK;
-    }
-
-    return E_NOINTERFACE;
-}
-HRESULT STDMETHODCALLTYPE NullMMDevice::OpenPropertyStore(DWORD, IPropertyStore **ppProperties) {
-    if (ppProperties == nullptr) {
-        return E_POINTER;
-    }
-    *ppProperties = new NullPropertyStore();
-    return S_OK;
-}
-HRESULT STDMETHODCALLTYPE NullMMDevice::GetId(LPWSTR *ppstrId) {
-    if (ppstrId == nullptr) {
-        return E_POINTER;
-    }
-    *ppstrId = co_task_wcsdup(NULL_DEVICE_ID);
-    return *ppstrId != nullptr ? S_OK : E_OUTOFMEMORY;
-}
-HRESULT STDMETHODCALLTYPE NullMMDevice::GetState(DWORD *pdwState) {
-    if (pdwState == nullptr) {
-        return E_POINTER;
-    }
-    *pdwState = DEVICE_STATE_ACTIVE;
-    return S_OK;
-}
-#pragma endregion
+#include "null_device.h"
+
+#include <atomic>
+#include <cstring>
+
+#include <audioclient.h>
+
+#include "hooks/audio/audio.h"
+#include "hooks/audio/audio_private.h"
+#include "hooks/audio/backends/wasapi/dummy_audio_client.h"
+#include "util/logging.h"
+#include "util/utils.h"
+
+#include "null_discard_backend.h"
+
+// friendly name reported by the synthetic device. must contain "Realtek" so the
+// gitadora arena device search matches it.
+static const wchar_t NULL_DEVICE_FRIENDLY_NAME[] = L"Realtek High Definition Audio";
+
+// arbitrary identifier reported by the synthetic device.
+static const wchar_t NULL_DEVICE_ID[] = L"{spice2x-null-render-device}";
+
+// PKEY_Device_FriendlyName, hardcoded to avoid pulling in functiondiscoverykeys_devpkey.h
+static const PROPERTYKEY PKEY_DEVICE_FRIENDLY_NAME_LOCAL = {
+    { 0xa45c254e, 0xdf1c, 0x4efd, { 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0 } },
+    14
+};
+
+bool null_render_device_enabled() {
+    return hooks::audio::INJECT_FAKE_REALTEK_AUDIO;
+}
+
+// duplicate a wide string into CoTaskMem so the caller can free it with
+// CoTaskMemFree / PropVariantClear as the COM API contract requires.
+static LPWSTR co_task_wcsdup(const wchar_t *src) {
+    const size_t bytes = (wcslen(src) + 1) * sizeof(wchar_t);
+    auto *dst = static_cast<LPWSTR>(CoTaskMemAlloc(bytes));
+    if (dst != nullptr) {
+        memcpy(dst, src, bytes);
+    }
+    return dst;
+}
+
+namespace {
+
+    // minimal IPropertyStore that only answers PKEY_Device_FriendlyName.
+    struct NullPropertyStore : IPropertyStore {
+        std::atomic<ULONG> ref_cnt = 1;
+
+        virtual ~NullPropertyStore() = default;
+
+        HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObj) override {
+            if (ppvObj == nullptr) {
+                return E_POINTER;
+            }
+            if (riid == __uuidof(IUnknown) || riid == __uuidof(IPropertyStore)) {
+                this->AddRef();
+                *ppvObj = this;
+                return S_OK;
+            }
+            *ppvObj = nullptr;
+            return E_NOINTERFACE;
+        }
+        ULONG STDMETHODCALLTYPE AddRef() override {
+            return ++this->ref_cnt;
+        }
+        ULONG STDMETHODCALLTYPE Release() override {
+            const ULONG refs = --this->ref_cnt;
+            if (refs == 0) {
+                delete this;
+            }
+            return refs;
+        }
+        HRESULT STDMETHODCALLTYPE GetCount(DWORD *cProps) override {
+            if (cProps == nullptr) {
+                return E_POINTER;
+            }
+            *cProps = 1;
+            return S_OK;
+        }
+        HRESULT STDMETHODCALLTYPE GetAt(DWORD iProp, PROPERTYKEY *pkey) override {
+            if (pkey == nullptr) {
+                return E_POINTER;
+            }
+            if (iProp != 0) {
+                return E_INVALIDARG;
+            }
+            *pkey = PKEY_DEVICE_FRIENDLY_NAME_LOCAL;
+            return S_OK;
+        }
+        HRESULT STDMETHODCALLTYPE GetValue(REFPROPERTYKEY key, PROPVARIANT *pv) override {
+            if (pv == nullptr) {
+                return E_POINTER;
+            }
+            PropVariantInit(pv);
+            if (key.fmtid == PKEY_DEVICE_FRIENDLY_NAME_LOCAL.fmtid
+                    && key.pid == PKEY_DEVICE_FRIENDLY_NAME_LOCAL.pid) {
+                pv->pwszVal = co_task_wcsdup(NULL_DEVICE_FRIENDLY_NAME);
+                if (pv->pwszVal == nullptr) {
+                    return E_OUTOFMEMORY;
+                }
+                pv->vt = VT_LPWSTR;
+            }
+            // unknown keys are returned as VT_EMPTY / S_OK
+            return S_OK;
+        }
+        HRESULT STDMETHODCALLTYPE SetValue(REFPROPERTYKEY, REFPROPVARIANT) override {
+            return STG_E_ACCESSDENIED;
+        }
+        HRESULT STDMETHODCALLTYPE Commit() override {
+            return S_OK;
+        }
+    };
+}
+
+#pragma region IUnknown
+HRESULT STDMETHODCALLTYPE NullMMDevice::QueryInterface(REFIID riid, void **ppvObj) {
+    if (ppvObj == nullptr) {
+        return E_POINTER;
+    }
+    if (riid == __uuidof(IUnknown) || riid == __uuidof(IMMDevice)) {
+        this->AddRef();
+        *ppvObj = this;
+        return S_OK;
+    }
+    *ppvObj = nullptr;
+    return E_NOINTERFACE;
+}
+ULONG STDMETHODCALLTYPE NullMMDevice::AddRef() {
+    return ++this->ref_cnt;
+}
+ULONG STDMETHODCALLTYPE NullMMDevice::Release() {
+    const ULONG refs = --this->ref_cnt;
+    if (refs == 0) {
+        delete this;
+    }
+    return refs;
+}
+#pragma endregion
+
+#pragma region IMMDevice
+HRESULT STDMETHODCALLTYPE NullMMDevice::Activate(
+    REFIID iid,
+    DWORD,
+    PROPVARIANT *,
+    void **ppInterface)
+{
+    if (ppInterface == nullptr) {
+        return E_POINTER;
+    }
+    *ppInterface = nullptr;
+
+    log_info("audio::null", "NullMMDevice::Activate {}", guid2s(iid));
+
+    if (iid == IID_IAudioClient) {
+        auto *client = static_cast<IAudioClient *>(new DummyIAudioClient(new NullDiscardBackend()));
+        *ppInterface = client;
+
+        return S_OK;
+    }
+
+    return E_NOINTERFACE;
+}
+HRESULT STDMETHODCALLTYPE NullMMDevice::OpenPropertyStore(DWORD, IPropertyStore **ppProperties) {
+    if (ppProperties == nullptr) {
+        return E_POINTER;
+    }
+    *ppProperties = new NullPropertyStore();
+    return S_OK;
+}
+HRESULT STDMETHODCALLTYPE NullMMDevice::GetId(LPWSTR *ppstrId) {
+    if (ppstrId == nullptr) {
+        return E_POINTER;
+    }
+    *ppstrId = co_task_wcsdup(NULL_DEVICE_ID);
+    return *ppstrId != nullptr ? S_OK : E_OUTOFMEMORY;
+}
+HRESULT STDMETHODCALLTYPE NullMMDevice::GetState(DWORD *pdwState) {
+    if (pdwState == nullptr) {
+        return E_POINTER;
+    }
+    *pdwState = DEVICE_STATE_ACTIVE;
+    return S_OK;
+}
+#pragma endregion

src/spice2x/hooks/audio/backends/mmdevice/null_device.h

@@ -1,39 +1,39 @@
-#pragma once
-
-#include <atomic>
-
-#include <mmdeviceapi.h>
-
-// returns true when a synthetic render endpoint should be injected into device
-// enumeration. games like gitadora arena search the render endpoint list for a
-// device whose friendly name contains "Realtek" and crash with a null pointer
-// dereference when no match exists. presenting a fake match that routes to the
-// null audio backend lets the search succeed while discarding the audio.
-bool null_render_device_enabled();
-
-// fake IMMDevice that reports a "Realtek" friendly name and activates straight
-// into the null audio backend, never touching real hardware.
-struct NullMMDevice : IMMDevice {
-    NullMMDevice() = default;
-
-    NullMMDevice(const NullMMDevice &) = delete;
-    NullMMDevice &operator=(const NullMMDevice &) = delete;
-
-    virtual ~NullMMDevice() = default;
-
-#pragma region IUnknown
-    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObj) override;
-    ULONG STDMETHODCALLTYPE AddRef() override;
-    ULONG STDMETHODCALLTYPE Release() override;
-#pragma endregion
-
-#pragma region IMMDevice
-    HRESULT STDMETHODCALLTYPE Activate(REFIID iid, DWORD dwClsCtx, PROPVARIANT *pActivationParams, void **ppInterface) override;
-    HRESULT STDMETHODCALLTYPE OpenPropertyStore(DWORD stgmAccess, IPropertyStore **ppProperties) override;
-    HRESULT STDMETHODCALLTYPE GetId(LPWSTR *ppstrId) override;
-    HRESULT STDMETHODCALLTYPE GetState(DWORD *pdwState) override;
-#pragma endregion
-
-private:
-    std::atomic<ULONG> ref_cnt = 1;
-};
+#pragma once
+
+#include <atomic>
+
+#include <mmdeviceapi.h>
+
+// returns true when a synthetic render endpoint should be injected into device
+// enumeration. games like gitadora arena search the render endpoint list for a
+// device whose friendly name contains "Realtek" and crash with a null pointer
+// dereference when no match exists. presenting a fake match that routes to the
+// null audio backend lets the search succeed while discarding the audio.
+bool null_render_device_enabled();
+
+// fake IMMDevice that reports a "Realtek" friendly name and activates straight
+// into the null audio backend, never touching real hardware.
+struct NullMMDevice : IMMDevice {
+    NullMMDevice() = default;
+
+    NullMMDevice(const NullMMDevice &) = delete;
+    NullMMDevice &operator=(const NullMMDevice &) = delete;
+
+    virtual ~NullMMDevice() = default;
+
+#pragma region IUnknown
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObj) override;
+    ULONG STDMETHODCALLTYPE AddRef() override;
+    ULONG STDMETHODCALLTYPE Release() override;
+#pragma endregion
+
+#pragma region IMMDevice
+    HRESULT STDMETHODCALLTYPE Activate(REFIID iid, DWORD dwClsCtx, PROPVARIANT *pActivationParams, void **ppInterface) override;
+    HRESULT STDMETHODCALLTYPE OpenPropertyStore(DWORD stgmAccess, IPropertyStore **ppProperties) override;
+    HRESULT STDMETHODCALLTYPE GetId(LPWSTR *ppstrId) override;
+    HRESULT STDMETHODCALLTYPE GetState(DWORD *pdwState) override;
+#pragma endregion
+
+private:
+    std::atomic<ULONG> ref_cnt = 1;
+};

src/spice2x/hooks/audio/backends/mmdevice/null_discard_backend.cpp

@@ -1,141 +1,139 @@
-#include "null_discard_backend.h"
-
-#include <algorithm>
-#include <chrono>
-
-#include "hooks/audio/util.h"
-#include "util/logging.h"
-#include "util/precise_timer.h"
-
-NullDiscardBackend::~NullDiscardBackend() {
-    this->running = false;
-    if (this->pacing_thread.joinable()) {
-        this->pacing_thread.join();
-    }
-}
-
-const WAVEFORMATEXTENSIBLE &NullDiscardBackend::format() const noexcept {
-    return this->format_;
-}
-
-HRESULT NullDiscardBackend::on_initialize(
-    AUDCLNT_SHAREMODE *,
-    DWORD *,
-    REFERENCE_TIME *hnsBufferDuration,
-    REFERENCE_TIME *,
-    const WAVEFORMATEX *pFormat,
-    LPCGUID)
-{
-    copy_wave_format(&this->format_, pFormat);
-
-    // honor the game's requested buffer duration, falling back to 10 ms
-    constexpr REFERENCE_TIME DEFAULT_REFTIME = 100000; // 10 ms in 100-ns units
-    this->period_reftime = (hnsBufferDuration && *hnsBufferDuration > 0)
-            ? *hnsBufferDuration
-            : DEFAULT_REFTIME;
-
-    this->buffer_frames = std::max<uint32_t>(1, static_cast<uint32_t>(
-            static_cast<double>(this->format_.Format.nSamplesPerSec)
-                    * this->period_reftime / 10000000.0 + 0.5));
-
-    log_info("audio::null", "initializing null render device with {} channels, {} Hz, {}-bit",
-             this->format_.Format.nChannels,
-             this->format_.Format.nSamplesPerSec,
-             this->format_.Format.wBitsPerSample);
-
-    return S_OK;
-}
-
-HRESULT NullDiscardBackend::on_get_buffer_size(uint32_t *buffer_frames) {
-    *buffer_frames = this->buffer_frames;
-    return S_OK;
-}
-
-HRESULT NullDiscardBackend::on_get_stream_latency(REFERENCE_TIME *latency) {
-    *latency = this->period_reftime;
-    return S_OK;
-}
-
-HRESULT NullDiscardBackend::on_get_current_padding(std::optional<uint32_t> &padding_frames) {
-    // discarded immediately, so the buffer always reads as fully drained
-    padding_frames = 0;
-    return S_OK;
-}
-
-HRESULT NullDiscardBackend::on_is_format_supported(
-    AUDCLNT_SHAREMODE *,
-    const WAVEFORMATEX *,
-    WAVEFORMATEX **ppClosestMatch)
-{
-    if (ppClosestMatch) {
-        *ppClosestMatch = nullptr;
-    }
-    return S_OK;
-}
-
-HRESULT NullDiscardBackend::on_get_mix_format(WAVEFORMATEX **) {
-    return E_NOTIMPL;
-}
-
-HRESULT NullDiscardBackend::on_get_device_period(
-    REFERENCE_TIME *default_device_period,
-    REFERENCE_TIME *minimum_device_period)
-{
-    if (default_device_period) {
-        *default_device_period = this->period_reftime;
-    }
-    if (minimum_device_period) {
-        *minimum_device_period = this->period_reftime;
-    }
-    return S_OK;
-}
-
-HRESULT NullDiscardBackend::on_start() {
-    if (!this->running.exchange(true)) {
-        this->pacing_thread = std::thread(&NullDiscardBackend::pace_loop, this);
-    }
-    return S_OK;
-}
-
-HRESULT NullDiscardBackend::on_stop() {
-    return S_OK;
-}
-
-HRESULT NullDiscardBackend::on_set_event_handle(HANDLE *event_handle) {
-    // keep the game's event so pace_loop() can wake it; there is no real device behind it
-    this->relay_handle = *event_handle;
-    return S_OK;
-}
-
-HRESULT NullDiscardBackend::on_get_buffer(uint32_t num_frames_requested, BYTE **ppData) {
-    const size_t buffer_size =
-            static_cast<size_t>(this->format_.Format.nBlockAlign) * num_frames_requested;
-    if (this->scratch.size() < buffer_size) {
-        this->scratch.resize(buffer_size);
-    }
-    *ppData = this->scratch.data();
-    return S_OK;
-}
-
-HRESULT NullDiscardBackend::on_release_buffer(uint32_t, DWORD) {
-    // discard the audio entirely
-    return S_OK;
-}
-
-void NullDiscardBackend::pace_loop() {
-    using namespace std::chrono;
-
-    timeutils::PreciseSleepTimer timer;
-
-    // audio is discarded, so timing precision and drift do not matter; just wake the
-    // game once per buffer period to keep its render thread from blocking on the event.
-    const auto period = duration_cast<steady_clock::duration>(
-            duration<double>(this->period_reftime / 10000000.0));
-
-    while (this->running.load()) {
-        if (this->relay_handle) {
-            SetEvent(this->relay_handle);
-        }
-        timer.sleep(period);
-    }
-}
+#include "null_discard_backend.h"
+
+#include <algorithm>
+#include <chrono>
+#include <thread>
+
+#include "hooks/audio/util.h"
+#include "util/logging.h"
+
+NullDiscardBackend::~NullDiscardBackend() {
+    this->running = false;
+    if (this->pacing_thread.joinable()) {
+        this->pacing_thread.join();
+    }
+}
+
+const WAVEFORMATEXTENSIBLE &NullDiscardBackend::format() const noexcept {
+    return this->format_;
+}
+
+HRESULT NullDiscardBackend::on_initialize(
+    AUDCLNT_SHAREMODE *,
+    DWORD *,
+    REFERENCE_TIME *hnsBufferDuration,
+    REFERENCE_TIME *,
+    const WAVEFORMATEX *pFormat,
+    LPCGUID)
+{
+    copy_wave_format(&this->format_, pFormat);
+
+    // honor the game's requested buffer duration, falling back to 10 ms
+    constexpr REFERENCE_TIME DEFAULT_REFTIME = 100000; // 10 ms in 100-ns units
+    this->period_reftime = (hnsBufferDuration && *hnsBufferDuration > 0)
+            ? *hnsBufferDuration
+            : DEFAULT_REFTIME;
+
+    this->buffer_frames = std::max<uint32_t>(1, static_cast<uint32_t>(
+            static_cast<double>(this->format_.Format.nSamplesPerSec)
+                    * this->period_reftime / 10000000.0 + 0.5));
+
+    log_info("audio::null", "initializing null render device with {} channels, {} Hz, {}-bit",
+             this->format_.Format.nChannels,
+             this->format_.Format.nSamplesPerSec,
+             this->format_.Format.wBitsPerSample);
+
+    return S_OK;
+}
+
+HRESULT NullDiscardBackend::on_get_buffer_size(uint32_t *buffer_frames) {
+    *buffer_frames = this->buffer_frames;
+    return S_OK;
+}
+
+HRESULT NullDiscardBackend::on_get_stream_latency(REFERENCE_TIME *latency) {
+    *latency = this->period_reftime;
+    return S_OK;
+}
+
+HRESULT NullDiscardBackend::on_get_current_padding(std::optional<uint32_t> &padding_frames) {
+    // discarded immediately, so the buffer always reads as fully drained
+    padding_frames = 0;
+    return S_OK;
+}
+
+HRESULT NullDiscardBackend::on_is_format_supported(
+    AUDCLNT_SHAREMODE *,
+    const WAVEFORMATEX *,
+    WAVEFORMATEX **ppClosestMatch)
+{
+    if (ppClosestMatch) {
+        *ppClosestMatch = nullptr;
+    }
+    return S_OK;
+}
+
+HRESULT NullDiscardBackend::on_get_mix_format(WAVEFORMATEX **) {
+    return E_NOTIMPL;
+}
+
+HRESULT NullDiscardBackend::on_get_device_period(
+    REFERENCE_TIME *default_device_period,
+    REFERENCE_TIME *minimum_device_period)
+{
+    if (default_device_period) {
+        *default_device_period = this->period_reftime;
+    }
+    if (minimum_device_period) {
+        *minimum_device_period = this->period_reftime;
+    }
+    return S_OK;
+}
+
+HRESULT NullDiscardBackend::on_start() {
+    if (!this->running.exchange(true)) {
+        this->pacing_thread = std::thread(&NullDiscardBackend::pace_loop, this);
+    }
+    return S_OK;
+}
+
+HRESULT NullDiscardBackend::on_stop() {
+    return S_OK;
+}
+
+HRESULT NullDiscardBackend::on_set_event_handle(HANDLE *event_handle) {
+    // keep the game's event so pace_loop() can wake it; there is no real device behind it
+    this->relay_handle = *event_handle;
+    return S_OK;
+}
+
+HRESULT NullDiscardBackend::on_get_buffer(uint32_t num_frames_requested, BYTE **ppData) {
+    const size_t buffer_size =
+            static_cast<size_t>(this->format_.Format.nBlockAlign) * num_frames_requested;
+    if (this->scratch.size() < buffer_size) {
+        this->scratch.resize(buffer_size);
+    }
+    *ppData = this->scratch.data();
+    return S_OK;
+}
+
+HRESULT NullDiscardBackend::on_release_buffer(uint32_t, DWORD) {
+    // discard the audio entirely
+    return S_OK;
+}
+
+void NullDiscardBackend::pace_loop() {
+    using namespace std::chrono;
+
+    // audio is discarded, so timing precision and drift do not matter; just wake the
+    // game once per buffer period to keep its render thread from blocking on the event.
+    const auto period = duration_cast<steady_clock::duration>(
+            duration<double>(this->period_reftime / 10000000.0));
+
+    while (this->running.load()) {
+        if (this->relay_handle) {
+            SetEvent(this->relay_handle);
+        }
+        std::this_thread::sleep_for(period);
+    }
+}

src/spice2x/hooks/audio/backends/mmdevice/null_discard_backend.h

@@ -1,54 +1,54 @@
-#pragma once
-
-#include <atomic>
-#include <optional>
-#include <thread>
-#include <vector>
-
-#include <audioclient.h>
-
-#include "hooks/audio/implementations/backend.h"
-
-// discards all audio while pacing the game's event handle once per buffer period, so the game
-// keeps running normally with nothing output to any real device. routed through the shared
-// DummyIAudioClient, the same plumbing the asio backend uses.
-struct NullDiscardBackend final : AudioBackend {
-    ~NullDiscardBackend() final;
-
-    const WAVEFORMATEXTENSIBLE &format() const noexcept override;
-
-    HRESULT on_initialize(
-        AUDCLNT_SHAREMODE *,
-        DWORD *,
-        REFERENCE_TIME *hnsBufferDuration,
-        REFERENCE_TIME *,
-        const WAVEFORMATEX *pFormat,
-        LPCGUID) override;
-    HRESULT on_get_buffer_size(uint32_t *buffer_frames) override;
-    HRESULT on_get_stream_latency(REFERENCE_TIME *latency) override;
-    HRESULT on_get_current_padding(std::optional<uint32_t> &padding_frames) override;
-    HRESULT on_is_format_supported(
-        AUDCLNT_SHAREMODE *,
-        const WAVEFORMATEX *,
-        WAVEFORMATEX **ppClosestMatch) override;
-    HRESULT on_get_mix_format(WAVEFORMATEX **) override;
-    HRESULT on_get_device_period(
-        REFERENCE_TIME *default_device_period,
-        REFERENCE_TIME *minimum_device_period) override;
-    HRESULT on_start() override;
-    HRESULT on_stop() override;
-    HRESULT on_set_event_handle(HANDLE *event_handle) override;
-    HRESULT on_get_buffer(uint32_t num_frames_requested, BYTE **ppData) override;
-    HRESULT on_release_buffer(uint32_t, DWORD) override;
-
-private:
-    void pace_loop();
-
-    WAVEFORMATEXTENSIBLE format_ {};
-    uint32_t buffer_frames = 0;
-    REFERENCE_TIME period_reftime = 0;
-    HANDLE relay_handle = nullptr;
-    std::vector<BYTE> scratch;
-    std::thread pacing_thread;
-    std::atomic<bool> running = false;
-};
+#pragma once
+
+#include <atomic>
+#include <optional>
+#include <thread>
+#include <vector>
+
+#include <audioclient.h>
+
+#include "hooks/audio/implementations/backend.h"
+
+// discards all audio while pacing the game's event handle once per buffer period, so the game
+// keeps running normally with nothing output to any real device. routed through the shared
+// DummyIAudioClient, the same plumbing the asio backend uses.
+struct NullDiscardBackend final : AudioBackend {
+    ~NullDiscardBackend() final;
+
+    const WAVEFORMATEXTENSIBLE &format() const noexcept override;
+
+    HRESULT on_initialize(
+        AUDCLNT_SHAREMODE *,
+        DWORD *,
+        REFERENCE_TIME *hnsBufferDuration,
+        REFERENCE_TIME *,
+        const WAVEFORMATEX *pFormat,
+        LPCGUID) override;
+    HRESULT on_get_buffer_size(uint32_t *buffer_frames) override;
+    HRESULT on_get_stream_latency(REFERENCE_TIME *latency) override;
+    HRESULT on_get_current_padding(std::optional<uint32_t> &padding_frames) override;
+    HRESULT on_is_format_supported(
+        AUDCLNT_SHAREMODE *,
+        const WAVEFORMATEX *,
+        WAVEFORMATEX **ppClosestMatch) override;
+    HRESULT on_get_mix_format(WAVEFORMATEX **) override;
+    HRESULT on_get_device_period(
+        REFERENCE_TIME *default_device_period,
+        REFERENCE_TIME *minimum_device_period) override;
+    HRESULT on_start() override;
+    HRESULT on_stop() override;
+    HRESULT on_set_event_handle(HANDLE *event_handle) override;
+    HRESULT on_get_buffer(uint32_t num_frames_requested, BYTE **ppData) override;
+    HRESULT on_release_buffer(uint32_t, DWORD) override;
+
+private:
+    void pace_loop();
+
+    WAVEFORMATEXTENSIBLE format_ {};
+    uint32_t buffer_frames = 0;
+    REFERENCE_TIME period_reftime = 0;
+    HANDLE relay_handle = nullptr;
+    std::vector<BYTE> scratch;
+    std::thread pacing_thread;
+    std::atomic<bool> running = false;
+};

src/spice2x/hooks/audio/backends/wasapi/audio_client.cpp

@@ -302,6 +302,7 @@ HRESULT STDMETHODCALLTYPE WrappedIAudioClient::Initialize(
                 device_format->nChannels * (device_format->wBitsPerSample / 8));
     }
 
+    hooks::audio::set_active_client(this, "WrappedIAudioClient::Initialize");
     return ret;
 }
 HRESULT STDMETHODCALLTYPE WrappedIAudioClient::GetBufferSize(UINT32 *pNumBufferFrames) {
@@ -651,5 +652,6 @@ HRESULT STDMETHODCALLTYPE WrappedIAudioClient::InitializeSharedAudioStream(
     log_info("audio::wasapi", "IAudioClient3::InitializeSharedAudioStream success, hr={}", FMT_HRESULT(ret));
     copy_wave_format(&hooks::audio::FORMAT, pFormat);
     copy_wave_format(&this->device_format, pFormat);
+    hooks::audio::set_active_client(this, "WrappedIAudioClient::InitializeSharedAudioStream");
     return ret;
 }

src/spice2x/hooks/audio/backends/wasapi/downmix.cpp

@@ -1,264 +1,264 @@
-#include "downmix.h"
-
-#include <algorithm>
-#include <cmath>
-#include <cstdint>
-#include <cstring>
-
-#include <audioclient.h>
-#include <ks.h>
-#include <ksmedia.h>
-
-#include "util/logging.h"
-
-#include "util.h"
-
-namespace hooks::audio {
-
-    namespace {
-
-        constexpr float ATT_3DB = 0.70710678f;
-
-        // speakers routed to the left/right output; anything else (center) feeds both sides
-        constexpr DWORD LEFT_SPEAKERS = SPEAKER_FRONT_LEFT | SPEAKER_BACK_LEFT | SPEAKER_SIDE_LEFT
-            | SPEAKER_FRONT_LEFT_OF_CENTER | SPEAKER_TOP_FRONT_LEFT | SPEAKER_TOP_BACK_LEFT;
-        constexpr DWORD RIGHT_SPEAKERS = SPEAKER_FRONT_RIGHT | SPEAKER_BACK_RIGHT | SPEAKER_SIDE_RIGHT
-            | SPEAKER_FRONT_RIGHT_OF_CENTER | SPEAKER_TOP_FRONT_RIGHT | SPEAKER_TOP_BACK_RIGHT;
-
-        // the speaker mask is only present on WAVE_FORMAT_EXTENSIBLE formats
-        DWORD read_channel_mask(const WAVEFORMATEX *fmt) {
-            if (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE
-                    && fmt->cbSize >= sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)) {
-                return reinterpret_cast<const WAVEFORMATEXTENSIBLE *>(fmt)->dwChannelMask;
-            }
-            return 0;
-        }
-
-        // call visit(channel_index, speaker_bit) for each present speaker, in channel order
-        template <typename F>
-        void for_each_speaker(DWORD mask, int channels, F &&visit) {
-            int channel = 0;
-            for (int bit = 0; bit < 18 && channel < channels; bit++) {
-                const DWORD speaker = 1u << bit;
-                if (mask & speaker) {
-                    visit(channel++, speaker);
-                }
-            }
-        }
-    }
-
-    void Downmix::setup(const WAVEFORMATEX *game_format, WAVEFORMATEXTENSIBLE *stereo_out,
-            DownmixAlgorithm algorithm) {
-        this->enabled = true;
-        this->algorithm = algorithm;
-        this->bytes_per_sample = game_format->wBitsPerSample / 8;
-        this->game_frame_size = game_format->nChannels * this->bytes_per_sample;
-
-        this->is_float = is_ieee_float(game_format);
-
-        // supported: 16/24/32-bit integer PCM and 32-bit float; anything else mixes to silence
-        const bool supported = this->is_float
-            ? this->bytes_per_sample == 4
-            : (this->bytes_per_sample >= 2 && this->bytes_per_sample <= 4);
-        if (!supported) {
-            log_fatal(
-                "audio::downmix",
-                "unsupported sample format ({}-bit {}), downmix will output silence",
-                game_format->wBitsPerSample, this->is_float ? "float" : "int");
-        }
-
-        this->left_mix.clear();
-        this->right_mix.clear();
-        this->build_layout_mix(game_format);
-
-        make_stereo_format(game_format, stereo_out);
-    }
-
-    void Downmix::make_stereo_format(const WAVEFORMATEX *game_format,
-            WAVEFORMATEXTENSIBLE *stereo_out) {
-        const int bytes_per_sample = game_format->wBitsPerSample / 8;
-
-        memcpy(stereo_out, game_format, sizeof(WAVEFORMATEXTENSIBLE));
-        stereo_out->Format.nChannels = 2;
-        stereo_out->Format.nBlockAlign = 2 * bytes_per_sample;
-        stereo_out->Format.nAvgBytesPerSec =
-            game_format->nSamplesPerSec * stereo_out->Format.nBlockAlign;
-        stereo_out->dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
-    }
-
-    HRESULT Downmix::initialize(IAudioClient *real, AUDCLNT_SHAREMODE share_mode, DWORD stream_flags,
-            REFERENCE_TIME buffer_duration, REFERENCE_TIME periodicity,
-            const WAVEFORMATEX *device_format, LPCGUID session_guid) {
-
-        // the smaller stereo buffer can end up unaligned for the device when the game sized the
-        // duration for its larger multi-channel format; the helper recovers from that.
-        return initialize_with_alignment_retry(real, "audio::downmix", share_mode, stream_flags,
-                buffer_duration, periodicity, device_format, session_guid);
-    }
-
-    void Downmix::add_channel(int channel, DWORD speaker, float gain) {
-        if (speaker & LEFT_SPEAKERS) {
-            this->left_mix.push_back({ channel, gain });
-        } else if (speaker & RIGHT_SPEAKERS) {
-            this->right_mix.push_back({ channel, gain });
-        } else { // center: feed both sides
-            this->left_mix.push_back({ channel, gain });
-            this->right_mix.push_back({ channel, gain });
-        }
-    }
-
-    // AC-4 stereo downmix (ETSI TS 103 190-1): front pair at unity, everything else -3 dB, LFE dropped
-    void Downmix::build_ac4_mix(DWORD mask, int channels) {
-        for_each_speaker(mask, channels, [&](int ch, DWORD speaker) {
-            if (speaker == SPEAKER_LOW_FREQUENCY) {
-                return;
-            }
-            const bool front_pair = speaker & (SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT);
-            this->add_channel(ch, speaker, front_pair ? 1.0f : ATT_3DB);
-        });
-    }
-
-    // keep only the channels in `keep` (front/rear/side), each at unity gain
-    void Downmix::build_extract_mix(DWORD mask, int channels, DWORD keep) {
-        for_each_speaker(mask, channels, [&](int ch, DWORD speaker) {
-            if (speaker & keep) {
-                this->add_channel(ch, speaker, 1.0f);
-            }
-        });
-    }
-
-    // keep every channel (LFE dropped), then average each side so its gains sum to unity
-    void Downmix::build_normalize_mix(DWORD mask, int channels) {
-        for_each_speaker(mask, channels, [&](int ch, DWORD speaker) {
-            if (speaker != SPEAKER_LOW_FREQUENCY) {
-                this->add_channel(ch, speaker, 1.0f);
-            }
-        });
-
-        for (auto *mix : { &this->left_mix, &this->right_mix }) {
-            if (!mix->empty()) {
-                const float gain = 1.0f / mix->size();
-                for (auto &c : *mix) {
-                    c.gain = gain;
-                }
-            }
-        }
-    }
-
-    // fallback when no speaker mask is present: fold interleaved L/R pairs (even->left, odd->right)
-    void Downmix::build_pairs_mix(int channels, float gain) {
-        for (int ch = 0; ch < channels; ch++) {
-            (((ch & 1) == 0) ? this->left_mix : this->right_mix).push_back({ ch, gain });
-        }
-    }
-
-    void Downmix::build_layout_mix(const WAVEFORMATEX *game_format) {
-        const int channels = game_format->nChannels;
-        const DWORD mask = read_channel_mask(game_format);
-
-        // without a mask the layout is unknown: extract/normalize have nothing to act on, so all
-        // algorithms fall back to folding L/R pairs (AC-4 still attenuates by -3 dB)
-        if (mask == 0) {
-            this->build_pairs_mix(channels,
-                this->algorithm == DownmixAlgorithm::AC4 ? ATT_3DB : 1.0f);
-            return;
-        }
-
-        switch (this->algorithm) {
-            case DownmixAlgorithm::FrontOnly:
-                this->build_extract_mix(mask, channels,
-                    SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT);
-                break;
-            case DownmixAlgorithm::RearOnly:
-                this->build_extract_mix(mask, channels,
-                    SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_BACK_CENTER);
-                break;
-            case DownmixAlgorithm::SideOnly:
-                this->build_extract_mix(mask, channels,
-                    SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT);
-                break;
-            case DownmixAlgorithm::Normalize:
-                this->build_normalize_mix(mask, channels);
-                break;
-            case DownmixAlgorithm::AC4:
-                this->build_ac4_mix(mask, channels);
-                break;
-        }
-    }
-
-    void Downmix::process(BYTE *dst, const BYTE *src, UINT32 frames) const {
-        const int bps = this->bytes_per_sample;
-        const int src_stride = this->game_frame_size;
-        const int dst_stride = 2 * bps;
-
-        if (dst == nullptr || src == nullptr || bps <= 0) {
-            return;
-        }
-
-        // sum each speaker's source channels into the matching stereo output
-        for (UINT32 i = 0; i < frames; i++) {
-            const BYTE *in = src + (size_t) i * src_stride;
-            BYTE *out = dst + (size_t) i * dst_stride;
-
-            float left = 0.0f;
-            float right = 0.0f;
-            for (const auto &c : this->left_mix) {
-                left += read_sample(in + c.channel * bps, bps, this->is_float) * c.gain;
-            }
-            for (const auto &c : this->right_mix) {
-                right += read_sample(in + c.channel * bps, bps, this->is_float) * c.gain;
-            }
-            write_sample(out, bps, this->is_float, left);
-            write_sample(out + bps, bps, this->is_float, right);
-        }
-    }
-
-    HRESULT Downmix::get_buffer(IAudioRenderClient *real, UINT32 frames, BYTE **ppData) {
-        const size_t needed = (size_t) frames * this->game_frame_size;
-        if (this->scratch.size() < needed) {
-            this->scratch.resize(needed);
-        }
-
-        HRESULT ret = real->GetBuffer(frames, &this->device_buffer);
-        if (FAILED(ret)) {
-            this->device_buffer = nullptr;
-            return ret;
-        }
-
-        *ppData = this->scratch.data();
-
-        return S_OK;
-    }
-
-    HRESULT Downmix::get_scratch(UINT32 frames, BYTE **ppData) {
-        const size_t needed = (size_t) frames * this->game_frame_size;
-        if (this->scratch.size() < needed) {
-            this->scratch.resize(needed);
-        }
-
-        *ppData = this->scratch.data();
-
-        return S_OK;
-    }
-
-    void Downmix::downmix_into(BYTE *dst, UINT32 frames) const {
-        this->process(dst, this->scratch.data(), frames);
-    }
-
-    void Downmix::write_device_buffer(UINT32 frames, DWORD flags) {
-        const int bps = this->bytes_per_sample;
-        const int dst_stride = 2 * bps;
-
-        if (this->device_buffer == nullptr || frames == 0 || bps <= 0) {
-            return;
-        }
-
-        // mute the first few buffers to avoid a pop on stream start
-        if (this->buffers_to_mute > 0) {
-            memset(this->device_buffer, 0, (size_t) frames * dst_stride);
-            this->buffers_to_mute--;
-        } else if ((flags & AUDCLNT_BUFFERFLAGS_SILENT) == 0) {
-            this->process(this->device_buffer, this->scratch.data(), frames);
-        }
-    }
-}
+#include "downmix.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+
+#include <audioclient.h>
+#include <ks.h>
+#include <ksmedia.h>
+
+#include "util/logging.h"
+
+#include "util.h"
+
+namespace hooks::audio {
+
+    namespace {
+
+        constexpr float ATT_3DB = 0.70710678f;
+
+        // speakers routed to the left/right output; anything else (center) feeds both sides
+        constexpr DWORD LEFT_SPEAKERS = SPEAKER_FRONT_LEFT | SPEAKER_BACK_LEFT | SPEAKER_SIDE_LEFT
+            | SPEAKER_FRONT_LEFT_OF_CENTER | SPEAKER_TOP_FRONT_LEFT | SPEAKER_TOP_BACK_LEFT;
+        constexpr DWORD RIGHT_SPEAKERS = SPEAKER_FRONT_RIGHT | SPEAKER_BACK_RIGHT | SPEAKER_SIDE_RIGHT
+            | SPEAKER_FRONT_RIGHT_OF_CENTER | SPEAKER_TOP_FRONT_RIGHT | SPEAKER_TOP_BACK_RIGHT;
+
+        // the speaker mask is only present on WAVE_FORMAT_EXTENSIBLE formats
+        DWORD read_channel_mask(const WAVEFORMATEX *fmt) {
+            if (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE
+                    && fmt->cbSize >= sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)) {
+                return reinterpret_cast<const WAVEFORMATEXTENSIBLE *>(fmt)->dwChannelMask;
+            }
+            return 0;
+        }
+
+        // call visit(channel_index, speaker_bit) for each present speaker, in channel order
+        template <typename F>
+        void for_each_speaker(DWORD mask, int channels, F &&visit) {
+            int channel = 0;
+            for (int bit = 0; bit < 18 && channel < channels; bit++) {
+                const DWORD speaker = 1u << bit;
+                if (mask & speaker) {
+                    visit(channel++, speaker);
+                }
+            }
+        }
+    }
+
+    void Downmix::setup(const WAVEFORMATEX *game_format, WAVEFORMATEXTENSIBLE *stereo_out,
+            DownmixAlgorithm algorithm) {
+        this->enabled = true;
+        this->algorithm = algorithm;
+        this->bytes_per_sample = game_format->wBitsPerSample / 8;
+        this->game_frame_size = game_format->nChannels * this->bytes_per_sample;
+
+        this->is_float = is_ieee_float(game_format);
+
+        // supported: 16/24/32-bit integer PCM and 32-bit float; anything else mixes to silence
+        const bool supported = this->is_float
+            ? this->bytes_per_sample == 4
+            : (this->bytes_per_sample >= 2 && this->bytes_per_sample <= 4);
+        if (!supported) {
+            log_fatal(
+                "audio::downmix",
+                "unsupported sample format ({}-bit {}), downmix will output silence",
+                game_format->wBitsPerSample, this->is_float ? "float" : "int");
+        }
+
+        this->left_mix.clear();
+        this->right_mix.clear();
+        this->build_layout_mix(game_format);
+
+        make_stereo_format(game_format, stereo_out);
+    }
+
+    void Downmix::make_stereo_format(const WAVEFORMATEX *game_format,
+            WAVEFORMATEXTENSIBLE *stereo_out) {
+        const int bytes_per_sample = game_format->wBitsPerSample / 8;
+
+        memcpy(stereo_out, game_format, sizeof(WAVEFORMATEXTENSIBLE));
+        stereo_out->Format.nChannels = 2;
+        stereo_out->Format.nBlockAlign = 2 * bytes_per_sample;
+        stereo_out->Format.nAvgBytesPerSec =
+            game_format->nSamplesPerSec * stereo_out->Format.nBlockAlign;
+        stereo_out->dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
+    }
+
+    HRESULT Downmix::initialize(IAudioClient *real, AUDCLNT_SHAREMODE share_mode, DWORD stream_flags,
+            REFERENCE_TIME buffer_duration, REFERENCE_TIME periodicity,
+            const WAVEFORMATEX *device_format, LPCGUID session_guid) {
+
+        // the smaller stereo buffer can end up unaligned for the device when the game sized the
+        // duration for its larger multi-channel format; the helper recovers from that.
+        return initialize_with_alignment_retry(real, "audio::downmix", share_mode, stream_flags,
+                buffer_duration, periodicity, device_format, session_guid);
+    }
+
+    void Downmix::add_channel(int channel, DWORD speaker, float gain) {
+        if (speaker & LEFT_SPEAKERS) {
+            this->left_mix.push_back({ channel, gain });
+        } else if (speaker & RIGHT_SPEAKERS) {
+            this->right_mix.push_back({ channel, gain });
+        } else { // center: feed both sides
+            this->left_mix.push_back({ channel, gain });
+            this->right_mix.push_back({ channel, gain });
+        }
+    }
+
+    // AC-4 stereo downmix (ETSI TS 103 190-1): front pair at unity, everything else -3 dB, LFE dropped
+    void Downmix::build_ac4_mix(DWORD mask, int channels) {
+        for_each_speaker(mask, channels, [&](int ch, DWORD speaker) {
+            if (speaker == SPEAKER_LOW_FREQUENCY) {
+                return;
+            }
+            const bool front_pair = speaker & (SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT);
+            this->add_channel(ch, speaker, front_pair ? 1.0f : ATT_3DB);
+        });
+    }
+
+    // keep only the channels in `keep` (front/rear/side), each at unity gain
+    void Downmix::build_extract_mix(DWORD mask, int channels, DWORD keep) {
+        for_each_speaker(mask, channels, [&](int ch, DWORD speaker) {
+            if (speaker & keep) {
+                this->add_channel(ch, speaker, 1.0f);
+            }
+        });
+    }
+
+    // keep every channel (LFE dropped), then average each side so its gains sum to unity
+    void Downmix::build_normalize_mix(DWORD mask, int channels) {
+        for_each_speaker(mask, channels, [&](int ch, DWORD speaker) {
+            if (speaker != SPEAKER_LOW_FREQUENCY) {
+                this->add_channel(ch, speaker, 1.0f);
+            }
+        });
+
+        for (auto *mix : { &this->left_mix, &this->right_mix }) {
+            if (!mix->empty()) {
+                const float gain = 1.0f / mix->size();
+                for (auto &c : *mix) {
+                    c.gain = gain;
+                }
+            }
+        }
+    }
+
+    // fallback when no speaker mask is present: fold interleaved L/R pairs (even->left, odd->right)
+    void Downmix::build_pairs_mix(int channels, float gain) {
+        for (int ch = 0; ch < channels; ch++) {
+            (((ch & 1) == 0) ? this->left_mix : this->right_mix).push_back({ ch, gain });
+        }
+    }
+
+    void Downmix::build_layout_mix(const WAVEFORMATEX *game_format) {
+        const int channels = game_format->nChannels;
+        const DWORD mask = read_channel_mask(game_format);
+
+        // without a mask the layout is unknown: extract/normalize have nothing to act on, so all
+        // algorithms fall back to folding L/R pairs (AC-4 still attenuates by -3 dB)
+        if (mask == 0) {
+            this->build_pairs_mix(channels,
+                this->algorithm == DownmixAlgorithm::AC4 ? ATT_3DB : 1.0f);
+            return;
+        }
+
+        switch (this->algorithm) {
+            case DownmixAlgorithm::FrontOnly:
+                this->build_extract_mix(mask, channels,
+                    SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT);
+                break;
+            case DownmixAlgorithm::RearOnly:
+                this->build_extract_mix(mask, channels,
+                    SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_BACK_CENTER);
+                break;
+            case DownmixAlgorithm::SideOnly:
+                this->build_extract_mix(mask, channels,
+                    SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT);
+                break;
+            case DownmixAlgorithm::Normalize:
+                this->build_normalize_mix(mask, channels);
+                break;
+            case DownmixAlgorithm::AC4:
+                this->build_ac4_mix(mask, channels);
+                break;
+        }
+    }
+
+    void Downmix::process(BYTE *dst, const BYTE *src, UINT32 frames) const {
+        const int bps = this->bytes_per_sample;
+        const int src_stride = this->game_frame_size;
+        const int dst_stride = 2 * bps;
+
+        if (dst == nullptr || src == nullptr || bps <= 0) {
+            return;
+        }
+
+        // sum each speaker's source channels into the matching stereo output
+        for (UINT32 i = 0; i < frames; i++) {
+            const BYTE *in = src + (size_t) i * src_stride;
+            BYTE *out = dst + (size_t) i * dst_stride;
+
+            float left = 0.0f;
+            float right = 0.0f;
+            for (const auto &c : this->left_mix) {
+                left += read_sample(in + c.channel * bps, bps, this->is_float) * c.gain;
+            }
+            for (const auto &c : this->right_mix) {
+                right += read_sample(in + c.channel * bps, bps, this->is_float) * c.gain;
+            }
+            write_sample(out, bps, this->is_float, left);
+            write_sample(out + bps, bps, this->is_float, right);
+        }
+    }
+
+    HRESULT Downmix::get_buffer(IAudioRenderClient *real, UINT32 frames, BYTE **ppData) {
+        const size_t needed = (size_t) frames * this->game_frame_size;
+        if (this->scratch.size() < needed) {
+            this->scratch.resize(needed);
+        }
+
+        HRESULT ret = real->GetBuffer(frames, &this->device_buffer);
+        if (FAILED(ret)) {
+            this->device_buffer = nullptr;
+            return ret;
+        }
+
+        *ppData = this->scratch.data();
+
+        return S_OK;
+    }
+
+    HRESULT Downmix::get_scratch(UINT32 frames, BYTE **ppData) {
+        const size_t needed = (size_t) frames * this->game_frame_size;
+        if (this->scratch.size() < needed) {
+            this->scratch.resize(needed);
+        }
+
+        *ppData = this->scratch.data();
+
+        return S_OK;
+    }
+
+    void Downmix::downmix_into(BYTE *dst, UINT32 frames) const {
+        this->process(dst, this->scratch.data(), frames);
+    }
+
+    void Downmix::write_device_buffer(UINT32 frames, DWORD flags) {
+        const int bps = this->bytes_per_sample;
+        const int dst_stride = 2 * bps;
+
+        if (this->device_buffer == nullptr || frames == 0 || bps <= 0) {
+            return;
+        }
+
+        // mute the first few buffers to avoid a pop on stream start
+        if (this->buffers_to_mute > 0) {
+            memset(this->device_buffer, 0, (size_t) frames * dst_stride);
+            this->buffers_to_mute--;
+        } else if ((flags & AUDCLNT_BUFFERFLAGS_SILENT) == 0) {
+            this->process(this->device_buffer, this->scratch.data(), frames);
+        }
+    }
+}

src/spice2x/hooks/audio/backends/wasapi/downmix.h

@@ -1,150 +1,150 @@
-#pragma once
-
-#include <optional>
-#include <vector>
-
-#include <windows.h>
-#include <mmreg.h>
-#include <audioclient.h>
-
-#include "hooks/audio/audio.h"
-
-struct IAudioClient;
-struct IAudioRenderClient;
-
-namespace hooks::audio {
-
-    // Generic WASAPI surround-to-stereo downmix. The real device is opened in stereo while the
-    // game keeps writing its native multi-channel audio into a scratch buffer; on release that
-    // buffer is mixed down into the two front channels.
-    //
-    // The mix is derived from the source format's speaker mask according to the selected
-    // DownmixAlgorithm:
-    //   FrontOnly / RearOnly / SideOnly - keep only that group of channels, routed to their side
-    //   AC4       - AC-4 stereo downmix coefficients (ETSI TS 103 190-1 §6.2.17): front left/right
-    //               pass at 0 dB, center and surrounds fold in at -3 dB, LFE dropped
-    //   Normalize - every channel folded in (center to both sides) with each output side averaged
-    //               so its channels are equally loud, LFE dropped
-    struct Downmix {
-
-        // a source channel routed into one output speaker at the given gain
-        struct Contribution {
-            int channel;
-            float gain;
-        };
-
-        // map an option value (front/rear/side/ac4/normalize) to its algorithm.
-        static std::optional<DownmixAlgorithm> name_to_algorithm(const char *value) {
-            if (_stricmp(value, "front") == 0) {
-                return DownmixAlgorithm::FrontOnly;
-            } else if (_stricmp(value, "rear") == 0) {
-                return DownmixAlgorithm::RearOnly;
-            } else if (_stricmp(value, "side") == 0) {
-                return DownmixAlgorithm::SideOnly;
-            } else if (_stricmp(value, "ac4") == 0) {
-                return DownmixAlgorithm::AC4;
-            } else if (_stricmp(value, "normalize") == 0) {
-                return DownmixAlgorithm::Normalize;
-            }
-
-            return std::nullopt;
-        }
-
-        // human-readable name of an algorithm, for logging.
-        static const char *algorithm_name(DownmixAlgorithm algorithm) {
-            switch (algorithm) {
-                case DownmixAlgorithm::FrontOnly: return "front";
-                case DownmixAlgorithm::RearOnly: return "rear";
-                case DownmixAlgorithm::SideOnly: return "side";
-                case DownmixAlgorithm::AC4: return "ac4";
-                case DownmixAlgorithm::Normalize: return "normalize";
-                default: return "unknown";
-            }
-        }
-
-        // whether the downmix is active for the current stream
-        bool enabled = false;
-
-        // algorithm used to fold the multi-channel audio into stereo
-        DownmixAlgorithm algorithm = DownmixAlgorithm::AC4;
-
-        // size in bytes of one frame of the game's multi-channel format
-        int game_frame_size = 0;
-
-        // size in bytes of a single sample (per channel)
-        int bytes_per_sample = 0;
-
-        // whether samples are IEEE floating point rather than integer PCM
-        bool is_float = false;
-
-        // enable the downmix for the given game format and fill stereo_out with the equivalent
-        // stereo format to open the real device with.
-        void setup(const WAVEFORMATEX *game_format, WAVEFORMATEXTENSIBLE *stereo_out,
-                   DownmixAlgorithm algorithm);
-
-        // build the stereo format equivalent to game_format (same sample rate and bit depth).
-        static void make_stereo_format(const WAVEFORMATEX *game_format,
-                                       WAVEFORMATEXTENSIBLE *stereo_out);
-
-        // initialize the real device with the stereo format. downmixing reduces the channel count,
-        // shrinking the buffer's byte size, so the duration the game sized for its multi-channel
-        // format can leave the smaller stereo buffer unaligned. on AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED
-        // this performs the standard WASAPI realignment and retries.
-        HRESULT initialize(IAudioClient *real, AUDCLNT_SHAREMODE share_mode, DWORD stream_flags,
-                           REFERENCE_TIME buffer_duration, REFERENCE_TIME periodicity,
-                           const WAVEFORMATEX *device_format, LPCGUID session_guid);
-
-        // mix `frames` frames of multi-channel `src` down into stereo `dst`.
-        void process(BYTE *dst, const BYTE *src, UINT32 frames) const;
-
-        // grab the real stereo device buffer and hand the game the scratch buffer to write into.
-        HRESULT get_buffer(IAudioRenderClient *real, UINT32 frames, BYTE **ppData);
-
-        // size the scratch and hand it to the game without acquiring a device buffer. used when a
-        // later stage (the resampler) owns the device interaction.
-        HRESULT get_scratch(UINT32 frames, BYTE **ppData);
-
-        // downmix the scratch the game wrote into the caller's stereo buffer, without touching the
-        // device. used to feed the resampler when the two stages are chained.
-        void downmix_into(BYTE *dst, UINT32 frames) const;
-
-        // mix the scratch buffer into the stereo device buffer held since get_buffer. the caller
-        // owns releasing the device buffer afterwards (see current_buffer / buffer_released).
-        void write_device_buffer(UINT32 frames, DWORD flags);
-
-        // the real device buffer currently held, or null.
-        BYTE *current_buffer() const { return this->device_buffer; }
-
-        // forget the held device buffer once the caller has released it.
-        void buffer_released() { this->device_buffer = nullptr; }
-
-    private:
-
-        // build the mix from the source speaker layout for the selected algorithm
-        void build_layout_mix(const WAVEFORMATEX *game_format);
-
-        // per-algorithm builders, each filling left_mix / right_mix from the speaker mask
-        void build_ac4_mix(DWORD mask, int channels);
-        void build_extract_mix(DWORD mask, int channels, DWORD keep);
-        void build_normalize_mix(DWORD mask, int channels);
-
-        // fallback for streams without a speaker mask: fold interleaved L/R pairs at `gain`
-        void build_pairs_mix(int channels, float gain);
-
-        // append one source channel to the output side(s) matching its speaker, at `gain`
-        void add_channel(int channel, DWORD speaker, float gain);
-
-        // source channels summed into each output speaker
-        std::vector<Contribution> left_mix;
-        std::vector<Contribution> right_mix;
-
-        // buffer the game writes its multi-channel audio into between get/release
-        std::vector<BYTE> scratch;
-
-        // the real stereo device buffer currently held, or null
-        BYTE *device_buffer = nullptr;
-
-        // leading buffers to silence to avoid a pop on stream start
-        int buffers_to_mute = 16;
-    };
-}
+#pragma once
+
+#include <optional>
+#include <vector>
+
+#include <windows.h>
+#include <mmreg.h>
+#include <audioclient.h>
+
+#include "hooks/audio/audio.h"
+
+struct IAudioClient;
+struct IAudioRenderClient;
+
+namespace hooks::audio {
+
+    // Generic WASAPI surround-to-stereo downmix. The real device is opened in stereo while the
+    // game keeps writing its native multi-channel audio into a scratch buffer; on release that
+    // buffer is mixed down into the two front channels.
+    //
+    // The mix is derived from the source format's speaker mask according to the selected
+    // DownmixAlgorithm:
+    //   FrontOnly / RearOnly / SideOnly - keep only that group of channels, routed to their side
+    //   AC4       - AC-4 stereo downmix coefficients (ETSI TS 103 190-1 §6.2.17): front left/right
+    //               pass at 0 dB, center and surrounds fold in at -3 dB, LFE dropped
+    //   Normalize - every channel folded in (center to both sides) with each output side averaged
+    //               so its channels are equally loud, LFE dropped
+    struct Downmix {
+
+        // a source channel routed into one output speaker at the given gain
+        struct Contribution {
+            int channel;
+            float gain;
+        };
+
+        // map an option value (front/rear/side/ac4/normalize) to its algorithm.
+        static std::optional<DownmixAlgorithm> name_to_algorithm(const char *value) {
+            if (_stricmp(value, "front") == 0) {
+                return DownmixAlgorithm::FrontOnly;
+            } else if (_stricmp(value, "rear") == 0) {
+                return DownmixAlgorithm::RearOnly;
+            } else if (_stricmp(value, "side") == 0) {
+                return DownmixAlgorithm::SideOnly;
+            } else if (_stricmp(value, "ac4") == 0) {
+                return DownmixAlgorithm::AC4;
+            } else if (_stricmp(value, "normalize") == 0) {
+                return DownmixAlgorithm::Normalize;
+            }
+
+            return std::nullopt;
+        }
+
+        // human-readable name of an algorithm, for logging.
+        static const char *algorithm_name(DownmixAlgorithm algorithm) {
+            switch (algorithm) {
+                case DownmixAlgorithm::FrontOnly: return "front";
+                case DownmixAlgorithm::RearOnly: return "rear";
+                case DownmixAlgorithm::SideOnly: return "side";
+                case DownmixAlgorithm::AC4: return "ac4";
+                case DownmixAlgorithm::Normalize: return "normalize";
+                default: return "unknown";
+            }
+        }
+
+        // whether the downmix is active for the current stream
+        bool enabled = false;
+
+        // algorithm used to fold the multi-channel audio into stereo
+        DownmixAlgorithm algorithm = DownmixAlgorithm::AC4;
+
+        // size in bytes of one frame of the game's multi-channel format
+        int game_frame_size = 0;
+
+        // size in bytes of a single sample (per channel)
+        int bytes_per_sample = 0;
+
+        // whether samples are IEEE floating point rather than integer PCM
+        bool is_float = false;
+
+        // enable the downmix for the given game format and fill stereo_out with the equivalent
+        // stereo format to open the real device with.
+        void setup(const WAVEFORMATEX *game_format, WAVEFORMATEXTENSIBLE *stereo_out,
+                   DownmixAlgorithm algorithm);
+
+        // build the stereo format equivalent to game_format (same sample rate and bit depth).
+        static void make_stereo_format(const WAVEFORMATEX *game_format,
+                                       WAVEFORMATEXTENSIBLE *stereo_out);
+
+        // initialize the real device with the stereo format. downmixing reduces the channel count,
+        // shrinking the buffer's byte size, so the duration the game sized for its multi-channel
+        // format can leave the smaller stereo buffer unaligned. on AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED
+        // this performs the standard WASAPI realignment and retries.
+        HRESULT initialize(IAudioClient *real, AUDCLNT_SHAREMODE share_mode, DWORD stream_flags,
+                           REFERENCE_TIME buffer_duration, REFERENCE_TIME periodicity,
+                           const WAVEFORMATEX *device_format, LPCGUID session_guid);
+
+        // mix `frames` frames of multi-channel `src` down into stereo `dst`.
+        void process(BYTE *dst, const BYTE *src, UINT32 frames) const;
+
+        // grab the real stereo device buffer and hand the game the scratch buffer to write into.
+        HRESULT get_buffer(IAudioRenderClient *real, UINT32 frames, BYTE **ppData);
+
+        // size the scratch and hand it to the game without acquiring a device buffer. used when a
+        // later stage (the resampler) owns the device interaction.
+        HRESULT get_scratch(UINT32 frames, BYTE **ppData);
+
+        // downmix the scratch the game wrote into the caller's stereo buffer, without touching the
+        // device. used to feed the resampler when the two stages are chained.
+        void downmix_into(BYTE *dst, UINT32 frames) const;
+
+        // mix the scratch buffer into the stereo device buffer held since get_buffer. the caller
+        // owns releasing the device buffer afterwards (see current_buffer / buffer_released).
+        void write_device_buffer(UINT32 frames, DWORD flags);
+
+        // the real device buffer currently held, or null.
+        BYTE *current_buffer() const { return this->device_buffer; }
+
+        // forget the held device buffer once the caller has released it.
+        void buffer_released() { this->device_buffer = nullptr; }
+
+    private:
+
+        // build the mix from the source speaker layout for the selected algorithm
+        void build_layout_mix(const WAVEFORMATEX *game_format);
+
+        // per-algorithm builders, each filling left_mix / right_mix from the speaker mask
+        void build_ac4_mix(DWORD mask, int channels);
+        void build_extract_mix(DWORD mask, int channels, DWORD keep);
+        void build_normalize_mix(DWORD mask, int channels);
+
+        // fallback for streams without a speaker mask: fold interleaved L/R pairs at `gain`
+        void build_pairs_mix(int channels, float gain);
+
+        // append one source channel to the output side(s) matching its speaker, at `gain`
+        void add_channel(int channel, DWORD speaker, float gain);
+
+        // source channels summed into each output speaker
+        std::vector<Contribution> left_mix;
+        std::vector<Contribution> right_mix;
+
+        // buffer the game writes its multi-channel audio into between get/release
+        std::vector<BYTE> scratch;
+
+        // the real stereo device buffer currently held, or null
+        BYTE *device_buffer = nullptr;
+
+        // leading buffers to silence to avoid a pop on stream start
+        int buffers_to_mute = 16;
+    };
+}

src/spice2x/hooks/audio/backends/wasapi/dummy_audio_client.cpp

@@ -75,13 +75,17 @@ HRESULT STDMETHODCALLTYPE DummyIAudioClient::Initialize(
     log_info("audio::wasapi", "IAudioClient::Initialize hook hit");
     print_format(ShareMode, StreamFlags, hnsBufferDuration, hnsPeriodicity, pFormat);
 
-    CHECK_RESULT(this->backend->on_initialize(
+    HRESULT ret = this->backend->on_initialize(
         &ShareMode,
         &StreamFlags,
         &hnsBufferDuration,
         &hnsPeriodicity,
         pFormat,
-        AudioSessionGuid));
+        AudioSessionGuid);
+    if (SUCCEEDED(ret)) {
+        hooks::audio::set_active_client(this, "DummyIAudioClient::Initialize");
+    }
+    CHECK_RESULT(ret);
 }
 HRESULT STDMETHODCALLTYPE DummyIAudioClient::GetBufferSize(UINT32 *pNumBufferFrames) {
     static std::once_flag printed;