api: log JSON parse error (#904)

## Link to GitHub Issue or related Pull Request, if one exists
developer request

## Description of change
Expose coin insert API over the SDK

## Testing
see sample sdk code

.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/ISSUE_TEMPLATE/bug_report.md

@@ -11,9 +11,7 @@ assignees: ''
 *name of game, version of game*
 
 ## Version of spice2x
-*version of spice, this can be seen in the About tab, and in log.txt*
-
-*please remember to test the LATEST beta version before posting a bug about it**
+*please remember to test the LATEST beta version before posting a bug about it*
 
 ## Describe the issue
 *what's the issue?*
@@ -22,3 +20,7 @@ assignees: ''
 > [!WARNING]
 > Please make sure you remove any personally identifiable information from the log file.
 > Please set `-loglevel` to `all` before launching the game for more verbose logs.
+
+## A note on issue management
+
+`Closed as not planned` means exactly that - it's closed, because it's not on our plans to address them any time soon. It doesn't mean your issue is invalid, it just means it's not a priority, and we can always revisit them later.

.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

@@ -1,8 +1,7 @@
 ## Contributing
 Baseline rules for patch submissions are as follows. Any patches violating the rules below will not be accepted.
 
-### New as of March 2025
-Pull requests in GitHub are open. You don't need to bother with patch file submissions anymore. To contribute, fork the repo (just the main branch), make changes in your fork, and contribute to upstream by opening a pull request to the main repo.
+To contribute, fork the repo (just the main branch), make changes in your fork, and contribute to upstream by opening a pull request to the main repo.
 
 ### Adding support for games
 
@@ -12,6 +11,19 @@ Pull requests in GitHub are open. You don't need to bother with patch file submi
 * 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.
 
+### 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.
+* 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.
+* Bundling third party DLL binary; e.g., Discord Social SDK, PC light control integration, and so on. These should be built as hook DLLs instead, optionally with [Spice SDK](https://github.com/spice2x/spice2x.github.io/wiki/Spice-SDK).
+
 ### Avoiding regressions
 
 The biggest risk in making code changes to spice is the risk of regressions. There is a **lot** of shared code used by many different games, reaching back game versions that are more than a decade old. It is practically impossible to test all supported games and versions.
@@ -22,7 +34,7 @@ Therefore, when making code changes, please be extremely careful about containin
 
 #### Config file compatibility
 
-Do not change the names of options, buttons binds, analogs, etc - since they are used as unique identifiers in config files. If they are changed, you will introduce an incompatibility with previous versions of config file.
+Do not change the names of buttons binds, analogs, strings for command line parameters, etc - since they are used as unique identifiers in config files. If they are changed, you will introduce an incompatibility with previous versions of config file.
 
 ### Code quality requirements
 
@@ -49,6 +61,9 @@ Watch out for legacy OS compatibility. Currently, the minimum support floor is W
 
 ### Code style requirements
 * Indents are four spaces.
+* Try to keep under 100 characters per line. This includes comments and string literals.
+* Avoid making unnecessary formatting or whitespace changes in a PR; e.g., watch out for text editor automatically stripping trailing whitespace. It pollutes the diff and slows down code review.
+* For signed/unsigned integer types, prefer `cstdint` types; e.g., use `int32_t`, `uint64_t` and not `int` and `unsigned long long`.
 * Always use \{ curly braces \} when appropriate; do not omit them even when it's optional; such as `for` `if` `else`, etc.
 
 OK:

README.md

@@ -56,6 +56,10 @@ We explicitly do **NOT** have a Discord server for dicussions - we try to do eve
 
 Please see [CONTRIBUTING page](https://github.com/spice2x/spice2x.github.io/blob/main/CONTRIBUTING.md) for a full list of guidelines when submitting code.
 
+### AI-Use Policy
+
+Use AI tools at your discretion, but remember that a human will review every issue and pull request. Please ensure submissions are accurate, relevant, and worth the reviewer’s time.
+
 ## Additional information
 
 Please read [README.md](https://github.com/spice2x/spice2x.github.io/blob/main/src/spice2x/README.md) inside `src/spice2x`.

pull_request_template.md

@@ -7,7 +7,7 @@
 > 
 > Feel free to remove this section after you have read it.
 
-## Link to GitHub Issue, if one exists
+## Link to GitHub Issue or related Pull Request, if one exists
 #0
 
 ## Description of change

src/spice2x/.gitignore

@@ -18,4 +18,9 @@ dist/*
 
 external/cv2pdb/*
 
-.ccache/*
+.ccache/*
+
+# Visual Studio
+.vs
+out
+CMakeSettings.json

src/spice2x/CMakeLists.txt

@@ -80,6 +80,25 @@ if(MSVC)
 
     # enable COMDAT folding for even smaller release builds
     add_link_options("$<$<CONFIG:RELEASE,MINSIZEREL>:/OPT:ICF>")
+
+    # always use UTF-8 (fix 4819)
+    add_compile_options("/utf-8")
+
+    # spectre mitigation warning
+    add_compile_options("/wd5045")
+
+    # implicit type convert warnings
+    add_compile_options("/wd4244")
+    add_compile_options("/wd4267")
+    add_compile_options("/wd4305")
+
+    # unreferenced local variable
+    add_compile_options("/wd4101")
+
+    # warning in winbase.h??
+    add_compile_options("/wd5039")
+
+
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     # disable warnings about using non _s variants like strncpy
     add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
@@ -90,6 +109,12 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     # RapidJSON does this
     add_compile_definitions(_SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING)
 
+    add_compile_options("-Wno-nontrivial-memcall") # imgui, rapidjson
+    add_compile_options("-Wno-deprecated-builtins") # robin_hood
+    add_compile_options("-Wno-deprecated-declarations") # rapidjson
+    add_compile_options("-Wno-inconsistent-missing-override") # headsocket
+    add_compile_options("-Wno-microsoft-exception-spec") # gcc/clang have different noexcept specifiers on d3d9 COM interfaces
+
     # warnings
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wunknown-warning-option")
 
@@ -99,6 +124,9 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static")
 else()
 
+    # warnings as errors
+    set(CMAKE_COMPILE_WARNING_AS_ERROR ON)
+
     # warnings
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra") # enable stuff
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-pointer-arith") # but we love pointer arithmetic :)
@@ -148,8 +176,8 @@ else()
         set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DNDEBUG")
 
         # file prefix map for relative working directory
-        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ffile-prefix-map=${CMAKE_SOURCE_DIR}=.")
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffile-prefix-map=${CMAKE_SOURCE_DIR}=.")
+        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ffile-prefix-map=\"${CMAKE_SOURCE_DIR}=.\"")
+        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffile-prefix-map=\"${CMAKE_SOURCE_DIR}=.\"")
     endif()
 
     # release with debug info flags
@@ -207,6 +235,13 @@ add_compile_definitions(
         _WIN32_IE=0x0400
 )
 
+# SPICE_XP: set by build_all.sh for the WinXP-compat toolchains. Gates out
+# the DX11 overlay backend
+option(SPICE_XP "Build for the WinXP-compat toolchain" OFF)
+if(SPICE_XP)
+    add_compile_definitions(SPICE_XP=1)
+endif()
+
 # acioemu log
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DACIOEMU_LOG")
 
@@ -219,8 +254,60 @@ add_subdirectory(external/discord-rpc EXCLUDE_FROM_ALL)
 add_subdirectory(external/hash-library EXCLUDE_FROM_ALL)
 add_subdirectory(external/imgui EXCLUDE_FROM_ALL)
 add_subdirectory(external/minhook EXCLUDE_FROM_ALL)
+add_subdirectory(external/wslay EXCLUDE_FROM_ALL)
 add_subdirectory(external/cpu_features EXCLUDE_FROM_ALL)
 
+# libjpeg-turbo, prebuilt into the deps image. The WinXP toolchains have their own
+# sysroot and cannot see it, so those targets build without JPEG support.
+add_library(spice_jpeg INTERFACE)
+if(NOT SPICE_XP)
+    # search static archives only: the mingw package also ships an import library,
+    # and linking that one would pull in a libjpeg DLL at runtime
+    set(SPICE_JPEG_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX})
+    find_package(JPEG)
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${SPICE_JPEG_SUFFIXES})
+
+    if(JPEG_FOUND)
+        target_link_libraries(spice_jpeg INTERFACE JPEG::JPEG)
+        target_compile_definitions(spice_jpeg INTERFACE SPICE_JPEG=1)
+    else()
+        message(WARNING
+                "libjpeg-turbo not found: screen capture over the API is disabled")
+    endif()
+endif()
+
+# x264 for the API H.264 video stream, installed into the mingw sysroots by the
+# deps image. The WinXP toolchains deliberately go without it and serve MJPEG only.
+add_library(spice_x264 INTERFACE)
+if(NOT SPICE_XP)
+    # search static archives only: the mingw package also ships an import library,
+    # and linking that one would pull in a libx264 DLL at runtime
+    set(SPICE_X264_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX})
+    find_library(X264_LIBRARY NAMES x264 libx264)
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ${SPICE_X264_SUFFIXES})
+
+    find_path(X264_INCLUDE_DIR NAMES x264.h)
+    if(X264_LIBRARY AND X264_INCLUDE_DIR)
+        target_include_directories(spice_x264 INTERFACE "${X264_INCLUDE_DIR}")
+        target_link_libraries(spice_x264 INTERFACE "${X264_LIBRARY}")
+        target_compile_definitions(spice_x264 INTERFACE SPICE_H264=1)
+    else()
+        message(WARNING
+                "x264 not found: the api video stream will only offer MJPEG")
+    endif()
+endif()
+
+# fpng's SIMD needs the whole unit built for SSE4.1, which its runtime CPU check
+# cannot undo, so keep it scalar rather than raising the CPU baseline
+set_source_files_properties(external/fpng/fpng.cpp PROPERTIES
+        COMPILE_DEFINITIONS "FPNG_NO_SSE=1")
+if(NOT MSVC)
+    set_source_files_properties(external/fpng/fpng.cpp PROPERTIES
+            COMPILE_OPTIONS "-fno-strict-aliasing")
+endif()
+
 # set link time optimizations (disabled for Debug builds for speed, disabled
 # for RelWithDebInfo builds due to "lto1: error: two or more sections for"
 # errors)
@@ -238,6 +325,7 @@ set_source_files_properties(cfg/manifest.rc PROPERTIES LANGUAGE RC)
 set_source_files_properties(cfg/icon.rc PROPERTIES LANGUAGE RC)
 set_source_files_properties(cfg/Win32D.rc PROPERTIES LANGUAGE RC)
 set_source_files_properties(build/manifest64.rc PROPERTIES LANGUAGE RC)
+set_source_files_properties(stubs/manifest.rc PROPERTIES LANGUAGE RC)
 
 # sources
 #########
@@ -281,6 +369,10 @@ set(SOURCE_FILES ${SOURCE_FILES}
         # api
         api/controller.cpp
         api/websocket.cpp
+        api/capture_pump.cpp
+        api/h264_stream.cpp
+        api/stream_format.cpp
+        api/stream_server.cpp
         api/request.cpp
         api/response.cpp
         api/module.cpp
@@ -296,6 +388,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
@@ -324,6 +417,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
         cfg/configurator.cpp
         cfg/configurator_wnd.cpp
         cfg/screen_resize.cpp
+        cfg/controller_presets.cpp
 
         # easrv
         easrv/easrv.cpp
@@ -338,12 +432,12 @@ set(SOURCE_FILES ${SOURCE_FILES}
         external/cardio/cardio_runner.cpp
 
         # external misc
-        external/scard/scard.cpp
         external/stackwalker/stackwalker.cpp
         external/tinyxml2/tinyxml2.cpp
         external/http-parser/http_parser.c
         external/usbhidusage/usb-hid-usage.c
-        external/toojpeg/toojpeg.cpp
+        external/fpng/fpng.cpp
+        external/scard/scard.cpp
 
         # games
         games/game.cpp
@@ -353,6 +447,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
         games/shared/twtouch.cpp
         games/popn/popn.cpp
         games/popn/io.cpp
+        games/popn/bi3a_hook.cpp
         games/bbc/bbc.cpp
         games/bbc/io.cpp
         games/hpm/hpm.cpp
@@ -370,15 +465,24 @@ 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
+        games/gitadora/handle.cpp
+        games/gitadora/j32d.cpp
+        games/gitadora/j33i.cpp
+        games/gitadora/bi2x_hook.cpp
         games/mga/mga.cpp
         games/mga/io.cpp
         games/mga/gunio.cpp
@@ -387,6 +491,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
@@ -415,6 +520,8 @@ set(SOURCE_FILES ${SOURCE_FILES}
         games/scotto/io.cpp
         games/drs/drs.cpp
         games/drs/io.cpp
+        games/drs/motion_cam.cpp
+        games/drs/rgb_cam.cpp
         games/we/we.cpp
         games/we/io.cpp
         games/we/touchpanel.cpp
@@ -425,6 +532,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
         games/otoca/p4io.cpp
         games/silentscope/silentscope.cpp
         games/silentscope/io.cpp
+        games/silentscope/projector.cpp
         games/pcm/pcm.cpp
         games/pcm/io.cpp
         games/onpara/onpara.cpp
@@ -443,17 +551,31 @@ set(SOURCE_FILES ${SOURCE_FILES}
         games/mfg/mfg.cpp
         games/mfg/io.cpp
         games/mfg/bi2a_hook.cpp
+        games/pc/pc.cpp
+        games/pc/io.cpp
+        games/pc/bi2x_hook.cpp
 
         # hooks
+        hooks/audio/acm.cpp
         hooks/audio/audio.cpp
+        hooks/audio/asio_driver_scan.cpp
+        hooks/audio/asio_proxy.cpp
         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
+        hooks/audio/backends/mmdevice/device_collection.cpp
         hooks/audio/backends/mmdevice/device_enumerator.cpp
+        hooks/audio/backends/mmdevice/null_device.cpp
+        hooks/audio/backends/mmdevice/null_discard_backend.cpp
         hooks/audio/backends/wasapi/audio_client.cpp
         hooks/audio/backends/wasapi/audio_render_client.cpp
+        hooks/audio/backends/wasapi/downmix.cpp
+        hooks/audio/backends/wasapi/resample.cpp
+        hooks/audio/backends/wasapi/shared.cpp
         hooks/audio/backends/wasapi/dummy_audio_client.cpp
         hooks/audio/backends/wasapi/dummy_audio_clock.cpp
         hooks/audio/backends/wasapi/dummy_audio_render_client.cpp
@@ -468,19 +590,32 @@ set(SOURCE_FILES ${SOURCE_FILES}
         hooks/devicehook.cpp
         hooks/graphics/graphics.cpp
         hooks/graphics/graphics_windowed.cpp
+        hooks/graphics/jpeg_encoder.cpp
+        hooks/graphics/nvapi_impl.cpp
         hooks/graphics/nvapi_hook.cpp
         hooks/graphics/nvenc_hook.cpp
         hooks/graphics/backends/d3d9/d3d9_backend.cpp
+        hooks/graphics/backends/d3d9/d3d9_readback.cpp
+        hooks/graphics/backends/d3d9/d3d9_screenshot.cpp
         hooks/graphics/backends/d3d9/d3d9_device.cpp
+        hooks/graphics/backends/d3d9/d3d9_gfdm.cpp
+        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
+        hooks/graphics/backends/d3d11/d3d11_backend.cpp
+        hooks/graphics/backends/d3d11/d3d11_swapchain.cpp
+        hooks/graphics/backends/d3d11/d3d11_factory.cpp
+        hooks/graphics/backends/d3d11/d3d11_vtable_capture.cpp
+        hooks/graphics/backends/d3d11/d3d11_screenshot.cpp
         hooks/input/dinput8/fake_backend.cpp
         hooks/input/dinput8/fake_device.cpp
         hooks/input/dinput8/hook.cpp
         hooks/lang.cpp
         hooks/libraryhook.cpp
         hooks/networkhook.cpp
+        hooks/icmphook_net.cpp
+        hooks/icmphook_iphlpapi.cpp
         hooks/powrprof.cpp
         #hooks/rom.cpp
         hooks/setupapihook.cpp
@@ -503,15 +638,18 @@ set(SOURCE_FILES ${SOURCE_FILES}
         misc/device.cpp
         misc/eamuse.cpp
         misc/extdev.cpp
+        misc/hotkeys.cpp
         misc/sciunit.cpp
         misc/sde.cpp
         misc/wintouchemu.cpp
+        misc/ami2000.cpp
 
         # nvapi
         nvapi/nvapi.cpp
 
         # overlay
         overlay/overlay.cpp
+        overlay/notifications.cpp
         overlay/window.cpp
         overlay/imgui/extensions.cpp
         overlay/imgui/impl_spice.cpp
@@ -520,9 +658,11 @@ set(SOURCE_FILES ${SOURCE_FILES}
         overlay/windows/camera_control.cpp
         overlay/windows/card_manager.cpp
         overlay/windows/drs_dancefloor.cpp
+        overlay/windows/gfdm_sub.cpp
         overlay/windows/screen_resize.cpp
         overlay/windows/sdvx_sub.cpp
         overlay/windows/config.cpp
+        overlay/windows/controller_presets.cpp
         overlay/windows/control.cpp
         overlay/windows/eadev.cpp
         overlay/windows/fps.cpp
@@ -536,11 +676,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
@@ -551,6 +707,8 @@ set(SOURCE_FILES ${SOURCE_FILES}
         rawinput/smxstage.h
         rawinput/smxdedicab.cpp
         rawinput/smxdedicab.h
+        rawinput/xinput.cpp
+        rawinput/xinput.h
 
         # reader
         reader/reader.cpp
@@ -558,12 +716,21 @@ set(SOURCE_FILES ${SOURCE_FILES}
         reader/structuredmessage.cpp
         reader/crypt.cpp
 
+        # sdk
+        sdk/sdk.cpp
+
         # stubs
         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
 
@@ -584,43 +751,102 @@ set(SOURCE_FILES ${SOURCE_FILES}
         util/time.cpp
         util/cpuutils.cpp
         util/netutils.cpp
+        util/precise_timer.cpp
         util/sysutils.cpp
         util/lz77.cpp
         util/tapeled.cpp
         util/execexe.cpp
+        util/dependencies.cpp
+        util/deferlog.cpp
+        util/socd_cleaner.cpp
 )
 
 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
+# the large-address-aware bit, which is set at link time. Compile the sources
+# once into a shared OBJECT library so spice_laa.exe only costs an extra link
+# instead of a full recompile.
+
+add_library(spicetools_spice_objs OBJECT ${SOURCE_FILES})
+target_link_libraries(spicetools_spice_objs
+        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
+target_link_libraries(spicetools_spice_objs PUBLIC winscard)
+
+if(NOT MSVC)
+    set_target_properties(spicetools_spice_objs PROPERTIES COMPILE_FLAGS "-m32")
+endif()
+
 # spice.exe
 ###########
 
 set(RESOURCE_FILES build/manifest.manifest build/manifest.rc build/icon.rc cfg/Win32D.rc)
-add_executable(spicetools_spice ${SOURCE_FILES} ${RESOURCE_FILES})
-target_link_libraries(spicetools_spice
-        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winscard winhttp
-        PRIVATE fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features)
+add_executable(spicetools_spice ${RESOURCE_FILES})
+target_link_libraries(spicetools_spice PRIVATE spicetools_spice_objs)
 set_target_properties(spicetools_spice PROPERTIES PREFIX "")
 set_target_properties(spicetools_spice PROPERTIES OUTPUT_NAME "spice")
 
 IF(NOT MSVC)
-    set_target_properties(spicetools_spice PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
+    set_target_properties(spicetools_spice PROPERTIES LINK_FLAGS "-m32")
 endif()
 
 # spice_laa.exe
 ###########
 
 set(RESOURCE_FILES build/manifest.manifest build/manifest.rc build/icon.rc cfg/Win32D.rc)
-add_executable(spicetools_spice_laa ${SOURCE_FILES} ${RESOURCE_FILES})
-target_link_libraries(spicetools_spice_laa
-        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winscard winhttp
-        PRIVATE fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features)
+add_executable(spicetools_spice_laa ${RESOURCE_FILES})
+target_link_libraries(spicetools_spice_laa PRIVATE spicetools_spice_objs)
 set_target_properties(spicetools_spice_laa PROPERTIES PREFIX "")
 set_target_properties(spicetools_spice_laa PROPERTIES OUTPUT_NAME "spice_laa")
-target_compile_definitions(spicetools_spice_laa PRIVATE SPICE32_LARGE_ADDRESS_AWARE=1)
 
 IF(NOT MSVC)
-    set_target_properties(spicetools_spice_laa PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32 -Wl,--large-address-aware")
+    set_target_properties(spicetools_spice_laa PROPERTIES LINK_FLAGS "-m32 -Wl,--large-address-aware")
+endif()
+
+# spice_linux.exe
+###########
+
+set(RESOURCE_FILES build/manifest.manifest build/manifest.rc build/icon.rc cfg/Win32D.rc)
+add_executable(spicetools_spice_linux ${SOURCE_FILES} ${RESOURCE_FILES})
+target_link_libraries(spicetools_spice_linux
+        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
+set_target_properties(spicetools_spice_linux PROPERTIES PREFIX "")
+set_target_properties(spicetools_spice_linux PROPERTIES OUTPUT_NAME "spice_linux")
+target_compile_definitions(spicetools_spice_linux PRIVATE NO_SCARD=1 PRIVATE SPICE_LINUX=1)
+
+IF(NOT MSVC)
+    set_target_properties(spicetools_spice_linux PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
 endif()
 
 # spice64.exe
@@ -631,26 +857,54 @@ add_executable(spicetools_spice64 ${SOURCE_FILES} ${RESOURCE_FILES})
 
 # do NOT link against: mf, mfplat, mfreadwrite; otherwise unity games will break
 target_link_libraries(spicetools_spice64
-        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winscard winhttp mfuuid strmiids dxva2
-        PRIVATE fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features)
-
+        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp mfuuid strmiids dxva2
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
+target_link_libraries(spicetools_spice64 PUBLIC winscard)
 set_target_properties(spicetools_spice64 PROPERTIES PREFIX "")
 set_target_properties(spicetools_spice64 PROPERTIES OUTPUT_NAME "spice64")
 target_compile_definitions(spicetools_spice64 PRIVATE SPICE64=1)
+if(NOT SPICE_XP)
+    target_link_libraries(spicetools_spice64 PUBLIC d3d11 dxgi)
+    target_compile_definitions(spicetools_spice64 PRIVATE SPICE_D3D11=1)
+endif()
 
 IF(NOT MSVC)
     set_target_properties(spicetools_spice64 PROPERTIES COMPILE_FLAGS "-m64" LINK_FLAGS "-m64")
 endif()
 
+# spice64_linux.exe
+#############
+
+set(RESOURCE_FILES build/manifest.manifest build/manifest64.rc build/icon.rc cfg/Win32D.rc)
+add_executable(spicetools_spice64_linux ${SOURCE_FILES} ${RESOURCE_FILES})
+
+# do NOT link against: mf, mfplat, mfreadwrite; otherwise unity games will break
+target_link_libraries(spicetools_spice64_linux
+        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp mfuuid strmiids dxva2
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features spice_jpeg spice_x264)
+set_target_properties(spicetools_spice64_linux PROPERTIES PREFIX "")
+set_target_properties(spicetools_spice64_linux PROPERTIES OUTPUT_NAME "spice64_linux")
+target_compile_definitions(spicetools_spice64_linux PRIVATE SPICE64=1)
+target_compile_definitions(spicetools_spice64_linux PRIVATE NO_SCARD=1 PRIVATE SPICE_LINUX=1)
+# spice64_linux is never built under the WinXP toolchain, so dx11 is always on.
+target_link_libraries(spicetools_spice64_linux PUBLIC d3d11 dxgi)
+target_compile_definitions(spicetools_spice64_linux PRIVATE SPICE_D3D11=1)
+
+IF(NOT MSVC)
+    set_target_properties(spicetools_spice64_linux PROPERTIES COMPILE_FLAGS "-m64" LINK_FLAGS "-m64")
+endif()
+
 # spicecfg.exe
 ##############
 
 set(SOURCE_FILES ${SOURCE_FILES} launcher/options.h launcher/options.cpp)
 set(RESOURCE_FILES cfg/manifest.manifest cfg/manifest.rc cfg/icon.rc cfg/Win32D.rc)
 add_executable(spicetools_cfg WIN32 ${SOURCE_FILES} ${RESOURCE_FILES})
+# the configurator serves neither the API nor the video stream, so it needs no codecs
 target_link_libraries(spicetools_cfg
-        PUBLIC ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winscard winhttp strmiids
-        PRIVATE fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features)
+        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp strmiids
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features)
+target_link_libraries(spicetools_cfg PUBLIC winscard)
 set_target_properties(spicetools_cfg PROPERTIES PREFIX "")
 set_target_properties(spicetools_cfg PROPERTIES OUTPUT_NAME "spicecfg")
 target_compile_definitions(spicetools_cfg PRIVATE SPICETOOLS_SPICECFG_STANDALONE=1)
@@ -659,13 +913,31 @@ if(NOT MSVC)
     set_target_properties(spicetools_cfg PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
 endif()
 
+# spicecfg_linux.exe
+##############
+
+set(SOURCE_FILES ${SOURCE_FILES} launcher/options.h launcher/options.cpp)
+set(RESOURCE_FILES cfg/manifest.manifest cfg/manifest.rc cfg/icon.rc cfg/Win32D.rc)
+add_executable(spicetools_cfg_linux WIN32 ${SOURCE_FILES} ${RESOURCE_FILES})
+target_link_libraries(spicetools_cfg_linux
+        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp strmiids
+        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook wslay imm32 dwmapi CpuFeatures::cpu_features)
+set_target_properties(spicetools_cfg_linux PROPERTIES PREFIX "")
+set_target_properties(spicetools_cfg_linux PROPERTIES OUTPUT_NAME "spicecfg_linux")
+target_compile_definitions(spicetools_cfg_linux PRIVATE SPICETOOLS_SPICECFG_STANDALONE=1)
+target_compile_definitions(spicetools_cfg_linux PRIVATE NO_SCARD=1 PRIVATE SPICE_LINUX=1)
+
+if(NOT MSVC)
+    set_target_properties(spicetools_cfg_linux PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
+endif()
+
 # stubs
 #######
 
 # kbt.dll
 set(SOURCE_FILES stubs/stubs.cpp)
 add_library(spicetools_stubs_kbt SHARED ${SOURCE_FILES} stubs/stubs.def)
-target_link_libraries(spicetools_stubs_kbt PRIVATE fmt-header-only)
+target_link_libraries(spicetools_stubs_kbt PRIVATE fmt::fmt-header-only)
 set_target_properties(spicetools_stubs_kbt PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_kbt PROPERTIES OUTPUT_NAME "kbt")
 target_compile_definitions(spicetools_stubs_kbt PRIVATE STUB=1)
@@ -676,7 +948,7 @@ endif()
 
 # kbt.dll 64bit
 add_library(spicetools_stubs_kbt64 SHARED ${SOURCE_FILES} stubs/stubs.def)
-target_link_libraries(spicetools_stubs_kbt64 PRIVATE fmt-header-only)
+target_link_libraries(spicetools_stubs_kbt64 PRIVATE fmt::fmt-header-only)
 set_target_properties(spicetools_stubs_kbt64 PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_kbt64 PROPERTIES OUTPUT_NAME "kbt")
 target_compile_definitions(spicetools_stubs_kbt64 PRIVATE STUB=1)
@@ -688,7 +960,7 @@ endif()
 # kld.dll
 set(SOURCE_FILES stubs/stubs.cpp)
 add_library(spicetools_stubs_kld SHARED ${SOURCE_FILES} stubs/stubs.def)
-target_link_libraries(spicetools_stubs_kld PRIVATE fmt-header-only)
+target_link_libraries(spicetools_stubs_kld PRIVATE fmt::fmt-header-only)
 set_target_properties(spicetools_stubs_kld PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_kld PROPERTIES OUTPUT_NAME "kld")
 target_compile_definitions(spicetools_stubs_kld PRIVATE STUB=1)
@@ -699,7 +971,7 @@ endif()
 
 # kld.dll 64bit
 add_library(spicetools_stubs_kld64 SHARED ${SOURCE_FILES} stubs/stubs.def)
-target_link_libraries(spicetools_stubs_kld64 PRIVATE fmt-header-only)
+target_link_libraries(spicetools_stubs_kld64 PRIVATE fmt::fmt-header-only)
 set_target_properties(spicetools_stubs_kld64 PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_kld64 PROPERTIES OUTPUT_NAME "kld")
 target_compile_definitions(spicetools_stubs_kld64 PRIVATE STUB=1)
@@ -710,7 +982,8 @@ endif()
 
 # nvcuda.dll
 set(SOURCE_FILES stubs/nvcuda.cpp)
-add_library(spicetools_stubs_nvcuda SHARED ${SOURCE_FILES} stubs/nvcuda.def)
+set(RESOURCE_FILES stubs/manifest.rc)
+add_library(spicetools_stubs_nvcuda SHARED ${SOURCE_FILES} ${RESOURCE_FILES} stubs/nvcuda.def)
 set_target_properties(spicetools_stubs_nvcuda PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_nvcuda PROPERTIES OUTPUT_NAME "nvcuda")
 
@@ -720,7 +993,8 @@ endif()
 
 # nvcuvid.dll
 set(SOURCE_FILES stubs/nvcuvid.cpp)
-add_library(spicetools_stubs_nvcuvid SHARED ${SOURCE_FILES} stubs/nvcuvid.def)
+set(RESOURCE_FILES stubs/manifest.rc)
+add_library(spicetools_stubs_nvcuvid SHARED ${SOURCE_FILES} ${RESOURCE_FILES} stubs/nvcuvid.def)
 set_target_properties(spicetools_stubs_nvcuvid PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_nvcuvid PROPERTIES OUTPUT_NAME "nvcuvid")
 
@@ -730,7 +1004,8 @@ endif()
 
 # nvEncodeAPI64.dll
 set(SOURCE_FILES stubs/nvEncodeAPI64.cpp)
-add_library(spicetools_stubs_nvEncodeAPI64 SHARED ${SOURCE_FILES} stubs/nvEncodeAPI64.def)
+set(RESOURCE_FILES stubs/manifest.rc)
+add_library(spicetools_stubs_nvEncodeAPI64 SHARED ${SOURCE_FILES} ${RESOURCE_FILES} stubs/nvEncodeAPI64.def)
 set_target_properties(spicetools_stubs_nvEncodeAPI64 PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_nvEncodeAPI64 PROPERTIES OUTPUT_NAME "nvEncodeAPI64")
 
@@ -740,7 +1015,8 @@ endif()
 
 # cpusbxpkm.dll (32 bit)
 set(SOURCE_FILES stubs/cpusbxpkm.cpp)
-add_library(spicetools_stubs_cpusbxpkm SHARED ${SOURCE_FILES} stubs/cpusbxpkm.def)
+set(RESOURCE_FILES stubs/manifest.rc)
+add_library(spicetools_stubs_cpusbxpkm SHARED ${SOURCE_FILES} ${RESOURCE_FILES} stubs/cpusbxpkm.def)
 set_target_properties(spicetools_stubs_cpusbxpkm PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_cpusbxpkm PROPERTIES OUTPUT_NAME "cpusbxpkm")
 
@@ -748,24 +1024,67 @@ if(NOT MSVC)
     set_target_properties(spicetools_stubs_cpusbxpkm PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
 endif()
 
+# sdk_sample_v0_flat_c.dll (32 bit)
+set(SOURCE_FILES sdk/sample/v0/flat_c/v0_flat_c.c)
+add_library(spicetools_sdk_sample_v0_flat_c_32 SHARED ${SOURCE_FILES} ${RESOURCE_FILES} sdk/sample/v0/flat_c/v0_flat_c.def)
+set_target_properties(spicetools_sdk_sample_v0_flat_c_32 PROPERTIES PREFIX "")
+set_target_properties(spicetools_sdk_sample_v0_flat_c_32 PROPERTIES OUTPUT_NAME "sdk_sample_v0_flat_c")
+
+if(NOT MSVC)
+    set_target_properties(spicetools_sdk_sample_v0_flat_c_32 PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
+endif()
+
+# sdk_sample_v0_flat_c.dll (64 bit)
+set(SOURCE_FILES sdk/sample/v0/flat_c/v0_flat_c.c)
+add_library(spicetools_sdk_sample_v0_flat_c_64 SHARED ${SOURCE_FILES} ${RESOURCE_FILES} sdk/sample/v0/flat_c/v0_flat_c.def)
+set_target_properties(spicetools_sdk_sample_v0_flat_c_64 PROPERTIES PREFIX "")
+set_target_properties(spicetools_sdk_sample_v0_flat_c_64 PROPERTIES OUTPUT_NAME "sdk_sample_v0_flat_c")
+
+if(NOT MSVC)
+    set_target_properties(spicetools_sdk_sample_v0_flat_c_64 PROPERTIES COMPILE_FLAGS "-m64" LINK_FLAGS "-m64")
+endif()
+
+# sdk_sample_v0_cpp.dll (64 bit)
+set(SOURCE_FILES sdk/sample/v0/cpp/v0_cpp.cpp)
+add_library(spicetools_sdk_sample_v0_cpp_64 SHARED ${SOURCE_FILES} ${RESOURCE_FILES} sdk/sample/v0/cpp/v0_cpp.def)
+set_target_properties(spicetools_sdk_sample_v0_cpp_64 PROPERTIES PREFIX "")
+set_target_properties(spicetools_sdk_sample_v0_cpp_64 PROPERTIES OUTPUT_NAME "sdk_sample_v0_cpp")
+
+if(NOT MSVC)
+    set_target_properties(spicetools_sdk_sample_v0_cpp_64 PROPERTIES COMPILE_FLAGS "-m64" LINK_FLAGS "-m64")
+endif()
+
 # output directories
 ####################
 
 # output config
-set_target_properties(spicetools_cfg
+set_target_properties(spicetools_cfg spicetools_cfg_linux
         PROPERTIES
         RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/spicetools")
 
 # output 32bit
-set_target_properties(spicetools_spice spicetools_spice_laa spicetools_stubs_kbt spicetools_stubs_kld spicetools_stubs_cpusbxpkm
+set_target_properties(spicetools_spice spicetools_spice_laa spicetools_spice_linux spicetools_stubs_kbt spicetools_stubs_kld spicetools_stubs_cpusbxpkm spicetools_sdk_sample_v0_flat_c_32
         PROPERTIES
         ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/archive32"
         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/spicetools/32"
         RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/spicetools/32")
 
 # output 64bit
-set_target_properties(spicetools_spice64 spicetools_stubs_kbt64 spicetools_stubs_kld64 spicetools_stubs_nvcuda spicetools_stubs_nvcuvid spicetools_stubs_nvEncodeAPI64
+set_target_properties(spicetools_spice64 spicetools_spice64_linux spicetools_stubs_kbt64 spicetools_stubs_kld64 spicetools_stubs_nvcuda spicetools_stubs_nvcuvid spicetools_stubs_nvEncodeAPI64 spicetools_sdk_sample_v0_flat_c_64 spicetools_sdk_sample_v0_cpp_64
         PROPERTIES
         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

@@ -127,7 +127,30 @@ doesn't matter since the TCP protocol doesn't allow for out of order data,
 however this may change when/if support for UDP is being introduced. The only
 restriction is that the ID has to be a valid 64-bit unsigned integer.
 
+#### Capture
+- get_screens()
+  - returns the screen numbers the game has registered for capture
+- get_jpg(screen: uint, quality: uint, divide: uint)
+  - returns the timestamp, width, height and base64 encoded JPEG of one screen
+  - all parameters are optional and default to screen 0, quality 70, divide 1
+  - divide shrinks the image by that factor before encoding
+- get_streams()
+  - returns a dict describing the HTTP video stream, or no data at all when
+    `-apistream` is not enabled and there is nothing to describe
+  - `port` is the stream server port
+  - `formats` lists the wire formats this build serves, each with a `name`
+    (`h264` or `mjpeg`) and the `path` to request them on
+  - `screens` lists every capturable screen with its `width`, `height`, and
+    `busy`
+
 #### Card
+- get_cards()
+  - returns the current card ID and source for each active card reader
+  - each entry contains `index`, `card_id`, and `source`
+  - `source` is `file` or `override`
+  - file entries also contain `file_name`, without the full configured path
+  - `-card0` and `-card1` overrides do not contain `file_name`
+  - this function only works when an API password is configured
 - insert(index: uint, card_id: hex)
   - inserts a card which gets read by the emulated card readers for the game
   - index has to be either 0 (for P1) or 1 (for P2)
@@ -267,6 +290,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
@@ -277,12 +314,63 @@ which also means that your hex edits are applicable directly.
 - image_resize_set_scene(scene: int)
   - sets the active scene for image resize state; set to 0 to disable resize
 
+## Video Stream
+
+Separate from the JSON API, spice can serve the mirrored screen as a video
+stream over plain HTTP. Enable it with `-apistream`. It listens on the API port
+plus two, in the same way the WebSocket server uses the API port plus one, so
+`-api 1337` puts the stream on 1339. This means `-api` has to be enabled too.
+
+Rather than working the port out, clients should ask the JSON API for it with
+`capture.get_streams()`, which also reports which of the formats below this
+build serves, the size of each screen and whether one is already taken.
+
+Two formats are served:
+
+    http://host:1339/stream.mjpg    JPEG frames, multipart/x-mixed-replace
+    http://host:1339/stream.h264    H.264 annex-b, no container
+
+All accept the same optional query parameters:
+
+- `screen` - which screen to mirror, 0-3. Defaults to the subscreen when the
+  game has one, otherwise the main screen.
+- `fps` - frames per second, 1-60. Default 30.
+- `q` - quality, 1-100. Default 70. This is the JPEG quality for `stream.mjpg`
+  and is mapped onto the H.264 rate factor for `stream.h264`, so the same number
+  does not mean the same thing for both.
+
+For example:
+
+    http://host:1339/stream.h264?screen=1&fps=30&q=70
+
+See the wiki for format tradeoffs, latency tuning, testing commands and client
+notes.
+
+The stream is view only. Touch and other input still go through the JSON API,
+so a companion app needs both. There is no authentication on the stream port -
+anyone who can reach it can watch the screen.
+
+WinXP builds have no video stream. Neither encoder is compiled in, so nothing
+listens on the stream port even with `-apistream`, `capture.get_streams()`
+returns no data, and the JSON API's JPEG screen capture is unavailable for the
+same reason.
+
 ## Native wrapper libraries
 Spicetools provides wrapper libraries in: Arduino, C++, Dart, and Python.
 Python is the only one that is fully spec compliant.
 Other libraries may be missing features and contain bugs; please feel free to
 contribute code to fill the gaps if you work on a project using these libraries.
 
+## Spice SDK (for DLL hooks / plugins)
+
+As an alternative to Spice API, Spice SDK is available.
+
+This is a flat C, header-only library that can be included in your DLL. Once
+initialized, you can call directly into helper routines provided by Spicetools
+executable, making low-latency and high-throughput interactions possible.
+
+Check the documentation on the wiki for more details.
+
 ## License
 Unless otherwise noted, all files are licensed under the GPLv3.
 See the LICENSE file for the full license text.

src/spice2x/acio/bi2a/bi2a.cpp

@@ -9,11 +9,22 @@
 #include "games/drs/drs.h"
 #include "misc/eamuse.h"
 #include "util/logging.h"
+#include "util/socd_cleaner.h"
+#include "util/time.h"
 #include "util/utils.h"
 #include "util/tapeled.h"
 
 using namespace GameAPI;
 
+#define DEBUG_VERBOSE 0
+
+#if DEBUG_VERBOSE
+#define log_debug(module, format_str, ...) logger::push( \
+    LOG_FORMAT("M", module, format_str, ## __VA_ARGS__), logger::Style::GREY)
+#else
+#define log_debug(module, format_str, ...)
+#endif
+
 // state
 static uint8_t STATUS_BUFFER[272] {};
 static bool STATUS_BUFFER_FREEZE = false;
@@ -94,18 +105,25 @@ static bool __cdecl ac_io_bi2a_update_control_status_buffer() {
         }
 
         // volume left
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Left))) {
+        const auto now = get_performance_milliseconds();
+        const auto vol_l_state = socd::socd_clean(0,
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Left)),
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Right)),
+            now);
+        if (vol_l_state == socd::SocdCCW) {
             BI2A_VOLL = (BI2A_VOLL - games::sdvx::DIGITAL_KNOB_SENS) & 1023;
-        }
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Right))) {
+        } else if (vol_l_state == socd::SocdCW) {
             BI2A_VOLL = (BI2A_VOLL + games::sdvx::DIGITAL_KNOB_SENS) & 1023;
         }
 
         // volume right
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Left))) {
+        const auto vol_r_state = socd::socd_clean(1,
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Left)),
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Right)),
+            now);
+        if (vol_r_state == socd::SocdCCW) {
             BI2A_VOLR = (BI2A_VOLR - games::sdvx::DIGITAL_KNOB_SENS) & 1023;
-        }
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Right))) {
+        } else if (vol_r_state == socd::SocdCW) {
             BI2A_VOLR = (BI2A_VOLR + games::sdvx::DIGITAL_KNOB_SENS) & 1023;
         }
 
@@ -127,6 +145,12 @@ static bool __cdecl ac_io_bi2a_update_control_status_buffer() {
         // save volumes in buffer
         *((uint16_t*) &STATUS_BUFFER[17]) = (uint16_t) ((vol_left) << 2);
         *((uint16_t*) &STATUS_BUFFER[19]) = (uint16_t) ((vol_right) << 2);
+
+        log_debug(
+            "bi2a",
+            "knobs = {} {}",
+            *((uint16_t*) &STATUS_BUFFER[17]),
+            *((uint16_t*) &STATUS_BUFFER[19]));
     }
 
     // DanceDanceRevolution

src/spice2x/acio/bmpu/bmpu.cpp

@@ -1,5 +1,7 @@
 #include "bmpu.h"
 
+#include <algorithm>
+
 #include "acio/icca/icca.h"
 #include "avs/game.h"
 #include "cfg/api.h"
@@ -9,6 +11,7 @@
 #include "games/ftt/io.h"
 #include "games/museca/io.h"
 #include "games/silentscope/io.h"
+#include "hooks/graphics/graphics.h"
 #include "launcher/launcher.h"
 #include "misc/eamuse.h"
 
@@ -530,15 +533,38 @@ static bool __cdecl ac_io_bmpu_update_control_status_buffer() {
             STATUS_BUFFER[4] |= 0x20;
         }
 
-        // joy stick raw input
+        // gun position, sent big endian; the game keeps the top 12 bits of each pair
         auto &analogs = games::silentscope::get_analogs();
+        auto &gun_x = analogs.at(games::silentscope::Analogs::GUN_X);
+        auto &gun_y = analogs.at(games::silentscope::Analogs::GUN_Y);
         unsigned short joy_x = 0x7FFF;
         unsigned short joy_y = 0x7FFF;
-        if (analogs.at(games::silentscope::Analogs::GUN_X).isSet()) {
-            joy_x = (unsigned short) (Analogs::getState(RI_MGR, analogs.at(games::silentscope::Analogs::GUN_X)) * USHRT_MAX);
-        }
-        if (analogs.at(games::silentscope::Analogs::GUN_Y).isSet()) {
-            joy_y = (unsigned short) (Analogs::getState(RI_MGR, analogs.at(games::silentscope::Analogs::GUN_Y)) * USHRT_MAX);
+
+        if (gun_x.isSet() || gun_y.isSet()) {
+            if (gun_x.isSet()) {
+                joy_x = (unsigned short) (Analogs::getState(RI_MGR, gun_x) * USHRT_MAX);
+            }
+            if (gun_y.isSet()) {
+                joy_y = (unsigned short) (Analogs::getState(RI_MGR, gun_y) * USHRT_MAX);
+            }
+        } else {
+
+            // the gun reports where it is aimed, which a relative pointer cannot express - the
+            // calibration screen asks for the screen centre and two corners, so read the cursor
+            POINT cursor {};
+            RECT client {};
+            POINT origin {};
+            if (NDD_MAIN_WINDOW != nullptr &&
+                GetCursorPos(&cursor) &&
+                GetClientRect(NDD_MAIN_WINDOW, &client) &&
+                ClientToScreen(NDD_MAIN_WINDOW, &origin) &&
+                client.right > 1 && client.bottom > 1)
+            {
+                const LONG x = std::clamp(cursor.x - origin.x, 0L, client.right - 1);
+                const LONG y = std::clamp(cursor.y - origin.y, 0L, client.bottom - 1);
+                joy_x = (unsigned short) (x * USHRT_MAX / (client.right - 1));
+                joy_y = (unsigned short) (y * USHRT_MAX / (client.bottom - 1));
+            }
         }
 
         // invert X axis

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/icca/icca.cpp

@@ -35,24 +35,33 @@ struct ICCA_STATUS_LA9 {
 static_assert(sizeof(struct ICCA_STATUS) == 24, "ICCA_STATUS must be 24 bytes");
 
 enum ICCA_WORKFLOW {
-    STEP,
-    SLEEP,
-    START,
-    INIT,
-    READY,
-    GET_USERID,
-    ACTIVE,
-    EJECT,
-    EJECT_CHECK,
-    END,
-    CLOSE_EJECT,
-    CLOSE_E_CHK,
-    CLOSE_END,
-    ERR_GETUID = -2
+    STEP = 0,
+    SLEEP = 1,
+    START = 2,
+    INIT = 3,
+    READY = 4,
+    GET_USERID = 5,
+    ACTIVE = 6,
+    EJECT = 7,
+    EJECT_CHECK = 8,
+    END = 9,
+    CLOSE_EJECT = 10,
+    CLOSE_E_CHK = 11,
+    CLOSE_END = 12,
+    ERR_GETUID = -2,
+    ERR_REMOVED = -11
 };
+
+// used by RA as the status_code
+enum ICCA_STATUS_CODE {
+    EMPTY = 1,
+    ENGAGED = 2
+};
+
 struct ICCA_UNIT {
     struct ICCA_STATUS status {};
     enum ICCA_WORKFLOW state = STEP;
+    enum ICCA_WORKFLOW state_jdz = SLEEP;
     bool card_cmd_pressed = false;
     bool card_in = false;
     double card_in_time = 0.0;
@@ -75,6 +84,11 @@ static inline int icca_get_active_count() {
 }
 
 static inline int icca_get_unit_id(int unit_id) {
+    // on RA the unit_id is zero-indexed
+    if (avs::game::is_model("JDZ")) {
+        return unit_id;
+    }
+
     if (icca_get_active_count() < 2)
         return 1;
     else {
@@ -122,9 +136,15 @@ static inline void update_card(int unit_id) {
                     IS_LAST_CARD_FELICA = is_card_uid_felica(unit->status.uid);
 
                     unit->state = acio::ICCA_COMPAT_ACTIVE ? START : ACTIVE;
+                    unit->state_jdz = ACTIVE;
                     unit->status.error = 0;
+                    unit->status.front_sensor = 1;
+                    unit->status.rear_sensor = 1;
                 } else {
                     unit->state = ERR_GETUID;
+                    unit->state_jdz = ERR_GETUID;
+                    unit->status.front_sensor = 1;
+                    unit->status.rear_sensor = 1;
                     memset(unit->status.uid, 0, 8);
                 }
                 unit->card_in = true;
@@ -132,10 +152,25 @@ static inline void update_card(int unit_id) {
             } else if (unit->state == EJECT_CHECK) {
                 unit->state = SLEEP;
                 unit->card_in = false;
+                unit->status.front_sensor = 0;
+                unit->status.rear_sensor = 0;
+            } else if (unit->state_jdz == READY) {
+                unit->state = GET_USERID;
+                unit->state_jdz = GET_USERID;
+                unit->status.error = 0;
+                unit->status.front_sensor = 1;
+                unit->status.rear_sensor = 1;
+                unit->card_in = true;
+                unit->card_in_time = get_performance_seconds();
             }
         } else {
             unit->state = acio::ICCA_COMPAT_ACTIVE ? START : ACTIVE;
+            if (unit->state_jdz == READY) {
+                unit->state_jdz = GET_USERID;
+            }
             unit->status.error = 0;
+            unit->status.front_sensor = 1;
+            unit->status.rear_sensor = 1;
             unit->card_in = true;
             unit->card_in_time = get_performance_seconds();
         }
@@ -144,6 +179,12 @@ static inline void update_card(int unit_id) {
         unit->state = CLOSE_EJECT;
         if (fabs(get_performance_seconds() - unit->card_in_time) > CARD_TIMEOUT) {
             unit->card_in = false;
+            memset(unit->status.uid, 0, 8);
+            if (unit->state_jdz == ACTIVE || unit->state_jdz == GET_USERID) {
+                unit->state_jdz = ERR_REMOVED;
+            }
+            unit->status.front_sensor = 0;
+            unit->status.rear_sensor = 0;
         }
     }
 
@@ -302,7 +343,11 @@ static char __cdecl ac_io_icca_get_status(void *a1, void *a2) {
 
     // copy state to output buffer
     ICCA_UNIT *unit = &ICCA_UNITS[unit_id];
-    unit->status.status_code = unit->state;
+    if (avs::game::is_model("JDZ")) {
+        unit->status.status_code = unit->card_in ? ENGAGED : EMPTY;
+    } else {
+        unit->status.status_code = unit->state;
+    }
     memcpy(status, &unit->status, sizeof(struct ICCA_STATUS));
 
     // funny workaround
@@ -387,6 +432,11 @@ static char __cdecl ac_io_icca_req_uid(int unit_id) {
 static int __cdecl ac_io_icca_req_uid_isfinished(int unit_id, DWORD *read_state) {
     unit_id = icca_get_unit_id(unit_id);
     ICCA_UNIT *unit = &ICCA_UNITS[unit_id];
+    if (avs::game::is_model("JDZ")) {
+        // hack for RA - only ever seen it as this
+        *read_state = 8;
+        return 1;
+    }
     if (unit->card_in) {
         if (fabs(get_performance_seconds() - unit->card_in_time) < CARD_TIMEOUT) {
             unit->state = END;
@@ -403,16 +453,61 @@ static int __cdecl ac_io_icca_send_keep_alive_packet(int a1, int a2, int a3) {
     return 0;
 }
 
+static int __cdecl ac_io_icca_workflow_jdz(int workflow, int unit_id) {
+
+    unit_id = icca_get_unit_id(unit_id);
+    ICCA_UNIT *unit = &ICCA_UNITS[unit_id];
+    switch (workflow) {
+        // RA uses "STEP" as more of a polling thing it seems
+        case STEP:
+            switch (unit->state_jdz) {
+                case CLOSE_EJECT:
+                    unit->state_jdz = CLOSE_E_CHK;
+                    break;
+                case CLOSE_E_CHK:
+                    unit->state_jdz = CLOSE_END;
+                    break;
+                case CLOSE_END:
+                    unit->state_jdz = SLEEP;
+                    break;
+                default:
+                    break;
+            }
+            break;
+        case SLEEP:
+            unit->state = SLEEP;
+            break;
+        case START:
+            unit->state_jdz = INIT;
+            break;
+        case INIT:
+        case READY:
+            unit->state_jdz = READY;
+            break;
+        case CLOSE_EJECT:
+            unit->state_jdz = CLOSE_EJECT;
+            return CLOSE_E_CHK;
+        case CLOSE_END:
+            unit->state_jdz = SLEEP;
+            break;
+        default:
+            // should probably log a warning here
+            break;
+    }
+    return unit->state_jdz;
+}
+
 static int __cdecl ac_io_icca_workflow(int workflow, int unit_id) {
+    // RA uses a different workflow process for the slotted readers; treat it differently
+    if (avs::game::is_model("JDZ")) {
+        return ac_io_icca_workflow_jdz(workflow, unit_id);
+    }
 
     unit_id = icca_get_unit_id(unit_id);
     ICCA_UNIT *unit = &ICCA_UNITS[unit_id];
     switch (workflow) {
         case STEP:
-            if (avs::game::is_model("JDZ"))
-                unit->state = SLEEP;
-            else
-                unit->state = STEP;
+            unit->state = STEP;
             break;
         case SLEEP:
             unit->state = SLEEP;
@@ -441,7 +536,6 @@ static int __cdecl ac_io_icca_workflow(int workflow, int unit_id) {
         default:
             break;
     }
-
     return unit->state;
 }
 
@@ -467,6 +561,14 @@ acio::ICCAModule::ICCAModule(HMODULE module, acio::HookMode hookMode) : ACIOModu
 void acio::ICCAModule::attach() {
     ACIOModule::attach();
 
+    // workaround for RA; ac_io_icca_cardunit_init is never called so treat like both are initialized
+    if (avs::game::is_model("JDZ")) {
+        ICCA_UNITS[0].initialized = true;
+        ICCA_UNITS[1].initialized = true;
+
+        CARD_TIMEOUT = 10.0; // keep the card in the slot for longer
+    }
+
     // hooks
     ACIO_MODULE_HOOK(ac_io_icca_cardunit_init);
     ACIO_MODULE_HOOK(ac_io_icca_cardunit_init_isfinished);

src/spice2x/acio/j32d/j32d.cpp

@@ -52,7 +52,7 @@ static bool __cdecl ac_io_j32d_update_control_status_buffer(size_t a1) {
         float pad3_vel = Buttons::getVelocity(RI_MGR, buttons.at(games::ftt::Buttons::Pad3));
         float pad4_vel = Buttons::getVelocity(RI_MGR, buttons.at(games::ftt::Buttons::Pad4));
         // FIXME(felix): this logic seems wrong for analog handling but correct for digital inputs
-        if (pad1_vel > 0.f) {
+        if (Buttons::getState(RI_MGR, buttons.at(games::ftt::Buttons::Pad1))) {
             STATUS_BUFFER[6] = (int) (51.f * pad1_vel + 0.5f);
         }
         if (Buttons::getState(RI_MGR, buttons.at(games::ftt::Buttons::Pad2))) {
@@ -67,10 +67,10 @@ static bool __cdecl ac_io_j32d_update_control_status_buffer(size_t a1) {
 
         // process analogs
         auto &analogs = games::ftt::get_analogs();
-        auto pad1_analog = analogs.at(games::ftt::Analogs::Pad1);
-        auto pad2_analog = analogs.at(games::ftt::Analogs::Pad2);
-        auto pad3_analog = analogs.at(games::ftt::Analogs::Pad3);
-        auto pad4_analog = analogs.at(games::ftt::Analogs::Pad4);
+        auto &pad1_analog = analogs.at(games::ftt::Analogs::Pad1);
+        auto &pad2_analog = analogs.at(games::ftt::Analogs::Pad2);
+        auto &pad3_analog = analogs.at(games::ftt::Analogs::Pad3);
+        auto &pad4_analog = analogs.at(games::ftt::Analogs::Pad4);
         if (pad1_analog.isSet()) {
             auto val = (uint32_t) (51.f * Analogs::getState(RI_MGR, pad1_analog) + 0.5f);
             STATUS_BUFFER[6] = MAX(STATUS_BUFFER[6], val);

src/spice2x/acio/kfca/kfca.cpp

@@ -8,10 +8,21 @@
 #include "games/sdvx/io.h"
 #include "misc/eamuse.h"
 #include "rawinput/rawinput.h"
+#include "util/socd_cleaner.h"
+#include "util/time.h"
 #include "util/utils.h"
 
 using namespace GameAPI;
 
+#define DEBUG_VERBOSE 0
+
+#if DEBUG_VERBOSE
+#define log_debug(module, format_str, ...) logger::push( \
+    LOG_FORMAT("M", module, format_str, ## __VA_ARGS__), logger::Style::GREY)
+#else
+#define log_debug(module, format_str, ...)
+#endif
+
 // globals
 uint8_t KFCA_VOL_SOUND = 96;
 uint8_t KFCA_VOL_HEADPHONE = 96;
@@ -342,18 +353,25 @@ static char __cdecl ac_io_kfca_update_control_status_buffer() {
         }
 
         // volume left
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Left))) {
+        const auto now = get_performance_milliseconds();
+        const auto vol_l_state = socd::socd_clean(0,
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Left)),
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Right)),
+            now);
+        if (vol_l_state == socd::SocdCCW) {
             KFCA_VOLL = (KFCA_VOLL - games::sdvx::DIGITAL_KNOB_SENS) & 1023;
-        }
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Right))) {
+        } else if (vol_l_state == socd::SocdCW) {
             KFCA_VOLL = (KFCA_VOLL + games::sdvx::DIGITAL_KNOB_SENS) & 1023;
         }
 
         // volume right
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Left))) {
+        const auto vol_r_state = socd::socd_clean(1,
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Left)),
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Right)),
+            now);
+        if (vol_r_state == socd::SocdCCW) {
             KFCA_VOLR = (KFCA_VOLR - games::sdvx::DIGITAL_KNOB_SENS) & 1023;
-        }
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Right))) {
+        } else if (vol_r_state == socd::SocdCW) {
             KFCA_VOLR = (KFCA_VOLR + games::sdvx::DIGITAL_KNOB_SENS) & 1023;
         }
 
@@ -371,6 +389,8 @@ static char __cdecl ac_io_kfca_update_control_status_buffer() {
         // proper loops
         vol_left %= 1024;
         vol_right %= 1024;
+        
+        log_debug("kfca", "knobs = {} {}", vol_left, vol_right);
 
         // save volumes in buffer
         STATUS_BUFFER[input_offset + 16 + 0] |= (unsigned char) ((vol_left << 6) & 0xFF);

src/spice2x/acio/mdxf/mdxf.cpp

@@ -1,68 +1,253 @@
 #include "mdxf.h"
+#include "mdxf_poll.h"
+
+#include <mutex>
 
 #include "avs/game.h"
+#include "games/ddr/ddr.h"
 #include "games/ddr/io.h"
 #include "launcher/launcher.h"
 #include "rawinput/rawinput.h"
 #include "util/logging.h"
+#include "util/precise_timer.h"
 #include "util/utils.h"
 
+#define MDFX_DEBUG_VERBOSE 0
+
+#if MDFX_DEBUG_VERBOSE
+#define log_debug(module, format_str, ...) logger::push( \
+    LOG_FORMAT("M", module, format_str, ## __VA_ARGS__), logger::Style::GREY)
+#else
+#define log_debug(module, format_str, ...)
+#endif
+
 // constants
 const size_t STATUS_BUFFER_SIZE = 32;
+const size_t STATUS_BUFFER_NUM_ENTRIES = 16;
 
 // static stuff
-static uint8_t COUNTER = 0;
+static uint8_t HEAD_P1 = 0;
+static uint8_t HEAD_P2 = 0;
+
+static uint16_t PREV_STATE_P1 = 0;
+static uint16_t PREV_STATE_P2 = 0;
+static uint64_t PREV_TIME_P1 = 0;
+static uint64_t PREV_TIME_P2 = 0;
+
+static std::mutex MUTEX_P1;
+static std::mutex MUTEX_P2;
+
+static bool IS_MDXF_ACTIVE = false;
+
+static const uint8_t BACKFILL_INTERVAL_MS = 4;
+static const uint8_t BACKFILL_PADDING_MS = 2;
+
+// These are used to determine if a thread needs to be spun up to keep pad state ring buffers populated with enough recent polls
+static uint64_t START_TIME = 0;
+static int CALL_COUNT = 0;
+static const int THRESHOLD_REFRESH_RATE = 120;
+
+static std::atomic<bool> IS_REFRESH_RATE_MEASUREMENT_STARTED{false};
+static std::atomic<bool> IS_REFRESH_RATE_DETERMINED{false};
+static std::atomic<bool> IS_THREAD_NEEDED{false};
+static std::atomic<bool> MDXF_THREAD_RUNNING{false};
+
+static std::thread MDXF_THREAD;
+
+static constexpr int THREAD_REFRESH_RATE_HZ = 125;
+static constexpr auto THREAD_PERIOD = std::chrono::milliseconds(1000 / THREAD_REFRESH_RATE_HZ);
 
 // buffers
 #pragma pack(push, 1)
 static struct {
-    uint8_t STATUS_BUFFER_P1[7][STATUS_BUFFER_SIZE] {};
-    uint8_t STATUS_BUFFER_P2[7][STATUS_BUFFER_SIZE] {};
+    uint8_t STATUS_BUFFER_P1[STATUS_BUFFER_NUM_ENTRIES][STATUS_BUFFER_SIZE] {};
+    uint8_t STATUS_BUFFER_P2[STATUS_BUFFER_NUM_ENTRIES][STATUS_BUFFER_SIZE] {};
 } BUFFERS {};
 #pragma pack(pop)
 
 static bool STATUS_BUFFER_FREEZE = false;
 
+// Decides which method to use for populating ring buffer entries for "padding".
+// Overwritten in spicecfg using P4IO Buffer Algorithm option.
+// THREAD_MODE: Spins a thread running at THREAD_REFRESH_RATE_HZ which periodically fills the ring
+//              buffer with auxiliary entries. Falls back on BACKFILL_MODE
+// BACKFILL_MODE: On every update cycle, fill the ring buffer with entries for the last known state
+//                BACKFILL_INTERVAL_MS apart from each other from the time of the last entry to the
+//                current time before adding the entry for the current state.
+// AUTO_MODE: thread mode if <120Hz, backfill if >=120Hz
+acio::MDXFBufferFillMode acio::MDXF_BUFFER_FILL_MODE = acio::MDXFBufferFillMode::AUTO_MODE;
+
+typedef enum {
+    ARKMDXP4_POLL = 0,
+    INTERNAL_POLL = 1,
+    EXTERNAL_POLL = 2
+} MDXFPollSource;
+
 typedef uint64_t (__cdecl *ARK_GET_TICK_TIME64_T)();
 
 static uint64_t arkGetTickTime64() {
-    static ARK_GET_TICK_TIME64_T getTickTime64 =
-        (ARK_GET_TICK_TIME64_T)GetProcAddress(avs::game::DLL_INSTANCE, "arkGetTickTime64");
-    if (getTickTime64 == nullptr) {
-        // this works on 32-bit versions of avs, but not on 64.
-        // it's better than nothing though.
-        return timeGetTime();
+    static ARK_GET_TICK_TIME64_T getTickTime64 = nullptr;
+
+    if (!getTickTime64) {
+        HMODULE h = avs::game::DLL_INSTANCE;
+        if (h) {
+            getTickTime64 = (ARK_GET_TICK_TIME64_T)GetProcAddress(h, "arkGetTickTime64");
+        }
+    }
+    // this works on 32-bit versions of avs, but not on 64.
+    // it's better than nothing though.
+    return getTickTime64 ? getTickTime64() : timeGetTime();
+}
+
+// Used to keep the ring buffer populated with steady updates. 60Hz interval is too slow
+static void mdxf_thread_start() {
+    bool expected = false;
+    if (!MDXF_THREAD_RUNNING.compare_exchange_strong(expected, true)) {
+        return;
+    }
+
+    log_info("mdxf", "starting poll thread");
+
+    MDXF_THREAD = std::thread([] {
+        SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_BELOW_NORMAL);
+
+        timeutils::PreciseSleepTimer timer;
+        while (MDXF_THREAD_RUNNING.load(std::memory_order_acquire)) {
+            mdxf_poll(false);
+            timer.sleep(THREAD_PERIOD);
+        }
+    });
+}
+
+static void mdxf_thread_stop() {
+    if (!MDXF_THREAD_RUNNING.exchange(false)) {
+        return;
+    }
+
+    if (MDXF_THREAD.joinable()) {
+        MDXF_THREAD.join();
+    }
+
+}
+
+// Snaps measured refresh rate to best fit
+static int snap_refresh_rate(int measured_hz) {
+    static constexpr std::array<int, 6> rates = {
+        60, 120, 144, 165, 180, 240
+    };
+
+    int best = rates[0];
+    int best_err = std::fabs(measured_hz - best);
+
+    for (int r : rates) {
+        int err = std::fabs(measured_hz - r);
+        if (err < best_err) {
+            best = r;
+            best_err = err;
+        }
+    }
+    return best;
+}
+
+// Increments the number of times the update function was called,
+// then calculates the current refresh rate of the game
+// (20 seconds after the game starts, until 25 seconds)
+static void count_calls_from_game() {
+    if (IS_REFRESH_RATE_DETERMINED) {
+        return;
+    }
+
+    const uint64_t current_time = arkGetTickTime64();
+
+    if (!IS_REFRESH_RATE_MEASUREMENT_STARTED) {
+        if (START_TIME == 0) {
+            START_TIME = current_time;
+        }
+
+        // boot screen takes about 10 seconds, so let's wait for double that
+        if ((current_time - START_TIME) < 20000) {
+            // too early, do nothing
+            return;
+        } else {
+            // 20s has passed for the first time, start measuring on next call
+            IS_REFRESH_RATE_MEASUREMENT_STARTED = true;
+            START_TIME = current_time;
+            log_debug("mdxf", "measurement begin");
+            return;
+        }
+    }
+
+    const uint64_t elapsed_time = current_time - START_TIME;
+    CALL_COUNT++;
+    if (elapsed_time >= 5000) {
+        double measured_hz = static_cast<double>(CALL_COUNT) * 1000.0 / static_cast<double>(elapsed_time);
+        
+        // Account for the main loop calling this twice per iteration
+        measured_hz *= 0.5;
+        const int snapped_hz = snap_refresh_rate(static_cast<int>(measured_hz));
+
+        IS_REFRESH_RATE_DETERMINED = true;
+        IS_THREAD_NEEDED = (snapped_hz < THRESHOLD_REFRESH_RATE);
+        log_info(
+            "mdxf",
+            "detected: {} Hz, best fit: {} Hz",
+            static_cast<int>(measured_hz),
+            snapped_hz);
+
+        if (IS_THREAD_NEEDED) {
+            mdxf_thread_start();
+        }
     }
-    return getTickTime64();
 }
 
 /*
  * Implementations
  */
 
-static bool __cdecl ac_io_mdxf_get_control_status_buffer(int node, void *buffer, uint8_t a3, uint8_t a4) {
+static uint64_t __cdecl ac_io_mdxf_get_control_status_buffer(int node, void *out, uint8_t index, uint8_t head_in) {
 
+    // Default error value (matches original mask behavior)
+    auto error_ret = static_cast<uint64_t>(node - 0x11) & 0xFFFFFFFFFFFFFF00;
+    
     // Dance Dance Revolution
     if (avs::game::is_model("MDX")) {
-
-        // get buffer index
-        auto i = (COUNTER + a3) % std::size(BUFFERS.STATUS_BUFFER_P1);
-
-        // copy buffer
+        // Select player-specific state
+        std::mutex* mutex = nullptr;
+        uint8_t* head = nullptr;
+        uint8_t (*buffer)[STATUS_BUFFER_SIZE];
+        size_t size = STATUS_BUFFER_NUM_ENTRIES;
+        
         if (node == 17 || node == 25) {
-            memcpy(buffer, BUFFERS.STATUS_BUFFER_P1[i], STATUS_BUFFER_SIZE);
+            mutex = &MUTEX_P1;
+            head = &HEAD_P1;
+            buffer = BUFFERS.STATUS_BUFFER_P1;
         } else if (node == 18 || node == 26) {
-            memcpy(buffer, BUFFERS.STATUS_BUFFER_P2[i], STATUS_BUFFER_SIZE);
+            mutex = &MUTEX_P2;
+            head = &HEAD_P2;
+            buffer = BUFFERS.STATUS_BUFFER_P2;
         } else {
-
-            // fill with zeros on unknown node
-            memset(buffer, 0, STATUS_BUFFER_SIZE);
-            return false;
+            memset(out, 0, STATUS_BUFFER_SIZE);
+            return error_ret;
         }
+        
+        std::lock_guard<std::mutex> lock(*mutex);
+        
+        const uint8_t start_index = (head_in == 0xFF) ? *head : head_in;
+
+        // Compute ring index: walk backwards from start_index as index increases
+        // Assumes ring buffer size is a power of two
+        const size_t mask = size - 1;
+        const size_t offset = static_cast<size_t>(index) & mask;
+        const size_t i = (static_cast<size_t>(start_index) - offset + size) & mask;
+
+        // Copy the chosen entry
+        memcpy(out, buffer[i], STATUS_BUFFER_SIZE);
+
+        // Return the start value actually used
+        return static_cast<uint64_t>(start_index);
     }
 
-    // return success
-    return true;
+    return error_ret;
 }
 
 static bool __cdecl ac_io_mdxf_set_output_level(unsigned int a1, unsigned int a2, uint8_t value) {
@@ -104,37 +289,58 @@ static bool __cdecl ac_io_mdxf_set_output_level(unsigned int a1, unsigned int a2
     return true;
 }
 
-static bool __cdecl ac_io_mdxf_update_control_status_buffer(int node) {
-
-    // increase counter
-    COUNTER = (COUNTER + 1) % std::size(BUFFERS.STATUS_BUFFER_P1);
+static bool __cdecl ac_io_mdxf_update_control_status_buffer_impl(int node, MDXFPollSource source, uint64_t current_time) {
 
     // check freeze
     if (STATUS_BUFFER_FREEZE) {
         return true;
     }
 
-    // clear buffer
-    uint8_t *buffer = nullptr;
-    switch (node) {
-        case 17:
-        case 25:
-            buffer = BUFFERS.STATUS_BUFFER_P1[COUNTER];
-            break;
-        case 18:
-        case 26:
-            buffer = BUFFERS.STATUS_BUFFER_P2[COUNTER];
-            break;
-        default:
-
-            // return failure on unknown node
-            return false;
-    }
-    memset(buffer, 0, STATUS_BUFFER_SIZE);
-
     // Dance Dance Revolution
     if (avs::game::is_model("MDX")) {
-
+        // Marks this module as actively being used, allowing this function to be called from other sources
+        if (source == ARKMDXP4_POLL) {
+            if (!IS_MDXF_ACTIVE) {
+                log_debug("mdxf", "initializing mdxf I/O support");
+                IS_MDXF_ACTIVE = true;
+                if (acio::MDXF_BUFFER_FILL_MODE == acio::MDXFBufferFillMode::THREAD_MODE) {
+                    IS_THREAD_NEEDED = true;
+                    mdxf_thread_start();
+                }
+            }
+            if (acio::MDXF_BUFFER_FILL_MODE == acio::MDXFBufferFillMode::AUTO_MODE) {
+                count_calls_from_game();
+            }
+        }
+        
+        uint8_t (*buffer)[STATUS_BUFFER_SIZE];
+        uint8_t *head = nullptr;
+        uint16_t *prev_state = nullptr;
+        uint64_t *prev_time = nullptr;
+        std::mutex* mutex = nullptr;
+        
+        switch (node) {
+            case 17:
+            case 25:
+                mutex = &MUTEX_P1;
+                head = &HEAD_P1;
+                prev_state = &PREV_STATE_P1;
+                prev_time = &PREV_TIME_P1;
+                buffer = BUFFERS.STATUS_BUFFER_P1;
+                break;
+            case 18:
+            case 26:
+                mutex = &MUTEX_P2;
+                head = &HEAD_P2;
+                prev_state = &PREV_STATE_P2;
+                prev_time = &PREV_TIME_P2;
+                buffer = BUFFERS.STATUS_BUFFER_P2;
+                break;
+            default:
+                // return failure on unknown node
+                return false;
+        }
+    
         // Sensor Map (LDUR):
         // FOOT DOWN = bit 32-35 = byte 4, bit 0-3
         // FOOT UP = bit 36-39 = byte 4, bit 4-7
@@ -155,40 +361,137 @@ static bool __cdecl ac_io_mdxf_update_control_status_buffer(int node) {
 
         // decide on button map
         const size_t *button_map = nullptr;
+        int player = 0;
         switch (node) {
             case 17:
             case 25:
                 button_map = &buttons_p1[0];
+                player = 1;
                 break;
             case 18:
             case 26:
                 button_map = &buttons_p2[0];
+                player = 2;
                 break;
         }
+        
+        uint16_t current_state;
+        
+        // Only call getState() if called externally when actual input events happen, otherwise use previous known state
+        if (source == EXTERNAL_POLL) {
+            // get buttons
+            auto &buttons = games::ddr::get_buttons();
+            
+            // get analogs
+            bool analog_left = false;
+            bool analog_right = false;
+            games::ddr::get_analog_x_axis(player, analog_left, analog_right);
+            bool analog_up = false;
+            bool analog_down = false;
+            games::ddr::get_analog_y_axis(player, analog_up, analog_down);
+            
+            uint8_t up_down = 0;
+            uint8_t left_right = 0;
+            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[0])) || analog_up) {
+                up_down |= 0xF0;
+            }
+            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[1])) || analog_down) {
+                up_down |= 0x0F;
+            }
+            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[2])) || analog_left) {
+                left_right |= 0xF0;
+            }
+            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[3])) || analog_right) {
+                left_right |= 0x0F;
+            }
+            current_state = (uint16_t(up_down) << 8) | left_right;
+        } else {
+            current_state = *prev_state;
+        }
+        
+        std::lock_guard<std::mutex> lock(*mutex);
+        
+        const bool has_state_changed = *prev_state != current_state;
+        const bool has_time_changed = *prev_time < current_time;
+        
+        // If state hasn't changed and either the update was triggered externally or the time hasn't changed, then don't advance head pointer or write a new entry
+        if (!has_state_changed && (source == EXTERNAL_POLL || !has_time_changed)) {
+            return true;
+        }
+        
+        // The start and stop time cutoffs for backfilling entries. Min(..) ensures times aren't negative.
+        // The stop time is just before the current_time, set by BACKFILL_PADDING_MS, which avoids the last backfilled entry being too close to current_time.
+        uint64_t start_time = *prev_time;
+        const uint64_t stop_time = current_time - std::min<uint64_t>(current_time, BACKFILL_PADDING_MS);
+        
+        // Ensures the first iteration will write the first entry at current_time and not backfill to time 0ms.
+        if (start_time == 0) {
+            start_time = current_time - std::min<uint64_t>(current_time, BACKFILL_INTERVAL_MS);
+        }
+        
+        // Ensures only STATUS_BUFFER_NUM_ENTRIES entries at most are backfilled
+        const uint64_t max_backfill = BACKFILL_INTERVAL_MS * STATUS_BUFFER_NUM_ENTRIES;
+        const uint64_t min_time = current_time - std::min<uint64_t>(current_time, max_backfill);
+        if (start_time < min_time) {
+            start_time = min_time;
+        }
+        
+        // Don't backfill entries if called externally or if a separate thread is being used to fill auxiliary entries
+        if (source == EXTERNAL_POLL || IS_THREAD_NEEDED) {
+            start_time = stop_time - 1;
+        }
+        
+        uint64_t time = start_time;
+        uint16_t state = *prev_state;
+        
+        // Backfill entries a fixed interval apart from each other between prev_time and current_time
+        while (time < stop_time) {
+            // Advance head pointer
+            *head = (*head + 1) % STATUS_BUFFER_NUM_ENTRIES;
+            uint8_t* buffer_entry = buffer[*head];
 
-        *(uint64_t*)&buffer[0x18] = arkGetTickTime64();
-
-        // get buttons
-        auto &buttons = games::ddr::get_buttons();
-
-        if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[0]))) {
-            buffer[4] |= 0xF0;
-        }
-        if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[1]))) {
-            buffer[4] |= 0x0F;
-        }
-        if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[2]))) {
-            buffer[5] |= 0xF0;
-        }
-        if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[3]))) {
-            buffer[5] |= 0x0F;
+            // Clear buffer
+            memset(buffer_entry, 0, STATUS_BUFFER_SIZE);
+            
+            time += BACKFILL_INTERVAL_MS;
+            
+            // If the stop time is reached, then write current_time and current_state instead for this final iteration
+            const bool isEdge = (time >= stop_time);
+            if (isEdge) {
+                state = current_state;
+                time = current_time;
+            }
+            
+            // Write button state
+            buffer_entry[4] = (state >> 8) & 0xFF;
+            buffer_entry[5] = state & 0xFF;
+            
+            // Write game time
+            *(uint64_t*)&buffer_entry[0x18] = time;
         }
+        
+        *prev_state = current_state;
+        *prev_time = current_time;
     }
 
     // return success
     return true;
 }
 
+static bool __cdecl ac_io_mdxf_update_control_status_buffer(int node) {
+    return ac_io_mdxf_update_control_status_buffer_impl(node, ARKMDXP4_POLL, arkGetTickTime64());
+}
+
+// Used for triggering updates of the controller states from outside arkmdxp4.dll main refresh loop (i.e. within rawinput.cpp on controller events)
+void mdxf_poll(bool isExternal) {
+    if (IS_MDXF_ACTIVE) {
+        const MDXFPollSource source = isExternal ? EXTERNAL_POLL : INTERNAL_POLL;
+        const uint64_t call_time_ms = arkGetTickTime64();
+        ac_io_mdxf_update_control_status_buffer_impl(17, source, call_time_ms);
+        ac_io_mdxf_update_control_status_buffer_impl(18, source, call_time_ms);
+    }
+}
+
 /*
  * Module stuff
  */
@@ -207,3 +510,9 @@ void acio::MDXFModule::attach() {
     ACIO_MODULE_HOOK(ac_io_mdxf_set_output_level);
     ACIO_MODULE_HOOK(ac_io_mdxf_update_control_status_buffer);
 }
+
+acio::MDXFModule::~MDXFModule() {
+    if (IS_THREAD_NEEDED) {
+        mdxf_thread_stop();
+    }
+}

src/spice2x/acio/mdxf/mdxf.h

@@ -4,10 +4,24 @@
 
 namespace acio {
 
+    enum class MDXFBufferFillMode {
+        // backfill mode, but if <120Hz, enable poll thread
+        AUTO_MODE,
+
+        // forces poll thread
+        THREAD_MODE,
+
+        // forces backfill mode (no poll thread)
+        BACKFILL_MODE
+    };
+
+    extern MDXFBufferFillMode MDXF_BUFFER_FILL_MODE;
+
     class MDXFModule : public ACIOModule {
     public:
         MDXFModule(HMODULE module, HookMode hookMode);
 
         virtual void attach() override;
+        ~MDXFModule() override; 
     };
 }

src/spice2x/acio/mdxf/mdxf_poll.h

@@ -0,0 +1,5 @@
+// mdxf_poll.h
+#pragma once
+
+// Called from rawinput thread whenever inputs have just been updated
+void mdxf_poll(bool isExternal);

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
@@ -84,7 +86,7 @@ static bool __cdecl ac_io_panb_start_auto_input() {
     return true;
 }
 
-static uint8_t panb_get_button_velocity(Button button, Button button_soft, Button button_medium, Button button_hard) {
+static uint8_t panb_get_button_velocity(Button& button, Button& button_soft, Button& button_medium, Button& button_hard) {
     const auto velocity = Buttons::getVelocity(RI_MGR, button);
     const auto velocity_soft = Buttons::getVelocity(RI_MGR, button_soft);
     const auto velocity_medium = Buttons::getVelocity(RI_MGR, button_medium);
@@ -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/acio2emu/packet.cpp

@@ -95,12 +95,19 @@ namespace acio2emu {
             break;
 
         default:
-            log_fatal("acio2emu", "cannot set step: unknown value: {}", s);
+            log_fatal(
+                "acio2emu",
+                "cannot set step: unknown value: {}",
+                static_cast<uint32_t>(s));
             break;
         }
 
         if (!valid) {
-            log_fatal("acio2emu", "illegal transition detected: {} -> {}", step_, s);
+            log_fatal(
+                "acio2emu",
+                "illegal transition detected: {} -> {}",
+                static_cast<uint32_t>(step_),
+                static_cast<uint32_t>(s));
         }
 #endif
         step_ = s;

src/spice2x/acioemu/device.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <string>
 
 #include "util/circular_buffer.h"

src/spice2x/acioemu/icca.cpp

@@ -2,8 +2,10 @@
 
 #include "acio/icca/icca.h"
 #include "avs/game.h"
+#include "games/sdvx/sdvx.h"
 #include "misc/eamuse.h"
 #include "util/logging.h"
+#include "util/precise_timer.h"
 #include "util/utils.h"
 
 using namespace acioemu;
@@ -45,11 +47,12 @@ ICCADevice::ICCADevice(bool flip_order, bool keypad_thread, uint8_t node_count)
     // keypad thread for faster polling
     if (keypad_thread) {
         this->keypad_thread = new std::thread([this]() {
+            timeutils::PreciseSleepTimer timer;
             while (this->cards) {
                 for (int unit = 0; unit < this->node_count; unit++) {
                     this->update_keypad(unit, false);
                 }
-                Sleep(7);
+                timer.sleep(7);
             }
         });
     }
@@ -101,13 +104,10 @@ bool ICCADevice::parse_msg(MessageData *msg_in,
 
             // send version data
             auto msg = this->create_msg(msg_in, MSG_VERSION_SIZE);
-            if (
-                avs::game::is_model({"LDJ", "TBS", "UJK"}) ||
-                // SDVX Valkyrie cabinet mode
-                (avs::game::is_model("KFC") && (avs::game::SPEC[0] == 'G' || avs::game::SPEC[0] == 'H'))
-            ) {
+            if (avs::game::is_model({"LDJ", "TBS", "UJK", "XIF"}) ||
+                games::sdvx::is_valkyrie_model()) {
                 this->set_version(msg, 0x3, 0, 1, 7, 0, "ICCA");
-            } else if (avs::game::is_model({"VFG"})) {
+            } else if (avs::game::is_model("VFG")) {
                 this->set_version(msg, 0x3, 0, 1, 7, 0, "ICCB");
             } else {
                 this->set_version(msg, 0x3, 0, 1, 6, 0, "ICCA");
@@ -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
@@ -373,7 +373,7 @@ void ICCADevice::update_card(int unit) {
     bool kb_insert_press = false;
 
     // eamio keypress
-    kb_insert_press |= eamuse_get_keypad_state((size_t) unit) & (1 << EAM_IO_INSERT);
+    kb_insert_press |= static_cast<bool>(eamuse_get_keypad_state((size_t) unit) & (1 << EAM_IO_INSERT));
 
     // check for card
     if (this->cards[unit] == nullptr && (eamuse_card_insert_consume(this->node_count, unit) || kb_insert_press)) {
@@ -520,11 +520,7 @@ void ICCADevice::update_status(int unit) {
             buffer[1] = felica ? 0x01 : 0x00;
             buffer[10] = felica ? 0x01 : 0x00;
 
-        } else if (
-            avs::game::is_model({"LDJ", "TBS"}) ||
-            // SDVX Valkyrie cabinet mode
-            (avs::game::is_model("KFC") && (avs::game::SPEC[0] == 'G' || avs::game::SPEC[0] == 'H'))) {
-
+        } else if (avs::game::is_model({"LDJ", "TBS", "XIF"}) || games::sdvx::is_valkyrie_model()) {
             // set status to 0 otherwise reader power on fails
             buffer[0] = 0x00;
         } else {

src/spice2x/api/capture_pump.cpp

@@ -0,0 +1,59 @@
+#include "capture_pump.h"
+
+#include <array>
+#include <atomic>
+#include <mutex>
+
+#include "hooks/graphics/graphics.h"
+
+namespace api::capture_pump {
+
+    namespace {
+
+        std::array<std::mutex, GRAPHICS_CAPTURE_SCREEN_NO> CONSUMER_M;
+
+        // read once per capture from the present thread, so it stays lock free
+        std::atomic<bool> CLAIMED[GRAPHICS_CAPTURE_SCREEN_NO] {};
+
+        bool valid_screen(int screen) {
+            return 0 <= screen && screen < static_cast<int>(GRAPHICS_CAPTURE_SCREEN_NO);
+        }
+    }
+
+    bool capture_direct(int screen, std::shared_ptr<uint8_t[]> &out, int divide,
+            uint64_t *timestamp, int *width, int *height) {
+
+        if (!valid_screen(screen)) {
+            return false;
+        }
+
+        std::lock_guard<std::mutex> lock(CONSUMER_M[screen]);
+        graphics_capture_trigger(screen);
+        return graphics_capture_receive_raw(
+                screen, out, divide, timestamp, width, height);
+    }
+
+    bool claim_screen(int screen) {
+        if (!valid_screen(screen)) {
+            return false;
+        }
+
+        return !CLAIMED[screen].exchange(true);
+    }
+
+    void release_screen(int screen) {
+        if (!valid_screen(screen)) {
+            return;
+        }
+
+        CLAIMED[screen] = false;
+    }
+
+    bool screen_claimed(int screen) {
+        if (!valid_screen(screen)) {
+            return false;
+        }
+
+        return CLAIMED[screen];
+    }
+}

src/spice2x/api/capture_pump.h

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

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,12 +5,16 @@
 
 #include <utility>
 
+#include "client.h"
 #include "cfg/configurator.h"
 #include "external/rapidjson/document.h"
+#include "external/rapidjson/error/en.h"
 #include "util/crypt.h"
 #include "util/logging.h"
 #include "util/utils.h"
 
+#include "overlay/notifications.h"
+
 #include "module.h"
 #include "modules/analogs.h"
 #include "modules/buttons.h"
@@ -26,6 +30,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"
@@ -34,6 +39,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)
 {
@@ -197,6 +204,9 @@ void Controller::connection_handler(api::ClientState client_state) {
 
     // log connection
     log_info("api", "client connected: {}", client_address_str);
+    overlay::notifications::add(
+            overlay::notifications::Severity::Success,
+            fmt::format("API client connected ({})", client_address_str));
     client_states_m.lock();
     client_states.emplace_back(&client_state);
     client_states_m.unlock();
@@ -277,6 +287,9 @@ void Controller::connection_handler(api::ClientState client_state) {
 
     // log disconnect
     log_info("api", "client disconnected: {}", client_address_str);
+    overlay::notifications::add(
+            overlay::notifications::Severity::Info,
+            fmt::format("API client disconnected ({})", client_address_str));
     client_states_m.lock();
     client_states.erase(std::remove(client_states.begin(), client_states.end(), &client_state));
     client_states_m.unlock();
@@ -300,6 +313,8 @@ bool Controller::process_request(ClientState *state, const char *in, size_t in_s
 
     // check for parse error
     if (document.HasParseError()) {
+        log_warning("api", "Request JSON parse error: {} (byte offset {}, decrypted request length {} bytes)",
+            GetParseError_En(document.GetParseError()), document.GetErrorOffset(), in_size);
 
         // return empty response and close connection
         out->push_back(0);
@@ -325,9 +340,11 @@ bool Controller::process_request(ClientState *state, const char *in, size_t in_s
             if (module->name == request.module) {
                 module_found = true;
 
-                // check password force
-                if (module->password_force && this->password.empty() && request.function != "session_refresh") {
-                    Value err("Module requires the password to be set.");
+                // check password requirement
+                if (module->requires_password(request.function)
+                        && this->password.empty()
+                        && request.function != "session_refresh") {
+                    Value err("Function requires the password to be set.");
                     response.add_error(err);
                     break;
                 }
@@ -403,8 +420,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) {
@@ -416,6 +436,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/h264_stream.cpp

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

src/spice2x/api/h264_stream.h

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

src/spice2x/api/module.cpp

@@ -16,6 +16,14 @@ namespace api {
         this->password_force = password_force;
     }
 
+    void Module::require_password(const std::string &function) {
+        this->password_force_functions.emplace(function);
+    }
+
+    bool Module::requires_password(const std::string &function) const {
+        return this->password_force || this->password_force_functions.contains(function);
+    }
+
     void Module::handle(Request &req, Response &res) {
 
         // log module access

src/spice2x/api/module.h

@@ -4,6 +4,7 @@
 #include <map>
 #include <string>
 #include <sstream>
+#include <unordered_set>
 #include <external/robin_hood.h>
 
 #include "response.h"
@@ -26,6 +27,13 @@ namespace api {
         // default constructor
         explicit Module(std::string name, bool password_force=false);
 
+        void require_password(const std::string &function);
+
+    private:
+
+        // functions which expose sensitive data or actions
+        std::unordered_set<std::string> password_force_functions;
+
     public:
 
         // virtual deconstructor
@@ -35,6 +43,8 @@ namespace api {
         std::string name;
         bool password_force;
 
+        bool requires_password(const std::string &function) const;
+
         // the magic
         void handle(Request &req, Response &res);
 

src/spice2x/api/modules/analogs.cpp

@@ -6,6 +6,7 @@
 #include "launcher/launcher.h"
 #include "games/io.h"
 #include "util/utils.h"
+#include "acio/mdxf/mdxf_poll.h"
 
 using namespace std::placeholders;
 using namespace rapidjson;
@@ -104,6 +105,7 @@ namespace api::modules {
                 for (auto &analog : *this->analogs) {
                     analog.override_enabled = false;
                 }
+                mdxf_poll(true);
             }
             return;
         }
@@ -148,6 +150,7 @@ namespace api::modules {
             if (analog.getName() == name) {
                 analog.override_state = CLAMP(state, 0.f, 1.f);
                 analog.override_enabled = true;
+                mdxf_poll(true);
                 return true;
             }
         }
@@ -167,6 +170,7 @@ namespace api::modules {
         for (auto &analog : *this->analogs) {
             if (analog.getName() == name) {
                 analog.override_enabled = false;
+                mdxf_poll(true);
                 return true;
             }
         }

src/spice2x/api/modules/buttons.cpp

@@ -6,6 +6,7 @@
 #include "launcher/launcher.h"
 #include "games/io.h"
 #include "util/utils.h"
+#include "acio/mdxf/mdxf_poll.h"
 
 using namespace std::placeholders;
 using namespace rapidjson;
@@ -107,6 +108,7 @@ namespace api::modules {
                 for (auto &button : *this->buttons) {
                     button.override_enabled = false;
                 }
+                mdxf_poll(true);
             }
             return;
         }
@@ -153,6 +155,7 @@ namespace api::modules {
                         GameAPI::Buttons::BUTTON_PRESSED : GameAPI::Buttons::BUTTON_NOT_PRESSED;
                 button.override_velocity = CLAMP(state, 0.f, 1.f);
                 button.override_enabled = true;
+                mdxf_poll(true);
                 return true;
             }
         }
@@ -172,6 +175,7 @@ namespace api::modules {
         for (auto &button : *this->buttons) {
             if (button.getName() == name) {
                 button.override_enabled = false;
+                mdxf_poll(true);
                 return true;
             }
         }

src/spice2x/api/modules/capture.cpp

@@ -1,7 +1,14 @@
 #include "capture.h"
+#include <atomic>
 #include <functional>
+#include <mutex>
+#include <unordered_map>
+#include "api/capture_pump.h"
+#include "api/stream_format.h"
+#include "api/stream_server.h"
 #include "external/rapidjson/document.h"
 #include "hooks/graphics/graphics.h"
+#include "hooks/graphics/jpeg_encoder.h"
 #include "util/crypt.h"
 
 using namespace std::placeholders;
@@ -14,9 +21,60 @@ namespace api::modules {
 
     static thread_local std::vector<uint8_t> CAPTURE_BUFFER;
 
+    struct CachedFrame {
+        std::vector<uint8_t> jpeg;
+        uint64_t timestamp = 0;
+        int width = 0;
+        int height = 0;
+    };
+
+    static std::mutex FRAME_CACHE_M;
+    static std::unordered_map<int, CachedFrame> FRAME_CACHE;
+
+    static void add_jpeg_response(
+            int screen,
+            uint64_t timestamp,
+            int width,
+            int height,
+            const std::vector<uint8_t> &jpeg,
+            Response &res) {
+
+        auto encoded = crypt::base64_encode(jpeg.data(), jpeg.size());
+
+        Value data;
+        data.SetString(encoded.c_str(), encoded.length(), res.doc()->GetAllocator());
+        res.add_data(timestamp);
+        res.add_data(width);
+        res.add_data(height);
+        res.add_data(data);
+
+        std::lock_guard<std::mutex> lock(FRAME_CACHE_M);
+        FRAME_CACHE[screen] = {jpeg, timestamp, width, height};
+    }
+
+    static bool try_cached_response(int screen, Response &res) {
+        std::lock_guard<std::mutex> lock(FRAME_CACHE_M);
+        const auto pos = FRAME_CACHE.find(screen);
+        if (pos == FRAME_CACHE.end() || pos->second.jpeg.empty()) {
+            return false;
+        }
+
+        const auto &cached = pos->second;
+        auto encoded = crypt::base64_encode(cached.jpeg.data(), cached.jpeg.size());
+
+        Value data;
+        data.SetString(encoded.c_str(), encoded.length(), res.doc()->GetAllocator());
+        res.add_data(cached.timestamp);
+        res.add_data(cached.width);
+        res.add_data(cached.height);
+        res.add_data(data);
+        return true;
+    }
+
     Capture::Capture() : Module("capture") {
         functions["get_screens"] = std::bind(&Capture::get_screens, this, _1, _2);
         functions["get_jpg"] = std::bind(&Capture::get_jpg, this, _1, _2);
+        functions["get_streams"] = std::bind(&Capture::get_streams, this, _1, _2);
     }
 
     /**
@@ -41,7 +99,6 @@ namespace api::modules {
      * reduce: uint for dividing image size
      */
     void Capture::get_jpg(Request &req, Response &res) {
-        CAPTURE_BUFFER.reserve(1024 * 128);
 
         // settings
         int screen = 0;
@@ -67,28 +124,119 @@ namespace api::modules {
         uint64_t timestamp = 0;
         int width = 0;
         int height = 0;
-        graphics_capture_trigger(screen);
-        bool success = graphics_capture_receive_jpeg(screen, [] (uint8_t byte) {
-            CAPTURE_BUFFER.push_back(byte);
-        }, true, quality, true, divide, &timestamp, &width, &height);
-        if (!success) {
+
+        std::shared_ptr<uint8_t[]> pixels;
+        bool success = capture_pump::capture_direct(
+                screen, pixels, divide, &timestamp, &width, &height);
+
+        if (success) {
+            CAPTURE_BUFFER.clear();
+            success = jpeg_encoder::encode(
+                    CAPTURE_BUFFER, pixels.get(), width, height, quality);
+        }
+
+        if (success) {
+            add_jpeg_response(screen, timestamp, width, height, CAPTURE_BUFFER, res);
+            CAPTURE_BUFFER.clear();
             return;
         }
 
-        // encode to base64
-        auto encoded = crypt::base64_encode(
-                CAPTURE_BUFFER.data(),
-                CAPTURE_BUFFER.size());
-
-        // clear buffer
+        // fall back to the last successful frame while the game is busy loading
         CAPTURE_BUFFER.clear();
+        try_cached_response(screen, res);
+    }
 
-        // add data to response
-        Value data;
-        data.SetString(encoded.c_str(), encoded.length(), res.doc()->GetAllocator());
-        res.add_data(timestamp);
-        res.add_data(width);
-        res.add_data(height);
-        res.add_data(data);
+    /**
+     * get_streams()
+     */
+    void Capture::get_streams(Request &req, Response &res) {
+
+        auto &alloc = res.doc()->GetAllocator();
+
+        // nothing is listening without -apistream, so there is no stream to describe
+        const unsigned short port = stream_server_port();
+        if (port == 0) {
+            return;
+        }
+
+        Value formats(kArrayType);
+        for (const auto &[name, path] : stream_formats()) {
+            Value entry(kObjectType);
+            entry.AddMember("name", Value(name.c_str(), alloc), alloc);
+            entry.AddMember("path", Value(path.c_str(), alloc), alloc);
+            formats.PushBack(entry, alloc);
+        }
+
+        std::vector<int> screen_numbers;
+        graphics_screens_get(screen_numbers);
+
+        // measuring a screen nobody has captured yet waits for the game to present, which can
+        // take as long as the whole request is allowed, so only one screen is measured per
+        // call and the rest are reported null until a later one settles them. which screen
+        // gets the attempt rotates, otherwise one that never presents would take every
+        // request and the screens behind it would stay unmeasured forever
+        int probe_screen = -1;
+        {
+            std::vector<int> unmeasured;
+            for (const auto screen : screen_numbers) {
+                if (screen < static_cast<int>(GRAPHICS_CAPTURE_SCREEN_NO)
+                        && !graphics_capture_last_size(screen, nullptr, nullptr)
+                        && !capture_pump::screen_claimed(screen)) {
+                    unmeasured.push_back(screen);
+                }
+            }
+
+            if (!unmeasured.empty()) {
+                static std::atomic<unsigned> probe_cursor { 0 };
+                probe_screen = unmeasured[probe_cursor.fetch_add(1) % unmeasured.size()];
+            }
+        }
+
+        Value screens(kArrayType);
+        for (const auto screen : screen_numbers) {
+            if (screen >= static_cast<int>(GRAPHICS_CAPTURE_SCREEN_NO)) {
+                continue;
+            }
+
+            int width = 0;
+            int height = 0;
+            bool known = graphics_capture_last_size(screen, &width, &height);
+
+            // a probe holds the screen for as long as it waits, so a second caller arriving
+            // during one would queue behind it and then take a wait of its own; let it report
+            // the screen as unmeasured instead and pick the size up once the first is done
+            static std::atomic<bool> probe_running { false };
+            if (!known && screen == probe_screen && !probe_running.exchange(true)) {
+                std::shared_ptr<uint8_t[]> pixels;
+                known = capture_pump::capture_direct(
+                        screen, pixels, 1, nullptr, &width, &height);
+                probe_running = false;
+            }
+
+            // a screen of unknown size cannot be described, and a client told about it could
+            // not size its decoder anyway; leaving it out until it has been measured beats
+            // handing over an entry that has to be treated as absent
+            if (!known) {
+                continue;
+            }
+
+            Value entry(kObjectType);
+            entry.AddMember("screen", screen, alloc);
+            entry.AddMember("width", width, alloc);
+            entry.AddMember("height", height, alloc);
+
+            // a screen carries one viewer at a time, so this is what decides whether a client
+            // can connect at all; still racy by the time it does, only more honest than not
+            entry.AddMember("busy", capture_pump::screen_claimed(screen), alloc);
+
+            screens.PushBack(entry, alloc);
+        }
+
+        Value info(kObjectType);
+        info.AddMember("port", port, alloc);
+        info.AddMember("formats", formats, alloc);
+        info.AddMember("screens", screens, alloc);
+
+        res.add_data(info);
     }
 }

src/spice2x/api/modules/capture.h

@@ -19,5 +19,6 @@ namespace api::modules {
         // function definitions
         void get_screens(Request &req, Response &res);
         void get_jpg(Request &req, Response &res);
+        void get_streams(Request &req, Response &res);
     };
 }

src/spice2x/api/modules/card.cpp

@@ -1,4 +1,5 @@
 #include "card.h"
+#include <fstream>
 #include <functional>
 #include "external/rapidjson/document.h"
 #include "util/logging.h"
@@ -11,8 +12,71 @@ using namespace rapidjson;
 
 namespace api::modules {
 
+    static bool normalize_card_id(const std::string &value, std::string &card_id) {
+        if (value.size() != 16) {
+            return false;
+        }
+
+        uint8_t card_bin[8] {};
+        if (!hex2bin(value.c_str(), card_bin)) {
+            return false;
+        }
+
+        card_id = bin2hex(card_bin, std::size(card_bin));
+        return true;
+    }
+
+    static bool read_card_id(const std::filesystem::path &path, std::string &card_id) {
+        std::ifstream file(path);
+        char buffer[16] {};
+        if (!file.read(buffer, std::size(buffer))) {
+            return false;
+        }
+
+        return normalize_card_id(std::string(buffer, std::size(buffer)), card_id);
+    }
+
     Card::Card() : Module("card") {
+        functions["get_cards"] = std::bind(&Card::get_cards, this, _1, _2);
         functions["insert"] = std::bind(&Card::insert, this, _1, _2);
+        require_password("get_cards");
+    }
+
+    /**
+     * get_cards()
+     */
+    void Card::get_cards(Request &req, Response &res) {
+        auto &alloc = res.doc()->GetAllocator();
+
+        for (int index = 0; index < eamuse_get_game_keypads(); index++) {
+            std::string card_id;
+            std::string filename;
+            const auto card_override = eamuse_get_card_override(index);
+            const bool has_override = !card_override.empty();
+
+            if (has_override) {
+                if (!normalize_card_id(card_override, card_id)) {
+                    continue;
+                }
+            } else {
+                const auto path = eamuse_get_card_path(index);
+                if (!read_card_id(path, card_id)) {
+                    continue;
+                }
+
+                const auto filename_u8 = path.filename().u8string();
+                filename.assign(filename_u8.begin(), filename_u8.end());
+            }
+
+            Value card(kObjectType);
+            card.AddMember("index", index, alloc);
+            card.AddMember("card_id", Value(card_id.c_str(), alloc), alloc);
+            card.AddMember("source", Value(has_override ? "override" : "file", alloc), alloc);
+            if (!has_override) {
+                card.AddMember("file_name", Value(filename.c_str(), alloc), alloc);
+            }
+            res.add_data(card);
+        }
     }
 
     /**

src/spice2x/api/modules/card.h

@@ -12,6 +12,7 @@ namespace api::modules {
     private:
 
         // function definitions
+        void get_cards(Request &req, Response &res);
         void insert(Request &req, Response &res);
     };
 }

src/spice2x/api/modules/coin.cpp

@@ -61,7 +61,7 @@ namespace api::modules {
             return error_type(res, "amount", "int");
 
         // add to coin stock
-        eamuse_coin_set_stock(eamuse_coin_get_stock() + std::max(0, req.params[0].GetInt()));
+        eamuse_coin_add(std::max(0, req.params[0].GetInt()));
     }
 
     /*

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/drs.cpp

@@ -34,7 +34,7 @@ namespace api::modules {
     void DRS::touch_set(Request &req, Response &res) {
 
         // get all touch points
-        games::drs::drs_touch_t touches[16];
+        auto touches = std::make_unique<games::drs::drs_touch_t[]>(req.params.Size());
         size_t i = 0;
         for (Value &param : req.params.GetArray()) {
 
@@ -86,6 +86,6 @@ namespace api::modules {
         }
 
         // apply touch points
-        games::drs::fire_touches(touches, i);
+        games::drs::fire_touches(touches.get(), i);
     }
 }

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,6 +1,8 @@
 #include "keypads.h"
 
+#include <chrono>
 #include <functional>
+#include <thread>
 
 #include <windows.h>
 
@@ -91,11 +93,11 @@ namespace api::modules {
 
             // set
             eamuse_set_keypad_overrides(keypad, state);
-            Sleep(sleep_time);
+            std::this_thread::sleep_for(std::chrono::milliseconds(sleep_time));
 
             // unset
             eamuse_set_keypad_overrides(keypad, 0);
-            Sleep(sleep_time);
+            std::this_thread::sleep_for(std::chrono::milliseconds(sleep_time));
         }
     }
 

src/spice2x/api/modules/memory.cpp

@@ -58,7 +58,7 @@ namespace api::modules {
 
         // check if file exists in modules
         if (!fileutils::file_exists(dll_path)) {
-            return error(res, "Couldn't find " + dll_path.string());
+            return error(res, fmt::format("Couldn't find {}", dll_path));
         }
 
         // get module
@@ -118,7 +118,7 @@ namespace api::modules {
 
         // check if file exists in modules
         if (!fileutils::file_exists(dll_path)) {
-            return error(res, "Couldn't find " + dll_path.string());
+            return error(res, fmt::format("Couldn't find {}", dll_path));
         }
 
         // get module
@@ -196,7 +196,7 @@ namespace api::modules {
 
         // check if file exists in modules
         if (!fileutils::file_exists(dll_path)) {
-            return error(res, "Couldn't find " + dll_path.string());
+            return error(res, fmt::format("Couldn't find {}", dll_path));
         }
 
         // get module

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/dart/spiceapi-websocket/spiceapi.dart

@@ -11,6 +11,7 @@ part "src/exceptions.dart";
 part "src/rc4.dart";
 part "src/wrappers/analogs.dart";
 part "src/wrappers/buttons.dart";
+part "src/wrappers/capture.dart";
 part "src/wrappers/card.dart";
 part "src/wrappers/coin.dart";
 part "src/wrappers/control.dart";

src/spice2x/api/resources/dart/spiceapi-websocket/src/connection.dart

@@ -4,8 +4,8 @@ part of spiceapi;
 class Connection {
 
   // settings
-  static const _TIMEOUT = Duration(seconds: 2);
-  static const _BUFFER_SIZE = 1024 * 8;
+  static const _TIMEOUT = Duration(seconds: 3);
+  static const _BUFFER_SIZE = 1024 * 1024 * 8;
 
   // state
   final String host, pass;

src/spice2x/api/resources/dart/spiceapi-websocket/src/wrappers/capture.dart

@@ -0,0 +1,47 @@
+part of spiceapi;
+
+class CaptureData {
+  int timestamp;
+  int width, height;
+  Uint8List data;
+}
+
+var _base64DecoderInstance = Base64Decoder();
+
+Future<List> captureGetScreens(Connection con) {
+  var req = Request("capture", "get_screens");
+  return con.request(req).then((res) {
+    return res.getData();
+  });
+}
+
+Future<CaptureData> captureGetJPG(Connection con, {
+  int screen = 0,
+  int quality = 70,
+  int divide = 1,
+}) {
+  var req = Request("capture", "get_jpg");
+  req.addParam(screen);
+  req.addParam(quality);
+  req.addParam(divide);
+  return con.request(req).then((res) {
+    var captureData = CaptureData();
+    var data = res.getData();
+    if (data.length > 0) captureData.timestamp = data[0];
+    if (data.length > 1) captureData.width = data[1];
+    if (data.length > 2) captureData.height = data[2];
+    if (data.length > 3) {
+      captureData.data = _base64DecoderInstance.convert(data[3]);
+    }
+    return captureData;
+  });
+}
+
+/// Describes the HTTP video stream, or null when this spice2x serves none.
+Future<Map> captureGetStreams(Connection con) {
+  var req = Request("capture", "get_streams");
+  return con.request(req).then((res) {
+    var data = res.getData();
+    return data.length > 0 ? data[0] : null;
+  });
+}

src/spice2x/api/resources/dart/spiceapi-websocket/src/wrappers/card.dart

@@ -1,5 +1,32 @@
 part of spiceapi;
 
+class CardInfo {
+  final int index;
+  final String cardID;
+  final String source;
+  final String? fileName;
+
+  CardInfo(this.index, this.cardID, this.source, this.fileName);
+}
+
+Future<List<CardInfo>> cardGetCards(Connection con) {
+  var req = Request("card", "get_cards");
+  return con.request(req).then((res) {
+    List<CardInfo> cards = [];
+    for (var value in res.getData()) {
+      cards.add(
+        CardInfo(
+          value["index"],
+          value["card_id"],
+          value["source"],
+          value["file_name"],
+        ),
+      );
+    }
+    return cards;
+  });
+}
+
 Future<void> cardInsert(Connection con, int unit, String cardID) {
   var req = Request("card", "insert");
   req.addParam(unit);

src/spice2x/api/resources/dart/spiceapi/src/wrappers/capture.dart

@@ -17,7 +17,7 @@ Future<List> captureGetScreens(Connection con) {
 
 Future<CaptureData> captureGetJPG(Connection con, {
   int screen = 0,
-  int quality = 60,
+  int quality = 70,
   int divide = 1,
 }) {
   var req = Request("capture", "get_jpg");
@@ -36,3 +36,12 @@ Future<CaptureData> captureGetJPG(Connection con, {
     return captureData;
   });
 }
+
+/// Describes the HTTP video stream, or null when this spice2x serves none.
+Future<Map> captureGetStreams(Connection con) {
+  var req = Request("capture", "get_streams");
+  return con.request(req).then((res) {
+    var data = res.getData();
+    return data.length > 0 ? data[0] : null;
+  });
+}

src/spice2x/api/resources/dart/spiceapi/src/wrappers/card.dart

@@ -1,5 +1,32 @@
 part of spiceapi;
 
+class CardInfo {
+  final int index;
+  final String cardID;
+  final String source;
+  final String? fileName;
+
+  CardInfo(this.index, this.cardID, this.source, this.fileName);
+}
+
+Future<List<CardInfo>> cardGetCards(Connection con) {
+  var req = Request("card", "get_cards");
+  return con.request(req).then((res) {
+    List<CardInfo> cards = [];
+    for (var value in res.getData()) {
+      cards.add(
+        CardInfo(
+          value["index"],
+          value["card_id"],
+          value["source"],
+          value["file_name"],
+        ),
+      );
+    }
+    return cards;
+  });
+}
+
 Future<void> cardInsert(Connection con, int unit, String cardID) {
   var req = Request("card", "insert");
   req.addParam(unit);

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

@@ -2,11 +2,13 @@ from .connection import Connection
 from .request import Request
 from .analogs import *
 from .buttons import *
+from .capture import *
 from .card import *
 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/capture.py

@@ -0,0 +1,33 @@
+import base64
+
+from .connection import Connection
+from .request import Request
+
+
+def capture_get_screens(con: Connection):
+    res = con.request(Request("capture", "get_screens"))
+    return res.get_data()
+
+
+def capture_get_jpg(con: Connection, screen: int = 0, quality: int = 70, divide: int = 1):
+    req = Request("capture", "get_jpg")
+    req.add_param(screen)
+    req.add_param(quality)
+    req.add_param(divide)
+    data = con.request(req).get_data()
+
+    if len(data) < 4:
+        return None
+
+    return {
+        "timestamp": data[0],
+        "width": data[1],
+        "height": data[2],
+        "data": base64.b64decode(data[3]),
+    }
+
+
+def capture_get_streams(con: Connection):
+    """Describes the HTTP video stream, or None when this spice2x serves none."""
+    data = con.request(Request("capture", "get_streams")).get_data()
+    return data[0] if data else None

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

@@ -2,6 +2,10 @@ from .connection import Connection
 from .request import Request
 
 
+def card_get_cards(con: Connection):
+    return con.request(Request("card", "get_cards")).get_data()
+
+
 def card_insert(con: Connection, unit: int, card_id: str):
     req = Request("card", "insert")
     req.add_param(unit)

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/response.cpp

@@ -22,7 +22,7 @@ Response::Response(uint64_t id) {
     // check for error
     auto error = document.GetParseError();
     if (error)
-        log_warning("api", "response template parse error: {}", error);
+        log_warning("api", "response template parse error: {}", static_cast<uint32_t>(error));
 
     // set ID
     document["id"].SetUint64(id);

src/spice2x/api/serial.cpp

@@ -1,7 +1,9 @@
 #include "controller.h"
 #include "serial.h"
 
+#include <chrono>
 #include <string>
+#include <thread>
 #include <utility>
 
 #include "util/logging.h"
@@ -160,7 +162,7 @@ namespace api {
 
                 // slow down on reconnect
                 if (this->running) {
-                    Sleep(retry_time);
+                    std::this_thread::sleep_for(std::chrono::milliseconds(retry_time));
                 }
             }
         });

src/spice2x/api/stream_format.cpp

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

src/spice2x/api/stream_format.h

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

src/spice2x/api/stream_server.cpp

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

src/spice2x/api/stream_server.h

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

src/spice2x/api/websocket.cpp

@@ -1,169 +1,579 @@
-#define HEADSOCKET_IMPLEMENTATION
-#include "external/headsocket.h"
+#include <winsock2.h>
+#include <ws2tcpip.h>
 
 #include "websocket.h"
-#include "util/utils.h"
-#include "util/rc4.h"
-#include "util/logging.h"
-#include "controller.h"
 
-using namespace headsocket;
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <cctype>
+#include <chrono>
+#include <cstring>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "external/wslay/msvc_compat.h"
+#include <wslay/wslay.h>
+
+#include "controller.h"
+#include "external/hash-library/sha1.h"
+#include "overlay/notifications.h"
+#include "util/crypt.h"
+#include "util/logging.h"
 
 namespace api {
 
-    /*
-     * Client class declaration
-     */
-    class WebSocketClient : public web_socket_client {
+    namespace {
 
-        // required class header
-        HEADSOCKET_CLIENT(WebSocketClient, web_socket_client);
+        constexpr int server_backlog = 4;
+        constexpr size_t client_limit = 8;
 
-    private:
-        ClientState *state = nullptr;
+        // a peer that connects and then says nothing must not hold a slot forever
+        constexpr int handshake_timeout_ms = 5000;
+        constexpr size_t request_size_limit = 8 * 1024;
+        constexpr uint64_t message_size_limit = 64 * 1024;
 
-    protected:
-        bool async_received_data(const data_block &db, uint8_t *ptr, size_t length) override;
+        // how long a quiet connection waits before the loop rechecks whether we are stopping
+        constexpr int idle_poll_ms = 500;
 
-        void on_accept() override;
-        void on_disconnect() override;
-    };
+        // RFC 6455 appends this to the client key before hashing
+        constexpr const char *websocket_guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
-    /*
-     * Server class declaration
-     */
-    class WebSocketServer : public web_socket_server<WebSocketClient> {
-        HEADSOCKET_SERVER(WebSocketServer, web_socket_server);
-    public:
-        WebSocketController *websocket;
-    };
+        constexpr double notification_throttle_seconds = 0.5;
 
-    void api::WebSocketServer::init() {}
+        std::string trim(const std::string &text) {
+            const auto begin = text.find_first_not_of(" \t");
+            if (begin == std::string::npos) {
+                return "";
+            }
+            return text.substr(begin, text.find_last_not_of(" \t") - begin + 1);
+        }
+
+        std::string to_lower(std::string text) {
+            std::transform(text.begin(), text.end(), text.begin(), [](unsigned char c) {
+                return static_cast<char>(std::tolower(c));
+            });
+            return text;
+        }
+
+        bool contains_token(const std::string &value, const std::string &expected) {
+            size_t pos = 0;
+            while (pos < value.size()) {
+                const size_t end = value.find(',', pos);
+                if (to_lower(trim(value.substr(pos, end - pos))) == expected) {
+                    return true;
+                }
+                if (end == std::string::npos) {
+                    break;
+                }
+                pos = end + 1;
+            }
+            return false;
+        }
+
+        bool valid_websocket_key(const std::string &key) {
+            if (key.size() != 24 || key[22] != '=' || key[23] != '=') {
+                return false;
+            }
+
+            const std::string alphabet =
+                    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+            for (size_t i = 0; i < 22; i++) {
+                if (alphabet.find(key[i]) == std::string::npos) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        bool send_all(SOCKET socket, const std::string &text) {
+            size_t remaining = text.size();
+            const char *cursor = text.data();
+
+            while (remaining > 0) {
+                const int sent = send(socket, cursor, static_cast<int>(remaining), 0);
+                if (sent <= 0) {
+                    return false;
+                }
+                cursor += sent;
+                remaining -= static_cast<size_t>(sent);
+            }
+
+            return true;
+        }
+
+        void set_recv_timeout(SOCKET socket, int milliseconds) {
+            const DWORD timeout = static_cast<DWORD>(milliseconds);
+            setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO,
+                    reinterpret_cast<const char *>(&timeout), sizeof(timeout));
+        }
+
+        std::string accept_key(const std::string &client_key) {
+            SHA1 sha1;
+            sha1.add(client_key.data(), client_key.size());
+            sha1.add(websocket_guid, strlen(websocket_guid));
+
+            unsigned char digest[SHA1::HashBytes] {};
+            sha1.getHash(digest);
+
+            return crypt::base64_encode(digest, sizeof(digest));
+        }
+
+        bool handshake(SOCKET socket) {
+            std::string request;
+            char byte = 0;
+            bool complete = false;
+
+            while (request.size() < request_size_limit) {
+                const int read = recv(socket, &byte, 1, 0);
+                if (read <= 0) {
+                    return false;
+                }
+
+                request.push_back(byte);
+                if (request.size() >= 4
+                        && request.compare(request.size() - 4, 4, "\r\n\r\n") == 0) {
+                    complete = true;
+                    break;
+                }
+            }
+
+            std::string key;
+            std::string version;
+            bool connection_upgrade = false;
+            bool upgrade = false;
+            const size_t request_line_end = request.find("\r\n");
+                const std::string request_line = request.substr(0, request_line_end);
+                const size_t target_end = request_line.find(' ', 4);
+                const bool valid_request_line = request_line_end != std::string::npos
+                    && request_line.compare(0, 4, "GET ") == 0
+                        && target_end != std::string::npos
+                    && target_end > 4
+                    && target_end == request_line.rfind(' ')
+                    && request_line.substr(target_end + 1) == "HTTP/1.1";
+            size_t pos = request_line_end;
+
+            while (pos != std::string::npos) {
+                const size_t end = request.find("\r\n", pos + 2);
+                if (end == std::string::npos || end == pos + 2) {
+                    break;
+                }
+
+                const std::string line = request.substr(pos + 2, end - pos - 2);
+                const size_t colon = line.find(':');
+                if (colon != std::string::npos) {
+                    const std::string name = to_lower(trim(line.substr(0, colon)));
+                    const std::string value = trim(line.substr(colon + 1));
+
+                    if (name == "sec-websocket-key") {
+                        key = value;
+                    } else if (name == "sec-websocket-version") {
+                        version = value;
+                    } else if (name == "connection") {
+                        connection_upgrade = connection_upgrade
+                                || contains_token(value, "upgrade");
+                    } else if (name == "upgrade") {
+                        upgrade = upgrade || contains_token(value, "websocket");
+                    }
+                }
+
+                pos = end;
+            }
+
+                if (!complete || !valid_request_line || !connection_upgrade || !upgrade
+                    || version != "13" || !valid_websocket_key(key)) {
+                send_all(socket,
+                        "HTTP/1.1 400 Bad Request\r\n"
+                        "Connection: close\r\n"
+                        "Content-Length: 0\r\n"
+                        "\r\n");
+                return false;
+            }
+
+            // deliberately echoes back no extension or subprotocol: naming one the client did
+            // not offer is a handshake failure, and none of them are wanted here
+            return send_all(socket,
+                    "HTTP/1.1 101 Switching Protocols\r\n"
+                    "Upgrade: websocket\r\n"
+                    "Connection: Upgrade\r\n"
+                    "Sec-WebSocket-Accept: " + accept_key(key) + "\r\n"
+                    "\r\n");
+        }
+
+        // everything one connection needs; wslay hands this back to the callbacks
+        struct Session {
+            SOCKET socket = INVALID_SOCKET;
+            Controller *controller = nullptr;
+            ClientState *state = nullptr;
+            bool failed = false;
+        };
+
+        ssize_t recv_callback(wslay_event_context_ptr ctx, uint8_t *buffer, size_t length,
+                int flags, void *user_data) {
+
+            (void) flags;
+
+            auto *session = static_cast<Session *>(user_data);
+            const int read = recv(session->socket, reinterpret_cast<char *>(buffer),
+                    static_cast<int>(length), 0);
+
+            if (read > 0) {
+                return read;
+            }
+
+            // the socket is non-blocking, so an empty one has to read as "nothing yet"
+            // rather than as a dead peer
+            if (read < 0 && WSAGetLastError() == WSAEWOULDBLOCK) {
+                wslay_event_set_error(ctx, WSLAY_ERR_WOULDBLOCK);
+                return -1;
+            }
+
+            wslay_event_set_error(ctx,
+                    read == 0 ? WSLAY_ERR_NO_MORE_MSG : WSLAY_ERR_CALLBACK_FAILURE);
+            return -1;
+        }
+
+        ssize_t send_callback(wslay_event_context_ptr ctx, const uint8_t *data, size_t length,
+                int flags, void *user_data) {
+
+            (void) flags;
+
+            auto *session = static_cast<Session *>(user_data);
+            const int sent = send(session->socket, reinterpret_cast<const char *>(data),
+                    static_cast<int>(length), 0);
+
+            if (sent > 0) {
+                return sent;
+            }
+
+            if (sent < 0 && WSAGetLastError() == WSAEWOULDBLOCK) {
+                wslay_event_set_error(ctx, WSLAY_ERR_WOULDBLOCK);
+                return -1;
+            }
+
+            wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE);
+            return -1;
+        }
+
+        void on_msg_recv(wslay_event_context_ptr ctx,
+                const struct wslay_event_on_msg_recv_arg *arg, void *user_data) {
+
+            auto *session = static_cast<Session *>(user_data);
+
+            // pings and closes are wslay's business, it answers them itself
+            if (wslay_is_ctrl_frame(arg->opcode)) {
+                return;
+            }
+
+            if (arg->opcode != WSLAY_BINARY_FRAME) {
+                log_warning("api::websocket", "ignoring a non-binary message");
+                return;
+            }
+
+            std::vector<char> in(arg->msg, arg->msg + arg->msg_length);
+            std::vector<char> out;
+
+            if (session->state->cipher) {
+                session->state->cipher->crypt(
+                        reinterpret_cast<uint8_t *>(in.data()), in.size());
+            }
+
+            session->controller->process_request(session->state, &in, &out);
+
+            if (session->state->cipher) {
+                session->state->cipher->crypt(
+                        reinterpret_cast<uint8_t *>(out.data()), out.size());
+            }
+
+            wslay_event_msg reply {};
+            reply.opcode = WSLAY_BINARY_FRAME;
+            reply.msg = reinterpret_cast<const uint8_t *>(out.data());
+            reply.msg_length = out.size();
+
+            if (wslay_event_queue_msg(ctx, &reply) != 0) {
+                session->failed = true;
+                return;
+            }
+
+            Controller::process_password_change(session->state);
+        }
+    }
 
-    /*
-     * Controller state so we don't have to import headsocket stuff in our header
-     */
     struct WebSocketControllerState {
-        std::shared_ptr<WebSocketServer> server;
+        struct Client {
+            std::thread thread;
+            SOCKET socket = INVALID_SOCKET;
+            bool active = false;
+        };
+
+        Controller *controller = nullptr;
+        unsigned short port = 0;
+        SOCKET listener = INVALID_SOCKET;
+        bool wsa_started = false;
+        std::atomic_bool running { false };
+        std::thread acceptor;
+        std::mutex clients_m;
+        std::array<Client, client_limit> clients;
+
+        bool open_listener();
+        void accept_worker();
+        void client_worker(int slot, SOCKET socket, std::string address);
+        void stop();
     };
 
+    bool WebSocketControllerState::open_listener() {
+        WSADATA wsa_data;
+        const int error = WSAStartup(MAKEWORD(2, 2), &wsa_data);
+        if (error != 0) {
+            log_warning("api::websocket", "WSAStartup() returned {}", error);
+            return false;
+        }
+        this->wsa_started = true;
+
+        this->listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+        if (this->listener == INVALID_SOCKET) {
+            log_warning("api::websocket", "socket() returned {}", WSAGetLastError());
+            return false;
+        }
+
+        sockaddr_in address {};
+        address.sin_family = AF_INET;
+        address.sin_addr.s_addr = INADDR_ANY;
+        address.sin_port = htons(this->port);
+
+        if (bind(this->listener, reinterpret_cast<sockaddr *>(&address), sizeof(address))
+                == SOCKET_ERROR) {
+            log_warning("api::websocket", "bind() returned {}", WSAGetLastError());
+            return false;
+        }
+
+        if (listen(this->listener, server_backlog) == SOCKET_ERROR) {
+            log_warning("api::websocket", "listen() returned {}", WSAGetLastError());
+            return false;
+        }
+
+        return true;
+    }
+
+    void WebSocketControllerState::accept_worker() {
+
+        while (this->running) {
+            sockaddr_in client_address {};
+            int client_address_size = sizeof(sockaddr_in);
+
+            const SOCKET client = accept(
+                    this->listener, reinterpret_cast<sockaddr *>(&client_address),
+                    &client_address_size);
+
+            if (client == INVALID_SOCKET) {
+                // on shutdown the listener is closed under us; otherwise do not spin
+                if (this->running) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                }
+                continue;
+            }
+
+            if (!this->running) {
+                closesocket(client);
+                break;
+            }
+
+            // formatted by hand rather than with inet_ntop, which needs a newer Windows than
+            // the XP toolchain targets, or inet_ntoa, which answers from a shared buffer
+            const uint32_t raw = ntohl(client_address.sin_addr.s_addr);
+            const std::string address = fmt::format("{}.{}.{}.{}",
+                    (raw >> 24) & 0xff, (raw >> 16) & 0xff, (raw >> 8) & 0xff, raw & 0xff);
+
+            int slot = -1;
+            {
+                std::lock_guard<std::mutex> lock(this->clients_m);
+                for (size_t i = 0; i < this->clients.size(); i++) {
+                    if (!this->clients[i].active) {
+                        this->clients[i].active = true;
+                        this->clients[i].socket = client;
+                        slot = static_cast<int>(i);
+                        break;
+                    }
+                }
+            }
+
+            if (slot < 0) {
+                log_warning("api::websocket", "client limit of {} hit", client_limit);
+                overlay::notifications::add_throttled(
+                        overlay::notifications::Severity::Warning,
+                        "api::websocket.client_limit",
+                        notification_throttle_seconds,
+                        fmt::format("API websocket refused: client limit reached ({})", address));
+                closesocket(client);
+                continue;
+            }
+
+            // this thread is the only one that touches the thread objects, so the slot's
+            // previous occupant gets reaped here rather than being detached
+            if (this->clients[slot].thread.joinable()) {
+                this->clients[slot].thread.join();
+            }
+
+            // the handshake runs on the client thread on purpose: doing it here would put
+            // every later connection behind whatever this one is waiting for
+            this->clients[slot].thread = std::thread([this, slot, client, address] {
+                this->client_worker(slot, client, address);
+            });
+        }
+    }
+
+    void WebSocketControllerState::client_worker(int slot, SOCKET socket, std::string address) {
+
+        // wslay writes a frame header and its payload as separate sends, so leaving Nagle on
+        // holds the payload back until the peer acknowledges the header, costing a delayed
+        // ack per message; requests here are small and latency sensitive
+        int nodelay = 1;
+        setsockopt(socket, IPPROTO_TCP, TCP_NODELAY,
+                reinterpret_cast<const char *>(&nodelay), sizeof(nodelay));
+
+        set_recv_timeout(socket, handshake_timeout_ms);
+
+        if (handshake(socket)) {
+            // wslay reads until the socket would block, so leaving it blocking would make
+            // every reply wait out a receive timeout before the send got a turn
+            u_long non_blocking = 1;
+            ioctlsocket(socket, FIONBIO, &non_blocking);
+
+            Session session;
+            session.socket = socket;
+            session.controller = this->controller;
+            session.state = new ClientState();
+            this->controller->init_state(session.state);
+
+            log_info("api::websocket", "client connected: {}", address);
+            overlay::notifications::add(
+                    overlay::notifications::Severity::Success,
+                    fmt::format("API websocket client connected ({})", address));
+
+            wslay_event_callbacks callbacks {};
+            callbacks.recv_callback = recv_callback;
+            callbacks.send_callback = send_callback;
+            callbacks.on_msg_recv_callback = on_msg_recv;
+
+            wslay_event_context_ptr ctx = nullptr;
+            if (wslay_event_context_server_init(&ctx, &callbacks, &session) == 0) {
+                wslay_event_config_set_max_recv_msg_length(ctx, message_size_limit);
+                while (this->running && !session.failed
+                        && (wslay_event_want_read(ctx) || wslay_event_want_write(ctx))) {
+
+                    fd_set read_set;
+                    fd_set write_set;
+                    FD_ZERO(&read_set);
+                    FD_ZERO(&write_set);
+
+                    if (wslay_event_want_read(ctx)) {
+                        FD_SET(socket, &read_set);
+                    }
+                    if (wslay_event_want_write(ctx)) {
+                        FD_SET(socket, &write_set);
+                    }
+
+                    // bounded so a silent connection still notices us shutting down
+                    timeval timeout {};
+                    timeout.tv_usec = idle_poll_ms * 1000;
+
+                    if (select(0, &read_set, &write_set, nullptr, &timeout) < 0) {
+                        break;
+                    }
+
+                    if (FD_ISSET(socket, &read_set) && wslay_event_recv(ctx) != 0) {
+                        break;
+                    }
+
+                    // unconditional, so a reply queued by the read above goes out now
+                    if (wslay_event_send(ctx) != 0) {
+                        break;
+                    }
+                }
+
+                wslay_event_context_free(ctx);
+            }
+
+            Controller::free_state(session.state);
+            delete session.state;
+
+            log_info("api::websocket", "client disconnected: {}", address);
+            overlay::notifications::add(
+                    overlay::notifications::Severity::Info,
+                    fmt::format("API websocket client disconnected ({})", address));
+        }
+
+        closesocket(socket);
+
+        std::lock_guard<std::mutex> lock(this->clients_m);
+        this->clients[slot].socket = INVALID_SOCKET;
+        this->clients[slot].active = false;
+    }
+
+    void WebSocketControllerState::stop() {
+        this->running = false;
+
+        if (this->listener != INVALID_SOCKET) {
+            closesocket(this->listener);
+            this->listener = INVALID_SOCKET;
+        }
+
+        // drops the client threads out of their blocking send/recv
+        {
+            std::lock_guard<std::mutex> lock(this->clients_m);
+            for (auto &client : this->clients) {
+                if (client.socket != INVALID_SOCKET) {
+                    ::shutdown(client.socket, SD_BOTH);
+                }
+            }
+        }
+
+        if (this->acceptor.joinable()) {
+            this->acceptor.join();
+        }
+
+        // joining is what guarantees no client thread outlives this object
+        for (auto &client : this->clients) {
+            if (client.thread.joinable()) {
+                client.thread.join();
+            }
+        }
+
+        if (this->wsa_started) {
+            WSACleanup();
+            this->wsa_started = false;
+        }
+    }
+
     WebSocketController::WebSocketController(Controller *controller, uint16_t port) {
         this->controller = controller;
 
-        // create state
         this->state = new WebSocketControllerState();
+        this->state->controller = controller;
+        this->state->port = port;
 
-        // start server
-        this->state->server = WebSocketServer::create(port);
-        this->state->server->websocket = this;
-        if (this->state->server->is_running()) {
-            log_info("api::websocket", "server listening on port: {}", port);
-        } else {
+        if (!this->state->open_listener()) {
             log_warning("api::websocket", "server failed to listen on port: {}", port);
+            return;
         }
+
+        this->state->running = true;
+        this->state->acceptor = std::thread([this] {
+            this->state->accept_worker();
+        });
+
+        log_info("api::websocket", "server listening on port: {}", port);
     }
 
     WebSocketController::~WebSocketController() {
-
-        // stop server
-        this->state->server->stop();
-
-        // delete state
+        this->state->stop();
         delete this->state;
+        this->state = nullptr;
     }
 
     void WebSocketController::free_socket() {
-        this->state->server->stop();
-    }
-
-    void WebSocketClient::on_accept() {
-        web_socket_client::on_accept();
-
-        // get pointer to server
-        auto srv = reinterpret_cast<WebSocketServer *>(server().get());
-        if (!srv || !srv->websocket) {
-            log_fatal("api::websocket", "on_accept has no server");
-        }
-
-        // check for init
-        state = new ClientState();
-        srv->websocket->controller->init_state(state);
-
-        // log connection
-        log_info("api::websocket", "client connected");
-    }
-
-    void WebSocketClient::on_disconnect() {
-
-        // log disconnection
-        log_info("api::websocket", "client disconnected");
-
-        // get pointer to server
-        auto srv = reinterpret_cast<WebSocketServer *>(server().get());
-        if (!srv || !srv->websocket) {
-            log_fatal("api::websocket", "on_disconnect has no server");
-        }
-
-        // clean up state
-        srv->websocket->controller->free_state(state);
-        delete state;
-        state = nullptr;
-
-        // call super
-        web_socket_client::on_disconnect();
-    }
-
-    /*
-     * This is where business actually happens, gets called on every datablock receive
-     */
-    bool WebSocketClient::async_received_data(const data_block &db, uint8_t *ptr, size_t length) {
-
-        // get pointer to server
-        auto srv = reinterpret_cast<WebSocketServer *>(server().get());
-        if (!srv || !srv->websocket) {
-            log_fatal("api::websocket", "received datablock without server");
-        }
-
-        // check state
-        if (!state) {
-            log_fatal("api::websocket", "client with no state received datablock");
-        }
-
-        // check datablock type
-        switch (db.op) {
-            case opcode::binary: {
-
-                // allocate buffers
-                std::vector<char> in(ptr, ptr + length);
-                std::vector<char> out;
-
-                // crypt in-data
-                if (state->cipher) {
-                    state->cipher->crypt(reinterpret_cast<uint8_t *>(in.data()), in.size());
-                }
-
-                // process request
-                srv->websocket->controller->process_request(state, &in, &out);
-
-                // crypt out-data
-                if (state->cipher) {
-                    state->cipher->crypt(reinterpret_cast<uint8_t *>(out.data()), out.size());
-                }
-
-                // send answer
-                push(out.data(), out.size());
-
-                // check for password change
-                srv->websocket->controller->process_password_change(state);
-
-                break;
-            }
-            default:
-                log_warning("api::websocket", "datablock received with non-binary type");
-                break;
-        }
-
-        // always consume the datablock, nomnom
-        return true;
+        this->state->stop();
     }
 }

src/spice2x/avs/automap.cpp

@@ -263,7 +263,7 @@ namespace avs::automap {
     int property_node_read(avs::core::node_ptr node, avs::core::node_type type, void *data, uint32_t data_size) {
         auto result = avs::core::property_node_read(node, type, data, data_size);
         if (result < 0 && property_patches_enabled(nullptr, node)) {
-            log_warning("automap", "property_node_read failed ({}): {}", type, result);
+            log_warning("automap", "property_node_read failed ({}): {}", static_cast<uint32_t>(type), result);
 
             // probably wrong type
             memset(data, 0, data_size);
@@ -278,7 +278,7 @@ namespace avs::automap {
             if (parent_node && parent_node != node) {
                 char name_buf[256] {};
                 if (avs::core::property_node_name(node, name_buf, sizeof(name_buf)) >= 0) {
-                    log_warning("automap", "property_node_read replace type ({}): {}", type, result);
+                    log_warning("automap", "property_node_read replace type ({}): {}", static_cast<uint32_t>(type), result);
                     avs::core::property_node_remove(node);
                     avs::core::property_node_create(nullptr, parent_node, type, name_buf, data);
                 }

src/spice2x/avs/core.cpp

@@ -7,7 +7,10 @@
 #include <stdint.h>
 
 #include "external/robin_hood.h"
+#include "games/popn/popn.h"
 #include "launcher/logger.h"
+#include "launcher/signal.h"
+#include "util/deferlog.h"
 #include "util/detour.h"
 #include "util/fileutils.h"
 #include "util/libutils.h"
@@ -1106,9 +1109,12 @@ namespace avs {
 
             // SOUND VOLTEX
             {"soundvoltex.dll", 0x10000000},
+            // GITADORA
+            {"gdxg.dll", 0x2000000},
 #endif
             // jubeat
             {"jubeat.dll", 0x2000000},
+            {"jubeat2019.dll", 0x10000000},
 
             // MUSECA
             {"museca.dll", 0xC000000},
@@ -1163,7 +1169,7 @@ namespace avs {
             // Ongaku Paradise
             {"arkjc9.dll", 0xA00000},
 
-            // KAMUNITY 
+            // KAMUNITY
             {"kamunity.dll", 33554432},
         };
 
@@ -1175,6 +1181,15 @@ namespace avs {
                 return;
             }
 
+            // hack, both hello! popn and popn hc using popn.dll
+            if (games::popn::is_pikapika_model()) {
+                auto old_size = HEAP_SIZE;
+                HEAP_SIZE = 0x20000000;
+                DEFAULT_HEAP_SIZE_SET = true;
+                log_info("avs-core", "updated heap size: {} -> {}", old_size, avs::core::HEAP_SIZE);
+                return;
+            }
+
             if (HEAP_SIZE_DEFAULTS.find(dll_name) != HEAP_SIZE_DEFAULTS.end()) {
                 auto old_size = HEAP_SIZE;
 
@@ -1230,6 +1245,7 @@ namespace avs {
                                 break;
                             case 'F':
                                 new_style = logger::Style::RED;
+                                deferredlogs::report_fatal_message();
                                 break;
                             default:
                                 position = 0;
@@ -1298,6 +1314,7 @@ namespace avs {
                     break;
                 case 'F':
                     style = logger::Style::RED;
+                    deferredlogs::report_fatal_message();
                     break;
                 case 'W':
                     style = logger::Style::YELLOW;
@@ -1500,8 +1517,9 @@ namespace avs {
                         "    * It's also possible that you have incomplete game data\n"
                         "    * Do NOT copy over random DLLs from another game installation; DLL must match game version\n"
                         "\n"
-                    , DLL_NAME, MODULE_PATH.string()) };
-                    log_fatal("avs-ea3", "{}", info_str);
+                    , DLL_NAME, MODULE_PATH) };
+                    log_warning("avs-ea3", "{}", info_str);
+                    log_fatal("avs-ea3", "Failed to find critical avs DLL on disk (avs2-core.dll OR {})", DLL_NAME);
                 }
             }
 
@@ -1736,7 +1754,17 @@ namespace avs {
             return;
         }
 
-        static void create_dir(
+        static void avs_dir_err(const std::filesystem::path &src_path)
+        {
+            deferredlogs::defer_error_messages({
+                "AVS filesystem initialization failure was previously detected during boot!",
+                fmt::format("    ERROR: directory could not be created: {}", src_path),
+                fmt::format("    if you see a crash, it may have been caused by bad <mounttable> contents in {}", avs::core::CFG_PATH),
+                "    fix the XML file and try again"
+            });
+        }
+
+        static void create_avs_dir(
                 const std::string_view &avs_path,
                 const std::string_view &src_path)
         {
@@ -1745,6 +1773,7 @@ namespace avs {
             auto real_path = std::filesystem::absolute(src_path, err);
 
             if (err) {
+                avs_dir_err(real_path);
                 log_warning("avs-core", "failed to resolve '{}' path: {}", avs_path, err.message());
                 return;
             }
@@ -1752,12 +1781,14 @@ namespace avs {
             auto created = std::filesystem::create_directories(real_path, err);
 
             if (created) {
-                log_info("avs-core", "created '{}' at '{}'", avs_path, real_path.string());
+                log_info("avs-core", "created '{}' at '{}'", avs_path, real_path);
             }
+
             if (err) {
+                avs_dir_err(real_path);
                 log_warning("avs-core", "failed to create '{}' folder at '{}': {}",
                         avs_path,
-                        real_path.string(),
+                        real_path,
                         err.message());
             }
         }
@@ -1815,7 +1846,7 @@ namespace avs {
                 return;
             }
 
-            create_dir(avs_path, device_path);
+            create_avs_dir(avs_path, device_path);
         }
 
         static void create_avs_config_fs_table(
@@ -1870,7 +1901,7 @@ namespace avs {
                     continue;
                 }
 
-                create_dir(dst_path, src_path);
+                create_avs_dir(dst_path, src_path);
             } while ((vfs_node = property_node_traversal(vfs_node, TRAVERSE_NEXT_SEARCH_RESULT)));
         }
 
@@ -1891,6 +1922,15 @@ namespace avs {
             // create nvram and raw directories if possible for mounttable configurations
             create_avs_config_fs_table(config, config_node);
 
+#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(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");
+            }
+#endif
+
             // set log level
             if (!LOG_LEVEL_CUSTOM.empty()) {
                 property_search_remove_safe(config, config_node, "/log/level");
@@ -1924,6 +1964,7 @@ namespace avs {
             static const char *LOG_LEVELS[] = { "disable", "fatal", "warning", "info", "misc", "all" };
             char current_log_level_buffer[32] { 0 };
             uint32_t current_log_level = 0;
+            std::string log_level_as_str;
 
             if (VERSION == AVSLEGACY || VERSION == AVS21360) {
                 auto level_node = property_search(config, config_node, "/log/level");
@@ -1939,6 +1980,7 @@ namespace avs {
                 {
                     if (current_log_level < std::size(LOG_LEVELS)) {
                         log_info("avs-core", "log level: {}", LOG_LEVELS[current_log_level]);
+                        log_level_as_str = LOG_LEVELS[current_log_level];
                     } else {
                         log_fatal("avs-core", "log level ({}) is invalid!", current_log_level);
                     }
@@ -1958,7 +2000,7 @@ namespace avs {
                         level_node = property_node_create(config, config_node, NODE_TYPE_str, "/log/level",
                                 LOG_LEVELS[current_log_level]);
                     } else {
-                        log_fatal("avs-core", "log level ({}) is invalid!", current_log_level);
+                        log_fatal("avs-core", "log level ({}) is invalid! *", current_log_level);
                     }
                 }
 
@@ -1971,12 +2013,27 @@ namespace avs {
                 if (property_node_refer(config, config_node, "/log/level",
                         NODE_TYPE_str, current_log_level_buffer, sizeof(current_log_level_buffer)) > 0)
                 {
-                    log_info("avs-core", "log level: {}", current_log_level_buffer);
+                    log_info("avs-core", "log level: {} *", current_log_level_buffer);
+                    log_level_as_str = current_log_level_buffer;
                 } else {
-                    log_warning("avs-core", "log level: unknown");
+                    log_warning("avs-core", "log level: unknown *");
                 }
             }
 
+            if (log_level_as_str == "disable" ||
+                log_level_as_str == "fatal" ||
+                log_level_as_str == "warning" ||
+                log_level_as_str == "info") {
+
+                deferredlogs::defer_error_messages({
+                    fmt::format(
+                        "log level is set to `{}` (either in avs-config.xml or using -loglevel)", log_level_as_str),
+                        "    this log file may have omitted important error messages from the game",
+                        "    if you are troubleshooting crashes or failures, it is recommended that you",
+                        "    set AVS Log Level (-loglevel) option to `all`",
+                        });
+            }
+
             // fix time offset
             auto t_now = std::time(nullptr);
             auto tm_now = *std::gmtime(&t_now);

src/spice2x/avs/ea3.cpp

@@ -5,9 +5,11 @@
 #include "build/defs.h"
 #include "easrv/easrv.h"
 #include "easrv/smartea.h"
-#include "games/mfc/mfc.h"
+#include "games/gitadora/gitadora.h"
 #include "hooks/avshook.h"
+#include "hooks/graphics/graphics.h"
 #include "util/detour.h"
+#include "util/deferlog.h"
 #include "util/fileutils.h"
 #include "util/libutils.h"
 #include "util/logging.h"
@@ -41,6 +43,7 @@ namespace avs {
         int HTTP11 = -1;
         int URL_SLASH = -1;
         int PCB_TYPE = -1;
+        bool EA3_DEBUG_VERBOSE = false;
 
         // handle
         std::string VERSION_STR = "unknown";
@@ -148,8 +151,10 @@ namespace avs {
                         "    * It's also possible that you have incomplete game data\n"
                         "    * Do NOT copy over random DLLs from another game installation; DLL must match game version\n"
                         "\n"
-                    , DLL_NAME, MODULE_PATH.string()) };
-                    log_fatal("avs-ea3", "{}", info_str);
+                    , DLL_NAME, MODULE_PATH) };
+
+                    log_warning("avs-ea3", "{}", info_str);
+                    log_fatal("avs-ea3", "Failed to find critical ea3 DLL on disk (avs2-ea3.dll OR {})", DLL_NAME);
                 }
             }
 
@@ -212,7 +217,25 @@ namespace avs {
                 ea3_config_name = "prop/eamuse-config.xml";
             }
 
-            log_info("avs-ea3", "booting (using {})", ea3_config_name);
+            if (fileutils::file_exists(ea3_config_name)) {
+                log_info("avs-ea3", "found {} on disk", ea3_config_name);
+            } else if (CFG_PATH.size()) {
+                log_fatal("avs-ea3", "user-specified ea3 config file is missing: {}", ea3_config_name);
+            } else {
+                log_warning("avs-ea3", "looked for the following files in order:");
+                log_warning("avs-ea3", "  * prop/ea3-config.xml");
+                log_warning("avs-ea3", "  * prop/ea3-cfg.xml");
+                if (avs::game::DLL_NAME == "beatstream1.dll") {
+                    log_warning("avs-ea3", "  * prop/ea3-config-1.xml");
+                }
+                if (avs::game::DLL_NAME == "beatstream2.dll") {
+                    log_warning("avs-ea3", "  * prop/ea3-config-2.xml");
+                }
+                log_warning("avs-ea3", "  * prop/eamuse-config.xml");
+                log_warning("avs-ea3", "none of the files above were found, game will fail to boot");
+                log_warning("avs-ea3", "usually, this means your game data is incomplete");
+                log_fatal("avs-ea3", "no ea3 config file found in prop directory; check log messages");
+            }
 
             // remember new config path
             CFG_PATH = ea3_config_name;
@@ -279,6 +302,7 @@ namespace avs {
 
             // read software nodes
             if (ea3_soft != nullptr) {
+                log_misc("avs-ea3", "reading soft id from {}...", ea3_config_name);
                 avs::core::property_node_refer(ea3_config, ea3_soft, "model",
                         avs::core::NODE_TYPE_str, EA3_MODEL, 4);
                 avs::core::property_node_refer(ea3_config, ea3_soft, "dest",
@@ -290,6 +314,7 @@ namespace avs {
                 avs::core::property_node_refer(ea3_config, ea3_soft, "ext",
                         avs::core::NODE_TYPE_str, EA3_EXT, 11);
             } else if (fileutils::file_exists("prop/ea3-ident.xml")) {
+                log_misc("avs-ea3", "reading soft id from prop/ea3-ident.xml...");
 
                 // read ident config
                 auto ea3_ident = avs::core::config_read("prop/ea3-ident.xml");
@@ -313,7 +338,14 @@ namespace avs {
                 // clean up
                 avs::core::config_destroy(ea3_ident);
             } else {
-                log_fatal("avs-ea3", "node not found in '{}': /ea3/soft", ea3_config_name);
+                // <ea3><soft> node missing error
+                log_warning("avs-ea3", "soft id (datecode) not found in prop XML files");
+                log_warning("avs-ea3", "get fixed prop files and try again - you have incomplete data");
+                log_warning("avs-ea3", "for experts only:");
+                log_warning("avs-ea3", "  * add the missing <soft>...</soft> node to {}", ea3_config_name);
+                log_warning("avs-ea3", "  * alternatively, provide ea3-ident.xml with <ea3_conf><soft>...");
+
+                log_fatal("avs-ea3", "datecode missing in '{}'; 'prop/ea3-ident.xml' also missing", ea3_config_name);
             }
 
             // set account id (`EA3_PCBID` is valid if and only if `/ea3/id` is present)
@@ -356,6 +388,12 @@ namespace avs {
                 }
             }
 
+            // fall back to default PCBID if node is not found
+            if (!EA3_PCBID[0] && PCBID_CUSTOM.empty()) {
+                log_warning("avs-ea3", "no PCBID set, falling back to default PCBID value (01201000000000010101)");
+                PCBID_CUSTOM = "01201000000000010101";
+            }
+
             // custom PCBID
             if (!PCBID_CUSTOM.empty()) {
 
@@ -399,13 +437,18 @@ namespace avs {
                         avs::core::NODE_TYPE_str, "/ea3/id/accountid", &EA3_ACCOUNTID);
             }
 
-            // check if PCBID is defined
+            // check if PCBID is defined - should never hit, left for sanity check only
             if (avs::core::property_search(ea3_config, nullptr, "/ea3/id/pcbid") == nullptr) {
                 log_fatal("avs-ea3", "node not found: /ea3/id/pcbid (try using -p to specify PCBID)");
             } else if (strlen(EA3_PCBID) == 0) {
                 log_fatal("avs-ea3", "no PCBID set (try using -p to specify PCBID)");
             }
 
+            // remove <debug> since it can expose pcbid in logged requests
+            if (!EA3_DEBUG_VERBOSE) {
+                avs::core::property_search_remove_safe(ea3_config, nullptr, "/ea3/debug/verbose");
+            }
+
             // remember IDs
             char pcbid_buffer[256] { 0 };
             char accountid_buffer[256] { 0 };
@@ -470,8 +513,15 @@ namespace avs {
             std::ostringstream init_code;
             init_code << EA3_MODEL;
             init_code << EA3_DEST;
-            init_code << EA3_SPEC;
-            init_code << EA3_REV;
+            if (avs::game::DLL_NAME == "arkmdxbio2.dll" &&
+                strcmp(EA3_MODEL, "MDX") == 0 && strcmp(EA3_SPEC, "I") == 0) {
+                // ddr gold cab
+                init_code << "G";
+                init_code << "B";
+            } else {
+                init_code << EA3_SPEC;
+                init_code << EA3_REV;
+            }
             init_code << EA3_EXT;
             std::string init_code_str = init_code.str();
 
@@ -497,12 +547,42 @@ namespace avs {
                 }
             }
 
+            // update -WINDOW in app-config
+            if (games::gitadora::is_arena_model()) {
+                avs::core::property_search_remove_safe(app_config, nullptr, "/param/cmdline");
+                std::string cmdline{};
+                if (games::gitadora::is_drum()) {
+                    if (GRAPHICS_WINDOWED) {
+                        cmdline = "-d -DM -WINDOW";
+                    } else {
+                        cmdline = "-d -DM";
+                    }
+                } else {
+                    if (GRAPHICS_WINDOWED) {
+                        cmdline = "-g -GF -WINDOW";
+                    } else {
+                        cmdline = "-g -GF";
+                    }
+                }
+                log_info("avs-ea3", "using cmdline: `{}`", cmdline);
+                avs::core::property_node_create(app_config, nullptr,
+                        avs::core::NODE_TYPE_str, "/param/cmdline", cmdline.c_str());
+            }
+
             auto app_param = avs::core::property_search_safe(app_config, nullptr, "/param");
 
             // call the game init
-            log_info("avs-ea3", "calling entry init");
+            log_info("avs-ea3", "calling dll_entry_init (init code = {})", init_code_str);
             if (!avs::game::entry_init(init_code_str.data(), app_param)) {
-                log_fatal("avs-ea3", "entry init failed :(");
+                for (size_t i = 0; i < 255; i++) {
+                    log_warning("avs-ea3", "dll_entry_init failed :(");
+                }
+                deferredlogs::defer_error_messages({
+                    "dll_entry_init failed",
+                    "    init code: " + init_code_str,
+                    "    this is a fatal error that causes boot failure",
+                    "    most likely, your prop files have errors"
+                });
             }
 
             // accommodate changes to soft id code
@@ -511,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)
             {
@@ -549,6 +630,7 @@ namespace avs {
             soft_id_code << EA3_EXT;
             std::string soft_id_code_str = soft_id_code.str();
             log_info("avs-ea3", "soft id code: {}", soft_id_code_str);
+            deferredlogs::set_softid(soft_id_code_str);
 
             // set soft ID code
             avs::core::avs_std_setenv("/env/profile/soft_id_code", soft_id_code_str.c_str());

src/spice2x/avs/ea3.h

@@ -28,6 +28,7 @@ namespace avs {
         extern int HTTP11;
         extern int URL_SLASH;
         extern int PCB_TYPE;
+        extern bool EA3_DEBUG_VERBOSE;
 
         // handle
         extern std::string VERSION_STR;

src/spice2x/avs/game.cpp

@@ -73,14 +73,13 @@ namespace avs {
 
             // load game instance
             const auto dll_path = MODULE_PATH / DLL_NAME;
-            const auto dll_path_s = dll_path.string();
-            log_info("avs-game", "DLL path: {}", dll_path_s.c_str());
+            log_info("avs-game", "DLL path: {}", dll_path);
 
             // MAX_PATH is 260
-            if (130 <= dll_path_s.length()) {
+            if (const auto dll_path_len = dll_path.wstring().length(); 130 <= dll_path_len) {
                 log_warning(
                     "avs-game",
-                    "PATH TOO LONG WARNING\n\n\n"
+                    "PATH TOO LONG WARNING\n\n"
                     "-------------------------------------------------------------------\n"
                     "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
                     "WARNING - WARNING - WARNING - WARNING - WARNING - WARNING - WARNING\n"
@@ -93,12 +92,29 @@ namespace avs {
                     "long, often resulting in random crashes. Move the game contents to\n"
                     "a directory with shorter path.\n"
                     "-------------------------------------------------------------------\n\n",
-                    dll_path_s, dll_path_s.length());
+                    dll_path, dll_path_len);
             }
+
+            // ddr gamemdx.dll user error
+            if (avs::game::is_model("MDX") && DLL_NAME == "gamemdx.dll") {
+                log_warning(
+                    "ddr",
+                    "BAD GAME DLL ERROR\n\n"
+                    "!!!                                                            !!!\n"
+                    "!!! -exec gamemdx.dll was specified                            !!!\n"
+                    "!!! this is the wrong DLL; the game will not load              !!!\n"
+                    "!!! remove -exec argument and try again.                       !!!\n"
+                    "!!!                                                            !!!\n"
+                    );
+                log_fatal("ddr", "BAD GAME DLL ERROR (don't use -exec gamemdx.dll, that's the wrong DLL)");
+            }
+
+            // file not found on disk
             if (!fileutils::file_exists(dll_path)) {
-                log_warning("avs-game", "game DLL could not be found on disk: {}", dll_path.string().c_str());
+                log_warning("avs-game", "game DLL could not be found on disk: {}", dll_path);
                 log_warning("avs-game", "double check -exec and -modules parameters; unless you know what you're doing, leave them blank");
             }
+
             if (fileutils::verify_header_pe(dll_path)) {
                 DLL_INSTANCE = libutils::load_library(dll_path);
             }
@@ -106,7 +122,7 @@ namespace avs {
             // load entry points
             dll_entry_init = (ENTRY_INIT_T) libutils::get_proc(DLL_INSTANCE, ENTRY_INIT_NAME);
             dll_entry_main = (ENTRY_MAIN_T) libutils::get_proc(DLL_INSTANCE, ENTRY_MAIN_NAME);
-            log_info("avs-game", "loaded successfully ({})", fmt::ptr(DLL_INSTANCE));
+            log_info("avs-game", "loaded {} successfully ({})", DLL_NAME, fmt::ptr(DLL_INSTANCE));
         }
 
         bool entry_init(char *sid_code, void *app_param) {

src/spice2x/build/controller_presets.xml

@@ -0,0 +1,327 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<templates>
+    <!-- PHOENIXWAN controller preset for Beatmania IIDX
+
+       Button indices 0-6: keys 1-7
+       Button indices 8-11: E1 (Start for Deluxe Model Style), E2 (Effect), E3 (VEFX), E4 (P1 Start for Lightning Model Style)
+
+        P1 Side                     P2 Side
+             8 9 10 11          8 9 10 11
+              2  4  6            2  4  6
+       TT   1  3  5  7         1  3  5  7   TT -->
+    <template name="DJ DAO PHOENIXWAN" game="Beatmania IIDX">
+        <buttons>
+            <button name="P1 1" vkey="0" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 2" vkey="1" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 3" vkey="2" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 4" vkey="3" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 5" vkey="4" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 6" vkey="5" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 7" vkey="6" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 1" vkey="0" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 2" vkey="1" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 3" vkey="2" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 4" vkey="3" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 5" vkey="4" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 6" vkey="5" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 7" vkey="6" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <!-- P1 Start: E1 primary (index 8), E4 alternative (index 11) -->
+            <button name="P1 Start" vkey="8" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 Start" vkey="11" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <!-- P2 Start: E1 primary (index 8), E4 alternative (index 11) -->
+            <button name="P2 Start" vkey="8" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 Start" vkey="11" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <!-- EFFECT: E2 (index 9), primary P2 side, alternative P1 side -->
+            <button name="EFFECT" vkey="9" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="EFFECT" vkey="9" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <!-- VEFX: E3 (index 10), primary P2 side, alternative P1 side -->
+            <button name="VEFX" vkey="10" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="VEFX" vkey="10" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+        </buttons>
+        <analogs>
+            <analog name="Turntable P1" devid="Player 1" index="4" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Turntable P2" devid="Player 2" index="4" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+        </analogs>
+        <lights>
+            <light name="P1 1" devid="Player 1" index="0"/>
+            <light name="P1 2" devid="Player 1" index="1"/>
+            <light name="P1 3" devid="Player 1" index="2"/>
+            <light name="P1 4" devid="Player 1" index="3"/>
+            <light name="P1 5" devid="Player 1" index="4"/>
+            <light name="P1 6" devid="Player 1" index="5"/>
+            <light name="P1 7" devid="Player 1" index="6"/>
+            <light name="P2 1" devid="Player 2" index="0"/>
+            <light name="P2 2" devid="Player 2" index="1"/>
+            <light name="P2 3" devid="Player 2" index="2"/>
+            <light name="P2 4" devid="Player 2" index="3"/>
+            <light name="P2 5" devid="Player 2" index="4"/>
+            <light name="P2 6" devid="Player 2" index="5"/>
+            <light name="P2 7" devid="Player 2" index="6"/>
+            <!-- Start buttons bind both E1 (index 8) and E4 (index 11), but lights use
+           Lightning Model style only (one per side) to avoid both lighting up at once -->
+            <light name="P1 Start" devid="Player 1" index="10"/>
+            <light name="P2 Start" devid="Player 2" index="7"/>
+            <light name="VEFX" devid="Player 1" index="8"/>
+            <light name="VEFX" devid="Player 2" index="8"/>
+            <light name="Effect" devid="Player 1" index="9"/>
+            <light name="Effect" devid="Player 2" index="9"/>
+        </lights>
+    </template>
+    <!-- Common "double scratch" BMS playstyle: LSHIFT   A S D SPACE L ; '   RSHIFT -->
+    <!-- Uses Up/Down arrows for turntable navigation -->
+    <template name="Keyboard (linear, double scratch, QWERTY)" game="Beatmania IIDX">
+        <buttons>
+            <button name="P1 1" vkey="65" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 2" vkey="83" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 3" vkey="68" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 4" vkey="32" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 5" vkey="76" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 6" vkey="186" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 7" vkey="222" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 TT+" vkey="40" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 TT-" vkey="38" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 TT+/-" vkey="160" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 TT+/- Alternate" vkey="161" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 Start" vkey="13" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 Start" vkey="69" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="EFFECT" vkey="81" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="VEFX" vkey="87" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+        </buttons>
+        <keypad_buttons/>
+        <analogs/>
+        <lights/>
+    </template>
+    <template name="arcin (arcin-infinitas)" game="Beatmania IIDX">
+        <buttons>
+            <button name="P1 1" vkey="0" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 2" vkey="1" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 3" vkey="2" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 4" vkey="3" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 5" vkey="4" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 6" vkey="5" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 7" vkey="6" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 Start" vkey="9" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 1" vkey="0" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 2" vkey="1" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 3" vkey="2" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 4" vkey="3" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 5" vkey="4" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 6" vkey="5" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 7" vkey="6" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 Start" vkey="9" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="EFFECT" vkey="11" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="EFFECT" vkey="11" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="VEFX" vkey="10" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="VEFX" vkey="10" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+        </buttons>
+        <keypad_buttons/>
+        <!-- Assumes analog mode. Need to invert direction since this FW is designed for INF. -->
+        <analogs>
+            <analog name="Turntable P1" devid="arcin (1p)" index="0" sensivity="1" deadzone="0" deadzone_mirror="false" invert="true" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Turntable P2" devid="arcin (2p)" index="0" sensivity="1" deadzone="0" deadzone_mirror="false" invert="true" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+        </analogs>
+        <lights>
+            <light name="P1 1" devid="arcin (1p)" index="0"/>
+            <light name="P1 2" devid="arcin (1p)" index="1"/>
+            <light name="P1 3" devid="arcin (1p)" index="2"/>
+            <light name="P1 4" devid="arcin (1p)" index="3"/>
+            <light name="P1 5" devid="arcin (1p)" index="4"/>
+            <light name="P1 6" devid="arcin (1p)" index="5"/>
+            <light name="P1 7" devid="arcin (1p)" index="6"/>
+            <light name="P2 1" devid="arcin (2p)" index="0"/>
+            <light name="P2 2" devid="arcin (2p)" index="1"/>
+            <light name="P2 3" devid="arcin (2p)" index="2"/>
+            <light name="P2 4" devid="arcin (2p)" index="3"/>
+            <light name="P2 5" devid="arcin (2p)" index="4"/>
+            <light name="P2 6" devid="arcin (2p)" index="5"/>
+            <light name="P2 7" devid="arcin (2p)" index="6"/>
+            <light name="P1 Start" devid="arcin (1p)" index="9"/>
+            <light name="P2 Start" devid="arcin (2p)" index="9"/>
+        </lights>
+    </template>
+    <!-- This controller has many modes; here, we use HID Analog mode which is meant for data -->
+    <template name="DJ DAO Nostroller (Analog mode)" game="Nostalgia">
+        <buttons/>
+        <keypad_buttons/>
+        <analogs>
+            <analog name="Key 1" devid="Analogs key 01-28" index="4" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 2" devid="Analogs key 01-28" index="5" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 3" devid="Analogs key 01-28" index="6" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 4" devid="Analogs key 01-28" index="7" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 5" devid="Analogs key 01-28" index="8" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 6" devid="Analogs key 01-28" index="9" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 7" devid="Analogs key 01-28" index="10" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 8" devid="Analogs key 01-28" index="11" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 9" devid="Analogs key 01-28" index="12" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 10" devid="Analogs key 01-28" index="13" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 11" devid="Analogs key 01-28" index="14" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 12" devid="Analogs key 01-28" index="15" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 13" devid="Analogs key 01-28" index="16" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 14" devid="Analogs key 01-28" index="17" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 15" devid="Analogs key 01-28" index="18" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 16" devid="Analogs key 01-28" index="19" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 17" devid="Analogs key 01-28" index="20" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 18" devid="Analogs key 01-28" index="21" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 19" devid="Analogs key 01-28" index="22" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 20" devid="Analogs key 01-28" index="23" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 21" devid="Analogs key 01-28" index="24" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 22" devid="Analogs key 01-28" index="25" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 23" devid="Analogs key 01-28" index="26" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 24" devid="Analogs key 01-28" index="27" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 25" devid="Analogs key 01-28" index="28" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 26" devid="Analogs key 01-28" index="29" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 27" devid="Analogs key 01-28" index="30" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 28" devid="Analogs key 01-28" index="31" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+        </analogs>
+        <lights>
+            <light name="Key 1 R" devid="Lights 01-14" index="0"/>
+            <light name="Key 1 G" devid="Lights 01-14" index="1"/>
+            <light name="Key 1 B" devid="Lights 01-14" index="2"/>
+            <light name="Key 2 R" devid="Lights 01-14" index="3"/>
+            <light name="Key 2 G" devid="Lights 01-14" index="4"/>
+            <light name="Key 2 B" devid="Lights 01-14" index="5"/>
+            <light name="Key 3 R" devid="Lights 01-14" index="6"/>
+            <light name="Key 3 G" devid="Lights 01-14" index="7"/>
+            <light name="Key 3 B" devid="Lights 01-14" index="8"/>
+            <light name="Key 4 R" devid="Lights 01-14" index="9"/>
+            <light name="Key 4 G" devid="Lights 01-14" index="10"/>
+            <light name="Key 4 B" devid="Lights 01-14" index="11"/>
+            <light name="Key 5 R" devid="Lights 01-14" index="12"/>
+            <light name="Key 5 G" devid="Lights 01-14" index="13"/>
+            <light name="Key 5 B" devid="Lights 01-14" index="14"/>
+            <light name="Key 6 R" devid="Lights 01-14" index="15"/>
+            <light name="Key 6 G" devid="Lights 01-14" index="16"/>
+            <light name="Key 6 B" devid="Lights 01-14" index="17"/>
+            <light name="Key 7 R" devid="Lights 01-14" index="18"/>
+            <light name="Key 7 G" devid="Lights 01-14" index="19"/>
+            <light name="Key 7 B" devid="Lights 01-14" index="20"/>
+            <light name="Key 8 R" devid="Lights 01-14" index="21"/>
+            <light name="Key 8 G" devid="Lights 01-14" index="22"/>
+            <light name="Key 8 B" devid="Lights 01-14" index="23"/>
+            <light name="Key 9 R" devid="Lights 01-14" index="24"/>
+            <light name="Key 9 G" devid="Lights 01-14" index="25"/>
+            <light name="Key 9 B" devid="Lights 01-14" index="26"/>
+            <light name="Key 10 R" devid="Lights 01-14" index="27"/>
+            <light name="Key 10 G" devid="Lights 01-14" index="28"/>
+            <light name="Key 10 B" devid="Lights 01-14" index="29"/>
+            <light name="Key 11 R" devid="Lights 01-14" index="30"/>
+            <light name="Key 11 G" devid="Lights 01-14" index="31"/>
+            <light name="Key 11 B" devid="Lights 01-14" index="32"/>
+            <light name="Key 12 R" devid="Lights 01-14" index="33"/>
+            <light name="Key 12 G" devid="Lights 01-14" index="34"/>
+            <light name="Key 12 B" devid="Lights 01-14" index="35"/>
+            <light name="Key 13 R" devid="Lights 01-14" index="36"/>
+            <light name="Key 13 G" devid="Lights 01-14" index="37"/>
+            <light name="Key 13 B" devid="Lights 01-14" index="38"/>
+            <light name="Key 14 R" devid="Lights 01-14" index="39"/>
+            <light name="Key 14 G" devid="Lights 01-14" index="40"/>
+            <light name="Key 14 B" devid="Lights 01-14" index="41"/>
+            <light name="Key 15 R" devid="Lights 15-28" index="0"/>
+            <light name="Key 15 G" devid="Lights 15-28" index="1"/>
+            <light name="Key 15 B" devid="Lights 15-28" index="2"/>
+            <light name="Key 16 R" devid="Lights 15-28" index="3"/>
+            <light name="Key 16 G" devid="Lights 15-28" index="4"/>
+            <light name="Key 16 B" devid="Lights 15-28" index="5"/>
+            <light name="Key 17 R" devid="Lights 15-28" index="6"/>
+            <light name="Key 17 G" devid="Lights 15-28" index="7"/>
+            <light name="Key 17 B" devid="Lights 15-28" index="8"/>
+            <light name="Key 18 R" devid="Lights 15-28" index="9"/>
+            <light name="Key 18 G" devid="Lights 15-28" index="10"/>
+            <light name="Key 18 B" devid="Lights 15-28" index="11"/>
+            <light name="Key 19 R" devid="Lights 15-28" index="12"/>
+            <light name="Key 19 G" devid="Lights 15-28" index="13"/>
+            <light name="Key 19 B" devid="Lights 15-28" index="14"/>
+            <light name="Key 20 R" devid="Lights 15-28" index="15"/>
+            <light name="Key 20 G" devid="Lights 15-28" index="16"/>
+            <light name="Key 20 B" devid="Lights 15-28" index="17"/>
+            <light name="Key 21 R" devid="Lights 15-28" index="18"/>
+            <light name="Key 21 G" devid="Lights 15-28" index="19"/>
+            <light name="Key 21 B" devid="Lights 15-28" index="20"/>
+            <light name="Key 22 R" devid="Lights 15-28" index="21"/>
+            <light name="Key 22 G" devid="Lights 15-28" index="22"/>
+            <light name="Key 22 B" devid="Lights 15-28" index="23"/>
+            <light name="Key 23 R" devid="Lights 15-28" index="24"/>
+            <light name="Key 23 G" devid="Lights 15-28" index="25"/>
+            <light name="Key 23 B" devid="Lights 15-28" index="26"/>
+            <light name="Key 24 R" devid="Lights 15-28" index="27"/>
+            <light name="Key 24 G" devid="Lights 15-28" index="28"/>
+            <light name="Key 24 B" devid="Lights 15-28" index="29"/>
+            <light name="Key 25 R" devid="Lights 15-28" index="30"/>
+            <light name="Key 25 G" devid="Lights 15-28" index="31"/>
+            <light name="Key 25 B" devid="Lights 15-28" index="32"/>
+            <light name="Key 26 R" devid="Lights 15-28" index="33"/>
+            <light name="Key 26 G" devid="Lights 15-28" index="34"/>
+            <light name="Key 26 B" devid="Lights 15-28" index="35"/>
+            <light name="Key 27 R" devid="Lights 15-28" index="36"/>
+            <light name="Key 27 G" devid="Lights 15-28" index="37"/>
+            <light name="Key 27 B" devid="Lights 15-28" index="38"/>
+            <light name="Key 28 R" devid="Lights 15-28" index="39"/>
+            <light name="Key 28 G" devid="Lights 15-28" index="40"/>
+            <light name="Key 28 B" devid="Lights 15-28" index="41"/>
+        </lights>
+    </template>
+    <!-- Gitaller has two modes - digital tilt and analog axis. This binds both of them at the same time. -->
+    <template name="DJ DAO Gitaller" game="GitaDora">
+        <buttons>
+            <button name="Guitar P1 Start" vkey="9" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Help" vkey="8" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Pick Up" vkey="5" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Pick Down" vkey="6" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 R" vkey="0" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 G" vkey="1" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 B" vkey="2" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Y" vkey="3" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 P" vkey="4" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Wail Up" vkey="10" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Wail Down" vkey="11" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+        </buttons>
+        <keypad_buttons/>
+        <analogs>
+            <analog name="Guitar P1 Wail X" devid="Gitaller P1" index="1" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Guitar P1 Wail Y" devid="Gitaller P1" index="0" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Guitar P1 Wail Z" devid="Gitaller P1" index="5" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+        </analogs>
+        <lights/>
+    <!-- Gen 1 FAUCETWO in HID mode; should also work for later gens -->
+    </template>
+        <template name="DJ DAO FAUCETWO" game="Sound Voltex">
+        <buttons>
+            <button name="BT-A" vkey="1" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="BT-B" vkey="2" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="BT-C" vkey="3" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="BT-D" vkey="4" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="FX-L" vkey="5" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="FX-R" vkey="6" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Start" vkey="0" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+        </buttons>
+        <keypad_buttons/>
+        <analogs>
+            <analog name="VOL-L" devid="Buttons (MI_01)" index="1" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="VOL-R" devid="Buttons (MI_01)" index="0" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+        </analogs>
+        <lights>
+            <light name="BT-A" devid="Lights (MI_02)" index="24"/>
+            <light name="BT-B" devid="Lights (MI_02)" index="25"/>
+            <light name="BT-C" devid="Lights (MI_02)" index="26"/>
+            <light name="BT-D" devid="Lights (MI_02)" index="27"/>
+            <light name="FX-L" devid="Lights (MI_02)" index="28"/>
+            <light name="FX-R" devid="Lights (MI_02)" index="29"/>
+            <light name="Start" devid="Lights (MI_02)" index="30"/>
+            <light name="Upper Left Speaker Avg R" devid="Lights (MI_02)" index="0"/>
+            <light name="Upper Left Speaker Avg G" devid="Lights (MI_02)" index="1"/>
+            <light name="Upper Left Speaker Avg B" devid="Lights (MI_02)" index="2"/>
+            <light name="Upper Right Speaker Avg R" devid="Lights (MI_02)" index="9"/>
+            <light name="Upper Right Speaker Avg G" devid="Lights (MI_02)" index="10"/>
+            <light name="Upper Right Speaker Avg B" devid="Lights (MI_02)" index="11"/>
+            <light name="Lower Left Speaker Avg R" devid="Lights (MI_02)" index="3"/>
+            <light name="Lower Left Speaker Avg G" devid="Lights (MI_02)" index="4"/>
+            <light name="Lower Left Speaker Avg B" devid="Lights (MI_02)" index="5"/>
+            <light name="Lower Right Speaker Avg R" devid="Lights (MI_02)" index="6"/>
+            <light name="Lower Right Speaker Avg G" devid="Lights (MI_02)" index="7"/>
+            <light name="Lower Right Speaker Avg B" devid="Lights (MI_02)" index="8"/>
+            <light name="Control Panel Avg R" devid="Lights (MI_02)" index="15"/>
+            <light name="Control Panel Avg G" devid="Lights (MI_02)" index="16"/>
+            <light name="Control Panel Avg B" devid="Lights (MI_02)" index="17"/>
+        </lights>
+    </template>
+</templates>

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>
@@ -23,7 +24,7 @@
     <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
         <security>
             <requestedPrivileges>
-                <requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
+                <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
             </requestedPrivileges>
         </security>
     </trustInfo>

src/spice2x/build/resource.h

@@ -2,7 +2,6 @@
 
 #define IDC_STATIC                      -1
 #define IDD_DIALOG1                     129
-#define IDR_CHANGELOG                   130
 #define IDR_LICENSES                    131
 #define IDR_PATCHES                     132
 #define IDR_README                      133

src/spice2x/build_all.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # set to EN-US for consistency
 LANG=en_us_8859_1
@@ -41,14 +41,21 @@ done
 # settings
 GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD 2> /dev/null || echo "none")
 GIT_HEAD=$(git rev-parse HEAD || echo "none")
-TOOLCHAIN_32="/usr/share/mingw/toolchain-i686-w64-mingw32.cmake"
-TOOLCHAIN_64="/usr/share/mingw/toolchain-x86_64-w64-mingw32.cmake"
+TOOLCHAIN_32="${TOOLCHAIN_32:-"/usr/share/mingw/toolchain-i686-w64-mingw32.cmake"}"
+TOOLCHAIN_64="${TOOLCHAIN_64:-"/usr/share/mingw/toolchain-x86_64-w64-mingw32.cmake"}"
+TOOLCHAIN_WINXP_32="${TOOLCHAIN_WINXP_32:-"/opt/llvm-mingw-xp/toolchain-files/cmake/i686-mingw32-clang.cmake"}"
+TOOLCHAIN_WINXP_64="${TOOLCHAIN_WINXP_64:-"/opt/llvm-mingw-xp/toolchain-files/cmake/x86_64-mingw32-clang.cmake"}"
 BUILDDIR_32_RELEASE="./cmake-build-release-32"
 BUILDDIR_32_DEBUG="./cmake-build-debug-32"
 BUILDDIR_64_RELEASE="./cmake-build-release-64"
 BUILDDIR_64_DEBUG="./cmake-build-debug-64"
+BUILDDIR_WINXP_32_RELEASE="./cmake-build-release-winxp-32"
+BUILDDIR_WINXP_32_DEBUG="./cmake-build-debug-winxp-32"
+BUILDDIR_WINXP_64_RELEASE="./cmake-build-release-winxp-64"
+BUILDDIR_WINXP_64_DEBUG="./cmake-build-debug-winxp-64"
 DEBUG=0
 OUTDIR="./bin/spice2x"
+OUTDIR_EXTRAS="./bin/spice2x/extras"
 
 # disabled UPX since it tends to falsely trigger malware detection
 UPX_ENABLE=0
@@ -59,20 +66,44 @@ INCLUDE_SRC=1
 DIST_ENABLE=1
 DIST_FOLDER="./dist"
 DIST_NAME="spice2x-$(date +%y)-$(date +%m)-$(date +%d).zip"
+DIST_NAME_EXTRAS="spice2x-$(date +%y)-$(date +%m)-$(date +%d)-full.zip"
 DIST_COMMENT=${DIST_NAME}$'\n'"$GIT_BRANCH - $GIT_HEAD"$'\nThank you for playing.'
-TARGETS_32="spicetools_stubs_kbt spicetools_stubs_kld spicetools_cfg spicetools_spice spicetools_spice_laa spicetools_stubs_cpusbxpkm"
-TARGETS_64="spicetools_stubs_kbt64 spicetools_stubs_kld64 spicetools_stubs_nvEncodeAPI64 spicetools_stubs_nvcuvid spicetools_stubs_nvcuda spicetools_spice64"
+TARGETS_32="spicetools_stubs_kbt spicetools_stubs_kld spicetools_cfg spicetools_cfg_linux spicetools_spice spicetools_spice_laa spicetools_spice_linux spicetools_stubs_cpusbxpkm spicetools_sdk_sample_v0_flat_c_32"
+TARGETS_64="spicetools_stubs_kbt64 spicetools_stubs_kld64 spicetools_stubs_nvEncodeAPI64 spicetools_stubs_nvcuvid spicetools_stubs_nvcuda spicetools_spice64 spicetools_spice64_linux spicetools_sdk_sample_v0_flat_c_64 spicetools_sdk_sample_v0_cpp_64"
+TARGETS_XP32="spicetools_cfg spicetools_spice"
+TARGETS_XP64="spicetools_spice64"
 
 # determine build type
 BUILD_TYPE="Release"
 BUILDDIR_32=${BUILDDIR_32_RELEASE}
 BUILDDIR_64=${BUILDDIR_64_RELEASE}
+BUILDDIR_WINXP_32=${BUILDDIR_WINXP_32_RELEASE}
+BUILDDIR_WINXP_64=${BUILDDIR_WINXP_64_RELEASE}
 if ((DEBUG > 0))
 then
 	BUILD_TYPE="Debug"
 	BUILDDIR_32=${BUILDDIR_32_DEBUG}
 	BUILDDIR_64=${BUILDDIR_64_DEBUG}
-	DIST_NAME=$(echo ${DIST_NAME} | sed 's/\.[^.]*$/-dbg&/')
+	BUILDDIR_WINXP_32=${BUILDDIR_WINXP_32_DEBUG}
+	BUILDDIR_WINXP_64=${BUILDDIR_WINXP_64_DEBUG}
+	DIST_NAME=$(echo "${DIST_NAME}" | sed 's/\.[^.]*$/-dbg&/')
+fi
+
+# is the XP-compatible toolchain installed?
+XP_MUST_BUILD=0
+# 64-bit WinXP builds are disabled by default; set to 1 to opt in
+BUILD_XP_64_ENABLE=0
+BUILD_XP_32=0
+BUILD_XP_64=0
+if [ -f "$TOOLCHAIN_WINXP_32" ]; then
+	BUILD_XP_32=1;
+elif ((XP_MUST_BUILD > 0))
+then
+	echo "WinXP 32bit toolchain not available, aborting"
+	exit 1
+fi
+if ((BUILD_XP_64_ENABLE > 0)) && [ -f "$TOOLCHAIN_WINXP_64" ]; then
+	BUILD_XP_64=1;
 fi
 
 # determine number of cores
@@ -88,6 +119,18 @@ echo "Git Branch: $GIT_BRANCH"
 echo "Git Head: $GIT_HEAD"
 echo "Toolchain for 32bit targets: $TOOLCHAIN_32"
 echo "Toolchain for 64bit targets: $TOOLCHAIN_64"
+if ((BUILD_XP_32 > 0))
+then
+	echo "Toolchain for WinXP 32bit targets: $TOOLCHAIN_WINXP_32"
+else
+	echo "WinXP 32bit toolchain not available, skipping WinXP 32bit builds"
+fi
+if ((BUILD_XP_64 > 0))
+then
+	echo "Toolchain for WinXP 64bit targets: $TOOLCHAIN_WINXP_64"
+else
+	echo "WinXP 64bit builds disabled, skipping WinXP 64bit builds"
+fi
 echo "Distribution Name: $DIST_NAME"
 echo "Build Type: $BUILD_TYPE"
 echo "Cores: $CORES"
@@ -112,7 +155,7 @@ time (
 	fi
 	mkdir -p ${BUILDDIR_32}
 	pushd ${BUILDDIR_32} > /dev/null
-	cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_32} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} $OLDPWD && ninja ${TARGETS_32}
+	cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_32} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} "$OLDPWD" && ninja ${TARGETS_32}
 	popd > /dev/null
 
 	# 64 bit
@@ -125,14 +168,87 @@ time (
 	fi
 	mkdir -p ${BUILDDIR_64}
 	pushd ${BUILDDIR_64} > /dev/null
-	cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_64} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} $OLDPWD && ninja ${TARGETS_64}
+	cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_64} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} "$OLDPWD" && ninja ${TARGETS_64}
 	popd > /dev/null
 
+	if ((BUILD_XP_32 > 0))
+	then
+		# 32 bit Windows XP
+		echo ""
+		echo "Building 32bit targets (WinXP toolchain)..."
+		echo "========================="
+		if ((CLEAN_BUILD > 0))
+		then
+			rm -rf ${BUILDDIR_WINXP_32}
+		fi
+		mkdir -p ${BUILDDIR_WINXP_32}
+		pushd ${BUILDDIR_WINXP_32} > /dev/null
+		cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_WINXP_32} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DSPICE_XP=ON "$OLDPWD" && ninja ${TARGETS_XP32}
+		popd > /dev/null
+	else
+		echo ""
+		echo "Skipping WinXP 32bit builds, toolchain not specified"
+	fi
+
+	if ((BUILD_XP_64 > 0))
+	then
+		# 64 bit Windows XP
+		echo ""
+		echo "Building 64bit targets (WinXP toolchain)..."
+		echo "========================="
+		if ((CLEAN_BUILD > 0))
+		then
+			rm -rf ${BUILDDIR_WINXP_64}
+		fi
+		mkdir -p ${BUILDDIR_WINXP_64}
+		pushd ${BUILDDIR_WINXP_64} > /dev/null
+		cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_WINXP_64} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DSPICE_XP=ON "$OLDPWD" && ninja ${TARGETS_XP64}
+		popd > /dev/null
+	else
+		echo ""
+		echo "Skipping WinXP 64bit builds"
+	fi
+
 	echo ""
 	echo "Compilation process done :)"
 	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 ""
+	echo "Checking XP compatibility..."
+	echo "============================="
+	if ! command -v windows_dll_compat_checker &> /dev/null; then
+		echo "WARNING: windows_dll_compat_checker not found, skipping XP compatibility check"
+	else
+		if ((BUILD_XP_64 > 0))
+		then
+			windows_dll_compat_checker -s PREMADE/winxp_x86_64.ini \
+				${BUILDDIR_WINXP_64}/spicetools/64/spice64.exe
+		fi
+		if ((BUILD_XP_32 > 0))
+		then
+			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
+	fi
+fi
+
 # generate PDBs
 if false  # ((DEBUG > 0))
 then
@@ -179,11 +295,24 @@ fi
 
 # copy to output directory
 echo "Copy files to output directory..."
+
 rm -rf ${OUTDIR}
 mkdir -p ${OUTDIR}
 mkdir -p ${OUTDIR}/stubs/32
 mkdir -p ${OUTDIR}/stubs/64
-mkdir -p ${OUTDIR}/extras/largeaddressaware
+
+rm -rf ${OUTDIR_EXTRAS}
+mkdir -p ${OUTDIR_EXTRAS}
+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
+fi
+
 if false # ((DEBUG > 0))
 then
     # debug files
@@ -191,30 +320,33 @@ then
     cp ${BUILDDIR_32}/spicetools/spicecfg-pdb.pdb ${OUTDIR} 2>/dev/null
     cp ${BUILDDIR_32}/spicetools/32/spice-pdb.exe ${OUTDIR} 2>/dev/null
     cp ${BUILDDIR_32}/spicetools/32/spice-pdb.pdb ${OUTDIR} 2>/dev/null
-    #cp ${BUILDDIR_32}/spicetools/32/kbt.dll ${OUTDIR}/stubs/32 2>/dev/null
-    #cp ${BUILDDIR_32}/spicetools/32/kld.dll ${OUTDIR}/stubs/32 2>/dev/null
     cp ${BUILDDIR_64}/spicetools/64/spice64-pdb.exe ${OUTDIR} 2>/dev/null
     cp ${BUILDDIR_64}/spicetools/64/spice64-pdb.pdb ${OUTDIR} 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/kbt.dll ${OUTDIR}/stubs/64 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/kld.dll ${OUTDIR}/stubs/64 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/nvEncodeAPI64.dll ${OUTDIR}/stubs/64 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/nvcuda.dll ${OUTDIR}/stubs/64 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/nvcuvid.dll ${OUTDIR}/stubs/64 2>/dev/null
-	#cp ${BUILDDIR_32}/spicetools/32/cpusbxpkm.dll ${OUTDIR}/stubs/32 2>/dev/null
 else
     # release files
     cp ${BUILDDIR_32}/spicetools/spicecfg.exe ${OUTDIR} 2>/dev/null
+    cp ${BUILDDIR_32}/spicetools/spicecfg_linux.exe ${OUTDIR_EXTRAS}/linux/spicecfg.exe 2>/dev/null
     cp ${BUILDDIR_32}/spicetools/32/spice.exe ${OUTDIR} 2>/dev/null
-    cp ${BUILDDIR_32}/spicetools/32/spice_laa.exe ${OUTDIR}/extras/largeaddressaware/spice.exe 2>/dev/null
-    #cp ${BUILDDIR_32}/spicetools/32/kbt.dll ${OUTDIR}/stubs/32 2>/dev/null
-    #cp ${BUILDDIR_32}/spicetools/32/kld.dll ${OUTDIR}/stubs/32 2>/dev/null
+    cp ${BUILDDIR_32}/spicetools/32/spice_laa.exe ${OUTDIR_EXTRAS}/largeaddressaware/spice.exe 2>/dev/null
+    cp ${BUILDDIR_32}/spicetools/32/spice_linux.exe ${OUTDIR_EXTRAS}/linux/spice.exe 2>/dev/null
     cp ${BUILDDIR_64}/spicetools/64/spice64.exe ${OUTDIR} 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/kbt.dll ${OUTDIR}/stubs/64 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/kld.dll ${OUTDIR}/stubs/64 2>/dev/null
+    cp ${BUILDDIR_64}/spicetools/64/spice64_linux.exe ${OUTDIR_EXTRAS}/linux/spice64.exe 2>/dev/null
     cp ${BUILDDIR_64}/spicetools/64/nvEncodeAPI64.dll ${OUTDIR}/stubs/64 2>/dev/null
     cp ${BUILDDIR_64}/spicetools/64/nvcuda.dll ${OUTDIR}/stubs/64 2>/dev/null
     cp ${BUILDDIR_64}/spicetools/64/nvcuvid.dll ${OUTDIR}/stubs/64 2>/dev/null
     cp ${BUILDDIR_32}/spicetools/32/cpusbxpkm.dll ${OUTDIR}/stubs/32 2>/dev/null
+	cp ${BUILDDIR_32}/spicetools/32/sdk_sample_v0_flat_c.dll ${OUTDIR_EXTRAS}/sdk/samples/32/v0_flat_c.dll 2>/dev/null
+	cp ${BUILDDIR_64}/spicetools/64/sdk_sample_v0_flat_c.dll ${OUTDIR_EXTRAS}/sdk/samples/64/v0_flat_c.dll 2>/dev/null
+	cp ${BUILDDIR_64}/spicetools/64/sdk_sample_v0_cpp.dll ${OUTDIR_EXTRAS}/sdk/samples/64/v0_cpp.dll 2>/dev/null
+	if ((BUILD_XP_32 > 0))
+	then
+		cp ${BUILDDIR_WINXP_32}/spicetools/spicecfg.exe ${OUTDIR_EXTRAS}/winxp 2>/dev/null
+		cp ${BUILDDIR_WINXP_32}/spicetools/32/spice.exe ${OUTDIR_EXTRAS}/winxp 2>/dev/null
+	fi
+	if ((BUILD_XP_64 > 0))
+	then
+		cp ${BUILDDIR_WINXP_64}/spicetools/64/spice64.exe ${OUTDIR_EXTRAS}/winxp 2>/dev/null
+	fi
 fi
 
 # pack source files to output directory
@@ -223,24 +355,32 @@ mkdir -p ${OUTDIR}/src
 if ((INCLUDE_SRC > 0))
 then
 	echo "Generating source file archive..."
-	git archive --format tar.gz --prefix=spice2x/ HEAD ./ > ${OUTDIR}/src/spice2x-${GIT_BRANCH}.tar.gz 2>/dev/null || \
+	git archive --format tar.gz --prefix=spice2x/ HEAD ./ > "${OUTDIR}/src/spice2x-${GIT_BRANCH}.tar.gz" 2>/dev/null || \
 		echo "WARNING: Couldn't get git to create the archive. Is this a git repository?"
 fi
 
+# sdk headers
+cp -r ./sdk/include ${OUTDIR_EXTRAS}/sdk
+
 # copy resources
-rm -rf ${OUTDIR}/api
-mkdir ${OUTDIR}/api
+rm -rf ${OUTDIR_EXTRAS}/api
+mkdir ${OUTDIR_EXTRAS}/api
 find ./api/resources/python -name "__pycache__" -exec rm -rf {} +
-cp -r ./api/resources/* ${OUTDIR}/api
+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
 	echo "Building dist..."
 	mkdir -p ${DIST_FOLDER}
-	rm -rf ${DIST_FOLDER}/${DIST_NAME}
-	pushd ${OUTDIR}/.. > /dev/null
-	zip -qrXT9 $OLDPWD/${DIST_FOLDER}/${DIST_NAME} . -z <<< "$DIST_COMMENT"
+	rm -rf "${DIST_FOLDER}/${DIST_NAME}"
+	pushd ${OUTDIR} > /dev/null
+	zip -qrXT9 "$OLDPWD/${DIST_FOLDER}/${DIST_NAME}" . -x "extras/*" -z <<< "$DIST_COMMENT"
+	echo "Building extras..."
+	zip -qrXT9 "$OLDPWD/${DIST_FOLDER}/${DIST_NAME_EXTRAS}" . -z <<< "$DIST_COMMENT"
 	popd > /dev/null
 fi
 

src/spice2x/build_docker.bat

@@ -1,7 +1,7 @@
 docker build --pull external/docker -t spicetools/deps
 docker build --build-context gitroot=%cd%/../../.git . -t spicetools/spice
-docker run --rm -it -v %cd%/dist:/src/src/spice2x/dist -v %cd%/bin:/src/src/spice2x/bin -v %cd%/.ccache:/src/src/spice2x/.ccache spicetools/spice %*
+docker run --rm -i -v %cd%/dist:/src/src/spice2x/dist -v %cd%/bin:/src/src/spice2x/bin -v %cd%/.ccache:/src/src/spice2x/.ccache spicetools/spice %*
 @REM to generate PDBs, set DEBUG to 1 in build_all.sh, place cv2pdb in external\cv2pdb, and run below
 @REM external\cv2pdb\cv2pdb.exe bin\spice2x\spicecfg.exe bin\spice2x\spicecfg-pdb.exe bin\spice2x\spicecfg-pdb.pdb
 @REM external\cv2pdb\cv2pdb.exe bin\spice2x\spice.exe bin\spice2x\spice-pdb.exe bin\spice2x\spice-pdb.pdb
-@REM external\cv2pdb\cv2pdb.exe bin\spice2x\spice64.exe bin\spice2x\spice64-pdb.exe bin\spice2x\spice64-pdb.pdb
+@REM external\cv2pdb\cv2pdb.exe bin\spice2x\spice64.exe bin\spice2x\spice64-pdb.exe bin\spice2x\spice64-pdb.pdb

src/spice2x/build_docker.sh

@@ -1,4 +1,12 @@
-#!/bin/bash
-docker build --pull $PWD/external/docker -t spicetools/deps --platform linux/x86_64
-docker build --build-context gitroot=$PWD/../../.git . -t spicetools/spice:latest
-docker run --rm -v $PWD/dist:/src/src/spice2x/dist -v $PWD/bin:/src/src/spice2x/bin -v $PWD/.ccache:/src/src/spice2x/.ccache spicetools/spice "$@"
+#!/usr/bin/env bash
+
+set -eu
+
+docker build --pull "$PWD/external/docker" -t spicetools/deps --platform linux/x86_64
+docker build --build-context gitroot="$PWD/../../.git" . -t spicetools/spice:latest
+
+# Interactive TTY if available, so docker build can be Ctrl+C'd
+DOCKER_FLAGS=""
+[ -t 0 ] && DOCKER_FLAGS="-it"
+
+docker run $DOCKER_FLAGS --rm -v "$PWD/dist:/src/src/spice2x/dist" -v "$PWD/bin:/src/src/spice2x/bin" -v "$PWD/.ccache:/src/src/spice2x/.ccache" spicetools/spice "$@"

src/spice2x/build_release.bat

@@ -1,2 +1,3 @@
 del /s /q .ccache
+del /s /q dist
 call build_docker.bat

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/Win32D.rc

@@ -9,10 +9,10 @@
 #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
 LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
 
-IDR_CHANGELOG RCDATA "../changelog.txt"
 IDR_LICENSES RCDATA "../licenses.txt"
 IDR_PATCHES RCDATA "../build/patches.json"
 IDR_README RCDATA "../readme.txt"
 IDR_DSEGFONT RCDATA "../external/dseg/DSEG14Classic-Italic.ttf"
+IDR_CONTROLLER_PRESETS_BUILTIN RCDATA "../build/controller_presets.xml"
 
 #endif

src/spice2x/cfg/analog.cpp

@@ -90,6 +90,10 @@ std::string Analog::getDisplayString(rawinput::RawInputManager *manager) {
                 return "MIDI Unknown Index " + indexString + " (" + device->desc + ")";
             }
         }
+        case rawinput::XINPUT_GAMEPAD:
+            return fmt::format("{} ({})",
+                xinput::get_analog_string(static_cast<xinput::XInputAnalogEnum>(index)),
+                device->desc);
         case rawinput::DESTROYED:
             return "Device unplugged (" + indexString + ")";
         default:
@@ -203,22 +207,38 @@ float Analog::applyMultiplier(float value) {
 }
 
 float Analog::normalizeAnalogValue(float value) {
-    // effectively the same as fmodf(value, 1.f)
-    // for small values, this is MUCH faster than fmodf.
-    float new_value = value;
-    while (new_value > 1.f) {
-        new_value -= 1.f;
+    if (getType() == GameAPI::Analogs::AnalogType::Circular) {
+        // effectively the same as fmodf(value, 1.f)
+        // for small values, this is MUCH faster than fmodf.
+        float new_value = value;
+        while (new_value > 1.f) {
+            new_value -= 1.f;
+        }
+        while (new_value < 0.f) {
+            new_value += 1.f;
+        }
+        return new_value;
+
+    } else {
+        // clamp to [0, 1] range
+        return std::clamp(value, 0.f, 1.f);
     }
-    while (new_value < 0.f) {
-        new_value += 1.f;
-    }
-    return new_value;
 }
 
 float Analog::applyDeadzone(float raw_value) {
     float value = raw_value;
-    const auto deadzone = this->getDeadzone();
-    if (deadzone > 0) {
+    auto deadzone = this->getDeadzone();
+
+    // in the past, positive deadzone applied in the center, negative deadzone applied to 0
+    // after each analog value received a type (circular/linear) this has been simpliifed to
+    // positive values only since we can figure out where the rest value is
+    // for back compat, treat negative value as positive
+    if (deadzone < 0.f) {
+        deadzone = -deadzone;
+    }
+
+    // relative mode assumes that user is using a stick, so center is neutral regardless of analog type
+    if (getType() != GameAPI::Analogs::AnalogType::LinearPositive || isRelativeMode()) {
 
         // calculate values
         const auto delta = value - 0.5f;
@@ -251,7 +271,7 @@ float Analog::applyDeadzone(float raw_value) {
             }
         }
 
-    } else if (deadzone < 0) {
+    } else {
 
         // invert for mirror
         if (this->getDeadzoneMirror()) {
@@ -259,8 +279,8 @@ float Analog::applyDeadzone(float raw_value) {
         }
 
         // deadzone from minimum value
-        if (deadzone > -1 && value > -deadzone) {
-            value = std::min(1.f, (value + deadzone) / (1.f + deadzone));
+        if (deadzone < 1.f && deadzone < value) {
+            value = std::max(0.f, (value - deadzone) / (1.f - deadzone));
         } else {
             value = 0.f;
         }
@@ -271,4 +291,75 @@ float Analog::applyDeadzone(float raw_value) {
         }
     }
     return value;
-}
+}
+
+float Analog::getRelativeModeValue(float raw_value) {
+    const auto now = get_performance_seconds();
+    auto delta_time = now - this->rel_mode_last_read_time_s;
+
+    if (this->rel_mode_last_read_time_s != 0.f) {
+        // some heuristics to prevent huge jumps:
+        //  * if we went for more than 250ms without polls, discard it (e.g., during loading screens)
+        //  * cap the delta at 100ms to prevent huge jumps in case of very infrequent polling
+        if (delta_time < 0.f || 0.25f < delta_time) {
+            delta_time = 0.f;
+        } else if (delta_time > 0.1f) {
+            delta_time = 0.1f;
+        }
+
+        // scale [0, 1] to [-1, 1] to simplify calculations
+        const auto delta_raw_value = (raw_value - 0.5f) * 2.f;
+
+        // target is one revolution per second at max speed at 1.0 sensitivity
+        auto adjusted_delta_value = delta_raw_value * delta_time;
+
+        // multiplier / divisor
+        if (this->getMultiplier() > 1) {
+            adjusted_delta_value *= this->getMultiplier();
+        } else if (this->getMultiplier() < -1) {
+            adjusted_delta_value /= -this->getMultiplier();
+        }
+
+        // sensitivity
+        if (this->isSensitivitySet()) {
+            adjusted_delta_value *= this->getSensitivity();
+        }
+
+        // calculate the new absolute value
+        this->rel_mode_absolute_value += adjusted_delta_value;
+    }
+
+    // update for next poll
+    this->rel_mode_last_read_time_s = now;
+    this->rel_mode_absolute_value = normalizeAnalogValue(this->rel_mode_absolute_value);
+    return this->rel_mode_absolute_value;
+}
+
+float Analog::getDelayedValue(float raw_value) {
+    const double delay_ms = static_cast<double>(this->getDelayMs());
+    if (delay_ms == 0.0) {
+        return raw_value;
+    }
+
+    // always push a new value
+    const auto now = get_performance_milliseconds();
+    this->delayed_inputs.emplace(now, raw_value);
+    
+    // drain the queue down to reasonable length to prevent unconstrained growth
+    // this would accommodate 1 second at ~1000Hz which is overkill
+    // (UI only allows for 250ms of delay)
+    while (this->delayed_inputs.size() > 1024) {
+        this->delayed_inputs.pop();
+    }
+
+    // pop until we find the oldest value still inside the delay window
+    while (this->delayed_inputs.size() > 1) {
+        const auto delta_t = now - this->delayed_inputs.front().time_in_ms;
+        if (delta_t <= delay_ms) {
+            break;
+        }
+        this->delayed_inputs.pop();
+    }
+
+    return this->delayed_inputs.front().value;
+}

src/spice2x/cfg/analog.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <array>
 #include <string>
 #include <cmath>
@@ -13,12 +14,32 @@ namespace rawinput {
     class RawInputManager;
 }
 
+namespace GameAPI::Analogs {
+    enum class AnalogType {
+        // default; values wrap around (below 0 turns into 1, over 1 is 0)
+        // knobs, turntables
+        Circular = 0,
+
+        // typical joystick that rests at the center and caps at [0, 1]
+        LinearCentered = 1,
+
+        // one-directional value (sliders and instruments like piano/drum velocity)
+        // starts at 0 and goes up to 1
+        LinearPositive = 2,
+    };
+}
+
 struct AnalogMovingAverage {
     double time_in_ms;
     float sine;
     float cosine;
 };
 
+struct AnalogDelayEntry {
+    double time_in_ms;
+    float value;
+};
+
 class Analog {
 private:
     std::string name;
@@ -31,10 +52,11 @@ private:
     float last_state = 0.5f;
     bool sensitivity_set = false;
     bool deadzone_set = false;
+    GameAPI::Analogs::AnalogType type = GameAPI::Analogs::AnalogType::Circular;
     
     // smoothing function
     bool smoothing = false;
-    std::array<AnalogMovingAverage, ANALOG_HISTORY_CNT> vector_history;
+    std::array<AnalogMovingAverage, ANALOG_HISTORY_CNT> vector_history = {};
     int vector_history_index = 0;
     float smoothed_last_state = 0.f;
 
@@ -48,12 +70,13 @@ private:
     unsigned short divisor_region = 0;
 
     // relative input mode
-    float absolute_value_for_rel_mode = 0.5f;
+    float rel_mode_absolute_value = 0.5f;
+    float rel_mode_last_read_time_s = 0.f;
     bool relative_mode = false;
 
-    // circular buffer (delayed input)
-    int delay_buffer_depth = 0;
-    std::queue<float> delay_buffer;
+    // delay
+    uint32_t delay_ms = 0;
+    std::queue<AnalogDelayEntry> delayed_inputs;
 
     float calculateAngularDifference(float old_rads, float new_rads);
     float normalizeAngle(float rads);
@@ -66,7 +89,8 @@ public:
     float override_state = 0.5f;
 
     explicit Analog(std::string name) : name(std::move(name)) {
-        vector_history.fill({0.0, 0.f, 0.f});
+    };
+    explicit Analog(std::string name, GameAPI::Analogs::AnalogType type) : name(std::move(name)), type(type) {
     };
 
     std::string getDisplayString(rawinput::RawInputManager* manager);
@@ -74,6 +98,8 @@ public:
     float applyAngularSensitivity(float raw_rads);
     float applyMultiplier(float raw_value);
     float applyDeadzone(float raw_value);
+    float getRelativeModeValue(float raw_value);
+    float getDelayedValue(float raw_value);
 
     inline bool isSet() {
         if (this->override_enabled) {
@@ -82,16 +108,22 @@ public:
         return this->index != 0xFF;
     }
 
-    inline void clearBindings() {
-        device_identifier = "";
-        index = 0xFF;
+    inline void resetValues() {
         setSensitivity(1.f);
         setDeadzone(0.f);
         invert = false;
         smoothing = false;
+        deadzone_mirror = false;
         setMultiplier(1);
         setRelativeMode(false);
-        setDelayBufferDepth(0);
+        setLastState(0.5f);
+        setDelayMs(0);
+    }
+
+    inline void clearBindings() {
+        device_identifier = "";
+        index = 0xFF;
+        resetValues();
     }
 
     inline const std::string &getName() const {
@@ -187,25 +219,27 @@ public:
     }
 
     inline void setRelativeMode(bool relative_mode) {
+        if (relative_mode) {
+            this->smoothing = false;
+        }
         this->relative_mode = relative_mode;
-        this->absolute_value_for_rel_mode = 0.5f;
+        this->rel_mode_absolute_value = 0.5f;
+        this->rel_mode_last_read_time_s = 0.f;
     }
 
-    inline float getAbsoluteValue(float relative_delta) {
-        this->absolute_value_for_rel_mode =
-            normalizeAnalogValue(this->absolute_value_for_rel_mode + relative_delta);
-        return this->absolute_value_for_rel_mode;
+    inline GameAPI::Analogs::AnalogType getType() const {
+        return this->type;
     }
 
-    inline int getDelayBufferDepth() const {
-        return this->delay_buffer_depth;
+    inline void setType(GameAPI::Analogs::AnalogType type) {
+        this->type = type;
     }
 
-    inline void setDelayBufferDepth(int depth) {
-        this->delay_buffer_depth = depth;
+    inline uint32_t getDelayMs() const {
+        return this->delay_ms;
     }
 
-    inline std::queue<float> &getDelayBuffer() {
-        return this->delay_buffer;
+    inline void setDelayMs(uint32_t delay_ms) {
+        this->delay_ms = delay_ms;
     }
 };

src/spice2x/cfg/api.cpp

@@ -1,8 +1,11 @@
 #include "api.h"
 
+#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"
@@ -37,7 +40,11 @@ std::vector<Button> GameAPI::Buttons::sortButtons(
         for (auto &bt : buttons) {
             if (name == bt.getName()) {
                 button_found = true;
-                sorted.push_back(bt);
+                Button button_new = bt;
+                if (vkey_defaults) {
+                    button_new.setVKeyDefault(vkey_defaults->at(index));
+                }
+                sorted.push_back(button_new);
                 break;
             }
         }
@@ -47,6 +54,7 @@ std::vector<Button> GameAPI::Buttons::sortButtons(
 
             if (vkey_defaults) {
                 button.setVKey(vkey_defaults->at(index));
+                button.setVKeyDefault(vkey_defaults->at(index));
             }
         }
 
@@ -56,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) {
@@ -70,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;
@@ -193,9 +254,19 @@ GameAPI::Buttons::State GameAPI::Buttons::getState(rawinput::RawInputManager *ma
                             if (vKey < value_states->size()) {
                                 auto value = value_states->at(vKey);
                                 if (current_button->getAnalogType() == BAT_POSITIVE) {
-                                    state = value > 0.6f ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
+                                    float threshold = 0.6f;
+                                    if (current_button->getBatThreshold() > 0) {
+                                        threshold = std::clamp(current_button->getBatThreshold() / 100.f, 0.01f, 0.99f);
+                                    }
+                                    state = value > threshold ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
+
                                 } else if (current_button->getAnalogType() == BAT_NEGATIVE) {
-                                    state = value < 0.4f ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
+                                    float threshold = 0.4f;
+                                    if (current_button->getBatThreshold() > 0) {
+                                        threshold = std::clamp((100 - current_button->getBatThreshold()) / 100.f, 0.01f, 0.99f);
+                                    }
+                                    state = value < threshold ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
+
                                 } else {
                                     state = value > 0.01f ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
                                 }
@@ -384,7 +455,23 @@ GameAPI::Buttons::State GameAPI::Buttons::getState(rawinput::RawInputManager *ma
                 }
                 case rawinput::PIUIO_DEVICE: {
                     state = device->piuioDev->IsPressed(vKey) ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
+                    break;
                 }
+                case rawinput::XINPUT_GAMEPAD: {
+                    assert(reinterpret_cast<uintptr_t>(device->handle) < XUSER_MAX_COUNT);
+                    const auto player = static_cast<uint8_t>(reinterpret_cast<uintptr_t>(device->handle));
+                    state = manager->XINPUT_MGR->is_button_pressed(
+                        player,
+                        static_cast<xinput::XInputButtonEnum>(vKey)) ?
+                        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;
             }
@@ -437,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);
@@ -452,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) {
@@ -581,7 +668,7 @@ float Buttons::getVelocity(std::unique_ptr<rawinput::RawInputManager> &manager,
     }
 }
 
-float GameAPI::Analogs::getState(rawinput::Device *device, Analog &analog) {
+float GameAPI::Analogs::getState(rawinput::RawInputManager *manager, rawinput::Device *device, Analog &analog) {
     float value = 0.5f;
     if (!device) {
         return value;
@@ -644,88 +731,107 @@ float GameAPI::Analogs::getState(rawinput::Device *device, Analog &analog) {
         case rawinput::HID: {
 
             // get value
-            if (inverted) {
-                value = 1.f - device->hidInfo->value_states[index];
-            } else {
-                value = device->hidInfo->value_states[index];
+            if (index < device->hidInfo->value_states.size()) {
+                if (inverted) {
+                    value = 1.f - device->hidInfo->value_states[index];
+                } else {
+                    value = device->hidInfo->value_states[index];
+                }
             }
 
             // deadzone
-            if (analog.isDeadzoneSet()) {
+            // do not apply deadzone to circular analogs since it doesn't make sense (except in relative mode)
+            if (analog.isDeadzoneSet() &&
+                (analog.getType() != AnalogType::Circular || analog.isRelativeMode())) {
                 value = analog.applyDeadzone(value);
             }
 
-            if (analog.isRelativeMode()) {
-                float relative_delta = value - 0.5f;
-                // built-in scaling to make values reasonable
-                relative_delta /= 80.f;
+            if (analog.getType() == AnalogType::Circular) {
 
-                // integer multiplier/divisor
-                const auto mult = analog.getMultiplier();
-                if (mult < -1) {
-                    relative_delta /= -mult;
-                } else if (1 < mult) {
-                    relative_delta *= mult;
-                }
+                if (analog.isRelativeMode()) {
+                    value = analog.getRelativeModeValue(value);
 
-                // sensitivity (ranges from 0.0 to 4.0)
-                if (analog.isSensitivitySet()) {
-                    relative_delta *= analog.getSensitivity();
-                }
+                } else {
+                    // integer multiplier
+                    value = analog.applyMultiplier(value);
 
-                // translate relative movement to absolute value
-                value = analog.getAbsoluteValue(relative_delta);
+                    // smoothing/sensitivity
+                    if (analog.getSmoothing() || analog.isSensitivitySet()) {
+                        float rads = value * (float) M_TAU;
 
-            } else {
-                // integer multiplier
-                value = analog.applyMultiplier(value);
+                        // smoothing
+                        if (analog.getSmoothing()) {
 
-                // smoothing/sensitivity
-                if (analog.getSmoothing() || analog.isSensitivitySet()) {
-                    float rads = value * (float) M_TAU;
+                            // preserve direction
+                            if (rads >= M_TAU) {
+                                rads -= 0.0001f;
+                            }
 
-                    // smoothing
-                    if (analog.getSmoothing()) {
-
-                        // preserve direction
-                        if (rads >= M_TAU) {
-                            rads -= 0.0001f;
+                            // calculate angle
+                            rads = analog.getSmoothedValue(rads);
                         }
 
-                        // calculate angle
-                        rads = analog.getSmoothedValue(rads);
+                        // sensitivity
+                        if (analog.isSensitivitySet()) {
+                            rads = analog.applyAngularSensitivity(rads);
+                        }
+
+                        // apply to value
+                        value = rads * (float) M_1_TAU;
+                    }
+                }
+            } else {
+                // sensitivity
+                if (analog.isSensitivitySet()) {
+                    // adjust curve
+                    // values < 1.f : less sensitive around neutral
+                    // values > 1.f : more sensitive around neutral
+                    float curve = analog.getSensitivity();
+                    if (curve <= 0.f) {
+                        curve = 0.01f;
+                    }
+                    curve = 1.f / curve;
+
+                    if (analog.getType() == AnalogType::LinearCentered) {
+                        // convert 0.0..1.0 to -1.0..+1.0
+                        float signed_raw = (value - 0.5f) * 2.0f;
+                        // apply curve
+                        float sign = signed_raw < 0.0f ? -1.0f : 1.0f;
+                        float magnitude = fabsf(signed_raw);
+                        float curved = sign * powf(magnitude, curve);
+                        // convert back to 0.0..1.0
+                        value = curved * 0.5f + 0.5f;
+                    } else {
+                        value = powf(value, curve);
                     }
 
-                    // sensitivity
-                    if (analog.isSensitivitySet()) {
-                        rads = analog.applyAngularSensitivity(rads);
+                    value = std::clamp(value, 0.f, 1.f);
+                }
+
+                // multiplier / divisor
+                if (analog.getMultiplier() < -1) {
+                    if (analog.getType() == AnalogType::LinearCentered) {
+                        value = (value - 0.5f) / (-analog.getMultiplier()) + 0.5f;
+                    } else {
+                        value /= -analog.getMultiplier();
                     }
 
-                    // apply to value
-                    value = rads * (float) M_1_TAU;
+                    value = std::clamp(value, 0.f, 1.f);
+
+                } else if (analog.getMultiplier() > 1) {
+                    if (analog.getType() == AnalogType::LinearCentered) {
+                        value = (value - 0.5f) * analog.getMultiplier() + 0.5f;
+                    } else {
+                        value *= analog.getMultiplier();
+                    }
+
+                    value = std::clamp(value, 0.f, 1.f);
                 }
             }
 
             // delay
-            if (0 < analog.getDelayBufferDepth()) {
-                auto& queue = analog.getDelayBuffer();
-
-                // ensure the queue isn't too long; drop old values
-                while (analog.getDelayBufferDepth() <= (int)queue.size()) {
-                    queue.pop();
-                }
-
-                // always push new value
-                queue.push(value);
-
-                // get a new value to return
-                if ((int)queue.size() < analog.getDelayBufferDepth()) {
-                    // not enough in the queue, stall for now, shouldn't happen often
-                    value = analog.getLastState();
-                } else {
-                    value = queue.front();
-                    queue.pop();
-                }
+            if (analog.getDelayMs() > 0) {
+                value = analog.getDelayedValue(value);
             }
 
             break;
@@ -760,6 +866,18 @@ float GameAPI::Analogs::getState(rawinput::Device *device, Analog &analog) {
             }
             break;
         }
+        case rawinput::XINPUT_GAMEPAD: {
+            assert(reinterpret_cast<uintptr_t>(device->handle) < XUSER_MAX_COUNT);
+            const auto player = static_cast<uint8_t>(reinterpret_cast<uintptr_t>(device->handle));
+            value = manager->XINPUT_MGR->get_analog_state(
+                player,
+                static_cast<xinput::XInputAnalogEnum>(index));
+            // invert value
+            if (inverted) {
+                value = 1.f - value;
+            }
+            break;
+        }
         default:
             break;
     }
@@ -799,6 +917,42 @@ std::vector<Analog> GameAPI::Analogs::sortAnalogs(
     return sorted;
 }
 
+static std::vector<Analog> sortAnalogsWithTypeInternal(
+    std::vector<Analog> &analogs,
+    const std::initializer_list<GameAPI::Analogs::AnalogWithType> list) {
+
+    std::vector<Analog> sorted;
+
+    bool analog_found;
+    for (auto &a : list) {
+        analog_found = false;
+
+        for (auto &analog : analogs) {
+            if (a.name == analog.getName()) {
+                analog_found = true;
+                analog.setType(a.type);
+                sorted.push_back(analog);
+                break;
+            }
+        }
+
+        if (!analog_found) {
+            sorted.emplace_back(a.name, a.type);
+        }
+    }
+
+    return sorted;
+}
+
+void GameAPI::Analogs::sortAnalogsWithType(
+    std::vector<Analog> *analogs,
+    const std::initializer_list<AnalogWithType> list) {
+
+    if (analogs) {
+        *analogs = sortAnalogsWithTypeInternal(*analogs, list);
+    }
+}
+
 float GameAPI::Analogs::getState(rawinput::RawInputManager *manager, Analog &analog) {
 
     // check override
@@ -815,7 +969,7 @@ float GameAPI::Analogs::getState(rawinput::RawInputManager *manager, Analog &ana
         return analog.getLastState();
     }
 
-    float state = getState(device, analog);
+    float state = getState(manager, device, analog);
     analog.setLastState(state);
 
     return state;
@@ -859,7 +1013,45 @@ std::vector<Light> GameAPI::Lights::sortLights(
     return sorted;
 }
 
-void GameAPI::Lights::writeLight(rawinput::Device *device, int index, float value) {
+static std::vector<Light> sortLightsWithCategoryInternal(
+    const std::vector<Light> &lights,
+    const std::initializer_list<GameAPI::Lights::LightAndCategory> list)
+{
+    std::vector<Light> sorted;
+
+    bool light_found;
+    for (auto &name : list) {
+        light_found = false;
+
+        for (auto &light : lights) {
+            if (name.light_name == light.getName()) {
+                light_found = true;
+                Light light_new = light;
+                light_new.setCategory(name.category_name);
+                sorted.push_back(light_new);
+                break;
+            }
+        }
+
+        if (!light_found) {
+            sorted.emplace_back(name.light_name, name.category_name);
+        }
+    }
+
+    return sorted;
+}
+
+void GameAPI::Lights::sortLightsWithCategory(
+    std::vector<Light> *lights,
+    const std::initializer_list<LightAndCategory> list) {
+
+    if (lights) {
+        *lights = sortLightsWithCategoryInternal(*lights, list);
+    }
+}
+
+
+void GameAPI::Lights::writeLight(rawinput::RawInputManager *manager, rawinput::Device *device, int index, float value) {
 
     // check device
     if (!device) {
@@ -946,6 +1138,18 @@ void GameAPI::Lights::writeLight(rawinput::Device *device, int index, float valu
             }
             break;
         }
+        case rawinput::XINPUT_GAMEPAD: {
+            assert(reinterpret_cast<uintptr_t>(device->handle) < XUSER_MAX_COUNT);
+            const auto player = static_cast<uint8_t>(reinterpret_cast<uintptr_t>(device->handle));
+            if (index < static_cast<int>(xinput::XInputOutputEnum::COUNT)) {
+                manager->XINPUT_MGR->set_output_state(
+                    player, static_cast<xinput::XInputOutputEnum>(index), value);
+                // no need to set output_pending; xinput output handled immediately
+            } else {
+                log_warning("api", "invalid xinput light index: {}", index);
+            }
+            break;
+        }
         default:
             break;
     }
@@ -971,9 +1175,9 @@ void GameAPI::Lights::writeLight(rawinput::RawInputManager *manager, Light &ligh
 
         // write state
         if (light.override_enabled) {
-            writeLight(device, light.getIndex(), light.override_state);
+            writeLight(manager, device, light.getIndex(), light.override_state);
         } else {
-            writeLight(device, light.getIndex(), value);
+            writeLight(manager, device, light.getIndex(), value);
         }
     }
 

src/spice2x/cfg/api.h

@@ -6,24 +6,20 @@
 #include <windows.h>
 #include "option.h"
 
+#include "button.h"
+#include "analog.h"
+#include "light.h"
+
 namespace rawinput {
     class RawInputManager;
     struct Device;
 }
 
-class Button;
-class Analog;
-class Light;
 class Game;
 class Option;
 
 namespace GameAPI {
     namespace Buttons {
-        enum State {
-            BUTTON_PRESSED = true,
-            BUTTON_NOT_PRESSED = false
-        };
-
         /**
          * Parses the config and returns the buttons set by the user.
          *
@@ -89,14 +85,15 @@ namespace GameAPI {
                 const std::vector<Analog> &analogs,
                 const std::vector<std::string> &analog_names);
 
-        template<typename T>
-        void sortAnalogs(std::vector<Analog> *analogs, T t) {
-            const std::vector<std::string> analog_names { t };
+        struct AnalogWithType {
+            const std::string name;
+            const AnalogType type;
 
-            if (analogs) {
-                *analogs = GameAPI::Analogs::sortAnalogs(*analogs, analog_names);
-            }
-        }
+            AnalogWithType(std::string name, AnalogType type) :
+                name(std::move(name)), type(type) {}
+        };
+
+        void sortAnalogsWithType(std::vector<Analog> *analogs, const std::initializer_list<AnalogWithType> list);
 
         template<typename T, typename... Rest>
         void sortAnalogs(std::vector<Analog> *analogs, T t, Rest... rest) {
@@ -107,27 +104,19 @@ namespace GameAPI {
             }
         }
 
-        float getState(rawinput::Device *device, Analog &analog);
+        float getState(rawinput::RawInputManager *manager, rawinput::Device *device, Analog &analog);
         float getState(rawinput::RawInputManager *manager, Analog &analog);
         float getState(std::unique_ptr<rawinput::RawInputManager> &manager, Analog &analog);
     }
 
     namespace Lights {
+
         std::vector<Light> getLights(const std::string &game_name);
 
         std::vector<Light> sortLights(
                 const std::vector<Light> &lights,
                 const std::vector<std::string> &light_names);
 
-        template<typename T>
-        void sortLights(std::vector<Light> *lights, T t) {
-            const std::vector<std::string> light_names { t };
-
-            if (lights) {
-                *lights = GameAPI::Lights::sortLights(*lights, light_names);
-            }
-        }
-
         template<typename T, typename... Rest>
         void sortLights(std::vector<Light> *lights, T t, Rest... rest) {
             const std::vector<std::string> light_names { t, rest... };
@@ -137,7 +126,17 @@ namespace GameAPI {
             }
         }
 
-        void writeLight(rawinput::Device *device, int index, float value);
+        struct LightAndCategory {
+            const std::string category_name;
+            const std::string light_name;
+
+            LightAndCategory(std::string category_name, std::string light_name) :
+                category_name(std::move(category_name)), light_name(std::move(light_name))  {}
+        };
+
+        void sortLightsWithCategory(std::vector<Light> *lights, const std::initializer_list<LightAndCategory> list);
+
+        void writeLight(rawinput::RawInputManager *manager, rawinput::Device *device, int index, float value);
         void writeLight(rawinput::RawInputManager *manager, Light &light, float value);
         void writeLight(std::unique_ptr<rawinput::RawInputManager> &manager, Light &light, float value);
 
@@ -152,7 +151,3 @@ namespace GameAPI {
         void sortOptions(std::vector<Option> &, const std::vector<OptionDefinition> &);
     }
 }
-
-#include "button.h"
-#include "analog.h"
-#include "light.h"

src/spice2x/cfg/button.cpp

@@ -44,7 +44,7 @@ std::string Button::getVKeyString() {
         case 0x0C:
             return "Clear";
         case 0x0D:
-            return "Enter";
+            return "Enter/Return";
         case 0x10:
             return "Shift";
         case 0x11:
@@ -58,8 +58,28 @@ std::string Button::getVKeyString() {
             return "Pause";
         case 0x14:
             return "Caps Lock";
+        case 0x15:
+            return "IME Kana/Hangul";
+        case 0x16:
+            return "IME On";
+        case 0x17:
+            return "IME Junja";
+        case 0x18:
+            return "IME Final";
+        case 0x19:
+            return "IME Hanja/Kanji";
+        case 0x1A:
+            return "IME Off";
         case 0x1B:
             return "Escape";
+        case 0x1C:
+            return "IME Convert";
+        case 0x1D:
+            return "IME Nonconvert";
+        case 0x1E:
+            return "IME Accept";
+        case 0x1F:
+            return "IME Mode Change";
         case 0x20:
             return "Space";
         case 0x21:
@@ -163,37 +183,37 @@ std::string Button::getVKeyString() {
         case 0x5D:
             return "Apps";
         case 0x60:
-            return "Num 0";
+            return "Numpad 0";
         case 0x61:
-            return "Num 1";
+            return "Numpad 1";
         case 0x62:
-            return "Num 2";
+            return "Numpad 2";
         case 0x63:
-            return "Num 3";
+            return "Numpad 3";
         case 0x64:
-            return "Num 4";
+            return "Numpad 4";
         case 0x65:
-            return "Num 5";
+            return "Numpad 5";
         case 0x66:
-            return "Num 6";
+            return "Numpad 6";
         case 0x67:
-            return "Num 7";
+            return "Numpad 7";
         case 0x68:
-            return "Num 8";
+            return "Numpad 8";
         case 0x69:
-            return "Num 9";
+            return "Numpad 9";
         case 0x6A:
-            return "*";
+            return "Numpad *";
         case 0x6B:
-            return "+";
+            return "Numpad +";
         case 0x6C:
-            return "Seperator";
+            return "Numpad Seperator";
         case 0x6D:
-            return "-";
+            return "Numpad -";
         case 0x6E:
-            return ".";
+            return "Numpad .";
         case 0x6F:
-            return "/";
+            return "Numpad /";
         case 0x70:
             return "F1";
         case 0x71:
@@ -255,9 +275,11 @@ std::string Button::getVKeyString() {
         case 0xA3:
             return "Right Control";
         case 0xA4:
-            return "Left Menu";
+            return "Left Alt";
         case 0xA5:
-            return "Right Menu";
+            return "Right Alt";
+        case INVALID_VKEY:
+            return "Invalid";
         default:
 
             // check win API
@@ -277,14 +299,37 @@ 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();
     std::string vKeyString = fmt::format("{:#x}", vKey);
 
     // device must be existing
-    if (this->device_identifier.empty() && vKey == INVALID_VKEY) {
+    if (this->isNaive() && vKey == INVALID_VKEY) {
+        if (this->getInvert()) {
+            return "(always on)";
+        }
         return "";
     }
 
@@ -301,17 +346,17 @@ std::string Button::getDisplayString(rawinput::RawInputManager* manager) {
         switch (device->type) {
             case rawinput::MOUSE: {
                 const char *btn = "Unknown";
-                static const char *MOUSE_NAMES[] = {
-                        "Left Mouse",
-                        "Right Mouse",
-                        "Middle Mouse",
-                        "Mouse 1",
-                        "Mouse 2",
-                        "Mouse 3",
-                        "Mouse 4",
-                        "Mouse 5",
-                };
-                if (vKey < sizeof(MOUSE_NAMES)) {
+                static const std::array<const char *, 8>MOUSE_NAMES = {
+                    "Left Mouse",
+                    "Right Mouse",
+                    "Middle Mouse",
+                    "Mouse 1",
+                    "Mouse 2",
+                    "Mouse 3",
+                    "Mouse 4",
+                    "Mouse 5",
+                    };
+                if (vKey < MOUSE_NAMES.size()) {
                     btn = MOUSE_NAMES[vKey];
                 }
                 return fmt::format("{} ({})", btn, device->desc);
@@ -395,6 +440,10 @@ std::string Button::getDisplayString(rawinput::RawInputManager* manager) {
             }
             case rawinput::PIUIO_DEVICE:
                 return "PIUIO " + vKeyString;
+            case rawinput::XINPUT_GAMEPAD:
+                return fmt::format("{} ({})",
+                    xinput::get_button_string(static_cast<xinput::XInputButtonEnum>(vKey)),
+                    device->desc);
             case rawinput::DESTROYED:
                 return "Device unplugged (" + vKeyString + ")";
             default:

src/spice2x/cfg/button.h

@@ -1,15 +1,23 @@
 #pragma once
 
+#include <cstdint>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "api.h"
-
 namespace rawinput {
     class RawInputManager;
 }
 
+namespace GameAPI {
+    namespace Buttons {
+        enum State {
+            BUTTON_PRESSED = true,
+            BUTTON_NOT_PRESSED = false
+        };
+    }
+}
+
 enum ButtonAnalogType {
     BAT_NONE = 0,
     BAT_POSITIVE = 1,
@@ -41,19 +49,27 @@ 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;
+
     ButtonAnalogType analog_type = BAT_NONE;
     double debounce_up = 0.0;
     double debounce_down = 0.0;
+    int bat_threshold = 0; // for positive/negative only, value in percentage, zero is default
     bool invert = false;
+    bool is_temporary = false;
 
     GameAPI::Buttons::State last_state = GameAPI::Buttons::BUTTON_NOT_PRESSED;
     float last_velocity = 0.f;
     unsigned short velocity_threshold = 0;
 
-    std::string getVKeyString();
     std::string getMidiNoteString();
+    std::string getBindingDisplayString(rawinput::RawInputManager *manager);
 
 public:
+    std::string getVKeyString();
 
     // overrides
     bool override_enabled = false;
@@ -70,12 +86,20 @@ public:
         if (this->override_enabled) {
             return true;
         }
+
+        // has a device
+        if (!this->device_identifier.empty()) {
+            return true;
+        }
+
+        // naive, and has a valid vKey
         if (this->vKey != INVALID_VKEY) {
             return true;
         }
 
         for (auto &alternative : this->alternatives) {
-            if (alternative.vKey != INVALID_VKEY) {
+            if (!alternative.getDeviceIdentifier().empty() ||
+                alternative.getVKey() != INVALID_VKEY) {
                 return true;
             }
         }
@@ -88,6 +112,8 @@ public:
         alternatives.clear();
         device_identifier = "";
         analog_type = BAT_NONE;
+        bat_threshold = 0;
+        modifier_mask = 0;
     }
 
     std::string getDisplayString(rawinput::RawInputManager* manager);
@@ -100,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;
     }
@@ -116,6 +150,14 @@ public:
         this->vKey = vKey;
     }
 
+    inline unsigned short getVKeyDefault() const {
+        return this->vKey_default;
+    }
+
+    inline void setVKeyDefault(unsigned short vKey_default) {
+        this->vKey_default = vKey_default;
+    }
+
     inline ButtonAnalogType getAnalogType() const {
         return this->analog_type;
     }
@@ -140,6 +182,14 @@ public:
         this->debounce_down = debounce_time_down;
     }
 
+    inline void setBatThreshold(int bat_threshold) {
+        this->bat_threshold = bat_threshold;
+    }
+
+    inline int getBatThreshold() const {
+        return this->bat_threshold;
+    }
+
     inline bool getInvert() const {
         return this->invert;
     }
@@ -164,6 +214,14 @@ public:
         this->last_velocity = last_velocity;
     }
 
+    inline bool isTemporary() const {
+        return this->is_temporary;
+    }
+
+    inline void setTemporary(bool is_temporary) {
+        this->is_temporary = is_temporary;
+    }
+
     inline unsigned short getVelocityThreshold() const {
         return this->velocity_threshold;
     }
@@ -172,6 +230,20 @@ public:
         this->velocity_threshold = velocity_threshold;
     }
 
+    inline bool isValid() {
+        // temporarily created by UI
+        if (isTemporary()) {
+            return true;
+        }
+
+        // nothing is set
+        if (getDeviceIdentifier().empty() && getVKey() == INVALID_VKEY) {
+            return false;
+        }
+
+        return true;
+    }
+
     void getMidiVKey(int& channel, int& index);
     void setMidiVKey(rawinput::RawInputManager* manager, bool is_note, int channel, int index);
 

src/spice2x/cfg/config.cpp

@@ -1,5 +1,6 @@
 #include "config.h"
 #include "util/logging.h"
+#include "cfg/button.h"
 
 /*
  * This code absolutely sucks.
@@ -10,6 +11,14 @@
 // settings
 std::string CONFIG_PATH_OVERRIDE = "";
 
+#define CFG_DEBUG_VERBOSE 0
+
+#if CFG_DEBUG_VERBOSE
+#define log_debug(module, format_str, ...) logger::push( \
+    LOG_FORMAT("M", module, format_str, ## __VA_ARGS__), logger::Style::GREY)
+#else
+#define log_debug(module, format_str, ...)
+#endif
 
 ///////////////////
 /// Constructor ///
@@ -19,7 +28,7 @@ Config::Config() {
     this->status = false;
     if (CONFIG_PATH_OVERRIDE.length() > 0) {
         this->configLocation = CONFIG_PATH_OVERRIDE;
-        log_info("cfg", "using custom config file: {}", this->configLocation.string());
+        log_info("cfg", "using custom config file: {}", this->configLocation);
     } else {
         this->configLocation = std::filesystem::path(_wgetenv(L"APPDATA")) / L"spicetools.xml";
         // avoids logging the expanded appdata path as it contains user name
@@ -48,7 +57,7 @@ Config::Config() {
                 this->firstFillConfigFile();
                 break;
             case tinyxml2::XMLError::XML_ERROR_FILE_COULD_NOT_BE_OPENED:
-                log_fatal("cfg", "could not open config file: {}", this->configLocation.string());
+                log_fatal("cfg", "could not open config file: {}", this->configLocation);
                 break;
             case tinyxml2::XMLError::XML_ERROR_FILE_NOT_FOUND:
                 this->createConfigFile();
@@ -63,12 +72,12 @@ Config::Config() {
             case tinyxml2::XMLError::XML_ERROR_PARSING_UNKNOWN:
             case tinyxml2::XMLError::XML_ERROR_MISMATCHED_ELEMENT:
             case tinyxml2::XMLError::XML_ERROR_PARSING:
-                log_warning("cfg", "Couldn't read config file: {}", this->configLocation.string());
+                log_warning("cfg", "Couldn't read config file: {}", this->configLocation);
                 this->createConfigFile();
                 this->firstFillConfigFile();
                 break;
             default:
-                log_warning("cfg", "Unknown XML error reading config: {}", configLoadError);
+                log_warning("cfg", "Unknown XML error reading config: {}", static_cast<uint32_t>(configLoadError));
                 break;
         }
     } while (configLoadError != tinyxml2::XMLError::XML_SUCCESS);
@@ -89,7 +98,7 @@ bool Config::getStatus() {
     return this->status;
 }
 
-bool Config::addGame(Game &game) {
+bool Config::addGame(Game &game, bool save) {
     tinyxml2::XMLNode *rootNode = this->configFile.LastChild();
     tinyxml2::XMLElement *gameNodes = rootNode->FirstChildElement("game");
 
@@ -153,15 +162,19 @@ bool Config::addGame(Game &game) {
                     auto analogType = (int) BAT_NONE;
                     double debounce_up = 0.0;
                     double debounce_down = 0.0;
+                    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);
                     gameButtonNode->QueryDoubleAttribute("debounce_up", &debounce_up);
                     gameButtonNode->QueryDoubleAttribute("debounce_down", &debounce_down);
+                    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");
@@ -171,16 +184,20 @@ bool Config::addGame(Game &game) {
                         gameButtonNode->SetAttribute("devid", button->getDeviceIdentifier().c_str());
                         gameButtonNode->SetAttribute("debounce_up", debounce_up);
                         gameButtonNode->SetAttribute("debounce_down", debounce_down);
+                        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));
                         button->setAnalogType((ButtonAnalogType) analogType);
                         button->setDebounceUp(debounce_up);
                         button->setDebounceDown(debounce_down);
+                        button->setBatThreshold(bat_threshold);
                         button->setVelocityThreshold(velocity_threshold);
                         button->setInvert(invert);
+                        button->setModifierMask(static_cast<uint8_t>(modifier_mask));
                         if (devid) {
                             button->setDeviceIdentifier(devid);
                         }
@@ -198,8 +215,10 @@ bool Config::addGame(Game &game) {
                 gameButtonNode->SetAttribute("analogtype", (int) it.getAnalogType());
                 gameButtonNode->SetAttribute("debounce_up", it.getDebounceUp());
                 gameButtonNode->SetAttribute("debounce_down", it.getDebounceDown());
+                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);
             }
@@ -239,7 +258,7 @@ bool Config::addGame(Game &game) {
                 bool smoothing = false;
                 int multiplier = 1;
                 bool relative_mode = false;
-                int delay_buffer_depth = 0;
+                uint32_t delay = 0;
                 tinyxml2::XMLError err1 = gameAnalogNode->QueryIntAttribute("index", &index);
                 gameAnalogNode->QueryFloatAttribute("sensivity", &sensitivity);
                 gameAnalogNode->QueryFloatAttribute("deadzone", &deadzone);
@@ -248,7 +267,7 @@ bool Config::addGame(Game &game) {
                 gameAnalogNode->QueryBoolAttribute("smoothing", &smoothing);
                 gameAnalogNode->QueryIntAttribute("multiplier", &multiplier);
                 gameAnalogNode->QueryBoolAttribute("relative", &relative_mode);
-                gameAnalogNode->QueryIntAttribute("delay", &delay_buffer_depth);
+                gameAnalogNode->QueryUnsignedAttribute("delay_ms", &delay);
                 const char *devid = gameAnalogNode->Attribute("devid");
 
                 if (err1 != tinyxml2::XMLError::XML_SUCCESS || !devid) {
@@ -264,7 +283,7 @@ bool Config::addGame(Game &game) {
                     gameAnalogNode->SetAttribute("smoothing", it.getSmoothing());
                     gameAnalogNode->SetAttribute("multiplier", it.getMultiplier());
                     gameAnalogNode->SetAttribute("relative", it.isRelativeMode());
-                    gameAnalogNode->SetAttribute("delay", it.getDelayBufferDepth());
+                    gameAnalogNode->SetAttribute("delay_ms", it.getDelayMs());
                     gameAnalogsNode->InsertEndChild(gameAnalogNode);
                 } else {
                     it.setIndex(static_cast<unsigned short int>(index));
@@ -276,7 +295,7 @@ bool Config::addGame(Game &game) {
                     it.setSmoothing(smoothing);
                     it.setMultiplier(multiplier);
                     it.setRelativeMode(relative_mode);
-                    it.setDelayBufferDepth(delay_buffer_depth);
+                    it.setDelayMs(delay);
                 }
             } else {
                 gameAnalogNode = this->configFile.NewElement("analog");
@@ -289,7 +308,7 @@ bool Config::addGame(Game &game) {
                 gameAnalogNode->SetAttribute("smoothing", it.getSmoothing());
                 gameAnalogNode->SetAttribute("multiplier", it.getMultiplier());
                 gameAnalogNode->SetAttribute("relative", it.isRelativeMode());
-                gameAnalogNode->SetAttribute("delay", it.getDelayBufferDepth());
+                gameAnalogNode->SetAttribute("delay_ms", it.getDelayMs());
                 gameAnalogNode->SetAttribute("devid", it.getDeviceIdentifier().c_str());
                 gameAnalogsNode->InsertEndChild(gameAnalogNode);
             }
@@ -423,8 +442,10 @@ bool Config::addGame(Game &game) {
             gameButtonNode->SetAttribute("analogtype", it.getAnalogType());
             gameButtonNode->SetAttribute("debounce_up", it.getDebounceUp());
             gameButtonNode->SetAttribute("debounce_down", it.getDebounceDown());
+            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);
         }
@@ -443,7 +464,7 @@ bool Config::addGame(Game &game) {
             gameAnalogNode->SetAttribute("smoothing", it.getSmoothing());
             gameAnalogNode->SetAttribute("multiplier", it.getMultiplier());
             gameAnalogNode->SetAttribute("relative", it.isRelativeMode());
-            gameAnalogNode->SetAttribute("delay", it.getDelayBufferDepth());
+            gameAnalogNode->SetAttribute("delay_ms", it.getDelayMs());
             gameAnalogsNode->InsertEndChild(gameAnalogNode);
         }
 
@@ -471,13 +492,20 @@ bool Config::addGame(Game &game) {
         rootNode->InsertEndChild(gameNode);
     }
 
-    // save config
-    this->saveConfigFile();
+    // save config (skipped when caller batches multiple addGame calls
+    // and flushes once at the end via Config::save())
+    if (save) {
+        this->saveConfigFile();
+    }
 
     // return success
     return true;
 }
 
+void Config::save() {
+    this->saveConfigFile();
+}
+
 bool Config::updateBinding(const Game &game, const Button &button, int alternative) {
 
     // get root node
@@ -510,8 +538,10 @@ bool Config::updateBinding(const Game &game, const Button &button, int alternati
         return false;
     }
 
+    tinyxml2::XMLElement *gameButtonNode = nullptr;
+
     // iterate button nodes
-    tinyxml2::XMLElement *gameButtonNode = gameButtonsNode->FirstChildElement("button");
+    gameButtonNode = gameButtonsNode->FirstChildElement("button");
     int button_count = 0;
     while (gameButtonNode != nullptr) {
         const char *buttonNodeName = gameButtonNode->Attribute("name");
@@ -524,9 +554,11 @@ bool Config::updateBinding(const Game &game, const Button &button, int alternati
                 gameButtonNode->SetAttribute("analogtype", (int) button.getAnalogType());
                 gameButtonNode->SetAttribute("debounce_up", button.getDebounceUp());
                 gameButtonNode->SetAttribute("debounce_down", button.getDebounceDown());
+                gameButtonNode->SetAttribute("bat_threshold", button.getBatThreshold());
                 gameButtonNode->SetAttribute("velocity_threshold", button.getVelocityThreshold());
                 gameButtonNode->SetAttribute("invert", button.getInvert());
                 gameButtonNode->SetAttribute("devid", button.getDeviceIdentifier().c_str());
+                gameButtonNode->SetAttribute("modifiers", button.getModifierMask());
                 break;
             }
         }
@@ -540,9 +572,11 @@ bool Config::updateBinding(const Game &game, const Button &button, int alternati
             gameButtonNode->SetAttribute("analogtype", 0);
             gameButtonNode->SetAttribute("debounce_up", 0.0);
             gameButtonNode->SetAttribute("debounce_down", 0.0);
+            gameButtonNode->SetAttribute("bat_threshold", 0);
             gameButtonNode->SetAttribute("velocity_threshold", 0);
             gameButtonNode->SetAttribute("invert", false);
             gameButtonNode->SetAttribute("devid", "");
+            gameButtonNode->SetAttribute("modifiers", 0);
             gameButtonsNode->InsertEndChild(gameButtonNode);
         }
     }
@@ -574,6 +608,39 @@ bool Config::updateBinding(const Game &game, const Button &button, int alternati
         }
     }
 
+    // trim the trailing invalid (unbound) alternatives
+    tinyxml2::XMLElement *to_delete = nullptr;
+    gameButtonNode = gameButtonsNode->LastChildElement("button");
+    while (gameButtonNode != nullptr) {
+        const char *name = gameButtonNode->Attribute("name");
+        const char *devid = gameButtonNode->Attribute("devid");
+        int vkey = INVALID_VKEY;
+        gameButtonNode->QueryIntAttribute("vkey", &vkey);
+
+        // wrong button, ignore and keep iterating backwards
+        if (name == nullptr || std::string(name) != button.getName()) {
+            gameButtonNode = gameButtonNode->PreviousSiblingElement("button");
+            continue;
+        }
+
+        // found a node for this button, which means to_delete is not the first one
+        // delete the node for to_delete
+        if (to_delete != nullptr) {
+            log_debug("cfg", "deleting excessive button binding for {}", name);
+            gameButtonsNode->DeleteChild(to_delete);
+            to_delete = nullptr;
+        }
+
+        if ((devid == nullptr || strlen(devid) == 0) && vkey == INVALID_VKEY) {
+            // unbound button with no device ID, make a note of it so it can be deleted later
+            to_delete = gameButtonNode;
+            gameButtonNode = gameButtonNode->PreviousSiblingElement("button");
+        } else {
+            // valid binding found; stop iterating
+            break;
+        }
+    }
+
     // check if button was not found
     if (button_count == 0) {
         return false;
@@ -640,7 +707,7 @@ bool Config::updateBinding(const Game &game, const Analog &analog) {
         gameAnalogNode->SetAttribute("smoothing", analog.getSmoothing());
         gameAnalogNode->SetAttribute("multiplier", analog.getMultiplier());
         gameAnalogNode->SetAttribute("relative", analog.isRelativeMode());
-        gameAnalogNode->SetAttribute("delay", analog.getDelayBufferDepth());
+        gameAnalogNode->SetAttribute("delay_ms", analog.getDelayMs());
         gameAnalogNode->SetAttribute("devid", analog.getDeviceIdentifier().c_str());
     } else {
         gameAnalogNode = this->configFile.NewElement("analog");
@@ -652,7 +719,7 @@ bool Config::updateBinding(const Game &game, const Analog &analog) {
         gameAnalogNode->SetAttribute("smoothing", analog.getSmoothing());
         gameAnalogNode->SetAttribute("multiplier", analog.getMultiplier());
         gameAnalogNode->SetAttribute("relative", analog.isRelativeMode());
-        gameAnalogNode->SetAttribute("delay", analog.getDelayBufferDepth());
+        gameAnalogNode->SetAttribute("delay_ms", analog.getDelayMs());
         gameAnalogNode->SetAttribute("devid", analog.getDeviceIdentifier().c_str());
         gameAnalogsNode->InsertEndChild(gameAnalogNode);
     }
@@ -760,6 +827,37 @@ bool Config::updateBinding(const Game &game, const Light &light, int alternative
         }
     }
 
+    // trim the trailing invalid (unbound) alternatives
+    tinyxml2::XMLElement *to_delete = nullptr;
+    gameLightNode = gameLightsNode->LastChildElement("light");
+    while (gameLightNode != nullptr) {
+        const char *name = gameLightNode->Attribute("name");
+        const char *devid = gameLightNode->Attribute("devid");
+
+        // wrong light, ignore and keep iterating backwards
+        if (name == nullptr || std::string(name) != light.getName()) {
+            gameLightNode = gameLightNode->PreviousSiblingElement("light");
+            continue;
+        }
+
+        // found a node for this button, which means to_delete is not the first one
+        // delete the node for to_delete
+        if (to_delete != nullptr) {
+            log_debug("cfg", "deleting excessive light binding for {}", name);
+            gameLightsNode->DeleteChild(to_delete);
+            to_delete = nullptr;
+        }
+
+        if (devid == nullptr || strlen(devid) == 0) {
+            // unbound light, make a note of it so it can be deleted later
+            to_delete = gameLightNode;
+            gameLightNode = gameLightNode->PreviousSiblingElement("light");
+        } else {
+            // valid binding found; stop iterating
+            break;
+        }
+    }
+
     // check if light was not found
     if (light_count == 0) {
         return false;
@@ -871,14 +969,18 @@ std::vector<Button> Config::getButtons(const std::string &gameName) {
                 auto analogType = (int) BAT_NONE;
                 double debounce_up = 0.0;
                 double debounce_down = 0.0;
+                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);
                 gameButtonNode->QueryDoubleAttribute("debounce_down", &debounce_down);
+                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
@@ -891,8 +993,10 @@ std::vector<Button> Config::getButtons(const std::string &gameName) {
                         alt.setAnalogType((ButtonAnalogType) analogType);
                         alt.setDebounceUp(debounce_up);
                         alt.setDebounceDown(debounce_down);
+                        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));
                         }
@@ -909,8 +1013,10 @@ std::vector<Button> Config::getButtons(const std::string &gameName) {
                     button.setAnalogType((ButtonAnalogType) analogType);
                     button.setDebounceUp(debounce_up);
                     button.setDebounceDown(debounce_down);
+                    button.setBatThreshold(bat_threshold);
                     button.setVelocityThreshold(velocity_threshold);
                     button.setInvert(invert);
+                    button.setModifierMask(static_cast<uint8_t>(modifier_mask));
                     if (devid) {
                         button.setDeviceIdentifier(devid);
                     }
@@ -1055,7 +1161,7 @@ std::vector<Analog> Config::getAnalogs(const std::string &gameName) {
                 bool smoothing = false;
                 int multiplier = 1;
                 bool relative_mode = false;
-                int delay_buffer_depth = 0;
+                uint32_t delay = 0;
                 gameAnalogNode->QueryIntAttribute("index", &index);
                 gameAnalogNode->QueryFloatAttribute("sensivity", &sensitivity);
                 gameAnalogNode->QueryFloatAttribute("deadzone", &deadzone);
@@ -1064,7 +1170,7 @@ std::vector<Analog> Config::getAnalogs(const std::string &gameName) {
                 gameAnalogNode->QueryBoolAttribute("smoothing", &smoothing);
                 gameAnalogNode->QueryIntAttribute("multiplier", &multiplier);
                 gameAnalogNode->QueryBoolAttribute("relative", &relative_mode);
-                gameAnalogNode->QueryIntAttribute("delay", &delay_buffer_depth);
+                gameAnalogNode->QueryUnsignedAttribute("delay_ms", &delay);
                 const char *devid = gameAnalogNode->Attribute("devid");
 
                 // create analog and add to list
@@ -1077,7 +1183,7 @@ std::vector<Analog> Config::getAnalogs(const std::string &gameName) {
                 analog.setSmoothing(smoothing);
                 analog.setMultiplier(multiplier);
                 analog.setRelativeMode(relative_mode);
-                analog.setDelayBufferDepth(delay_buffer_depth);
+                analog.setDelayMs(delay);
                 if (devid) {
                     analog.setDeviceIdentifier(devid);
                 }
@@ -1237,17 +1343,32 @@ bool Config::firstFillConfigFile() {
 }
 
 void Config::saveConfigFile() {
-    // create a .tmp file and write to it...
+    // write the new config to a .tmp file first...
     const auto xml_result = this->configFile.SaveFile(this->configLocationTemp.c_str(), false);
     if (xml_result != tinyxml2::XMLError::XML_SUCCESS) {
-        log_info("cfg", "failed to write file: {}", this->configLocationTemp.string());
+        log_info("cfg", "failed to write file: {}", this->configLocationTemp);
         return;
     }
-    // copy the .tmp file to the main file...
-    if (CopyFileW(this->configLocationTemp.c_str(), this->configLocation.c_str(), false) == 0) {
-        log_warning("cfg", "CopyFileA failed: 0x{:08x}", GetLastError());
+
+    // ...flush the .tmp file to disk so a crash/power loss can't leave it half-written...
+    HANDLE tmp_handle = CreateFileW(
+        this->configLocationTemp.c_str(),
+        GENERIC_WRITE, FILE_SHARE_READ, nullptr,
+        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (tmp_handle != INVALID_HANDLE_VALUE) {
+        FlushFileBuffers(tmp_handle);
+        CloseHandle(tmp_handle);
+    }
+
+    // ...then atomically replace the real config with the .tmp file.
+    // Unlike CopyFile (which truncates and rewrites the destination in place),
+    // an NTFS rename is atomic: the existing config is never left half-overwritten,
+    // so an interrupted save can't corrupt it. MoveFileEx also removes the .tmp on success.
+    if (MoveFileExW(
+            this->configLocationTemp.c_str(),
+            this->configLocation.c_str(),
+            MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) == 0) {
+        log_warning("cfg", "MoveFileExW failed: 0x{:08x}", GetLastError());
         return;
     }
-    // delete the .tmp file (not critical if this fails)
-    DeleteFileW(this->configLocationTemp.c_str());
-}
+}

src/spice2x/cfg/config.h

@@ -22,7 +22,12 @@ public:
     bool getStatus();
     bool createConfigFile();
 
-    bool addGame(Game &game);
+    bool addGame(Game &game, bool save = true);
+
+    // flush pending in-memory changes to disk; intended to be paired with
+    // addGame(game, false) in bulk-init paths so we write the XML once instead
+    // of once per game
+    void save();
 
     bool updateBinding(const Game &game, const Button &button, int alternative);
     bool updateBinding(const Game &game, const Analog &analog);

src/spice2x/cfg/configurator.cpp

@@ -1,11 +1,16 @@
-#include "configurator.h"
+#include "configurator.h"
+
+#include <d3d9.h>
 
 #include "overlay/overlay.h"
+#include "util/libutils.h"
+#include "util/logging.h"
 
 namespace cfg {
 
     // globals
     bool CONFIGURATOR_STANDALONE = false;
+    bool CONFIGURATOR_FORCE_SOFTWARE_RENDER = false;
     ConfigType CONFIGURATOR_TYPE = ConfigType::Config;
 
     Configurator::Configurator() {
@@ -16,13 +21,98 @@ namespace cfg {
         CONFIGURATOR_STANDALONE = false;
     }
 
+    // Attempt to bring up a D3D9 device backing the configurator's window so the
+    // overlay can use the hardware-accelerated imgui_impl_dx9 path instead of
+    // the CPU rasterizer. Returns true if both Direct3DCreate9 and CreateDevice
+    // succeed; the caller falls back to overlay::create_software() otherwise so
+    // that environments without D3D9 (Wine without dxvk, headless test boxes,
+    // GPUs whose drivers reject HAL) still get a working configurator.
+    static bool try_init_d3d9(ConfiguratorWindow &wnd) {
+        if (cfg::CONFIGURATOR_FORCE_SOFTWARE_RENDER) {
+            return false;
+        }
+
+        if (wnd.hWnd == nullptr) {
+            return false;
+        }
+
+        // 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;
+        }
+
+        D3DPRESENT_PARAMETERS pp {};
+        pp.Windowed = TRUE;
+        pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+        // D3DFMT_UNKNOWN -> driver picks the current desktop format
+        pp.BackBufferFormat = D3DFMT_UNKNOWN;
+        pp.BackBufferWidth = static_cast<UINT>(wnd.client_width);
+        pp.BackBufferHeight = static_cast<UINT>(wnd.client_height);
+        pp.hDeviceWindow = wnd.hWnd;
+        pp.EnableAutoDepthStencil = FALSE;
+        pp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
+
+        IDirect3DDevice9 *device = nullptr;
+        // SOFTWARE_VERTEXPROCESSING is the most compatible behavior flag; the UI
+        // is tiny so we don't need hardware T&L. FPU_PRESERVE keeps our floating
+        // point environment intact in case other spice code relies on it.
+        const DWORD behavior_flags = D3DCREATE_SOFTWARE_VERTEXPROCESSING | D3DCREATE_FPU_PRESERVE;
+        HRESULT hr = d3d->CreateDevice(
+                D3DADAPTER_DEFAULT,
+                D3DDEVTYPE_HAL,
+                wnd.hWnd,
+                behavior_flags,
+                &pp,
+                &device);
+        if (FAILED(hr) || device == nullptr) {
+            log_warning("configurator",
+                "D3D9 CreateDevice failed (hr={:#x}), falling back to software renderer",
+                static_cast<unsigned int>(hr));
+            d3d->Release();
+            return false;
+        }
+
+        wnd.d3d = d3d;
+        wnd.device = device;
+        wnd.pp = pp;
+        wnd.use_d3d9 = true;
+        return true;
+    }
+
     void Configurator::run() {
 
-        // create instance
+        // bring up the overlay against either a real D3D9 device or the software
+        // rasterizer. The choice is one-shot - the in-game overlay always uses
+        // the same renderer the configurator picked here.
         overlay::ENABLED = true;
-        overlay::create_software(this->wnd.hWnd);
+        if (try_init_d3d9(this->wnd)) {
+            log_info("configurator", "using D3D9 hardware-accelerated renderer");
+            overlay::create_d3d9(this->wnd.hWnd, this->wnd.d3d, this->wnd.device);
+        } else {
+            log_info("configurator", "using software renderer");
+            overlay::create_software(this->wnd.hWnd);
+        }
         overlay::OVERLAY->set_active(true);
-        overlay::OVERLAY->hotkeys_enable = false;
         ImGui::GetIO().MouseDrawCursor = false;
 
         // run window

src/spice2x/cfg/configurator.h

@@ -11,6 +11,7 @@ namespace cfg {
     // globals
     extern bool CONFIGURATOR_STANDALONE;
     extern ConfigType CONFIGURATOR_TYPE;
+    extern bool CONFIGURATOR_FORCE_SOFTWARE_RENDER;
 
     class Configurator {
     private:

src/spice2x/cfg/configurator_wnd.cpp

@@ -1,11 +1,18 @@
-#include "configurator_wnd.h"
+#include "configurator_wnd.h"
+
+#include <algorithm>
+#include <cstring>
 
 #include <windows.h>
+#include <windowsx.h>
 
 #include "build/defs.h"
+#include "external/imgui/imgui.h"
 #include "launcher/shutdown.h"
 #include "overlay/overlay.h"
 #include "util/logging.h"
+#include "util/precise_timer.h"
+#include "util/utils.h"
 #include "cfg/configurator.h"
 
 #include "icon.h"
@@ -14,8 +21,177 @@ static const char *CLASS_NAME = "ConfiguratorWindow";
 static std::string WINDOW_TITLE;
 static int WINDOW_SIZE_X = 800;
 static int WINDOW_SIZE_Y = 600;
+static const int WINDOW_MIN_SIZE_X = 540;
+static const int WINDOW_MIN_SIZE_Y = 300;
 static HICON WINDOW_ICON = LoadIcon(GetModuleHandle(nullptr), MAKEINTRESOURCE(MAINICON));
 
+static const UINT_PTR RENDER_TIMER_ID = 1;
+
+// Map a virtual key code to the matching ImGuiKey. Mirrors the table used by
+// the in-game ImGui spice backend so navigation keys behave identically when
+// the configurator runs standalone and drives ImGui from Win32 messages.
+static ImGuiKey vk_to_imgui_key(WPARAM vkey) {
+    switch (vkey) {
+        case VK_TAB: return ImGuiKey_Tab;
+        case VK_LEFT: return ImGuiKey_LeftArrow;
+        case VK_RIGHT: return ImGuiKey_RightArrow;
+        case VK_UP: return ImGuiKey_UpArrow;
+        case VK_DOWN: return ImGuiKey_DownArrow;
+        case VK_PRIOR: return ImGuiKey_PageUp;
+        case VK_NEXT: return ImGuiKey_PageDown;
+        case VK_HOME: return ImGuiKey_Home;
+        case VK_END: return ImGuiKey_End;
+        case VK_INSERT: return ImGuiKey_Insert;
+        case VK_DELETE: return ImGuiKey_Delete;
+        case VK_BACK: return ImGuiKey_Backspace;
+        case VK_SPACE: return ImGuiKey_Space;
+        case VK_RETURN: return ImGuiKey_Enter;
+        case VK_ESCAPE: return ImGuiKey_Escape;
+        case VK_LSHIFT: return ImGuiKey_LeftShift;
+        case VK_RSHIFT: return ImGuiKey_RightShift;
+        case VK_SHIFT: return ImGuiKey_LeftShift;
+        case VK_LCONTROL: return ImGuiKey_LeftCtrl;
+        case VK_RCONTROL: return ImGuiKey_RightCtrl;
+        case VK_CONTROL: return ImGuiKey_LeftCtrl;
+        case 'A': return ImGuiKey_A;
+        case 'C': return ImGuiKey_C;
+        case 'V': return ImGuiKey_V;
+        case 'X': return ImGuiKey_X;
+        case 'Y': return ImGuiKey_Y;
+        case 'Z': return ImGuiKey_Z;
+        default: return ImGuiKey_None;
+    }
+}
+
+static ImGuiKey vk_to_imgui_mod_key(WPARAM vkey) {
+    switch (vkey) {
+        case VK_SHIFT:
+        case VK_LSHIFT:
+        case VK_RSHIFT:
+            return ImGuiMod_Shift;
+        case VK_CONTROL:
+        case VK_LCONTROL:
+        case VK_RCONTROL:
+            return ImGuiMod_Ctrl;
+        case VK_MENU:
+        case VK_LMENU:
+        case VK_RMENU:
+            return ImGuiMod_Alt;
+        default:
+            return ImGuiMod_None;
+    }
+}
+
+static cfg::ConfiguratorWindow *get_state(HWND hWnd) {
+    return reinterpret_cast<cfg::ConfiguratorWindow *>(
+        GetWindowLongPtrW(hWnd, GWLP_USERDATA));
+}
+
+// computes the top-left position that centers a window of the given size on
+// the primary monitor's work area (the desktop minus the taskbar); falls back
+// to (0, 0) if the monitor info can't be queried.
+static POINT center_on_primary_monitor(int width, int height) {
+    POINT pos = { 0, 0 };
+    HMONITOR mon = MonitorFromPoint(pos, MONITOR_DEFAULTTOPRIMARY);
+    MONITORINFO mi {};
+    mi.cbSize = sizeof(mi);
+    if (GetMonitorInfo(mon, &mi)) {
+        const int work_w = mi.rcWork.right - mi.rcWork.left;
+        const int work_h = mi.rcWork.bottom - mi.rcWork.top;
+        pos.x = mi.rcWork.left + (work_w - width) / 2;
+        pos.y = mi.rcWork.top + (work_h - height) / 2;
+    }
+    return pos;
+}
+
+// Returns the refresh rate (Hz) of the monitor the window currently lives on,
+// clamped to a sane range. Falls back to 60 if detection fails or the value
+// looks invalid (DEVMODE may report 0 or 1 to mean "use hardware default").
+static UINT detect_monitor_refresh_hz(HWND hWnd) {
+    UINT hz = 0;
+    HMONITOR mon = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST);
+    if (mon) {
+        MONITORINFOEXW mi {};
+        mi.cbSize = sizeof(mi);
+        if (GetMonitorInfoW(mon, reinterpret_cast<LPMONITORINFO>(&mi))) {
+            DEVMODEW dm {};
+            dm.dmSize = sizeof(dm);
+            if (EnumDisplaySettingsW(mi.szDevice, ENUM_CURRENT_SETTINGS, &dm)) {
+                hz = dm.dmDisplayFrequency;
+            }
+        }
+    }
+    if (hz <= 1) {
+        HDC hdc = GetDC(hWnd);
+        if (hdc) {
+            int v = GetDeviceCaps(hdc, VREFRESH);
+            if (v > 1) {
+                hz = static_cast<UINT>(v);
+            }
+            ReleaseDC(hWnd, hdc);
+        }
+    }
+    if (hz < 30 || hz > 240) {
+        hz = 60;
+    }
+    return hz;
+}
+
+// Software-path WM_PAINT: blit the overlay's pixel buffer to the window using
+// SetDIBitsToDevice. Avoids creating/destroying a GDI HBITMAP every frame.
+static void paint_software(HWND hWnd) {
+    if (!overlay::OVERLAY) {
+        PAINTSTRUCT ps {};
+        BeginPaint(hWnd, &ps);
+        EndPaint(hWnd, &ps);
+        return;
+    }
+
+    int width = 0;
+    int height = 0;
+    uint32_t *pixel_data = overlay::OVERLAY->sw_get_pixel_data(&width, &height);
+
+    PAINTSTRUCT paint {};
+    HDC hdc = BeginPaint(hWnd, &paint);
+
+    if (pixel_data && width > 0 && height > 0) {
+        BITMAPINFO bmi {};
+        bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+        bmi.bmiHeader.biWidth = width;
+        // negative height -> top-down DIB, matching how ImGui packs pixels
+        bmi.bmiHeader.biHeight = -height;
+        bmi.bmiHeader.biPlanes = 1;
+        bmi.bmiHeader.biBitCount = 32;
+        bmi.bmiHeader.biCompression = BI_RGB;
+
+        SetDIBitsToDevice(
+            hdc,
+            0, 0,
+            width, height,
+            0, 0,
+            0, height,
+            pixel_data,
+            &bmi,
+            DIB_RGB_COLORS);
+    }
+
+    EndPaint(hWnd, &paint);
+}
+
+void cfg::ConfiguratorWindow::start_timer() {
+    if (!this->timer_running && this->hWnd) {
+        SetTimer(this->hWnd, RENDER_TIMER_ID, this->timer_interval_ms, nullptr);
+        this->timer_running = true;
+    }
+}
+
+void cfg::ConfiguratorWindow::stop_timer() {
+    if (this->timer_running && this->hWnd) {
+        KillTimer(this->hWnd, RENDER_TIMER_ID);
+        this->timer_running = false;
+    }
+}
+
 cfg::ConfiguratorWindow::ConfiguratorWindow() {
 
     // register the window class
@@ -27,12 +203,22 @@ cfg::ConfiguratorWindow::ConfiguratorWindow() {
     wc.hIcon = WINDOW_ICON;
     RegisterClass(&wc);
 
+    // raise SetTimer resolution so high refresh rates (120/144Hz) are actually
+    // achievable. Without this, USER timers quantize to ~15.6ms and cap us
+    // near ~64 FPS. Uses the shared helper so it respects -notimerhacks
+    // (Use Legacy Timers) and the Win11 timer-throttling opt-out. The helper
+    // intentionally never calls timeEndPeriod; the kernel releases the request
+    // when spicecfg exits.
+    timeutils::set_timer_resolution();
+
     // determine window title
     if (cfg::CONFIGURATOR_TYPE == cfg::ConfigType::Config) {
         WINDOW_TITLE = "spice2x config (" + to_string(VERSION_STRING_CFG) + ")";
         WINDOW_SIZE_X = 800;
         WINDOW_SIZE_Y = 600;
     }
+    this->client_width = WINDOW_SIZE_X;
+    this->client_height = WINDOW_SIZE_Y;
 
     // open window
     this->hWnd = CreateWindowEx(
@@ -48,27 +234,58 @@ cfg::ConfiguratorWindow::ConfiguratorWindow() {
 
     if (this->hWnd) {
         overlay::USE_WM_CHAR_FOR_IMGUI_CHAR_INPUT = true;
+        // force dark title bar
+        set_window_dark_titlebar(this->hWnd, true);
     }
 }
 
 cfg::ConfiguratorWindow::~ConfiguratorWindow() {
 
+    this->stop_timer();
+
     // close window
     DestroyWindow(this->hWnd);
 
     // unregister class
     UnregisterClass(CLASS_NAME, GetModuleHandle(NULL));
+
+    // release D3D9 resources if any
+    if (this->device) {
+        this->device->Release();
+        this->device = nullptr;
+    }
+    if (this->d3d) {
+        this->d3d->Release();
+        this->d3d = nullptr;
+    }
 }
 
 void cfg::ConfiguratorWindow::run() {
 
+    const POINT pos = center_on_primary_monitor(WINDOW_SIZE_X, WINDOW_SIZE_Y);
+    SetWindowPos(this->hWnd, HWND_TOP, pos.x, pos.y, WINDOW_SIZE_X, WINDOW_SIZE_Y, 0);
+
     // show window
-    SetWindowPos(this->hWnd, HWND_TOP, 0, 0, WINDOW_SIZE_X, WINDOW_SIZE_Y, 0);
     ShowWindow(this->hWnd, SW_SHOWNORMAL);
     UpdateWindow(this->hWnd);
 
-    // draw overlay in 60 FPS
-    SetTimer(this->hWnd, 1, 1000 / 60, nullptr);
+    // SW_SHOWNORMAL usually activates a top-level window, but not always (e.g.,
+    // when the launching process doesn't have foreground rights to transfer).
+    // Force foreground+focus explicitly so WM_MOUSEWHEEL is routed to us from
+    // the very first frame; the Win32 default routes wheel events to the
+    // keyboard-focused window.
+    SetForegroundWindow(this->hWnd);
+    SetFocus(this->hWnd);
+
+    // match the render timer to the monitor refresh rate so scrolling stays smooth
+    // on 60/120/144 Hz panels. Idle CPU is bounded by overlay::sw_pixels_dirty
+    // (software path) and overlay::d3d9_frame_dirty (D3D9 path); the timer is also
+    // paused entirely when the window is minimized (see WM_SIZE handler).
+    const UINT hz = detect_monitor_refresh_hz(this->hWnd);
+    this->timer_interval_ms = std::max<UINT>(1, 1000 / hz);
+    log_info("configurator", "render timer {} ms ({} Hz)",
+        this->timer_interval_ms, hz);
+    this->start_timer();
 
     // window loop
     BOOL ret;
@@ -94,6 +311,22 @@ LRESULT CALLBACK cfg::ConfiguratorWindow::window_proc(HWND hWnd, UINT uMsg, WPAR
             }
             break;
         }
+        case WM_GETMINMAXINFO: {
+
+            // enforce a minimum window size so the UI can't be shrunk to a
+            // point where the tabs/controls become unusable. The minimum is
+            // expressed in client-area pixels and converted to a full window
+            // size that accounts for the current frame/title-bar style.
+            RECT rc = { 0, 0, WINDOW_MIN_SIZE_X, WINDOW_MIN_SIZE_Y };
+            DWORD style = static_cast<DWORD>(GetWindowLongPtrW(hWnd, GWL_STYLE));
+            DWORD ex_style = static_cast<DWORD>(GetWindowLongPtrW(hWnd, GWL_EXSTYLE));
+            if (AdjustWindowRectEx(&rc, style, FALSE, ex_style)) {
+                auto *mmi = reinterpret_cast<MINMAXINFO *>(lParam);
+                mmi->ptMinTrackSize.x = rc.right - rc.left;
+                mmi->ptMinTrackSize.y = rc.bottom - rc.top;
+            }
+            break;
+        }
         case WM_CREATE: {
 
             // set user data of window to class pointer
@@ -102,6 +335,72 @@ LRESULT CALLBACK cfg::ConfiguratorWindow::window_proc(HWND hWnd, UINT uMsg, WPAR
 
             break;
         }
+        case WM_SIZE: {
+
+            // pause/resume the render timer based on visibility
+            auto *state = get_state(hWnd);
+            if (state) {
+                if (wParam == SIZE_MINIMIZED) {
+                    state->window_minimized = true;
+                    state->stop_timer();
+                } else {
+                    if (state->window_minimized) {
+                        state->window_minimized = false;
+                        // force a full repaint on the next frame
+                        state->has_valid_draw_hash = false;
+                        state->start_timer();
+                    }
+                    const int new_w = LOWORD(lParam);
+                    const int new_h = HIWORD(lParam);
+                    if (new_w > 0 && new_h > 0
+                            && (new_w != state->client_width || new_h != state->client_height)) {
+                        state->client_width = new_w;
+                        state->client_height = new_h;
+
+                        // reset the D3D9 device with the new back-buffer size so the
+                        // hardware-accelerated path matches the window dimensions.
+                        if (state->use_d3d9 && state->device) {
+                            if (overlay::OVERLAY) {
+                                overlay::OVERLAY->reset_invalidate();
+                            }
+                            state->pp.BackBufferWidth = static_cast<UINT>(new_w);
+                            state->pp.BackBufferHeight = static_cast<UINT>(new_h);
+                            HRESULT hr = state->device->Reset(&state->pp);
+                            if (FAILED(hr)) {
+                                log_warning("configurator", "D3D9 device Reset failed, hr={:#x}",
+                                    static_cast<unsigned int>(hr));
+                            }
+                            if (overlay::OVERLAY) {
+                                overlay::OVERLAY->reset_recreate();
+                            }
+                        }
+
+                        // force a full repaint after resize
+                        state->has_valid_draw_hash = false;
+                    }
+                }
+            }
+            break;
+        }
+        case WM_DISPLAYCHANGE: {
+
+            // monitor refresh rate may have changed (or the window moved to a
+            // different monitor); re-detect and re-arm the render timer.
+            auto *state = get_state(hWnd);
+            if (state && state->timer_running) {
+                const UINT hz = detect_monitor_refresh_hz(hWnd);
+                const UINT new_interval = std::max<UINT>(1, 1000 / hz);
+                if (new_interval != state->timer_interval_ms) {
+                    state->stop_timer();
+                    state->timer_interval_ms = new_interval;
+                    state->start_timer();
+                    log_info("configurator",
+                        "WM_DISPLAYCHANGE: render timer {} ms ({} Hz)",
+                        new_interval, hz);
+                }
+            }
+            break;
+        }
         case WM_CLOSE:
         case WM_DESTROY: {
 
@@ -110,62 +409,192 @@ LRESULT CALLBACK cfg::ConfiguratorWindow::window_proc(HWND hWnd, UINT uMsg, WPAR
             break;
         }
         case WM_TIMER: {
+            if (wParam != RENDER_TIMER_ID) {
+                break;
+            }
 
-            // update overlay
+            auto *state = get_state(hWnd);
+
+            // skip rendering when the window is minimized or hidden - the timer is
+            // already paused on minimize, but defensively skip here as well.
+            if (state && (state->window_minimized || !IsWindowVisible(hWnd))) {
+                break;
+            }
+
+            const bool use_d3d9 = state && state->use_d3d9 && state->device;
+
+            // build the imgui frame (input is already buffered via WM_* messages)
             if (overlay::OVERLAY) {
                 overlay::OVERLAY->update();
                 overlay::OVERLAY->set_active(true);
                 overlay::OVERLAY->new_frame();
-                overlay::OVERLAY->render();
             }
 
-            // repaint window
-            InvalidateRect(hWnd, nullptr, TRUE);
+            if (use_d3d9) {
+                const HRESULT cl = state->device->TestCooperativeLevel();
+                if (cl == D3DERR_DEVICELOST) {
+                    break;
+                }
+                if (cl == D3DERR_DEVICENOTRESET) {
+                    if (overlay::OVERLAY) {
+                        overlay::OVERLAY->reset_invalidate();
+                    }
+                    const HRESULT reset_hr = state->device->Reset(&state->pp);
+                    if (SUCCEEDED(reset_hr) && overlay::OVERLAY) {
+                        overlay::OVERLAY->reset_recreate();
+                    }
+                    break;
+                }
+                if (FAILED(cl)) {
+                    break;
+                }
+
+                if (overlay::OVERLAY) {
+                    overlay::OVERLAY->render();
+                }
+
+                // skip Clear/Present when ImGui draw data is unchanged; the last
+                // presented frame stays visible (same fast path as sw_pixels_dirty).
+                const bool dirty = overlay::OVERLAY && overlay::OVERLAY->d3d9_frame_dirty;
+                const bool force_present = state && !state->has_valid_draw_hash;
+                if (dirty || force_present) {
+                    if (state) {
+                        state->has_valid_draw_hash = true;
+                    }
+                    state->device->Clear(0, nullptr, D3DCLEAR_TARGET,
+                        D3DCOLOR_RGBA(20, 18, 18, 255), 1.0f, 0);
+                    if (SUCCEEDED(state->device->BeginScene())) {
+                        if (overlay::OVERLAY) {
+                            overlay::OVERLAY->d3d9_render_draw(force_present);
+                        }
+                        state->device->EndScene();
+                    }
+                    const HRESULT hr = state->device->Present(nullptr, nullptr, nullptr, nullptr);
+                    if (hr == D3DERR_DEVICELOST) {
+                        break;
+                    }
+                }
+            } else {
+                if (overlay::OVERLAY) {
+                    overlay::OVERLAY->render();
+                }
+                // software path: the overlay's renderer already skipped the costly
+                // paint_imgui call when the draw data was unchanged. Only invalidate
+                // the window when those pixels actually changed, or on the first
+                // frame / after a resize when we lost the previously cached state.
+                const bool dirty = overlay::OVERLAY && overlay::OVERLAY->sw_pixels_dirty;
+                const bool force_repaint = state && !state->has_valid_draw_hash;
+                if (dirty || force_repaint) {
+                    if (state) {
+                        state->has_valid_draw_hash = true;
+                    }
+                    // pass FALSE for bErase - WM_ERASEBKGND already short-circuits, so
+                    // skipping the erase region avoids one extra Win32 round trip.
+                    InvalidateRect(hWnd, nullptr, FALSE);
+                }
+            }
+
             break;
         }
         case WM_ERASEBKGND: {
             return 1;
         }
         case WM_PAINT: {
-
-            // render overlay
-            if (overlay::OVERLAY) {
-
-                // get pixel data
-                int width, height;
-                uint32_t *pixel_data = overlay::OVERLAY->sw_get_pixel_data(&width, &height);
-                if (width > 0 && height > 0) {
-
-                    // create bitmap
-                    HBITMAP bitmap = CreateBitmap(width, height, 1, 8 * sizeof(uint32_t), pixel_data);
-
-                    // prepare paint
-                    PAINTSTRUCT paint{};
-                    HDC hdc = BeginPaint(hWnd, &paint);
-                    HDC hdcMem = CreateCompatibleDC(hdc);
-                    SetBkMode(hdc, TRANSPARENT);
-
-                    // draw bitmap
-                    SelectObject(hdcMem, bitmap);
-                    BitBlt(hdc, paint.rcPaint.left, paint.rcPaint.top,
-                            paint.rcPaint.right - paint.rcPaint.left,
-                            paint.rcPaint.bottom - paint.rcPaint.top,
-                            hdcMem, paint.rcPaint.left, paint.rcPaint.top, SRCCOPY);
-
-                    // delete bitmap
-                    DeleteObject(bitmap);
-
-                    // clean up
-                    DeleteDC(hdcMem);
-                    EndPaint(hWnd, &paint);
-                } else {
-                    return DefWindowProc(hWnd, uMsg, wParam, lParam);
-                }
+            paint_software(hWnd);
+            break;
+        }
+        case WM_ACTIVATE: {
+            const WORD activation = LOWORD(wParam);
+            if (activation == WA_INACTIVE) {
+                // dropping any held mouse buttons so we don't get stuck in a
+                // "button still pressed" state when we come back.
+                auto &io = ImGui::GetIO();
+                io.AddMouseButtonEvent(ImGuiMouseButton_Left, false);
+                io.AddMouseButtonEvent(ImGuiMouseButton_Right, false);
+                io.AddMouseButtonEvent(ImGuiMouseButton_Middle, false);
             } else {
-                return DefWindowProc(hWnd, uMsg, wParam, lParam);
+                // WA_ACTIVE or WA_CLICKACTIVE: make sure the keyboard focus is
+                // actually on this window so WM_MOUSEWHEEL gets routed to us
+                // again. Without this, scrolling silently stops working after
+                // the user alt-tabs back to spicecfg.
+                SetFocus(hWnd);
             }
             break;
         }
+        case WM_KILLFOCUS: {
+            // mirror the WA_INACTIVE mouse-button drop for the keyboard -
+            // without this, a key held during alt-tab stays "down" in ImGui
+            // state until the user presses and releases it again.
+            ImGui::GetIO().ClearInputKeys();
+            break;
+        }
+        // input messages routed straight into ImGui IO. This replaces the previous
+        // per-frame 256-VK rawinput scan in ImGui_ImplSpice_NewFrame for the
+        // standalone configurator (see CONFIGURATOR_STANDALONE branches there).
+        case WM_KEYDOWN:
+        case WM_SYSKEYDOWN:
+        case WM_KEYUP:
+        case WM_SYSKEYUP: {
+            if (wParam == VK_F4) {
+                return DefWindowProc(hWnd, uMsg, wParam, lParam);
+            }
+            const bool down = (uMsg == WM_KEYDOWN) || (uMsg == WM_SYSKEYDOWN);
+            auto &io = ImGui::GetIO();
+            const ImGuiKey key = vk_to_imgui_key(wParam);
+            if (key != ImGuiKey_None) {
+                io.AddKeyEvent(key, down);
+            }
+            const ImGuiKey mod = vk_to_imgui_mod_key(wParam);
+            if (mod != ImGuiMod_None) {
+                io.AddKeyEvent(mod, down);
+            }
+            break;
+        }
+        case WM_MOUSEMOVE: {
+            auto &io = ImGui::GetIO();
+            io.AddMousePosEvent(static_cast<float>(GET_X_LPARAM(lParam)),
+                                static_cast<float>(GET_Y_LPARAM(lParam)));
+            break;
+        }
+        case WM_LBUTTONDOWN:
+        case WM_LBUTTONUP:
+        case WM_RBUTTONDOWN:
+        case WM_RBUTTONUP:
+        case WM_MBUTTONDOWN:
+        case WM_MBUTTONUP: {
+            int button = 0;
+            bool down = false;
+            switch (uMsg) {
+                case WM_LBUTTONDOWN: button = ImGuiMouseButton_Left; down = true; break;
+                case WM_LBUTTONUP: button = ImGuiMouseButton_Left; down = false; break;
+                case WM_RBUTTONDOWN: button = ImGuiMouseButton_Right; down = true; break;
+                case WM_RBUTTONUP: button = ImGuiMouseButton_Right; down = false; break;
+                case WM_MBUTTONDOWN: button = ImGuiMouseButton_Middle; down = true; break;
+                case WM_MBUTTONUP: button = ImGuiMouseButton_Middle; down = false; break;
+            }
+            auto &io = ImGui::GetIO();
+            io.AddMouseButtonEvent(button, down);
+            if (down) {
+                SetCapture(hWnd);
+            } else {
+                ReleaseCapture();
+            }
+            break;
+        }
+        case WM_MOUSEWHEEL: {
+            const float delta = static_cast<float>(GET_WHEEL_DELTA_WPARAM(wParam))
+                / static_cast<float>(WHEEL_DELTA);
+            ImGui::GetIO().AddMouseWheelEvent(0.0f, delta);
+            break;
+        }
+#if !SPICE_XP
+        case WM_MOUSEHWHEEL: {
+            const float delta = static_cast<float>(GET_WHEEL_DELTA_WPARAM(wParam))
+                / static_cast<float>(WHEEL_DELTA);
+            ImGui::GetIO().AddMouseWheelEvent(delta, 0.0f);
+            break;
+        }
+#endif
         default:
             return DefWindowProc(hWnd, uMsg, wParam, lParam);
     }

src/spice2x/cfg/configurator_wnd.h

@@ -1,6 +1,9 @@
-#pragma once
+#pragma once
+
+#include <cstdint>
 
 #include <windows.h>
+#include <d3d9.h>
 
 namespace cfg {
 
@@ -9,11 +12,38 @@ namespace cfg {
 
         HWND hWnd;
 
+        // optional D3D9 device backing the configurator window; nullptr when running
+        // the software-rendered path. Owned by ConfiguratorWindow when set.
+        IDirect3D9 *d3d = nullptr;
+        IDirect3DDevice9 *device = nullptr;
+        D3DPRESENT_PARAMETERS pp {};
+        bool use_d3d9 = false;
+
+        // throttling / pause state. timer_interval_ms is the default until run()
+        // refines it to the actual monitor refresh rate (see detect_monitor_refresh_hz).
+        UINT timer_interval_ms = 1000 / 60;
+        bool timer_running = false;
+        bool window_minimized = false;
+
+        // tracks whether we've issued at least one InvalidateRect since window
+        // creation/resize. The overlay's per-frame "pixels changed" flag suppresses
+        // idle blits; this flag forces the very first blit on startup or after
+        // a resize so the window doesn't show garbage until the user moves the mouse.
+        bool has_valid_draw_hash = false;
+
+        // dimensions of the configurator client area (kept in sync with WM_SIZE)
+        int client_width = 0;
+        int client_height = 0;
+
         ConfiguratorWindow();
         ~ConfiguratorWindow();
 
         void run();
 
+        // start/stop the render timer based on visibility state
+        void start_timer();
+        void stop_timer();
+
         static LRESULT CALLBACK window_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
     };
 }

src/spice2x/cfg/controller_presets.cpp

@@ -0,0 +1,508 @@
+#include "overlay/windows/controller_presets.h"
+
+#include <filesystem>
+
+#include "cfg/resource.h"
+#include "external/tinyxml2/tinyxml2.h"
+#include "util/fileutils.h"
+#include "util/logging.h"
+#include "util/resutils.h"
+
+namespace overlay::windows {
+
+    static std::filesystem::path get_templates_path() {
+        return fileutils::get_config_file_path("ControllerPresets", "spicetools_presets.xml");
+    }
+
+    static void write_button_entry(tinyxml2::XMLDocument &doc, tinyxml2::XMLElement *parent,
+                                   const std::string &name, const TemplateButtonEntry &entry) {
+        auto *el = doc.NewElement("button");
+        el->SetAttribute("name", name.c_str());
+        el->SetAttribute("vkey", entry.vKey);
+        el->SetAttribute("analogtype", (int)entry.analog_type);
+        el->SetAttribute("devid", entry.device_identifier.c_str());
+        el->SetAttribute("invert", entry.invert);
+        el->SetAttribute("debounce_up", entry.debounce_up);
+        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);
+    }
+
+    static TemplateButtonEntry read_button_entry(tinyxml2::XMLElement *el) {
+        TemplateButtonEntry entry;
+        int vkey = INVALID_VKEY;
+        el->QueryIntAttribute("vkey", &vkey);
+        entry.vKey = (unsigned short)vkey;
+
+        int atype = 0;
+        el->QueryIntAttribute("analogtype", &atype);
+        entry.analog_type = (ButtonAnalogType)atype;
+
+        const char *devid = el->Attribute("devid");
+        entry.device_identifier = devid ? devid : "";
+
+        el->QueryBoolAttribute("invert", &entry.invert);
+        el->QueryDoubleAttribute("debounce_up", &entry.debounce_up);
+        el->QueryDoubleAttribute("debounce_down", &entry.debounce_down);
+
+        int vel = 0;
+        el->QueryIntAttribute("velocity_threshold", &vel);
+        entry.velocity_threshold = (unsigned short)vel;
+
+        int bat = 0;
+        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;
+    }
+
+    static void write_analog(tinyxml2::XMLDocument &doc, tinyxml2::XMLElement *parent,
+                             const TemplateAnalogBinding &analog) {
+        auto *el = doc.NewElement("analog");
+        el->SetAttribute("name", analog.name.c_str());
+        el->SetAttribute("devid", analog.device_identifier.c_str());
+        el->SetAttribute("index", analog.index);
+        el->SetAttribute("sensivity", analog.sensitivity);  // keep typo for compat
+        el->SetAttribute("deadzone", analog.deadzone);
+        el->SetAttribute("deadzone_mirror", analog.deadzone_mirror);
+        el->SetAttribute("invert", analog.invert);
+        el->SetAttribute("smoothing", analog.smoothing);
+        el->SetAttribute("multiplier", analog.multiplier);
+        el->SetAttribute("relative", analog.relative_mode);
+        el->SetAttribute("delay_ms", analog.delay_ms);
+        parent->InsertEndChild(el);
+    }
+
+    static TemplateAnalogBinding read_analog(tinyxml2::XMLElement *el) {
+        TemplateAnalogBinding a;
+        const char *name = el->Attribute("name");
+        a.name = name ? name : "";
+
+        const char *devid = el->Attribute("devid");
+        a.device_identifier = devid ? devid : "";
+
+        int idx = 0xFF;
+        el->QueryIntAttribute("index", &idx);
+        a.index = (unsigned short)idx;
+
+        el->QueryFloatAttribute("sensivity", &a.sensitivity);  // keep typo
+        el->QueryFloatAttribute("deadzone", &a.deadzone);
+        el->QueryBoolAttribute("deadzone_mirror", &a.deadzone_mirror);
+        el->QueryBoolAttribute("invert", &a.invert);
+        el->QueryBoolAttribute("smoothing", &a.smoothing);
+        el->QueryIntAttribute("multiplier", &a.multiplier);
+        el->QueryBoolAttribute("relative", &a.relative_mode);
+        el->QueryUnsignedAttribute("delay_ms", &a.delay_ms);
+
+        return a;
+    }
+
+    static void write_light_entry(tinyxml2::XMLDocument &doc, tinyxml2::XMLElement *parent,
+                                  const std::string &name, const TemplateLightEntry &entry) {
+        auto *el = doc.NewElement("light");
+        el->SetAttribute("name", name.c_str());
+        el->SetAttribute("devid", entry.device_identifier.c_str());
+        el->SetAttribute("index", entry.index);
+        parent->InsertEndChild(el);
+    }
+
+    static TemplateLightEntry read_light_entry(tinyxml2::XMLElement *el) {
+        TemplateLightEntry entry;
+        const char *devid = el->Attribute("devid");
+        entry.device_identifier = devid ? devid : "";
+
+        int idx = 0;
+        el->QueryIntAttribute("index", &idx);
+        entry.index = (unsigned int)idx;
+
+        return entry;
+    }
+
+    // Parse all templates from an already-loaded XMLDocument.
+    // is_builtin controls the is_builtin flag on each returned template.
+    static std::vector<ControllerTemplate> load_templates_from_doc(
+            tinyxml2::XMLDocument &doc, bool is_builtin) {
+        std::vector<ControllerTemplate> templates;
+
+        auto *root = doc.RootElement();
+        if (!root) {
+            return templates;
+        }
+
+        auto *tmpl_el = root->FirstChildElement("template");
+        while (tmpl_el) {
+            ControllerTemplate tmpl;
+            const char *name = tmpl_el->Attribute("name");
+            const char *game = tmpl_el->Attribute("game");
+            tmpl.name = name ? name : "";
+            tmpl.game_name = game ? game : "";
+            tmpl.is_builtin = is_builtin;
+
+            // buttons
+            auto *buttons_el = tmpl_el->FirstChildElement("buttons");
+            if (buttons_el) {
+                auto *btn_el = buttons_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.buttons) {
+                        if (b.name == btn_name_str) { binding = &b; break; }
+                    }
+                    if (!binding) {
+                        tmpl.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");
+                }
+            }
+
+            // 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) {
+                auto *btn_el = kp_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.keypad_buttons) {
+                        if (b.name == btn_name_str) { binding = &b; break; }
+                    }
+                    if (!binding) {
+                        tmpl.keypad_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");
+                }
+            }
+
+            // analogs
+            auto *analogs_el = tmpl_el->FirstChildElement("analogs");
+            if (analogs_el) {
+                auto *analog_el = analogs_el->FirstChildElement("analog");
+                while (analog_el) {
+                    tmpl.analogs.push_back(read_analog(analog_el));
+                    analog_el = analog_el->NextSiblingElement("analog");
+                }
+            }
+
+            // lights
+            auto *lights_el = tmpl_el->FirstChildElement("lights");
+            if (lights_el) {
+                auto *light_el = lights_el->FirstChildElement("light");
+                while (light_el) {
+                    const char *light_name = light_el->Attribute("name");
+                    std::string light_name_str = light_name ? light_name : "";
+
+                    TemplateLightBinding *binding = nullptr;
+                    for (auto &l : tmpl.lights) {
+                        if (l.name == light_name_str) { binding = &l; break; }
+                    }
+                    if (!binding) {
+                        tmpl.lights.push_back({light_name_str, read_light_entry(light_el), {}});
+                    } else {
+                        binding->alternatives.push_back(read_light_entry(light_el));
+                    }
+                    light_el = light_el->NextSiblingElement("light");
+                }
+            }
+
+            templates.push_back(std::move(tmpl));
+            tmpl_el = tmpl_el->NextSiblingElement("template");
+        }
+
+        return templates;
+    }
+
+    static std::vector<ControllerTemplate> load_builtin_templates() {
+        auto xml = resutil::load_file_string(IDR_CONTROLLER_PRESETS_BUILTIN);
+        tinyxml2::XMLDocument doc;
+        auto err = doc.Parse(xml.c_str());
+        if (err != tinyxml2::XML_SUCCESS) {
+            log_warning("templates", "failed to parse builtin templates XML: {}", (int)err);
+            return {};
+        }
+        return load_templates_from_doc(doc, true);
+    }
+
+    std::vector<ControllerTemplate> load_user_templates() {
+        std::vector<ControllerTemplate> templates;
+        auto path = get_templates_path();
+
+        tinyxml2::XMLDocument doc;
+        if (doc.LoadFile(path.c_str()) != tinyxml2::XML_SUCCESS) {
+            return templates;
+        }
+        return load_templates_from_doc(doc, false);
+    }
+
+    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) {
+
+        auto path = get_templates_path();
+        auto path_tmp = path;
+        path_tmp.replace_extension(L"tmp");
+
+        tinyxml2::XMLDocument doc;
+        if (doc.LoadFile(path.c_str()) != tinyxml2::XML_SUCCESS) {
+            auto *decl = doc.NewDeclaration();
+            doc.InsertFirstChild(decl);
+            auto *root = doc.NewElement("templates");
+            doc.InsertEndChild(root);
+        }
+
+        auto *root = doc.RootElement();
+        if (!root) {
+            root = doc.NewElement("templates");
+            doc.InsertEndChild(root);
+        }
+
+        // remove existing template with same name and game
+        auto *existing = root->FirstChildElement("template");
+        while (existing) {
+            auto *next = existing->NextSiblingElement("template");
+            const char *ename = existing->Attribute("name");
+            const char *egame = existing->Attribute("game");
+            if (ename && egame &&
+                std::string(ename) == tmpl.name &&
+                std::string(egame) == tmpl.game_name) {
+                root->DeleteChild(existing);
+            }
+            existing = next;
+        }
+
+        auto *tmpl_el = doc.NewElement("template");
+        tmpl_el->SetAttribute("name", tmpl.name.c_str());
+        tmpl_el->SetAttribute("game", tmpl.game_name.c_str());
+
+        // buttons — skip unbound entries
+        auto *buttons_el = doc.NewElement("buttons");
+        if (save_buttons) {
+            for (auto &btn : tmpl.buttons) {
+                if (!btn.primary.is_unbound()) {
+                    write_button_entry(doc, buttons_el, btn.name, btn.primary);
+                }
+                for (auto &alt : btn.alternatives) {
+                    if (!alt.is_unbound()) {
+                        write_button_entry(doc, buttons_el, btn.name, alt);
+                    }
+                }
+            }
+        }
+        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");
+            if (save_keypads) {
+                for (auto &btn : tmpl.keypad_buttons) {
+                    if (!btn.primary.is_unbound()) {
+                        write_button_entry(doc, kp_el, btn.name, btn.primary);
+                    }
+                    for (auto &alt : btn.alternatives) {
+                        if (!alt.is_unbound()) {
+                            write_button_entry(doc, kp_el, btn.name, alt);
+                        }
+                    }
+                }
+            }
+            tmpl_el->InsertEndChild(kp_el);
+        }
+
+        // analogs — skip unbound entries
+        auto *analogs_el = doc.NewElement("analogs");
+        if (save_analogs) {
+            for (auto &a : tmpl.analogs) {
+                if (!a.is_unbound()) {
+                    write_analog(doc, analogs_el, a);
+                }
+            }
+        }
+        tmpl_el->InsertEndChild(analogs_el);
+
+        // lights — skip unbound entries
+        auto *lights_el = doc.NewElement("lights");
+        if (save_lights) {
+            for (auto &l : tmpl.lights) {
+                if (!l.primary.is_unbound()) {
+                    write_light_entry(doc, lights_el, l.name, l.primary);
+                }
+                for (auto &alt : l.alternatives) {
+                    if (!alt.is_unbound()) {
+                        write_light_entry(doc, lights_el, l.name, alt);
+                    }
+                }
+            }
+        }
+        tmpl_el->InsertEndChild(lights_el);
+
+        root->InsertEndChild(tmpl_el);
+
+        // ensure directory exists
+        if (!path.parent_path().empty() && !std::filesystem::exists(path.parent_path())) {
+            fileutils::dir_create_recursive(path.parent_path());
+        }
+
+        // save atomically via temp file
+        auto save_err = doc.SaveFile(path_tmp.c_str());
+        if (save_err != tinyxml2::XML_SUCCESS) {
+            log_warning("templates", "failed to save templates file: {}", (int)save_err);
+            return false;
+        }
+
+        if (MoveFileExW(path_tmp.c_str(), path.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) == 0) {
+            log_warning("templates", "failed to rename templates file: 0x{:08x}", GetLastError());
+            return false;
+        }
+
+        log_info("templates", "templates file saved successfully");
+        return true;
+    }
+
+    bool delete_user_template(const std::string &game_name, const std::string &template_name) {
+        auto path = get_templates_path();
+
+        tinyxml2::XMLDocument doc;
+        if (doc.LoadFile(path.c_str()) != tinyxml2::XML_SUCCESS) return false;
+
+        auto *root = doc.RootElement();
+        if (!root) return false;
+
+        bool found = false;
+        auto *tmpl_el = root->FirstChildElement("template");
+        while (tmpl_el) {
+            auto *next = tmpl_el->NextSiblingElement("template");
+            const char *ename = tmpl_el->Attribute("name");
+            const char *egame = tmpl_el->Attribute("game");
+            if (ename && egame &&
+                std::string(ename) == template_name &&
+                std::string(egame) == game_name) {
+                root->DeleteChild(tmpl_el);
+                found = true;
+            }
+            tmpl_el = next;
+        }
+
+        if (found) {
+            auto path_tmp = path;
+            path_tmp.replace_extension(L"tmp");
+            if (doc.SaveFile(path_tmp.c_str()) == tinyxml2::XML_SUCCESS) {
+                MoveFileExW(path_tmp.c_str(), path.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH);
+            }
+        }
+
+        return found;
+    }
+
+    bool rename_user_template(const std::string &game_name,
+                              const std::string &old_name, const std::string &new_name) {
+        auto path = get_templates_path();
+
+        tinyxml2::XMLDocument doc;
+        if (doc.LoadFile(path.c_str()) != tinyxml2::XML_SUCCESS) return false;
+
+        auto *root = doc.RootElement();
+        if (!root) return false;
+
+        bool found = false;
+        auto *tmpl_el = root->FirstChildElement("template");
+        while (tmpl_el) {
+            const char *ename = tmpl_el->Attribute("name");
+            const char *egame = tmpl_el->Attribute("game");
+            if (ename && egame &&
+                std::string(ename) == old_name &&
+                std::string(egame) == game_name) {
+                tmpl_el->SetAttribute("name", new_name.c_str());
+                found = true;
+                break;
+            }
+            tmpl_el = tmpl_el->NextSiblingElement("template");
+        }
+
+        if (found) {
+            auto path_tmp = path;
+            path_tmp.replace_extension(L"tmp");
+            if (doc.SaveFile(path_tmp.c_str()) == tinyxml2::XML_SUCCESS) {
+                MoveFileExW(path_tmp.c_str(), path.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH);
+            }
+        }
+
+        return found;
+    }
+
+    std::vector<ControllerTemplate> get_templates_for_game(const std::string &game_name) {
+        std::vector<ControllerTemplate> result;
+
+        log_misc("templates", "loading built-in templates for {}", game_name);
+        for (auto &t : load_builtin_templates()) {
+            if (t.game_name == game_name) {
+                result.push_back(std::move(t));
+            }
+        }
+
+        log_misc("templates", "loading user templates for {}", game_name);
+        for (auto &t : load_user_templates()) {
+            if (t.game_name == game_name) {
+                result.push_back(std::move(t));
+            }
+        }
+
+        return result;
+    }
+
+}

src/spice2x/cfg/light.cpp

@@ -85,6 +85,15 @@ std::string Light::getDisplayString(rawinput::RawInputManager* manager) {
 
             return "Invalid SMX Dedicab Light (" + index_string + ")";
         }
+        case rawinput::XINPUT_GAMEPAD: {
+            if (index < static_cast<size_t>(xinput::XInputOutputEnum::COUNT)) {
+                return fmt::format("{} ({})",
+                    xinput::get_output_string(static_cast<xinput::XInputOutputEnum>(index)),
+                    device->desc);
+            }
+
+            return "Invalid XInput Gamepad Light (" + index_string + ")";
+        }
         case rawinput::DESTROYED:
             return "Unplugged device (" + index_string + ")";
         default:

src/spice2x/cfg/light.h

@@ -11,8 +11,10 @@ class Light {
 private:
     std::vector<Light> alternatives;
     std::string lightName;
+    std::string lightCategory;
     std::string deviceIdentifier = "";
     unsigned int index = 0;
+    bool is_temporary = false;
 
 public:
     float last_state = 0.f;
@@ -22,6 +24,8 @@ public:
     float override_state = 0.f;
 
     explicit Light(std::string lightName) : lightName(std::move(lightName)) {};
+    explicit Light(std::string lightName, std::string lightCategory) :
+        lightName(std::move(lightName)), lightCategory(std::move(lightCategory)) {};
 
     std::string getDisplayString(rawinput::RawInputManager* manager);
 
@@ -50,6 +54,14 @@ public:
         return this->lightName;
     }
 
+    inline const std::string &getCategory() const {
+        return this->lightCategory;
+    }
+
+    inline void setCategory(std::string category) {
+        this->lightCategory = std::move(category);
+    }
+
     inline const std::string &getDeviceIdentifier() const {
         return this->deviceIdentifier;
     }
@@ -65,4 +77,26 @@ public:
     inline void setIndex(unsigned int index) {
         this->index = index;
     }
+
+    inline bool isTemporary() const {
+        return this->is_temporary;
+    }
+
+    inline void setTemporary(bool is_temporary) {
+        this->is_temporary = is_temporary;
+    }
+
+    inline bool isValid() {
+        // temporarily created by UI
+        if (isTemporary()) {
+            return true;
+        }
+
+        // nothing is set
+        if (getDeviceIdentifier().empty()) {
+            return false;
+        }
+
+        return true;
+    }
 };

src/spice2x/cfg/manifest.manifest

@@ -20,10 +20,10 @@
         </dependentAssembly>
     </dependency>
     <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
-            <security>
-                <requestedPrivileges>
-                    <requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
-                </requestedPrivileges>
-            </security>
+        <security>
+            <requestedPrivileges>
+                <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
+            </requestedPrivileges>
+        </security>
     </trustInfo>
 </assembly>

src/spice2x/cfg/option.cpp

@@ -3,6 +3,10 @@
 #include "util/logging.h"
 #include "util/utils.h"
 
+static auto format_as(OptionType f) {
+    return fmt::underlying(f);
+}
+
 void Option::value_add(std::string new_value) {
 
     // put in primary slot if possible

src/spice2x/cfg/option.h

@@ -13,6 +13,16 @@ enum class OptionType {
     Hex,
 };
 
+enum class OptionPickerType {
+    None,
+    AsioDriver,
+    EACard,
+    CpuAffinity,
+    FilePath,
+    DirectoryPath,
+    Monitor,
+};
+
 struct OptionDefinition {
     std::string title;
     // unique identifier used for flag matching but also stored in config files
@@ -32,6 +42,12 @@ struct OptionDefinition {
     bool sensitive = false;
     std::vector<std::pair<std::string, std::string>> elements = {};
     bool disabled = false;
+    OptionPickerType picker = OptionPickerType::None;
+
+    // for OptionPickerType::FilePath
+    std::string file_extension = "";
+
+    std::string quick_setting_category = "";
 };
 
 class Option {

src/spice2x/cfg/resource.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#define IDR_CHANGELOG                   130
 #define IDR_LICENSES                    131
 #define IDR_PATCHES                     132
 #define IDR_README                      133
 #define IDR_DSEGFONT                    134
+#define IDR_CONTROLLER_PRESETS_BUILTIN  135

src/spice2x/cfg/screen_resize.cpp

@@ -1,9 +1,11 @@
 #include "screen_resize.h"
 
+#include "avs/game.h"
 #include "external/rapidjson/document.h"
 #include "external/rapidjson/pointer.h"
 #include "external/rapidjson/prettywriter.h"
 #include "misc/eamuse.h"
+#include "util/deferlog.h"
 #include "util/utils.h"
 #include "util/fileutils.h"
 #include "hooks/graphics/graphics.h"
@@ -19,7 +21,7 @@ namespace cfg {
         if (SCREEN_RESIZE_CFG_PATH_OVERRIDE.has_value()) {
             this->config_path = SCREEN_RESIZE_CFG_PATH_OVERRIDE.value();
             if (fileutils::file_exists(this->config_path)) {
-                log_info("ScreenResize", "loading config from: {}", this->config_path.string());
+                log_info("ScreenResize", "loading config from: {}", this->config_path);
                 file_exists = true;
             }
         } else {
@@ -33,7 +35,7 @@ namespace cfg {
 
     ScreenResize::~ScreenResize() {
     }
-    
+
     void ScreenResize::config_load() {
         std::string config = fileutils::text_read(this->config_path);
         if (config.empty()) {
@@ -48,7 +50,7 @@ namespace cfg {
         // check parse error
         auto error = doc.GetParseError();
         if (error) {
-            log_warning("ScreenResize", "config parse error: {}", error);
+            log_warning("ScreenResize", "config parse error: {}", static_cast<uint32_t>(error));
             return;
         }
 
@@ -76,8 +78,12 @@ namespace cfg {
             eamuse_get_game(),
             use_game_setting,
             root);
-        
+
         load_bool_value(doc, root + "enable_screen_resize", this->enable_screen_resize);
+        if (this->enable_screen_resize) {
+            log_misc("ScreenResize", "enabled by config file");
+        }
+
         load_bool_value(doc, root + "enable_linear_filter", this->enable_linear_filter);
         for (size_t i = 0; i < std::size(this->scene_settings); i++) {
             auto& scene = this->scene_settings[i];
@@ -87,6 +93,10 @@ namespace cfg {
             load_float_value(doc, root + prefix + "scale_x", scene.scale_x);
             load_float_value(doc, root + prefix + "scale_y", scene.scale_y);
             load_bool_value(doc, root + prefix + "keep_aspect_ratio", scene.keep_aspect_ratio);
+
+            int duplicate = 0;
+            load_int_value(doc, root + prefix + "duplicate", duplicate);
+            scene.duplicate = static_cast<cfg::ScreenDuplicateMode>(duplicate);
         }
 
         // windowed settings are always under game settings
@@ -201,6 +211,7 @@ namespace cfg {
             rapidjson::Pointer(root + prefix + "scale_x").Set(doc, scene.scale_x);
             rapidjson::Pointer(root + prefix + "scale_y").Set(doc, scene.scale_y);
             rapidjson::Pointer(root + prefix + "keep_aspect_ratio").Set(doc, scene.keep_aspect_ratio);
+            rapidjson::Pointer(root + prefix + "duplicate").Set(doc, scene.duplicate);
         }
 
         // windowed mode settings