cfg: turn a handful of parameter parsing errors into fatal (#554)

For parameters that require two values (`width, height` or `x, y`), if
the string fails to parse, turn into runtime failure.

CONTRIBUTING.md

@@ -29,7 +29,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
 

src/spice2x/CMakeLists.txt

@@ -170,8 +170,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
@@ -441,6 +441,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
         games/scotto/io.cpp
         games/drs/drs.cpp
         games/drs/io.cpp
+        games/drs/rgb_cam.cpp
         games/we/we.cpp
         games/we/io.cpp
         games/we/touchpanel.cpp
@@ -554,6 +555,7 @@ 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

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/avs/ea3.cpp

@@ -5,8 +5,9 @@
 #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"
@@ -528,6 +529,28 @@ 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

src/spice2x/build_all.sh

@@ -74,7 +74,7 @@ then
 	BUILD_TYPE="Debug"
 	BUILDDIR_32=${BUILDDIR_32_DEBUG}
 	BUILDDIR_64=${BUILDDIR_64_DEBUG}
-	DIST_NAME=$(echo ${DIST_NAME} | sed 's/\.[^.]*$/-dbg&/')
+	DIST_NAME=$(echo "${DIST_NAME}" | sed 's/\.[^.]*$/-dbg&/')
 fi
 
 # determine number of cores
@@ -114,7 +114,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
@@ -127,7 +127,7 @@ 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
 
 	echo ""
@@ -234,7 +234,7 @@ 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
 
@@ -249,11 +249,11 @@ if ((DIST_ENABLE > 0))
 then
 	echo "Building dist..."
 	mkdir -p ${DIST_FOLDER}
-	rm -rf ${DIST_FOLDER}/${DIST_NAME}
+	rm -rf "${DIST_FOLDER}/${DIST_NAME}"
 	pushd ${OUTDIR}/.. > /dev/null
-	zip -qrXT9 $OLDPWD/${DIST_FOLDER}/${DIST_NAME} spice2x -x "spice2x/extras/*" -z <<< "$DIST_COMMENT"
+	zip -qrXT9 "$OLDPWD/${DIST_FOLDER}/${DIST_NAME}" spice2x -x "spice2x/extras/*" -z <<< "$DIST_COMMENT"
 	echo "Building extras..."
-	zip -qrXT9 $OLDPWD/${DIST_FOLDER}/${DIST_NAME_EXTRAS} spice2x -z <<< "$DIST_COMMENT"
+	zip -qrXT9 "$OLDPWD/${DIST_FOLDER}/${DIST_NAME_EXTRAS}" spice2x -z <<< "$DIST_COMMENT"
 	popd > /dev/null
 fi
 

src/spice2x/build_docker.sh

@@ -1,4 +1,4 @@
 #!/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 "$@"
+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 "$@"

src/spice2x/cfg/api.cpp

@@ -644,10 +644,12 @@ 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

src/spice2x/cfg/button.cpp

@@ -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:
@@ -255,9 +275,9 @@ 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";
         default:
 
             // check win API
@@ -301,17 +321,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);

src/spice2x/cfg/button.h

@@ -45,6 +45,7 @@ private:
     double debounce_up = 0.0;
     double debounce_down = 0.0;
     bool invert = false;
+    bool is_temporary = false;
 
     GameAPI::Buttons::State last_state = GameAPI::Buttons::BUTTON_NOT_PRESSED;
     float last_velocity = 0.f;
@@ -164,6 +165,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 +181,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 ///
@@ -510,8 +519,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");
@@ -574,6 +585,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;
@@ -760,6 +804,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;

src/spice2x/cfg/light.h

@@ -13,6 +13,7 @@ private:
     std::string lightName;
     std::string deviceIdentifier = "";
     unsigned int index = 0;
+    bool is_temporary = false;
 
 public:
     float last_state = 0.f;
@@ -65,4 +66,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/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"
@@ -78,6 +80,10 @@ namespace cfg {
             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];

src/spice2x/cfg/screen_resize.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <atomic>
 #include <memory>
 #include <string>
 #include <optional>
@@ -51,6 +52,9 @@ namespace cfg {
         bool enable_linear_filter = true;
         fullscreen_setting scene_settings[4];
 
+        // state
+        std::atomic<bool> need_surface_clean = false;
+
         // windowed mode sizing
         // Windows terminology:
         //     window = rectangle including the frame

src/spice2x/games/ccj/bi2x_hook.cpp

@@ -1,5 +1,7 @@
 #include "bi2x_hook.h"
 
+#if SPICE64
+
 #include <cstdint>
 #include "util/detour.h"
 #include "util/logging.h"
@@ -16,15 +18,19 @@ namespace games::ccj {
      */
 
     struct AIO_SCI_COMM {
+        uint8_t data[0xf8];
     };
 
     struct AIO_NMGR_IOB2 {
+        uint8_t data[0xe30];
     };
 
     struct AIO_IOB2_BI2X_TBS {
+        uint8_t data[0x4680];
     };
 
     struct AIO_IOB2_BI2X_WRFIRM {
+        uint8_t data[0x20f48];
     };
 
     struct AIO_NMGR_IOB__NODEINFO {
@@ -72,6 +78,12 @@ namespace games::ccj {
         AIO_IOB2_BI2X_AC1__OUTPUTDATA OutputData;
     };
 
+    // checked with UJK-001-2024060400
+    static_assert(sizeof(AIO_SCI_COMM) == 0xf8);
+    static_assert(sizeof(AIO_NMGR_IOB2) == 0xe30);
+    static_assert(sizeof(AIO_IOB2_BI2X_TBS) == 0x4680);
+    static_assert(sizeof(AIO_IOB2_BI2X_WRFIRM) == 0x20f48);
+
     static void write_iccr_led(Lights::ccj_lights_t light, uint8_t value);
 
     /*
@@ -621,4 +633,6 @@ namespace games::ccj {
         detour::trampoline_try(libaioDll, "aioNodeCtl_IsError",
                                aioNodeCtl_IsError, &aioNodeCtl_IsError_orig);
     }
-}
+}
+
+#endif

src/spice2x/games/ccj/bi2x_hook.h

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

src/spice2x/games/ccj/ccj.cpp

@@ -68,9 +68,13 @@ namespace games::ccj {
         detour::trampoline_try("execexe.dll", MAKEINTRESOURCE(11),
                                (void*)execexe_CreateFileW_hook,(void**)&execexe_CreateFileW_orig);
 
+#if SPICE64
+
         // insert BI2X hooks
         bi2x_hook_init();
 
+#endif
+
         // insert trackball hooks
         trackball_hook_init();
 

src/spice2x/games/ddr/ddr.cpp

@@ -8,6 +8,7 @@
 #include "hooks/setupapihook.h"
 #include "hooks/sleephook.h"
 #include "hooks/input/dinput8/hook.h"
+#include "util/deferlog.h"
 #include "util/utils.h"
 #include "util/libutils.h"
 #include "util/fileutils.h"
@@ -108,18 +109,32 @@ namespace games::ddr {
                     log_info("ddr", "`{}` returned {}", cmd, result);
                 } else {
                     log_warning("ddr", "`{}` failed, returned {}", cmd, result);
+                    deferredlogs::defer_error_messages({
+                        "DDR codec registration failure",
+                        fmt::format("    {} failed to register with error {}", filename.string(), result)});
                 }
 
-                if (!contains_only_ascii(file.path().string())) {
-                    log_warning(
-                        "ddr",
-                        "BAD PATH ERROR\n\n\n"
-                        "!!!                                                          !!!\n"
-                        "!!! filesystem path to codec contains non-ASCII characters!  !!!\n"
-                        "!!! this may cause the game to crash!                        !!!\n"
-                        "!!!                                                          !!!\n"
-                        );
-                }
+                static std::once_flag printed;
+                std::call_once(printed, [file]() {
+                    if (!contains_only_ascii(file.path().string())) {
+                        log_warning(
+                            "ddr",
+                            "BAD PATH ERROR\n\n"
+                            "!!!                                                          !!!\n"
+                            "!!! filesystem path to codec contains non-ASCII characters!  !!!\n"
+                            "!!! this may cause failures when loading codecs, and         !!!\n"
+                            "!!! potentially leading the game to crash!                   !!!\n"
+                            "!!!                                                          !!!\n"
+                            );
+
+                        deferredlogs::defer_error_messages({
+                            "path to DDR codecs contain non-Latin characters",
+                            "    this may lead to movies not playing, white screen issue,",
+                            "    game hanging, or potentially a crash",
+                            "    move the game to a directory that does not contain non-Latin characters",
+                            "    if you encountered any issues"});
+                    }
+                });
             }
         }
     }

src/spice2x/games/drs/drs.cpp

@@ -8,6 +8,7 @@
 #include "util/detour.h"
 #include "util/logging.h"
 #include "util/memutils.h"
+#include "rgb_cam.h"
 
 #pragma pack(push)
 
@@ -150,6 +151,7 @@ namespace games::drs {
     char DRS_TAPELED[DRS_TAPELED_COLS_TOTAL][3] {};
     bool DISABLE_TOUCH = false;
     bool TRANSPOSE_TOUCH = false;
+    bool RGB_CAMERA_HOOK = false;
 
     std::vector<TouchEvent> TOUCH_EVENTS;
 
@@ -313,6 +315,10 @@ namespace games::drs {
         } else {
             log_info("drs", "no native input method detected");
         }
+
+        if (RGB_CAMERA_HOOK) {
+            init_rgb_camera_hook();
+        }
     }
 
     void DRSGame::detach() {

src/spice2x/games/drs/drs.h

@@ -31,6 +31,7 @@ namespace games::drs {
     extern std::vector<TouchEvent> TOUCH_EVENTS;
     extern bool DISABLE_TOUCH;
     extern bool TRANSPOSE_TOUCH;
+    extern bool RGB_CAMERA_HOOK;
 
     void fire_touches(drs_touch_t *events, size_t event_count);
     void start_touch();

src/spice2x/games/drs/rgb_cam.cpp

@@ -0,0 +1,170 @@
+#include "games/drs/rgb_cam.h"
+
+// set version to Windows 7 to enable Media Foundation functions
+#ifdef _WIN32_WINNT
+#undef _WIN32_WINNT
+#endif
+#define _WIN32_WINNT 0x0601
+
+// turn on C-style COM objects
+#define CINTERFACE
+
+#include <mfobjects.h>
+#include <mfidl.h>
+#include <string>
+
+#include "avs/game.h"
+#include "cfg/configurator.h"
+#include "hooks/cfgmgr32hook.h"
+#include "util/detour.h"
+#include "util/memutils.h"
+#include "util/logging.h"
+#include "util/utils.h"
+
+static VTBL_TYPE(IMFActivate, GetAllocatedString) GetAllocatedString_orig = nullptr;
+static decltype(MFEnumDeviceSources) *MFEnumDeviceSources_orig = nullptr;
+
+namespace games::drs {
+
+    /*
+     * Camera related stuff
+     */
+    static std::wstring CAMERA0_ID;
+
+    static HRESULT WINAPI GetAllocatedString_hook(IMFActivate* This, REFGUID guidKey, LPWSTR *ppwszValue,
+                                                  UINT32 *pcchLength)
+    {
+        // call the original
+        HRESULT result = GetAllocatedString_orig(This, guidKey, ppwszValue, pcchLength);
+
+        // log the cam name
+        log_misc("drs::rgbcam", "obtained {}", ws2s(*ppwszValue));
+
+        // try first camera
+        wchar_t *pwc = nullptr;
+        if (CAMERA0_ID.length() == 23) {
+            pwc = wcsstr(*ppwszValue, CAMERA0_ID.c_str());
+        }
+
+        // check if camera could be identified
+        if (pwc) {
+
+            // fake the USB IDs
+            pwc[4] = L'2';
+            pwc[5] = L'8';
+            pwc[6] = L'8';
+            pwc[7] = L'c';
+
+            pwc[13] = L'0';
+            pwc[14] = L'0';
+            pwc[15] = L'0';
+            pwc[16] = L'2';
+
+            pwc[21] = L'0';
+            pwc[22] = L'0';
+
+            log_misc("drs::rgbcam", "replaced {}", ws2s(*ppwszValue));
+        }
+
+        // return original result
+        return result;
+    }
+
+    static void hook_camera(std::wstring camera_id, std::string camera_instance) {
+        // don't hook if camera 0 is already hooked
+        if (CAMERA0_ID.length() > 0) {
+            return;
+        }
+
+        // save the camera ID
+        CAMERA0_ID = camera_id;
+
+        // cfgmgr hook
+        CFGMGR32_HOOK_SETTING camera_setting;
+        camera_setting.device_instance = 0xDEADBEEF;
+        camera_setting.parent_instance = ~camera_setting.device_instance;
+        camera_setting.device_id = "USB\\VEN_8086&DEV_8C2D";
+        camera_setting.device_node_id = "USB\\VID_288C&PID_0002&MI_00\\?&????????&?&????";
+        if (camera_instance.length() == 17) {
+            for (int i = 0; i < 17; i++) {
+                camera_setting.device_node_id[28 + i] = camera_instance[i];
+            }
+        }
+        cfgmgr32hook_add(camera_setting);
+
+        log_info("drs::rgbcam", "hooked camera @ {}", ws2s(camera_id));
+    }
+
+    static void hook_camera_vtable(IMFActivate *camera) {
+
+        // hook allocated string method for camera identification
+        memutils::VProtectGuard camera_guard(camera->lpVtbl);
+        camera->lpVtbl->GetAllocatedString = GetAllocatedString_hook;
+    }
+
+    static HRESULT WINAPI MFEnumDeviceSources_hook(IMFAttributes *pAttributes, IMFActivate ***pppSourceActivate,
+                                                   UINT32 *pcSourceActivate) {
+
+        // call original function
+        HRESULT result_orig = MFEnumDeviceSources_orig(pAttributes, pppSourceActivate, pcSourceActivate);
+
+        // check for capture devices
+        if (FAILED(result_orig) || !*pcSourceActivate) {
+            return result_orig;
+        }
+
+        // get camera
+        IMFActivate *camera = **pppSourceActivate;
+
+        // save original method for later use
+        if (GetAllocatedString_orig == nullptr) {
+            GetAllocatedString_orig = camera->lpVtbl->GetAllocatedString;
+        }
+
+        // hook allocated string method for camera identification
+        hook_camera_vtable(camera);
+
+        // get camera link
+        LPWSTR camera_link_lpwstr;
+        UINT32 camera_link_length;
+        if (SUCCEEDED(GetAllocatedString_orig(
+                camera,
+                MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK,
+                &camera_link_lpwstr,
+                &camera_link_length))) {
+
+            // cut name to make ID
+            std::wstring camera_link_ws = std::wstring(camera_link_lpwstr);
+            std::wstring camera_id = camera_link_ws.substr(8, 23);
+
+            log_info("drs::rgbcam", "found video capture device: {}", ws2s(camera_link_ws));
+
+            // only support cameras that start with \\?\usb
+            if (!string_begins_with(camera_link_ws, L"\\\\?\\usb")) {
+                return result_orig;
+            }
+
+            // get camera instance
+            std::string camera_link = ws2s(camera_link_ws);
+            std::string camera_instance = camera_link.substr(32, 17);
+
+            // hook the camera
+            hook_camera(camera_id, camera_instance);
+        } else {
+            log_warning("drs::rgbcam", "failed to open camera");
+        }
+
+        // return result
+        return result_orig;
+    }
+
+    void init_rgb_camera_hook() {
+        log_info("drs::rgbcam", "initializing camera hook");
+
+        cfgmgr32hook_init(avs::game::DLL_INSTANCE);
+
+        // camera media framework hook
+        MFEnumDeviceSources_orig = detour::iat_try(
+                "MFEnumDeviceSources", MFEnumDeviceSources_hook, avs::game::DLL_INSTANCE);
+    }
+}

src/spice2x/games/drs/rgb_cam.h

@@ -0,0 +1,5 @@
+#pragma once
+
+namespace games::drs {
+    void init_rgb_camera_hook();
+}

src/spice2x/games/gitadora/bi2x_hook.cpp

@@ -1,5 +1,7 @@
 #include "bi2x_hook.h"
 
+#if SPICE64
+
 #include <optional>
 #include <cstdint>
 #include "util/detour.h"
@@ -18,24 +20,29 @@ namespace games::gitadora {
     //  */
 
     struct AIO_NMGR_IOB2 {
+        uint8_t data[0xe18];
     };
 
     struct AIO_IOB2_BI2X_AC1__SETTING {
     };
 
     struct AIO_NMGR_IOB5 {
+        uint8_t data[0xb10];
     };
 
     struct AIO_SCI_COMM {
+        uint8_t data[0x100];
     };
 
     struct AIO_IOB5_Y32D {
+        uint8_t data[0x2e8];
     };
 
     // struct AIO_IOB5_Y33I {
     // };
 
     struct AIO_IOB2_BI2X_AC1 {
+        uint8_t data[0x4570];
     };
 
     struct AIO_NMGR_IOB__NODEINFO {
@@ -43,6 +50,7 @@ namespace games::gitadora {
     };
 
     struct AIO_IOB2_BI2X_WRFIRM {
+        uint8_t data[0x20f48];
     };
 
     struct AIO_SCI_COMM_T {
@@ -159,6 +167,14 @@ namespace games::gitadora {
         uint8_t unk[0xB1];
     };
 
+    // verified with M32-007-2025092400
+    static_assert(sizeof(AIO_NMGR_IOB2) == 0xe18);
+    static_assert(sizeof(AIO_NMGR_IOB5) == 0xb10);
+    static_assert(sizeof(AIO_SCI_COMM) == 0x100);
+    static_assert(sizeof(AIO_IOB5_Y32D) == 0x2e8);
+    static_assert(sizeof(AIO_IOB2_BI2X_AC1) == 0x4570);
+    static_assert(sizeof(AIO_IOB2_BI2X_WRFIRM) == 0x20f48);
+
      /*
       * typedefs
       */
@@ -701,4 +717,6 @@ namespace games::gitadora {
         detour::trampoline_try(libaioDll, "aioNodeCtl_UpdateDevicesStatus",
                                aioNodeCtl_UpdateDevicesStatus, &aioNodeCtl_UpdateDevicesStatus_orig);
     }
-}
+}
+
+#endif

src/spice2x/games/gitadora/bi2x_hook.h

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

src/spice2x/games/gitadora/gitadora.cpp

@@ -5,12 +5,14 @@
 #include "cfg/configurator.h"
 #include "hooks/audio/mme.h"
 #include "hooks/graphics/graphics.h"
+#include "misc/wintouchemu.h"
 #include "overlay/overlay.h"
 #include "util/cpuutils.h"
 #include "util/detour.h"
 #include "util/libutils.h"
 #include "util/logging.h"
 #include "util/sigscan.h"
+#include "util/socd_cleaner.h"
 #include "hooks/setupapihook.h"
 
 namespace games::gitadora {
@@ -18,6 +20,11 @@ namespace games::gitadora {
     // settings
     bool TWOCHANNEL = false;
     std::optional<unsigned int> CAB_TYPE = std::nullopt;
+    bool ARENA_SINGLE_WINDOW = false;
+    bool P1_LEFTY = false;
+    bool P2_LEFTY = false;
+    std::optional<std::string> SUBSCREEN_OVERLAY_SIZE;
+    std::optional<socd::SocdAlgorithm> PICK_ALGO = socd::SocdAlgorithm::PreferRecent;
 
     /*
      * Prevent GitaDora from creating folders on F drive
@@ -220,6 +227,16 @@ namespace games::gitadora {
                 GRAPHICS_WINDOWED && !cfg::CONFIGURATOR_STANDALONE) {
                 overlay::UI_SCALE_PERCENT = 250;
             }
+
+            // for guitar wail SOCD cleaning
+            socd::ALGORITHM = socd::SocdAlgorithm::PreferRecent;
+
+            // for guitar picking
+            if (PICK_ALGO.has_value()) {
+                log_info("gitadora", "guitar pick SOCD algorithm: {}", static_cast<int>(PICK_ALGO.value()));
+            } else {
+                log_info("gitadora", "guitar pick SOCD algorithm: legacy");
+            }
         }
     }
 
@@ -279,6 +296,13 @@ namespace games::gitadora {
 
             // volume change prevention
             hooks::audio::mme::init(avs::game::DLL_INSTANCE);
+
+            // touch hook
+            if (ARENA_SINGLE_WINDOW) {
+                wintouchemu::FORCE = true;
+                wintouchemu::INJECT_MOUSE_AS_WM_TOUCH = true;
+                wintouchemu::hook("GITADORA", avs::game::DLL_INSTANCE);
+            }
             return;
         }
 

src/spice2x/games/gitadora/gitadora.h

@@ -4,12 +4,18 @@
 
 #include "avs/game.h"
 #include "games/game.h"
+#include "util/socd_cleaner.h"
 
 namespace games::gitadora {
 
     // settings
     extern bool TWOCHANNEL;
     extern std::optional<unsigned int> CAB_TYPE;
+    extern bool ARENA_SINGLE_WINDOW;
+    extern bool P1_LEFTY;
+    extern bool P2_LEFTY;
+    extern std::optional<std::string> SUBSCREEN_OVERLAY_SIZE;
+    extern std::optional<socd::SocdAlgorithm> PICK_ALGO;
 
     class GitaDoraGame : public games::Game {
     public:
@@ -38,4 +44,12 @@ namespace games::gitadora {
             );
     }
 
+    static inline bool is_player_lefty(size_t player) {
+        if (player == 0) {
+            return P1_LEFTY;
+        } else if (player == 1) {
+            return P2_LEFTY;
+        }
+        return false;
+    }
 }

src/spice2x/games/gitadora/io.cpp

@@ -65,17 +65,18 @@ std::vector<Button> &games::gitadora::get_buttons() {
                 "Drum Help",
                 "Drum Button Extra 1",
                 "Drum Button Extra 2",
+
+                "Drum Left Cymbal",
                 "Drum Hi-Hat",
-                "Drum Hi-Hat Closed",
-                "Drum Hi-Hat Half-Open",
+                "Drum Left Pedal",
                 "Drum Snare",
                 "Drum Hi-Tom",
-                "Drum Low-Tom",
-                "Drum Right Cymbal",
                 "Drum Bass Pedal",
-                "Drum Left Cymbal",
-                "Drum Left Pedal",
-                "Drum Floor Tom"
+                "Drum Low-Tom",
+                "Drum Floor Tom",
+                "Drum Right Cymbal",
+                "Drum Hi-Hat Closed",
+                "Drum Hi-Hat Half-Open"
         );
     }
 
@@ -107,9 +108,18 @@ std::string games::gitadora::get_buttons_help() {
     // keep to max 100 characters wide
     return
         "guitar:\n"
+        "\n"
         " < R G B Y P --- Pick ] \n"
         "\n"
+        " If you normally hold your guitar left-handed (frets on right hand):\n"
+        "   * here, hold the guitar as right-handed (frets on left hand),\n"
+        "     and bind the buttons, pick, and wail controls\n"
+        "   * in Options tab, turn on GitaDora Lefty Guitar\n"
+        "   * finally, use the in-game option to turn on LEFT mode\n"
+        "\n"
+        "\n"
         "drums:\n"
+        "\n"
         " LeftCymbal                                RightCymbal\n"
         "         HiHat        HiTom      LowTom \n"
         "                  Snare              FloorTom \n"
@@ -117,10 +127,28 @@ std::string games::gitadora::get_buttons_help() {
         "             Left          Bass\n"
         "             Pedal         Pedal\n"
         "\n"
-        "Drums are NOT velocity-sensitive!\n"
+        " For MIDI drums with Open/Closed HiHat configurations or pads with\n"
+        " multiple hit zones, ensure you bind all variation using the Pages\n"
+        " button at the bottom."
+        ;
+}
+std::string games::gitadora::get_analogs_help() {
+    // keep to max 100 characters wide
+    return
+        "guitar:\n"
         "\n"
-        "For MIDI drums with Open/Closed HiHat configurations, bind variations below. "
-        "v2_drum algorithm might work better for those drums."
+        "X axis: 0% when body is held facing monitor, 50% when flat on a table\n"
+        "Y axis: 50% when held horizontal, 0% when neck is raised, 100% pointing down\n"
+        "Z axis: 50% at rest, 100% when swinging neck toward monitor (only used in XG series)\n"
+        "\n"
+        "You need both X and Y axis for up/down wail to work correctly in-game.\n"
+        "If you only have Y axis, consider using digital wailing instead.\n"
+        "\n"
+        "Ensure you clear all analog bindings if you want to use digital wailing.\n"
+        "\n"
+        "If you hold your guitar left-handed (frets on the right hand),\n"
+        "analog bindings will likely not work as intended.\n"
+        "Consider using digital wailing in Buttons tab."
         ;
 }
 

src/spice2x/games/gitadora/io.h

@@ -66,18 +66,21 @@ namespace games::gitadora {
             DrumHelp,
             DrumButtonExtra1,
             DrumButtonExtra2,
-            // note: this is the order they appear in the test menu
+            // note: this is the order of drums in the default layout
+            DrumLeftCymbal,
             DrumHiHat,
-            DrumHiHatClosed,
-            DrumHiHatHalfOpen,
+            DrumLeftPedal,
             DrumSnare,
             DrumHiTom,
-            DrumLowTom,
-            DrumRightCymbal,
             DrumBassPedal,
-            DrumLeftCymbal,
-            DrumLeftPedal,
-            DrumFloorTom
+            DrumLowTom,
+            DrumFloorTom,
+            DrumRightCymbal,
+
+            // these only exist for back compat
+            // (created before it was possible to map multiple input to a button)
+            DrumHiHatClosed,
+            DrumHiHatHalfOpen
         };
     }
 
@@ -209,6 +212,7 @@ namespace games::gitadora {
     // getters
     std::vector<Button> &get_buttons();
     std::string get_buttons_help();
+    std::string get_analogs_help();
     std::vector<Analog> &get_analogs();
     std::vector<Light> &get_lights();
 }

src/spice2x/games/gitadora/j33i.cpp

@@ -1,11 +1,12 @@
 
 #include "misc/eamuse.h"
-#include "util/utils.h"
+#include "games/gitadora/gitadora.h"
+#include "util/socd_cleaner.h"
 #include "util/time.h"
+#include "util/utils.h"
 #include "io.h"
 #include "j33i.h"
 
-
 #define GUITAR_BTN_R 0x7
 #define GUITAR_BTN_G 0x6
 #define GUITAR_BTN_B 0x5
@@ -91,28 +92,50 @@ bool games::gitadora::J33ISerialDevice::parse_msg(
                 payload.buttons |= 1 << GUITAR_BTN_P;
             }
 
-            if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1PickUp])) {
-                if (!GFDM_GF_PICK_STATE_UP) {
-                    GFDM_GF_PICK_STATE_UP = true;
-                    payload.buttons |= 1 << GUITAR_PICK_UP;
+
+            const auto pick_up = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1PickUp]);
+            const auto pick_down = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1PickDown]);
+            if (!games::gitadora::PICK_ALGO.has_value()) {
+                // legacy behavior (detect rising edges only, input for 1 frame)
+                if (pick_up) {
+                    if (!GFDM_GF_PICK_STATE_UP) {
+                        GFDM_GF_PICK_STATE_UP = true;
+                        payload.buttons |= 1 << GUITAR_PICK_UP;
+                    }
+                } else {
+                    GFDM_GF_PICK_STATE_UP = false;
+                }
+
+                if (pick_down) {
+                    if (!GFDM_GF_PICK_STATE_DOWN) {
+                        GFDM_GF_PICK_STATE_DOWN = true;
+                        payload.buttons |= 1 << GUITAR_PICK_DOWN;
+                    }
+                } else {
+                    GFDM_GF_PICK_STATE_DOWN = false;
                 }
             } else {
-                GFDM_GF_PICK_STATE_UP = false;
-            }
-
-            if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1PickDown])) {
-                if (!GFDM_GF_PICK_STATE_DOWN) {
-                    GFDM_GF_PICK_STATE_DOWN = true;
+                const auto socd = socd::socd_clean(
+                    0,
+                    pick_up,
+                    pick_down,
+                    get_performance_milliseconds(),
+                    games::gitadora::PICK_ALGO.value()
+                );
+                if (socd == socd::SocdCCW) {
+                    payload.buttons |= 1 << GUITAR_PICK_UP;
+                } else if (socd == socd::SocdCW) {
+                    payload.buttons |= 1 << GUITAR_PICK_DOWN;
+                } else if (socd == socd::SocdBoth) {
+                    payload.buttons |= 1 << GUITAR_PICK_UP;
                     payload.buttons |= 1 << GUITAR_PICK_DOWN;
                 }
-            } else {
-                GFDM_GF_PICK_STATE_DOWN = false;
             }
 
             auto &analogs = get_analogs();
 
-            // get x,y,z analog values [-0.5f, 0.5f], centered at 0.f
-            float x = 0.f;
+            // get x,y,z analog values [-0.5f, 0.5f]
+            float x = is_player_lefty(0) ? 0.3f : -0.5f;
             auto x_analog = analogs[Analogs::GuitarP1WailX];
             if (x_analog.isSet()) {
                 x = GameAPI::Analogs::getState(RI_MGR, x_analog) - 0.5f;
@@ -123,11 +146,6 @@ bool games::gitadora::J33ISerialDevice::parse_msg(
             if (y_analog.isSet()) {
                 y = GameAPI::Analogs::getState(RI_MGR, y_analog) - 0.5f;
             }
-            if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1WailUp])) {
-                y = -0.5f;
-            } else if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1WailDown])) {
-                y = 0.5f;
-            }
 
             float z = 0.f;
             auto z_analog = analogs[Analogs::GuitarP1WailZ];
@@ -135,6 +153,31 @@ bool games::gitadora::J33ISerialDevice::parse_msg(
                 z = GameAPI::Analogs::getState(RI_MGR, z_analog) - 0.5f;
             }
 
+            // handle digital wail up/down
+            const auto wail_up = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1WailUp]);
+            const auto wail_down = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1WailDown]);
+            const auto wail_result =
+                socd::get_guitar_wail(0, wail_up, wail_down, get_performance_milliseconds());
+            if (!is_player_lefty(0)) {
+                // righty
+                if (wail_result == socd::TiltUp) {
+                    x = 0;
+                    y = -0.5f;
+                } else if (wail_result == socd::TiltDown) {
+                    x = -0.5f;
+                    y = 0.5f;
+                }
+            } else {
+                // lefty
+                if (wail_result == socd::TiltUp) {
+                    x = 0.f;
+                    y = 0.f;
+                } else if (wail_result == socd::TiltDown) {
+                    x = 0.5f;
+                    y = 0.f;
+                }
+            }
+
             // convert x,y,z to unsigned integer values that the game expects
             const uint16_t x_int = x * ARENA_MODEL_WAIL_MAX * 2;
             const uint16_t y_int = y * ARENA_MODEL_WAIL_MAX * 2;

src/spice2x/games/io.cpp

@@ -47,6 +47,7 @@ namespace games {
     static robin_hood::unordered_map<std::string, std::vector<Button>> buttons_keypads;
     static robin_hood::unordered_map<std::string, std::vector<Button>> buttons_overlay;
     static robin_hood::unordered_map<std::string, std::string> buttons_help;
+    static robin_hood::unordered_map<std::string, std::string> analogs_help;
     static robin_hood::unordered_map<std::string, std::vector<Analog> &> analogs;
     static robin_hood::unordered_map<std::string, std::vector<Light> &> lights;
     static robin_hood::unordered_map<std::string, std::vector<Option>> options;
@@ -107,6 +108,7 @@ namespace games {
         games.push_back(gitadora);
         buttons.insert({ gitadora, gitadora::get_buttons() });
         buttons_help.insert({ gitadora, gitadora::get_buttons_help() });
+        analogs_help.insert({ gitadora, gitadora::get_analogs_help() });
         analogs.insert({ gitadora, gitadora::get_analogs() });
         lights.insert({ gitadora, gitadora::get_lights() });
         file_hints[gitadora].emplace_back("gdxg.dll");
@@ -322,7 +324,7 @@ namespace games {
         buttons_help.insert({ pc, pc::get_buttons_help() });
         analogs.insert({ pc, pc::get_analogs() });
         lights.insert({ pc, pc::get_lights() });
-        file_hints[pc].emplace_back("game/svm_Data");
+        file_hints[pc].emplace_back("game/svm.exe");
     }
 
     const std::vector<std::string> &get_games() {
@@ -349,6 +351,15 @@ namespace games {
         return it->second;
     }
 
+    std::string get_analogs_help(const std::string &game) {
+        initialize();
+        auto it = analogs_help.find(game);
+        if (it == analogs_help.end()) {
+            return "";
+        }
+        return it->second;
+    }
+
     static std::vector<Button> gen_buttons_keypads(const std::string &game) {
         auto buttons = GameAPI::Buttons::getButtons(game);
         std::vector<std::string> names;

src/spice2x/games/io.h

@@ -58,6 +58,7 @@ namespace games {
     const std::vector<std::string> &get_games();
     std::vector<Button> *get_buttons(const std::string &game);
     std::string get_buttons_help(const std::string &game);
+    std::string get_analogs_help(const std::string &game);
     std::vector<Button> *get_buttons_keypads(const std::string &game);
     std::vector<Button> *get_buttons_overlay(const std::string &game);
     std::vector<Analog> *get_analogs(const std::string &game);

src/spice2x/games/pc/bi2x_hook.cpp

@@ -1,5 +1,7 @@
 #include "bi2x_hook.h"
 
+#if SPICE64
+
 #include "util/execexe.h"
 #include "util/logging.h"
 #include "rawinput/rawinput.h"
@@ -9,9 +11,10 @@
 #include "util/tapeled.h"
 #include "pc.h"
 #include "util/utils.h"
+#include "util/time.h"
+#include "util/socd_cleaner.h"
 
 namespace games::pc {
-    bool PC_KNOB_MODE = false;
 
     constexpr float RELATIVE_DECAY = 0.02f;
     struct FADER_RELATIVE {
@@ -75,18 +78,22 @@ namespace games::pc {
      */
 
     struct AIO_SCI_COMM {
+        uint8_t data[0xf8];
     };
 
     struct AIO_NMGR_IOB2 {
+        uint8_t data[0xe30];
     };
 
     struct AIO_IOB2_BI2X_AC1 {
+        uint8_t data[0x4538];
     };
 
     struct AIO_IOB2_BI2X_AC1__SETTING {
     };
 
     struct AIO_IOB2_BI2X_WRFIRM {
+        uint8_t data[0x20f48];
     };
 
     struct AIO_IOB2_BI2X_AC1__INPUT
@@ -191,6 +198,12 @@ namespace games::pc {
         AIO_IOB2_BI2X_AC1__ICNPIN ICnPinHist[20];
     };
 
+    // verified with XIF-2024122300
+    static_assert(sizeof(AIO_SCI_COMM) == 0xf8);
+    static_assert(sizeof(AIO_NMGR_IOB2) == 0xe30);
+    static_assert(sizeof(AIO_IOB2_BI2X_AC1) == 0x4538);
+    static_assert(sizeof(AIO_IOB2_BI2X_WRFIRM) == 0x20f48);
+
     /*
      * typedefs
      */
@@ -338,14 +351,21 @@ namespace games::pc {
                 val = (GameAPI::Analogs::getState(RI_MGR, analogs[Analogs::FaderL]) - 0.5f) * 2;
             }
         }
-        if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderL_Left]) &&
-            GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderL_Right])) {
-            val = 0.f;
-        } else if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderL_Left])) {
+
+        const auto now = get_performance_milliseconds();
+
+        const auto fader_l_socd = socd::socd_clean(
+            0, // Fader-L
+            GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderL_Left]),
+            GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderL_Right]),
+            now);
+
+        if (fader_l_socd == socd::SocdCCW) {
             val = -1.0f;
-        } else if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderL_Right])) {
+        } else if (fader_l_socd == socd::SocdCW) {
             val = +1.0f;
         }
+
         o_DevStatus->Input.CN15_7 = (val < 0.2f) ? 0xFF : 0;
         o_DevStatus->Input.CN15_6 = (val > -0.85f && val < 0.35f) ? 0xFF : 0;
         o_DevStatus->Input.CN15_5 = (val > -0.6f && val < 0.6f) ? 0xFF : 0;
@@ -363,14 +383,19 @@ namespace games::pc {
                 val = (GameAPI::Analogs::getState(RI_MGR, analogs[Analogs::FaderR]) - 0.5f) * 2;
             }
         }
-        if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderR_Left]) &&
-            GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderR_Right])) {
-            val = 0.f;
-        } else if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderR_Left])) {
+
+        const auto fader_r_socd = socd::socd_clean(
+            1, // Fader-R
+            GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderR_Left]),
+            GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderR_Right]),
+            now);
+
+        if (fader_r_socd == socd::SocdCCW) {
             val = -1.0f;
-        } else if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FaderR_Right])) {
+        } else if (fader_r_socd == socd::SocdCW) {
             val = +1.0f;
         }
+
         o_DevStatus->Input.CN11_20 = (val < 0.2f) ? 0xFF : 0;
         o_DevStatus->Input.CN11_19 = (val > -0.85f && val < 0.35f) ? 0xFF : 0;
         o_DevStatus->Input.CN9_10 = (val > -0.6f && val < 0.6f) ? 0xFF : 0;
@@ -737,3 +762,5 @@ namespace games::pc {
     }
 
 }
+
+#endif

src/spice2x/games/pc/bi2x_hook.h

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

src/spice2x/games/pc/pc.cpp

@@ -12,10 +12,12 @@
 #include "misc/wintouchemu.h"
 #include "hooks/graphics/graphics.h"
 #include "rawinput/rawinput.h"
+#include "util/socd_cleaner.h"
 
 namespace games::pc {
     std::string PC_INJECT_ARGS = "";
     bool PC_NO_IO = false;
+    bool PC_KNOB_MODE = false;
 
     static acioemu::ACIOHandle *acioHandle = nullptr;
     static std::wstring portName = L"COM1";
@@ -61,6 +63,11 @@ namespace games::pc {
         return ERROR_NOT_SUPPORTED;
     }
 
+    void PCGame::pre_attach() {
+        // SOCD
+        socd::ALGORITHM = socd::SocdAlgorithm::PreferRecent;
+    }
+
     void PCGame::attach() {
         Game::attach();
 
@@ -78,9 +85,14 @@ namespace games::pc {
             execexe::load_library("libaio-iob2_video.dll");
             execexe::load_library("win10actlog.dll");
 
+#if SPICE64
+
             if (!PC_NO_IO) {
                 bi2x_hook_init();
             }
+
+#endif
+
         });
 
         const auto user32Dll = "user32.dll";

src/spice2x/games/pc/pc.h

@@ -11,6 +11,7 @@ namespace games::pc {
     public:
         PCGame() : Game("Polaris Chord") {}
 
+        virtual void pre_attach() override;
         virtual void attach() override;
         virtual void detach() override;
     };

src/spice2x/games/qks/bi2x_hook.cpp

@@ -1,5 +1,7 @@
 #include "bi2x_hook.h"
 
+#if SPICE64
+
 #include "util/detour.h"
 #include "util/logging.h"
 #include "rawinput/rawinput.h"
@@ -15,15 +17,19 @@ namespace games::qks {
      */
 
     struct AIO_SCI_COMM {
+        uint8_t data[0xf8];
     };
 
     struct AIO_NMGR_IOB {
+        uint8_t data[0xa00];
     };
 
     struct AIO_IOB2_BI2X_AC1 {
+        uint8_t data[0x3908];
     };
 
     struct AIO_IOB2_BI2X_WRFIRM {
+        uint8_t data[0x20f48];
     };
 
     struct AIO_NMGR_IOB__NODEINFO {
@@ -174,6 +180,12 @@ namespace games::qks {
         AIO_IOB2_BI2X_AC1__SETTING Setting;
     };
 
+    // verified with UKS-001-2024030600
+    static_assert(sizeof(AIO_IOB2_BI2X_AC1) == 0x3908);
+    static_assert(sizeof(AIO_SCI_COMM) == 0xf8);
+    static_assert(sizeof(AIO_NMGR_IOB) == 0xa00);
+    static_assert(sizeof(AIO_IOB2_BI2X_WRFIRM) == 0x20f48);
+
     /*
      * typedefs
      */
@@ -602,4 +614,6 @@ namespace games::qks {
         detour::trampoline_try(libaioDll, "aioNodeCtl_IsError",
                                aioNodeCtl_IsError, &aioNodeCtl_IsError_orig);
     }
-}
+}
+
+#endif

src/spice2x/games/qks/bi2x_hook.h

@@ -1,7 +1,11 @@
 #pragma once
 
+#if SPICE64
+
 #include <stdint.h>
 
 namespace games::qks {
     void bi2x_hook_init();
-}
+}
+
+#endif

src/spice2x/games/qks/qks.cpp

@@ -86,9 +86,13 @@ namespace games::qks {
         detour::trampoline_try("execexe.dll", MAKEINTRESOURCE(9),
                                execexe_CreateFileA_hook,&execexe_CreateFileA_orig);
 
+#if SPICE64
+
         // insert BI2X hooks
         bi2x_hook_init();
 
+#endif
+
         // add card reader
         acioHandle = new acioemu::ACIOHandle(portName.c_str());
         devicehook_init_trampoline();

src/spice2x/games/sdvx/bi2x_hook.cpp

@@ -60,9 +60,32 @@ namespace games::sdvx {
     // confirmed in EG final in aioIob2Bi2xUFC_Create
     static_assert(sizeof(AIO_IOB2_BI2X_UFC) == 0x39D8);
 
+    struct AIO_IOB2_BI2X_UFC__INPUT {
+        uint8_t DevIoCounter;
+        uint8_t bExIoAErr;
+        uint8_t bExIoBErr;
+        uint8_t bPcPowerOn;
+        uint8_t bPcPowerCheck;
+        uint8_t CoinCount;
+        uint8_t bTest;
+        uint8_t bService;
+        uint8_t bCoinSw;
+        uint8_t bCoinJam;
+        uint8_t bHPDetect;
+    };
+
     struct AIO_IOB2_BI2X_UFC__DEVSTATUS {
-        // of course you could work with variables here
-        uint8_t buffer[0x19E];
+        uint8_t InputCounter;
+        uint8_t OutputCounter;
+        uint8_t IoResetCounter;
+        uint8_t TapeLedCounter;
+        uint8_t TapeLedRate[8];
+        AIO_IOB2_BI2X_UFC__INPUT Input;
+        uint8_t unk_1[289];
+        uint16_t AnalogLeft;
+        uint16_t AnalogRight;
+        uint8_t Buttons;
+        uint8_t unk_2[97];
     };
 
     /*
@@ -156,8 +179,8 @@ namespace games::sdvx {
             AIO_IOB2_BI2X_UFC__GetDeviceStatus_orig(This, status);
         }
 
-        status->buffer[0] = count;
-        status->buffer[12] = count;
+        status->InputCounter = count;
+        status->Input.DevIoCounter = count;
         count++;
 
         // get buttons
@@ -165,27 +188,29 @@ namespace games::sdvx {
 
         // control buttons
         if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Test]))
-            status->buffer[18] = 0x01;
+            status->Input.bTest = 0x01;
         if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Service]))
-            status->buffer[19] = 0x01;
+            status->Input.bService = 0x01;
         if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::CoinMech]))
-            status->buffer[20] = 0x01;
+            status->Input.bCoinSw = 0x01;
         if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Start]))
-            status->buffer[316] |= 0x01;
+            status->Buttons |= 0x01;
         if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::BT_A]))
-            status->buffer[316] |= 0x02;
+            status->Buttons |= 0x02;
         if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::BT_B]))
-            status->buffer[316] |= 0x04;
+            status->Buttons |= 0x04;
         if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::BT_C]))
-            status->buffer[316] |= 0x08;
+            status->Buttons |= 0x08;
         if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::BT_D]))
-            status->buffer[316] |= 0x10;
+            status->Buttons |= 0x10;
         if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FX_L]))
-            status->buffer[316] |= 0x20;
+            status->Buttons |= 0x20;
         if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::FX_R]))
-            status->buffer[316] |= 0x40;
+            status->Buttons |= 0x40;
         if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Headphone]))
-            status->buffer[22] = 0x01;
+            status->Input.bHPDetect = 0x01;
+
+        status->Input.CoinCount += eamuse_coin_get_stock();
 
         const auto now = get_performance_milliseconds();
 
@@ -220,14 +245,14 @@ namespace games::sdvx {
             vol_right += (uint16_t) (GameAPI::Analogs::getState(RI_MGR, analogs[Analogs::VOL_R]) * 65535);
         }
 
-        *((uint16_t*) &status->buffer[312]) = vol_left;
-        *((uint16_t*) &status->buffer[314]) = vol_right;
+        status->AnalogLeft = vol_left;
+        status->AnalogRight = vol_right;
 
         log_debug(
             "bi2x_hook",
             "knobs = {} {}",
-            *((uint16_t*) &status->buffer[312]),
-            *((uint16_t*) &status->buffer[314]));
+            status->AnalogLeft,
+            status->AnalogRight);
     }
 
     static void __fastcall AIO_IOB2_BI2X_UFC__IoReset(AIO_IOB2_BI2X_UFC *This,

src/spice2x/games/sdvx/sdvx.cpp

@@ -65,10 +65,6 @@ namespace games::sdvx {
 
             // prevent the game from randomly picking an ASIO device
             if (!USE_ASIO) {
-                log_info(
-                    "sdvx::asio",
-                    "game tried to access HKLM\\SOFTWARE\\ASIO but ASIO is disabled; "
-                    "access prevented, ASIO init will fail");
                 return ERROR_FILE_NOT_FOUND;
             }
             // convince the game to use our hook (so we can swap in the preferred device)

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

@@ -82,7 +82,10 @@ HRESULT STDMETHODCALLTYPE WrappedIMMDevice::Activate(
         return ret;
     }
 
-    if (iid == IID_IAudioClient) {
+    // almost all games request IAudioClient
+    // so far we have not seen any games request IAudioClient2
+    // SDVX EG Final uses IID_IAudioClient3, but only when shared mode patch is on
+    if (iid == IID_IAudioClient || iid == IID_IAudioClient3) {
 
         // prevent initialization recursion when using some ASIO backends that proxy to DirectSound, WASAPI, or WDM
         // like ASIO4All or FlexASIO
@@ -92,23 +95,18 @@ HRESULT STDMETHODCALLTYPE WrappedIMMDevice::Activate(
         }
         std::lock_guard initialize_guard(hooks::audio::INITIALIZE_LOCK, std::adopt_lock);
 
-        auto client = reinterpret_cast<IAudioClient *>(*ppInterface);
-
         // release old audio client if initialized
         if (hooks::audio::CLIENT) {
             hooks::audio::CLIENT->Release();
         }
 
-        /*
-        ret = wrap_audio_client(pReal, dwClsCtx, pActivationParams, &client);
-        if (FAILED(ret)) {
-            return ret;
+        IAudioClient *client = nullptr;
+        if (iid == IID_IAudioClient) {
+            client = wrap_audio_client(reinterpret_cast<IAudioClient *>(*ppInterface));
+        } else { // IID_IAudioClient3
+            client = wrap_audio_client3(reinterpret_cast<IAudioClient3 *>(*ppInterface));
         }
-        */
-        client = wrap_audio_client(client);
-
         *ppInterface = client;
-
         // persist the audio client
         hooks::audio::CLIENT = client;
         hooks::audio::CLIENT->AddRef();

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

@@ -10,6 +10,7 @@
 #include "hooks/audio/implementations/asio.h"
 #include "hooks/audio/implementations/wave_out.h"
 //#include "util/co_task_mem_ptr.h"
+#include "util/utils.h"
 
 #include "defs.h"
 #include "dummy_audio_client.h"
@@ -40,114 +41,9 @@ static void fix_rec_format(WAVEFORMATEX *pFormat) {
     pFormat->nAvgBytesPerSec = pFormat->nSamplesPerSec * pFormat->nBlockAlign;
 }
 
-// TODO(felix): is it appropriate to automatically switch to shared mode? should we do a
-// `MessageBox` to notify the user?
-/*
-static bool check_for_exclusive_access(IAudioClient *client) {
-    static bool checked_once = false;
-    static bool previous_check_result = false;
-
-    CoTaskMemPtr<WAVEFORMATEX> mix_format;
-    REFERENCE_TIME requested_duration = 0;
-
-    if (checked_once) {
-        return previous_check_result;
-    }
-    if (audio::BACKEND.has_value()) {
-        return false;
-    }
-
-    // scope function so it has access to the local static variables
-    auto set_result = [](bool result) {
-        checked_once = true;
-        previous_check_result = result;
-
-        return result;
-    };
-
-    HRESULT ret = client->GetMixFormat(mix_format.ppv());
-    if (FAILED(ret)) {
-        PRINT_FAILED_RESULT("IAudioClient::GetMixFormat", ret);
-        return set_result(false);
-    }
-
-    log_info("audio::wasapi", "Mix Format:");
-    print_format(mix_format.data());
-
-    ret = client->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, mix_format.data(), nullptr);
-    if (ret == AUDCLNT_E_UNSUPPORTED_FORMAT) {
-        auto mix_format_ex = reinterpret_cast<WAVEFORMATEXTENSIBLE *>(mix_format.data());
-
-        log_warning("audio::wasapi", "device does not natively support the mix format, converting to PCM");
-
-        if (mix_format->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
-            IsEqualGUID(GUID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, mix_format_ex->SubFormat))
-        {
-            mix_format_ex->Format.wBitsPerSample = 16;
-            mix_format_ex->Format.nBlockAlign = mix_format_ex->Format.nChannels * (mix_format_ex->Format.wBitsPerSample / 8);
-            mix_format_ex->Format.nAvgBytesPerSec = mix_format_ex->Format.nSamplesPerSec * mix_format_ex->Format.nBlockAlign;
-            mix_format_ex->Samples.wValidBitsPerSample = 16;
-            mix_format_ex->SubFormat = GUID_KSDATAFORMAT_SUBTYPE_PCM;
-        } else if (mix_format->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) {
-            mix_format->wBitsPerSample = 16;
-            mix_format->nBlockAlign = mix_format->nChannels * (mix_format->wBitsPerSample / 8);
-            mix_format->nAvgBytesPerSec = mix_format->nSamplesPerSec * mix_format->nBlockAlign;
-            mix_format->wFormatTag = WAVE_FORMAT_PCM;
-        } else {
-            log_warning("audio::wasapi", "mix format is not a floating point format");
-            return set_result(false);
-        }
-
-        ret = client->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, mix_format.data(), nullptr);
-        if (FAILED(ret)) {
-            log_warning("audio::wasapi", "mix format is not supported");
-            return set_result(false);
-        }
-    }
-
-    ret = client->GetDevicePeriod(nullptr, &requested_duration);
-    if (FAILED(ret)) {
-        PRINT_FAILED_RESULT("IAudioClient::GetDevicePeriod", ret);
-        return false;
-    }
-
-    ret = client->Initialize(
-            AUDCLNT_SHAREMODE_EXCLUSIVE,
-            AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
-            requested_duration,
-            requested_duration,
-            mix_format.data(),
-            nullptr);
-
-    if (ret == AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED || SUCCEEDED(ret)) {
-        log_info("audio::wasapi", "exclusive mode is available, disabling backend");
-        return set_result(true);
-    } else {
-        log_warning("audio::wasapi", "exclusive mode is not available, enabling backend, hr={}", FMT_HRESULT(ret));
-    }
-
-    return set_result(false);
-}
-
-HRESULT wrap_audio_client(
-    IMMDevice *device,
-    DWORD cls_ctx,
-    PROPVARIANT *activation_params,
-    IAudioClient **audio_client)
-{
-    auto exclusive_available = check_for_exclusive_access(*audio_client);
-    (*audio_client)->Stop();
-    (*audio_client)->Reset();
-    (*audio_client)->Release();
-    *audio_client = nullptr;
-
-    SAFE_CALL("IMMDevice", "Activate", device->Activate(
-            IID_IAudioClient,
-            cls_ctx,
-            activation_params,
-            reinterpret_cast<void **>(audio_client)));
-*/
 IAudioClient *wrap_audio_client(IAudioClient *audio_client) {
+    log_misc("audio::wasapi", "wrapping IAudioClient");
+
     AudioBackend *backend = nullptr;
     bool requires_dummy = false;
 
@@ -164,9 +60,6 @@ IAudioClient *wrap_audio_client(IAudioClient *audio_client) {
                 break;
         }
     }
-    //} else if (!exclusive_available) {
-    //    backend = new WaveOutBackend();
-    //}
 
     IAudioClient *new_client;
 
@@ -182,6 +75,23 @@ IAudioClient *wrap_audio_client(IAudioClient *audio_client) {
 
     return new_client;
 }
+IAudioClient3 *wrap_audio_client3(IAudioClient3 *audio_client) {
+    // TODO: ASIO backend for IAudioClient3, if there is a game that needs it
+    log_misc("audio::wasapi", "wrapping IAudioClient3");
+
+    if (hooks::audio::BACKEND.has_value()) {
+        log_fatal(
+            "audio::wasapi",
+            "IAudioClient3 does not currently support backends! clear -audiobackend and try again");
+    }
+    if (hooks::audio::USE_DUMMY) {
+        log_fatal(
+            "audio::wasapi",
+            "IAudioClient3 does not currently support dummy context, clear -audiodummy and try again");
+    }
+
+    return new WrappedIAudioClient(audio_client, nullptr);
+}
 
 // IUnknown
 HRESULT STDMETHODCALLTYPE WrappedIAudioClient::QueryInterface(REFIID riid, void **ppvObj) {
@@ -190,8 +100,8 @@ HRESULT STDMETHODCALLTYPE WrappedIAudioClient::QueryInterface(REFIID riid, void
     }
 
     if (riid == IID_WrappedIAudioClient ||
-        riid == IID_IAudioClient)
-    {
+        riid == IID_IAudioClient ||
+        riid == IID_IAudioClient3) {
         this->AddRef();
         *ppvObj = this;
 
@@ -282,20 +192,6 @@ HRESULT STDMETHODCALLTYPE WrappedIAudioClient::Initialize(
     }
 
     log_info("audio::wasapi", "IAudioClient::Initialize success, hr={}", FMT_HRESULT(ret));
-
-    /*
-    if (ShareMode == AUDCLNT_SHAREMODE_SHARED) {
-        IAudioClockAdjustment *clock = nullptr;
-
-        SAFE_CALL("IAudioClient", "GetService", pReal->GetService(
-                IID_IAudioClockAdjustment,
-                reinterpret_cast<void **>(&clock)));
-
-        SAFE_CALL("IAudioClockAdjustment", "SetSampleRate", clock->SetSampleRate(
-                static_cast<float>(pFormat->nSamplesPerSec)));
-    }
-    */
-
     copy_wave_format(&hooks::audio::FORMAT, pFormat);
 
     return ret;
@@ -482,3 +378,93 @@ HRESULT STDMETHODCALLTYPE WrappedIAudioClient::GetService(REFIID riid, void **pp
 
     return ret;
 }
+
+HRESULT STDMETHODCALLTYPE WrappedIAudioClient::IsOffloadCapable(
+        AUDIO_STREAM_CATEGORY Category,
+        BOOL *pbOffloadCapable) {
+    WRAP_VERBOSE;
+
+    CHECK_RESULT(pReal3->IsOffloadCapable(Category, pbOffloadCapable));
+}
+
+HRESULT STDMETHODCALLTYPE WrappedIAudioClient::SetClientProperties( 
+    const AudioClientProperties *pProperties) {
+
+    WRAP_VERBOSE;
+    CHECK_RESULT(pReal3->SetClientProperties(pProperties));
+}
+
+HRESULT STDMETHODCALLTYPE WrappedIAudioClient::GetBufferSizeLimits( 
+    const WAVEFORMATEX *pFormat,
+    BOOL bEventDriven,
+    REFERENCE_TIME *phnsMinBufferDuration,
+    REFERENCE_TIME *phnsMaxBufferDuration) {
+
+    WRAP_VERBOSE;
+    CHECK_RESULT(pReal3->GetBufferSizeLimits(
+        pFormat,
+        bEventDriven,
+        phnsMinBufferDuration,
+        phnsMaxBufferDuration));
+}
+
+HRESULT STDMETHODCALLTYPE WrappedIAudioClient::GetSharedModeEnginePeriod( 
+    const WAVEFORMATEX *pFormat,
+    UINT32 *pDefaultPeriodInFrames,
+    UINT32 *pFundamentalPeriodInFrames,
+    UINT32 *pMinPeriodInFrames,
+    UINT32 *pMaxPeriodInFrames) {
+
+    WRAP_VERBOSE;
+    CHECK_RESULT(pReal3->GetSharedModeEnginePeriod(
+        pFormat,
+        pDefaultPeriodInFrames,
+        pFundamentalPeriodInFrames,
+        pMinPeriodInFrames,
+        pMaxPeriodInFrames));
+}
+
+HRESULT STDMETHODCALLTYPE WrappedIAudioClient::GetCurrentSharedModeEnginePeriod( 
+    WAVEFORMATEX **ppFormat,
+    UINT32 *pCurrentPeriodInFrames) {
+
+    WRAP_VERBOSE;
+    CHECK_RESULT(pReal3->GetCurrentSharedModeEnginePeriod(
+        ppFormat,
+        pCurrentPeriodInFrames));
+}
+
+HRESULT STDMETHODCALLTYPE WrappedIAudioClient::InitializeSharedAudioStream( 
+    DWORD StreamFlags,
+    UINT32 PeriodInFrames,
+    const WAVEFORMATEX *pFormat,
+    LPCGUID AudioSessionGuid) {
+
+    if (!pFormat) {
+        return E_POINTER;
+    }
+
+    // verbose output
+    log_info("audio::wasapi", "IAudioClient3::InitializeSharedAudioStream hook hit");
+    log_info("audio::wasapi", "... ShareMode         : {}", share_mode_str(AUDCLNT_SHAREMODE_SHARED));
+    log_info("audio::wasapi", "... StreamFlags       : {}", stream_flags_str(StreamFlags));
+    log_info("audio::wasapi", "... PeriodInFrames    : {}", PeriodInFrames);
+    print_format(pFormat);
+
+    // call next
+    HRESULT ret = pReal3->InitializeSharedAudioStream(
+        StreamFlags,
+        PeriodInFrames,
+        pFormat,
+        AudioSessionGuid);
+
+    // check for failure
+    if (FAILED(ret)) {
+        PRINT_FAILED_RESULT("IAudioClient3", "InitializeSharedAudioStream", ret);
+        return ret;
+    }
+
+    log_info("audio::wasapi", "IAudioClient3::InitializeSharedAudioStream success, hr={}", FMT_HRESULT(ret));
+    copy_wave_format(&hooks::audio::FORMAT, pFormat);
+    return ret;
+}

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

@@ -16,9 +16,16 @@ static const GUID IID_WrappedIAudioClient = {
 };
 
 IAudioClient *wrap_audio_client(IAudioClient *client);
+IAudioClient3 *wrap_audio_client3(IAudioClient3 *client);
 
-struct WrappedIAudioClient : IAudioClient {
-    explicit WrappedIAudioClient(IAudioClient *orig, AudioBackend *backend) : pReal(orig), backend(backend) {
+struct WrappedIAudioClient : IAudioClient3 {
+
+    explicit WrappedIAudioClient(IAudioClient3 *orig3, AudioBackend *backend) :
+        pReal(orig3), pReal3(orig3), backend(backend) {
+    }
+
+    explicit WrappedIAudioClient(IAudioClient *orig, AudioBackend *backend) :
+        pReal(orig), pReal3(nullptr), backend(backend) {
     }
 
     WrappedIAudioClient(const WrappedIAudioClient &) = delete;
@@ -47,9 +54,43 @@ struct WrappedIAudioClient : IAudioClient {
     HRESULT STDMETHODCALLTYPE GetService(REFIID riid, void **ppv) override;
 #pragma endregion
 
-    IAudioClient *const pReal;
-    AudioBackend *const backend;
+#pragma region IAudioClient2
+    HRESULT STDMETHODCALLTYPE IsOffloadCapable(
+        AUDIO_STREAM_CATEGORY Category,
+        BOOL *pbOffloadCapable) override;
 
+    HRESULT STDMETHODCALLTYPE SetClientProperties( 
+        const AudioClientProperties *pProperties) override;
+
+    HRESULT STDMETHODCALLTYPE GetBufferSizeLimits( 
+        const WAVEFORMATEX *pFormat,
+        BOOL bEventDriven,
+        REFERENCE_TIME *phnsMinBufferDuration,
+        REFERENCE_TIME *phnsMaxBufferDuration) override;
+#pragma endregion
+
+#pragma region IAudioClient3
+    HRESULT STDMETHODCALLTYPE GetSharedModeEnginePeriod( 
+        const WAVEFORMATEX *pFormat,
+        UINT32 *pDefaultPeriodInFrames,
+        UINT32 *pFundamentalPeriodInFrames,
+        UINT32 *pMinPeriodInFrames,
+        UINT32 *pMaxPeriodInFrames) override;
+    
+    HRESULT STDMETHODCALLTYPE GetCurrentSharedModeEnginePeriod( 
+        WAVEFORMATEX **ppFormat,
+        UINT32 *pCurrentPeriodInFrames) override;
+    
+    HRESULT STDMETHODCALLTYPE InitializeSharedAudioStream( 
+        DWORD StreamFlags,
+        UINT32 PeriodInFrames,
+        const WAVEFORMATEX *pFormat,
+        LPCGUID AudioSessionGuid) override;
+#pragma endregion
+
+    IAudioClient *const pReal;
+    IAudioClient3 *const pReal3;
+    AudioBackend *const backend;
     bool exclusive_mode = false;
     int frame_size = 0;
 };

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

@@ -149,5 +149,12 @@ LowLatencyAudioClient *LowLatencyAudioClient::Create(IMMDevice *device) {
     log_info("audio::lowlatency", "... max buffer size     : {} samples ({} ms)", maxPeriod, 1000.0f * maxPeriod / pFormat->nSamplesPerSec);
     log_info("audio::lowlatency", "... default buffer size : {} samples ({} ms)", defaultPeriod, 1000.0f * defaultPeriod / pFormat->nSamplesPerSec);
     log_info("audio::lowlatency", "... Windows will use minimum buffer size (instead of default) for shared mode audio clients from now on");
+    if (minPeriod < defaultPeriod) {
+        log_info("audio::lowlatency", "minimum period is less than default period, you will see latency improvement");
+    } else {
+        log_warning("audio::lowlatency", "minimum period is not less than default period, you will see NO latency improvement");
+        log_warning("audio::lowlatency", "this an audio driver / hardware limitation");
+    }
+
     return new LowLatencyAudioClient(audioClient);
 }

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

@@ -13,6 +13,7 @@
 
 #include "avs/game.h"
 #include "cfg/screen_resize.h"
+#include "games/gitadora/gitadora.h"
 #include "games/iidx/iidx.h"
 #include "games/sdvx/sdvx.h"
 #include "games/mfc/mfc.h"
@@ -812,6 +813,14 @@ HRESULT STDMETHODCALLTYPE WrappedIDirect3D9::CreateDevice(
             "either use -graphics-force-refresh option or change the desktop resolution beforehand.");
     }
 
+    if (!GRAPHICS_WINDOWED && num_adapters >= 2 && GRAPHICS_FORCE_REFRESH_SUB.has_value()) {
+        log_info("graphics::d3d9", "force sub refresh rate: {} => {} Hz (-graphics-force-refresh-sub option)",
+                pPresentationParameters[1].FullScreen_RefreshRateInHz,
+                GRAPHICS_FORCE_REFRESH_SUB.value());
+
+        pPresentationParameters[1].FullScreen_RefreshRateInHz = GRAPHICS_FORCE_REFRESH_SUB.value();
+    }
+
     // force single adapter
     if (GRAPHICS_FORCE_SINGLE_ADAPTER) {
         log_info("graphics::d3d9", "disabling adapter group device with force single adapter mode");
@@ -936,26 +945,37 @@ HRESULT STDMETHODCALLTYPE WrappedIDirect3D9::CreateDeviceEx(
 
     for (size_t i = 0; i < num_adapters; i++) {
         auto *params = &pPresentationParameters[i];
-        if (!GRAPHICS_WINDOWED && i == 0) {
-            GRAPHICS_FS_ORIGINAL_WIDTH = params->BackBufferWidth;
-            GRAPHICS_FS_ORIGINAL_HEIGHT = params->BackBufferHeight;
-            log_misc("graphics::d3d9", "original resolution: {}x{}", GRAPHICS_FS_ORIGINAL_WIDTH, GRAPHICS_FS_ORIGINAL_HEIGHT);
-            if (GRAPHICS_FS_CUSTOM_RESOLUTION.has_value()) {
+        if (!GRAPHICS_WINDOWED){
+            if (i == 0) {
+                GRAPHICS_FS_ORIGINAL_WIDTH = params->BackBufferWidth;
+                GRAPHICS_FS_ORIGINAL_HEIGHT = params->BackBufferHeight;
+                log_misc("graphics::d3d9", "original resolution: {}x{}", GRAPHICS_FS_ORIGINAL_WIDTH, GRAPHICS_FS_ORIGINAL_HEIGHT);
+                if (GRAPHICS_FS_CUSTOM_RESOLUTION.has_value()) {
+                    log_misc(
+                        "graphics::d3d9",
+                        "use custom resolution {}x{} => {}x{}",
+                        params->BackBufferWidth, params->BackBufferHeight,
+                        GRAPHICS_FS_CUSTOM_RESOLUTION.value().first,
+                        GRAPHICS_FS_CUSTOM_RESOLUTION.value().second);
+                    params->BackBufferWidth = GRAPHICS_FS_CUSTOM_RESOLUTION.value().first;
+                    params->BackBufferHeight = GRAPHICS_FS_CUSTOM_RESOLUTION.value().second;
+                } else if (GRAPHICS_FS_ORIENTATION_SWAP) {
+                    log_misc(
+                        "graphics::d3d9",
+                        "swap full orientation {}x{} => {}x{}",
+                        params->BackBufferWidth, params->BackBufferHeight,
+                        params->BackBufferHeight, params->BackBufferWidth);
+                    std::swap(params->BackBufferWidth, params->BackBufferHeight);
+                }
+            } else if (i == 1 && GRAPHICS_FS_CUSTOM_RESOLUTION_SUB.has_value()) {
                 log_misc(
                     "graphics::d3d9",
-                    "use custom resolution {}x{} => {}x{}",
+                    "use custom sub resolution {}x{} => {}x{}",
                     params->BackBufferWidth, params->BackBufferHeight,
-                    GRAPHICS_FS_CUSTOM_RESOLUTION.value().first,
-                    GRAPHICS_FS_CUSTOM_RESOLUTION.value().second);
-                params->BackBufferWidth = GRAPHICS_FS_CUSTOM_RESOLUTION.value().first;
-                params->BackBufferHeight = GRAPHICS_FS_CUSTOM_RESOLUTION.value().second;
-            } else if (GRAPHICS_FS_ORIENTATION_SWAP) {
-                log_misc(
-                    "graphics::d3d9",
-                    "swap full orientation {}x{} => {}x{}",
-                    params->BackBufferWidth, params->BackBufferHeight,
-                    params->BackBufferHeight, params->BackBufferWidth);
-                std::swap(params->BackBufferWidth, params->BackBufferHeight);
+                    GRAPHICS_FS_CUSTOM_RESOLUTION_SUB.value().first,
+                    GRAPHICS_FS_CUSTOM_RESOLUTION_SUB.value().second);
+                params->BackBufferWidth = GRAPHICS_FS_CUSTOM_RESOLUTION_SUB.value().first;
+                params->BackBufferHeight = GRAPHICS_FS_CUSTOM_RESOLUTION_SUB.value().second;
             }
         }
 
@@ -983,12 +1003,17 @@ HRESULT STDMETHODCALLTYPE WrappedIDirect3D9::CreateDeviceEx(
         for (size_t i = 0; i < num_adapters; i++) {
             auto *fullscreen_display_mode = &pFullscreenDisplayMode[i];
 
-            if (!GRAPHICS_WINDOWED && i == 0) {
-                if (GRAPHICS_FS_CUSTOM_RESOLUTION.has_value()) {
-                    fullscreen_display_mode->Width = GRAPHICS_FS_CUSTOM_RESOLUTION.value().first;
-                    fullscreen_display_mode->Height = GRAPHICS_FS_CUSTOM_RESOLUTION.value().second;
-                } else if (GRAPHICS_FS_ORIENTATION_SWAP) {
-                    std::swap(fullscreen_display_mode->Width, fullscreen_display_mode->Height);
+            if (!GRAPHICS_WINDOWED) {
+                if (i == 0) {
+                    if (GRAPHICS_FS_CUSTOM_RESOLUTION.has_value()) {
+                        fullscreen_display_mode->Width = GRAPHICS_FS_CUSTOM_RESOLUTION.value().first;
+                        fullscreen_display_mode->Height = GRAPHICS_FS_CUSTOM_RESOLUTION.value().second;
+                    } else if (GRAPHICS_FS_ORIENTATION_SWAP) {
+                        std::swap(fullscreen_display_mode->Width, fullscreen_display_mode->Height);
+                    }
+                } else if (i == 1 && GRAPHICS_FS_CUSTOM_RESOLUTION_SUB.has_value()) {
+                    fullscreen_display_mode->Width = GRAPHICS_FS_CUSTOM_RESOLUTION_SUB.value().first;
+                    fullscreen_display_mode->Height = GRAPHICS_FS_CUSTOM_RESOLUTION_SUB.value().second;
                 }
             }
 
@@ -1031,6 +1056,17 @@ HRESULT STDMETHODCALLTYPE WrappedIDirect3D9::CreateDeviceEx(
         }
     }
 
+    if (!GRAPHICS_WINDOWED && num_adapters >= 2 && GRAPHICS_FORCE_REFRESH_SUB.has_value()) {
+        log_info("graphics::d3d9", "force sub refresh rate: {} => {} Hz (-graphics-force-refresh-sub option)",
+                pPresentationParameters[1].FullScreen_RefreshRateInHz,
+                GRAPHICS_FORCE_REFRESH_SUB.value());
+
+        pPresentationParameters[1].FullScreen_RefreshRateInHz = GRAPHICS_FORCE_REFRESH_SUB.value();
+        if (pFullscreenDisplayMode) {
+            pFullscreenDisplayMode[1].RefreshRate = GRAPHICS_FORCE_REFRESH_SUB.value();
+        }
+    }
+
     // force single adapter
     if (GRAPHICS_FORCE_SINGLE_ADAPTER) {
         log_info("graphics::d3d9", "disabling adapter group device with force single adapter mode");
@@ -1151,9 +1187,15 @@ IDirect3DSurface9 *graphics_d3d9_ldj_get_sub_screen() {
 }
 
 static void graphics_d3d9_ldj_on_present(IDirect3DDevice9 *wrapped_device) {
+    // iidx/sdvx
+    int swapchain = 1;
+    if (games::gitadora::is_arena_model()) {
+        swapchain = 3;
+    }
+
     if (!ATTEMPTED_SUB_SWAP_CHAIN_ACQUIRE && SUB_SWAP_CHAIN == nullptr) {
         ATTEMPTED_SUB_SWAP_CHAIN_ACQUIRE = true;
-        HRESULT hr = wrapped_device->GetSwapChain(1, &SUB_SWAP_CHAIN);
+        HRESULT hr = wrapped_device->GetSwapChain(swapchain, &SUB_SWAP_CHAIN);
         if (FAILED(hr)) {
             log_warning(
                 "graphics::d3d9",
@@ -1364,7 +1406,9 @@ void graphics_d3d9_on_present(
     // for IIDX TDJ / SDVX UFC, handle subscreen
     const bool is_vm = games::sdvx::is_valkyrie_model();
     const bool is_tdj = avs::game::is_model("LDJ") && games::iidx::TDJ_MODE;
-    if (is_vm || is_tdj) {
+    const bool is_gfdm_arena =
+        games::gitadora::is_arena_model() && games::gitadora::ARENA_SINGLE_WINDOW;
+    if (is_vm || is_tdj || is_gfdm_arena) {
         graphics_d3d9_ldj_on_present(wrapped_device);
     }
 

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

@@ -4,6 +4,7 @@
 #include <mutex>
 
 #include "avs/game.h"
+#include "games/gitadora/gitadora.h"
 #include "hooks/graphics/graphics.h"
 #include "overlay/overlay.h"
 #include "util/flags_helper.h"
@@ -249,8 +250,16 @@ HRESULT STDMETHODCALLTYPE WrappedIDirect3DDevice9::CreateAdditionalSwapChain(
     WRAP_VERBOSE;
 
     HRESULT hr = pReal->CreateAdditionalSwapChain(pPresentationParameters, ppSwapChain);
-
+    bool create_swap_chain = false;
     if (avs::game::is_model({"LDJ", "KFC"})) {
+        create_swap_chain = true;
+    } else if (games::gitadora::is_arena_model() &&
+        games::gitadora::ARENA_SINGLE_WINDOW &&
+        pPresentationParameters->BackBufferWidth == 800) {
+        create_swap_chain = true;
+    }
+
+    if (create_swap_chain) {
         if (SUCCEEDED(hr) && !sub_swapchain) {
             sub_swapchain = new WrappedIDirect3DSwapChain9(this, *ppSwapChain);
             sub_swapchain->should_run_hooks = false;
@@ -295,7 +304,17 @@ HRESULT STDMETHODCALLTYPE WrappedIDirect3DDevice9::GetSwapChain(
         return D3D_OK;
     }
 
+    bool swap = false;
     if (iSwapChain == 1 && avs::game::is_model({"LDJ", "KFC"})) {
+        swap = true;
+    }
+    if (games::gitadora::is_arena_model() &&
+        games::gitadora::ARENA_SINGLE_WINDOW &&
+        iSwapChain == 3) {
+        swap = true;
+    }
+
+    if (swap) {
         if (sub_swapchain) {
             sub_swapchain->AddRef();
             *ppSwapChain = static_cast<IDirect3DSwapChain9 *>(sub_swapchain);
@@ -742,14 +761,12 @@ void SurfaceHook(IDirect3DDevice9 *pReal) {
     const int w = param.BackBufferWidth;
     const int h = param.BackBufferHeight;
 
-    if (cfg::SCREENRESIZE->enable_screen_resize) {
-        RECT rect {
-            0,
-            0,
-            (LONG)topSurface_width,
-            (LONG)topSurface_height,
-        };
-        pReal->ColorFill(topSurface, &rect, D3DCOLOR_XRGB(0, 0, 0));
+    // this code used to clear the surface using ColorFill on every call, but
+    // this turned out to be very expensive, leading to major frame drops in
+    // SDVX Live2D scenario
+    if (cfg::SCREENRESIZE->need_surface_clean) {
+        pReal->ColorFill(topSurface, nullptr, D3DCOLOR_XRGB(0, 0, 0));
+        cfg::SCREENRESIZE->need_surface_clean = false;
     }
     
     D3DLOCKED_RECT rect;

src/spice2x/hooks/graphics/graphics.cpp

@@ -61,8 +61,8 @@ bool GRAPHICS_SHOW_CURSOR = false;
 graphics_orientation GRAPHICS_ADJUST_ORIENTATION = ORIENTATION_NORMAL;
 bool GRAPHICS_WINDOWED = false;
 std::vector<HWND> GRAPHICS_WINDOWS;
-std::optional<HWND> GRAPHICS_WINDOW_MAIN;
 UINT GRAPHICS_FORCE_REFRESH = 0;
+std::optional<uint32_t> GRAPHICS_FORCE_REFRESH_SUB;
 std::optional<int> GRAPHICS_FORCE_VSYNC_BUFFER;
 bool GRAPHICS_FORCE_SINGLE_ADAPTER = false;
 bool GRAPHICS_PREVENT_SECONDARY_WINDOW = false;
@@ -71,6 +71,7 @@ bool GRAPHICS_9_ON_12_REQUESTED_BY_GAME = false;
 bool SUBSCREEN_FORCE_REDRAW = false;
 bool D3D9_DEVICE_HOOK_DISABLE = false;
 std::optional<std::pair<uint32_t, uint32_t>> GRAPHICS_FS_CUSTOM_RESOLUTION;
+std::optional<std::pair<uint32_t, uint32_t>> GRAPHICS_FS_CUSTOM_RESOLUTION_SUB;
 bool GRAPHICS_FS_ORIENTATION_SWAP = false;
 uint32_t GRAPHICS_FS_ORIGINAL_WIDTH = 0;
 uint32_t GRAPHICS_FS_ORIGINAL_HEIGHT = 0;
@@ -97,6 +98,7 @@ static decltype(SetCursor) *SetCursor_orig = nullptr;
 static decltype(SetWindowLongA) *SetWindowLongA_orig = nullptr;
 static decltype(SetWindowLongW) *SetWindowLongW_orig = nullptr;
 static decltype(SetWindowPos) *SetWindowPos_orig = nullptr;
+static decltype(ShowWindow) *ShowWindow_orig = nullptr;
 
 static void reset_window_hook(HWND hWnd) {
     overlay::destroy(hWnd);
@@ -299,6 +301,30 @@ static BOOL WINAPI ClipCursor_hook(const RECT *lpRect) {
     return ClipCursor_orig(lpRect);
 }
 
+static void fix_up_rb_auto_rotate_dimensions(DWORD &w, DWORD &h) {
+    // reflec beat
+    // for whatever reason, rb creates the first window it weird dimensions (774x1389 for reflesia, for example)
+    // so doing ChangeDisplaySettings as-is ends up with DISP_CHANGE_BADMODE
+    // while a second window (with title D3DProxyWindow) does get created with correct dimensions, it's
+    // too late to rotate the window then; as a workaround force the display change now with patched up dimensions
+
+    bool changed = false;
+    if (w == 774) {
+        // LBR, MBR reflesia
+        w = 768;
+        h = 1360;
+        changed = true;
+    } else if (w == 1086) {
+        // MBR (before reflesia)
+        w = 1080;
+        h = 1920;
+        changed = true;
+    }
+    if (changed) {
+        log_misc("graphics", "fix auto-rotate dimensions for reflec beat: w={}, h={}", w, h);
+    }
+}
+
 static HWND WINAPI CreateWindowExA_hook(DWORD dwExStyle, LPCSTR lpClassName, LPCSTR lpWindowName,
                                         DWORD dwStyle, int x, int y, int nWidth, int nHeight,
                                         HWND hWndParent, HMENU hMenu, HINSTANCE hInstance,
@@ -323,10 +349,19 @@ static HWND WINAPI CreateWindowExA_hook(DWORD dwExStyle, LPCSTR lpClassName, LPC
     // set display orientation and/or refresh rate
     // only set orientation when the target window is portrait
     // (avoid doing this for SDVX subscreen which is in landscape, for example)
-    const auto adjust_orientation =
+    auto adjust_orientation =
         (GRAPHICS_ADJUST_ORIENTATION == ORIENTATION_CW ||
          GRAPHICS_ADJUST_ORIENTATION == ORIENTATION_CCW);
 
+    // reflec beat
+    if (avs::game::is_model("KBR")) {
+        // KBR (rb1) launches landscape and draws rotated by itself, don't do any rotation
+        adjust_orientation = false;
+    } else if (avs::game::is_model({"LBR", "MBR"}) && window_name == "D3DProxyWindow") {
+        // do not auto-rotate for second window (D3DProxyWindow)
+        adjust_orientation = false;
+    }
+
     if ((nHeight > nWidth && adjust_orientation) || GRAPHICS_FORCE_REFRESH > 0) {
         DEVMODE mode {};
 
@@ -336,11 +371,16 @@ static HWND WINAPI CreateWindowExA_hook(DWORD dwExStyle, LPCSTR lpClassName, LPC
                 DWORD orientation = GRAPHICS_ADJUST_ORIENTATION == ORIENTATION_CW ? DMDO_90 : DMDO_270;
                 log_misc(
                     "graphics",
-                    "auto-rotate: call ChangeDisplaySettings and rotate display to DMDO_xx mode {}",
-                    orientation);
+                    "auto-rotate: call ChangeDisplaySettings and rotate display to DMDO_xx mode {}, w={}, h={}",
+                    orientation, nWidth, nHeight);
                 mode.dmPelsWidth = nWidth;
                 mode.dmPelsHeight = nHeight;
                 mode.dmDisplayOrientation = orientation;
+
+                // reflec beat
+                if (avs::game::is_model({"LBR", "MBR"})) {
+                    fix_up_rb_auto_rotate_dimensions(mode.dmPelsWidth, mode.dmPelsHeight);
+                }
             }
 
             if (GRAPHICS_FORCE_REFRESH > 0) {
@@ -355,7 +395,7 @@ static HWND WINAPI CreateWindowExA_hook(DWORD dwExStyle, LPCSTR lpClassName, LPC
 
             const auto disp_res = ChangeDisplaySettings(&mode, CDS_FULLSCREEN);
             if (disp_res != DISP_CHANGE_SUCCESSFUL) {
-                log_warning("graphics", "failed to change display settings: {}", disp_res);
+                log_warning("graphics", "ChangeDisplaySettings failed: {}", disp_res);
             }
         } else {
             log_warning("graphics", "failed to get display settings");
@@ -363,12 +403,10 @@ static HWND WINAPI CreateWindowExA_hook(DWORD dwExStyle, LPCSTR lpClassName, LPC
     }
 
     // gfdm
-    bool is_gitadora_main_window = false;
     if (avs::game::is_model({"J32", "J33", "K32", "K33", "L32", "L33", "M32"})) {
         // set window name
         if (!lpWindowName) {
             lpWindowName = "GITADORA";
-            is_gitadora_main_window = true;
         }
     }
 
@@ -376,7 +414,7 @@ static HWND WINAPI CreateWindowExA_hook(DWORD dwExStyle, LPCSTR lpClassName, LPC
     bool is_sdvx_sub_window = avs::game::is_model("KFC") && window_name.ends_with(" Sub Screen");
     bool is_gfdm_sub_window = games::gitadora::is_arena_model() && window_name.ends_with("SMALL");
 
-    // TDJ windowed mode with subscreen: hide maximize button
+    // hide maximize button (prevent misaligned touches)
     if ((is_tdj_sub_window && GRAPHICS_IIDX_WSUB) || is_sdvx_sub_window || is_gfdm_sub_window) {
         dwStyle &= ~(WS_MAXIMIZEBOX);
     }
@@ -384,7 +422,7 @@ static HWND WINAPI CreateWindowExA_hook(DWORD dwExStyle, LPCSTR lpClassName, LPC
     if (is_gfdm_sub_window) {
         dwStyle &= ~(WS_SIZEBOX);
     }
-    if ((is_tdj_sub_window || is_sdvx_sub_window || is_gfdm_sub_window) && GRAPHICS_WSUB_BORDERLESS) {
+    if ((is_tdj_sub_window || is_sdvx_sub_window) && GRAPHICS_WSUB_BORDERLESS) {
         dwStyle &= ~(WS_OVERLAPPEDWINDOW);
     }
 
@@ -411,11 +449,6 @@ static HWND WINAPI CreateWindowExA_hook(DWORD dwExStyle, LPCSTR lpClassName, LPC
             hWndParent, hMenu, hInstance, lpParam);
     GRAPHICS_WINDOWS.push_back(result);
 
-    // this is only really needed for arena model, but pre-arena model was single window anyway
-    if (is_gitadora_main_window) {
-        GRAPHICS_WINDOW_MAIN = result;
-    }
-
     if (is_tdj_sub_window) {
         // TDJ windowed mode: remember the subscreen window handle for later
         TDJ_SUBSCREEN_WINDOW = result;
@@ -432,13 +465,19 @@ static HWND WINAPI CreateWindowExA_hook(DWORD dwExStyle, LPCSTR lpClassName, LPC
         graphics_hook_subscreen_window(SDVX_SUBSCREEN_WINDOW);
     }
 
-    if (is_gfdm_sub_window) {
+    // only hook touch window if multiple windows are allowed
+    if (is_gfdm_sub_window && !games::gitadora::ARENA_SINGLE_WINDOW) {
         GFDM_SUBSCREEN_WINDOW = result;
         graphics_hook_subscreen_window(GFDM_SUBSCREEN_WINDOW);
     }
 
     disable_touch_indicators(result);
-    log_misc("graphics", "CreateWindowExA returned {}", fmt::ptr(result));
+    log_misc(
+        "graphics",
+        "CreateWindowExA returned {}, {}",
+        fmt::ptr(result),
+        lpWindowName ? lpWindowName : "(null)");
+
     return result;
 }
 
@@ -470,7 +509,8 @@ static HWND WINAPI CreateWindowExW_hook(DWORD dwExStyle, LPCWSTR lpClassName, LP
         }
 
         // windowed mode adjustments
-        if (GRAPHICS_WINDOWED) {
+        // check the width to filter out invisible system-created windows
+        if (GRAPHICS_WINDOWED && nWidth > 0) {
 
             // change window style
             dwExStyle = 0;
@@ -505,7 +545,12 @@ static HWND WINAPI CreateWindowExW_hook(DWORD dwExStyle, LPCWSTR lpClassName, LP
             hWndParent, hMenu, hInstance, lpParam);
     GRAPHICS_WINDOWS.push_back(result);
 
-    log_misc("graphics", "CreateWindowExW returned {}", fmt::ptr(result));
+    log_misc(
+        "graphics",
+        "CreateWindowExW returned {}, {}",
+        fmt::ptr(result),
+        lpWindowName ? ws2s(lpWindowName) : "(null)");
+
     disable_touch_indicators(result);
     return result;
 }
@@ -672,7 +717,7 @@ static BOOL WINAPI SetWindowPos_hook(HWND hWnd, HWND hWndInsertAfter,
 
     // prevent gitadora arena model from shifting windows around if the user has preferences
     if (GRAPHICS_WINDOWED && games::gitadora::is_arena_model() &&
-        GRAPHICS_WINDOW_MAIN.has_value() && hWnd == GRAPHICS_WINDOW_MAIN.value() &&
+        GRAPHICS_HOOKED_WINDOW.has_value() && hWnd == GRAPHICS_HOOKED_WINDOW.value() &&
         cfg::SCREENRESIZE->enable_window_resize) {
         return TRUE;
     }
@@ -681,6 +726,18 @@ static BOOL WINAPI SetWindowPos_hook(HWND hWnd, HWND hWndInsertAfter,
     return SetWindowPos_orig(hWnd, hWndInsertAfter, X, Y, cx, cy, uFlags);
 }
 
+static BOOL WINAPI ShowWindow_hook(HWND hWnd, int nCmdShow) {
+    if (games::gitadora::is_arena_model() &&
+        games::gitadora::ARENA_SINGLE_WINDOW &&
+        hWnd != GRAPHICS_HOOKED_WINDOW) {
+        log_info("graphics", "ShowWindow_hook - hiding sub window {}", fmt::ptr(hWnd));
+        return true;
+    }
+
+    // call original
+    return ShowWindow_orig(hWnd, nCmdShow);
+}
+
 static ATOM WINAPI RegisterClassA_hook(const WNDCLASSA *lpWndClass) {
 
     // check for null
@@ -823,6 +880,7 @@ void graphics_init() {
     SetWindowLongA_orig = detour::iat_try("SetWindowLongA", SetWindowLongA_hook);
     SetWindowLongW_orig = detour::iat_try("SetWindowLongW", SetWindowLongW_hook);
     SetWindowPos_orig = detour::iat_try("SetWindowPos", SetWindowPos_hook);
+    ShowWindow_orig = detour::iat_try("ShowWindow", ShowWindow_hook);
 
     detour::iat_try("MessageBoxA", MessageBoxA_hook);
     detour::iat_try("MessageBoxExA", MessageBoxExA_hook);

src/spice2x/hooks/graphics/graphics.h

@@ -31,12 +31,13 @@ extern bool GRAPHICS_SHOW_CURSOR;
 extern bool GRAPHICS_WINDOWED;
 extern graphics_orientation GRAPHICS_ADJUST_ORIENTATION;
 extern std::vector<HWND> GRAPHICS_WINDOWS;
-extern std::optional<HWND> GRAPHICS_WINDOW_MAIN;
 extern UINT GRAPHICS_FORCE_REFRESH;
+extern std::optional<uint32_t> GRAPHICS_FORCE_REFRESH_SUB;
 extern std::optional<int> GRAPHICS_FORCE_VSYNC_BUFFER;
 extern bool GRAPHICS_FORCE_SINGLE_ADAPTER;
 extern bool GRAPHICS_PREVENT_SECONDARY_WINDOW;
 extern std::optional<std::pair<uint32_t, uint32_t>> GRAPHICS_FS_CUSTOM_RESOLUTION;
+extern std::optional<std::pair<uint32_t, uint32_t>> GRAPHICS_FS_CUSTOM_RESOLUTION_SUB;
 extern bool GRAPHICS_FS_ORIENTATION_SWAP;
 extern uint32_t GRAPHICS_FS_ORIGINAL_WIDTH;
 extern uint32_t GRAPHICS_FS_ORIGINAL_HEIGHT;
@@ -49,6 +50,7 @@ extern std::optional<std::pair<uint32_t, uint32_t>> GRAPHICS_WINDOW_SIZE;
 extern std::optional<std::string> GRAPHICS_WINDOW_POS;
 extern bool GRAPHICS_WINDOW_ALWAYS_ON_TOP;
 extern bool GRAPHICS_WINDOW_BACKBUFFER_SCALE;
+extern std::optional<HWND> GRAPHICS_HOOKED_WINDOW;
 
 extern bool GRAPHICS_IIDX_WSUB;
 extern std::optional<std::string> GRAPHICS_WSUB_SIZE;
@@ -100,5 +102,8 @@ void graphics_capture_initial_window(HWND hWnd);
 void graphics_update_window_style(HWND hWnd);
 void graphics_update_z_order(HWND hWnd, bool always_on_top);
 void graphics_move_resize_window(HWND hWnd);
-bool graphics_window_change_crashes_game();
+bool graphics_window_options_breaks_game();
+bool graphics_window_decoration_change_crashes_game();
+bool graphics_window_resize_breaks_game();
+bool graphics_window_move_and_resize_breaks_game();
 void graphics_load_windowed_subscreen_parameters();

src/spice2x/hooks/graphics/graphics_windowed.cpp

@@ -1,6 +1,7 @@
 #include "graphics.h"
 
 #include "avs/game.h"
+#include "games/gitadora/gitadora.h"
 #include "cfg/screen_resize.h"
 #include "overlay/overlay.h"
 #include "util/logging.h"
@@ -23,6 +24,7 @@ std::optional<std::pair<uint32_t, uint32_t>> GRAPHICS_WINDOW_SIZE;
 std::optional<std::string> GRAPHICS_WINDOW_POS;
 bool GRAPHICS_WINDOW_ALWAYS_ON_TOP = false;
 bool GRAPHICS_WINDOW_BACKBUFFER_SCALE = false;
+std::optional<HWND> GRAPHICS_HOOKED_WINDOW;
 
 // IIDX Windowed Subscreen - starts out as false, enabled by IIDX module on pre-attach as needed
 bool GRAPHICS_IIDX_WSUB = false;
@@ -55,6 +57,8 @@ void graphics_capture_initial_window(HWND hWnd) {
 
     graphics_load_windowed_parameters();
 
+    GRAPHICS_HOOKED_WINDOW = hWnd;
+
     cfg::SCREENRESIZE->init_window_style = GetWindowLong(hWnd, GWL_STYLE);
     cfg::SCREENRESIZE->init_window_style_ex = GetWindowLong(hWnd, GWL_EXSTYLE);
 
@@ -66,8 +70,9 @@ void graphics_capture_initial_window(HWND hWnd) {
     RECT rect;
     if (!GetClientRect(hWnd, &rect)) {
         log_warning(
-            "graphics",
-            "graphics_capture_initial_window - GetClientRect failed, GLE: {}",
+            "graphics-windowed",
+            "[{}] graphics_capture_initial_window - GetClientRect failed, GLE: {}",
+            fmt::ptr(hWnd),
             GetLastError());
         return;
     }
@@ -79,12 +84,22 @@ void graphics_capture_initial_window(HWND hWnd) {
     cfg::SCREENRESIZE->init_client_aspect_ratio = (float)client_w / (float)client_h;
     log_debug(
         "graphics-windowed",
-        "graphics_capture_initial_window initial window size {}x{}, ratio {}",
+        "[{}] graphics_capture_initial_window initial window size {}x{}, ratio {}",
+        fmt::ptr(hWnd),
         client_w, client_h, cfg::SCREENRESIZE->init_client_aspect_ratio);
 
     // ensure frame size is captured
     graphics_wm_style_changed(hWnd, false);
 
+    // if the game is not compatible, ignore user-supplied values and keep the current size
+    if (graphics_window_resize_breaks_game()) {
+        cfg::SCREENRESIZE->client_width = client_w;
+        cfg::SCREENRESIZE->client_height = client_h;
+    }
+    if (graphics_window_move_and_resize_breaks_game()) {
+        cfg::SCREENRESIZE->enable_window_resize = false;
+    }
+
     // if there was no user-supplied dimension, seed it with the current size
     // so that the next resize operation will work
     if (cfg::SCREENRESIZE->client_width == 0) {
@@ -98,7 +113,8 @@ void graphics_capture_initial_window(HWND hWnd) {
     // resize must be done before applying the border
     if (cfg::SCREENRESIZE->enable_window_resize) {
         log_info(
-            "graphics-windowed", "change window rect - window offset: {}x{}, client size: {}x{}",
+            "graphics-windowed", "[{}] change window rect - window offset: {}x{}, client size: {}x{}",
+            fmt::ptr(hWnd),
             cfg::SCREENRESIZE->window_offset_x,
             cfg::SCREENRESIZE->window_offset_y,
             cfg::SCREENRESIZE->client_width,
@@ -108,12 +124,13 @@ void graphics_capture_initial_window(HWND hWnd) {
     // ddr hangs when window frame doesn't have overlapped
     if (cfg::SCREENRESIZE->window_decoration != cfg::WindowDecorationMode::Default) {
         log_info(
-            "graphics-windowed", "change window style - decoration: {}",
+            "graphics-windowed", "[{}] change window style - decoration: {}",
+            fmt::ptr(hWnd),
             cfg::SCREENRESIZE->window_decoration);
         graphics_update_window_style(hWnd);
     }
     if (cfg::SCREENRESIZE->window_always_on_top) {
-        log_info("graphics-windowed", "change window z-order - always on top");
+        log_info("graphics-windowed", "[{}] change window z-order - always on top", fmt::ptr(hWnd));
         graphics_update_z_order(hWnd, true);
     }
 
@@ -156,7 +173,7 @@ void graphics_load_windowed_parameters() {
             cfg::SCREENRESIZE->window_offset_x = result.first;
             cfg::SCREENRESIZE->window_offset_y = result.second;
         } else {
-            log_warning("graphics-windowed", "failed to parse -windowpos");
+            log_fatal("graphics-windowed", "failed to parse -windowpos");
         }
     }
 
@@ -185,7 +202,7 @@ void graphics_load_windowed_subscreen_parameters() {
             GRAPHICS_WSUB_WIDTH = result.first;
             GRAPHICS_WSUB_HEIGHT = result.second;
         } else {
-            log_warning("graphics-windowed", "failed to parse -wsubsize");
+            log_fatal("graphics-windowed", "failed to parse -iidxwsubsize / -sdvxwsubsize");
         }
     }
 
@@ -199,7 +216,7 @@ void graphics_load_windowed_subscreen_parameters() {
             GRAPHICS_WSUB_X = result.first;
             GRAPHICS_WSUB_Y = result.second;
         } else {
-            log_warning("graphics-windowed", "failed to parse -wsubpos");
+            log_fatal("graphics-windowed", "failed to parse -iidxwsubpos / -sdvxwsubpos");
         }
     }
 }
@@ -372,7 +389,7 @@ void graphics_update_window_style(HWND hWnd) {
     if (!GRAPHICS_WINDOWED) {
         return;
     }
-    if (graphics_window_change_crashes_game()) {
+    if (graphics_window_decoration_change_crashes_game()) {
         return;
     }
 
@@ -392,6 +409,9 @@ void graphics_update_window_style(HWND hWnd) {
             break;
         case cfg::WindowDecorationMode::ResizableFrame:
             style |= WS_OVERLAPPEDWINDOW;
+            if (graphics_window_resize_breaks_game()) {
+                style &= ~WS_SIZEBOX;
+            }
             break;
         case cfg::WindowDecorationMode::Default:
         default:
@@ -479,12 +499,19 @@ void graphics_move_resize_window(HWND hWnd) {
     log_debug("graphics-windowed", "graphics_move_resize_window returned");
 }
 
-bool graphics_window_change_crashes_game() {
+bool graphics_window_decoration_change_crashes_game() {
     static std::once_flag flag;
     static bool result = false;
     std::call_once(flag, []() {
         // ddr crashes when frame style changes
         result = avs::game::is_model("MDX");
+
+        // changing window decoration also changes dimensions and position
+        // so this must be prevented
+        if (graphics_window_move_and_resize_breaks_game()) {
+            result = true;
+        }
+
         if (result) {
             log_warning(
                 "graphics-windowed",
@@ -493,3 +520,43 @@ bool graphics_window_change_crashes_game() {
     });
     return result;
 }
+
+bool graphics_window_move_and_resize_breaks_game() {
+    static std::once_flag flag;
+    static bool result = false;
+
+    std::call_once(flag, []() {
+        // games like reflec beat in use spice touch overlay for windowed mode
+        // and mouse input breaks if window is moved as the overlay does not
+        // currently support window moves/resizes
+        result = avs::game::is_model({"KBR", "LBR", "MBR"});
+        if (result) {
+            log_warning(
+                "graphics-windowed",
+                "ignoring changes to window properties due to incompatibility with this game");
+        }
+    });
+    return result;
+}
+
+bool graphics_window_resize_breaks_game() {
+    // for whatever reason, gitadora games on dx/sd/sd2 cabs behave poorly when window is resized
+    // (eihter at launch or while it's running)
+    // usually results in: soft lock during scene transtions or really long transitions,
+    // backgrounds of menus not rendering, etc.
+    bool is_gitadora = avs::game::is_model({ "J32", "J33", "K32", "K33", "L32", "L33", "M32" });
+    bool is_arena = games::gitadora::is_arena_model();
+
+    bool result = graphics_window_move_and_resize_breaks_game() || (is_gitadora && !is_arena);
+
+    static std::once_flag flag;
+    std::call_once(flag, [&result]() {
+        if (result) {
+            log_warning(
+                "graphics-windowed",
+                "ignoring changes to window size due to incompatibility with this game");
+        }
+    });
+
+    return result;
+}

src/spice2x/launcher/launcher.cpp

@@ -107,6 +107,7 @@
 #include "util/libutils.h"
 #include "util/logging.h"
 #include "util/peb.h"
+#include "util/socd_cleaner.h"
 #include "util/sysutils.h"
 #include "util/tapeled.h"
 #include "util/time.h"
@@ -326,6 +327,10 @@ int main_implementation(int argc, char *argv[]) {
     if (options[launcher::Options::GraphicsForceRefresh].is_active()) {
         GRAPHICS_FORCE_REFRESH = options[launcher::Options::GraphicsForceRefresh].value_uint32();
     }
+    if (options[launcher::Options::FullscreenSubRefreshRate].is_active()) {
+        GRAPHICS_FORCE_REFRESH_SUB =
+            options[launcher::Options::FullscreenSubRefreshRate].value_uint32();
+    }
     if (options[launcher::Options::GraphicsForceSingleAdapter].value_bool()) {
         GRAPHICS_FORCE_SINGLE_ADAPTER = true;
     }
@@ -584,6 +589,25 @@ int main_implementation(int argc, char *argv[]) {
     if (options[launcher::Options::GitaDoraCabinetType].is_active()) {
         games::gitadora::CAB_TYPE = options[launcher::Options::GitaDoraCabinetType].value_uint32();
     }
+    if (options[launcher::Options::GitaDoraArenaSingleWindow].value_bool() && GRAPHICS_WINDOWED) {
+        games::gitadora::ARENA_SINGLE_WINDOW = true;
+    }
+    if (options[launcher::Options::GitaDoraWailHold].is_active()) {
+        socd::TILT_HOLD_MS = options[launcher::Options::GitaDoraWailHold].value_uint32();
+    }
+    if (options[launcher::Options::GitaDoraPickAlgo].is_active()) {
+        const auto text = options[launcher::Options::GitaDoraPickAlgo].value_text();
+        if (text == "legacy") {
+            games::gitadora::PICK_ALGO.reset();
+        } else if (text == "neutral") {
+            games::gitadora::PICK_ALGO = socd::SocdAlgorithm::Neutral;
+        } else if (text == "raw") {
+            games::gitadora::PICK_ALGO = socd::SocdAlgorithm::None;
+        }
+    }
+    if (options[launcher::Options::GitaDoraSubOverlaySize].is_active()) {
+        games::gitadora::SUBSCREEN_OVERLAY_SIZE = options[launcher::Options::GitaDoraSubOverlaySize].value_text();
+    }
     if (options[launcher::Options::LoadNostalgiaModule].value_bool()) {
         attach_nostalgia = true;
     }
@@ -605,6 +629,17 @@ int main_implementation(int argc, char *argv[]) {
     if (options[launcher::Options::GitaDoraTwoChannelAudio].value_bool()) {
         games::gitadora::TWOCHANNEL = true;
     }
+    if (options[launcher::Options::GitaDoraLefty].is_active()) {
+        const auto text = options[launcher::Options::GitaDoraLefty].value_text();
+        if (text == "p1") {
+            games::gitadora::P1_LEFTY = true;
+        } else if (text == "p2") {
+            games::gitadora::P2_LEFTY = true;
+        } else if (text == "both") {
+            games::gitadora::P1_LEFTY = true;
+            games::gitadora::P2_LEFTY = true;
+        }
+    }
     if (options[launcher::Options::LoadDDRModule].value_bool()) {
         attach_ddr = true;
     }
@@ -1048,8 +1083,8 @@ int main_implementation(int argc, char *argv[]) {
         std::pair<uint32_t, uint32_t> result;
         if (parse_width_height(options[launcher::Options::spice2x_WindowSize].value_text(), result)) {
             GRAPHICS_WINDOW_SIZE = result;
-        } else {
-            log_warning("launcher", "failed to parse -windowsize");
+        } else if (!cfg_run && !cfg::CONFIGURATOR_STANDALONE) {
+            log_fatal("launcher", "failed to parse -windowsize");
         }
     }
     if (options[launcher::Options::spice2x_WindowPosition].is_active()) {
@@ -1093,6 +1128,9 @@ int main_implementation(int argc, char *argv[]) {
     if (options[launcher::Options::spice2x_DRSTransposeTouch].value_bool()) {
         games::drs::TRANSPOSE_TOUCH = true;
     }
+    if (options[launcher::Options::DRSRGBCameraHook].value_bool()) {
+        games::drs::RGB_CAMERA_HOOK = true;
+    }
     if (options[launcher::Options::spice2x_AutoCard].is_active()) {
         const auto text = options[launcher::Options::spice2x_AutoCard].value_text();
         if (text == "p1") {
@@ -1347,12 +1385,33 @@ int main_implementation(int argc, char *argv[]) {
             );
     }
 
+    if (launcher::signal::DISABLE && !cfg::CONFIGURATOR_STANDALONE) {
+        log_warning(
+            "launcher",
+            "WARNING - user specified -signaldisable option\n\n\n"
+            "!!!                                                              !!!\n"
+            "!!! Using -signaldisable option disables all exception handling, !!!\n"
+            "!!! which means when the game crashes it will likely just vanish !!!\n"
+            "!!! without troubleshooting information in the logs.             !!!\n"
+            "!!!                                                              !!!\n"
+            );
+    }
+
     if (options[launcher::Options::FullscreenResolution].is_active()) {
         std::pair<uint32_t, uint32_t> result;
         if (parse_width_height(options[launcher::Options::FullscreenResolution].value_text(), result)) {
             GRAPHICS_FS_CUSTOM_RESOLUTION = result;
-        } else {
-            log_warning("launcher", "failed to parse -forceres");
+        } else if (!cfg_run && !cfg::CONFIGURATOR_STANDALONE) {
+            log_fatal("launcher", "failed to parse -forceres");
+        }
+    }
+
+    if (options[launcher::Options::FullscreenSubResolution].is_active()) {
+        std::pair<uint32_t, uint32_t> result;
+        if (parse_width_height(options[launcher::Options::FullscreenSubResolution].value_text(), result)) {
+            GRAPHICS_FS_CUSTOM_RESOLUTION_SUB = result;
+        } else if (!cfg_run && !cfg::CONFIGURATOR_STANDALONE) {
+            log_fatal("launcher", "failed to parse -forceressub");
         }
     }
 
@@ -1829,7 +1888,7 @@ int main_implementation(int argc, char *argv[]) {
             }
 
             // Polaris Chord
-            if (check_dll("kamunity.dll") && fileutils::dir_exists("game/svm_Data")) {
+            if (check_dll("kamunity.dll") && fileutils::file_exists("game/svm.exe")) {
                 avs::game::DLL_NAME = "kamunity.dll";
                 attach_io = true;
                 attach_pc = true;
@@ -1868,7 +1927,7 @@ int main_implementation(int argc, char *argv[]) {
                     "This usually means one of the following:\n\n"
                     "  1. You put spice executables in the wrong place, or\n"
                     "  2. XML files in prop directory are malformed or missing, or\n"
-                    "  3. You passed in invalid options (usually, path overrides like -exec)\n\n"
+                    "  3. You passed in invalid options (do not specify -exec or -modules if you don't know what you're doing)\n\n"
                 );
 
                 log_fatal("launcher", "module auto detection failed, see log.txt for troubleshooting");

src/spice2x/launcher/options.h

@@ -31,6 +31,8 @@ namespace launcher {
             GraphicsForceRefresh,
             FullscreenResolution,
             FullscreenOrientationFlip,
+            FullscreenSubResolution,
+            FullscreenSubRefreshRate,
             Graphics9On12,
             spice2x_Dx9On12,
             NoLegacy,
@@ -84,11 +86,11 @@ namespace launcher {
             SDVXPrinterJPGQuality,
             SDVXDisableCameras,
             SDVXNativeTouch,
+            spice2x_SDVXSubRedraw,
             spice2x_SDVXDigitalKnobSensitivity,
             SDVXDigitalKnobSocd,
             spice2x_SDVXAsioDriver,
             spice2x_SDVXSubPos,
-            spice2x_SDVXSubRedraw,
             LoadDDRModule,
             DDR43Mode,
             DDRSkipCodecRegisteration,
@@ -99,6 +101,11 @@ namespace launcher {
             LoadGitaDoraModule,
             GitaDoraTwoChannelAudio,
             GitaDoraCabinetType,
+            GitaDoraArenaSingleWindow,
+            GitaDoraLefty,
+            GitaDoraWailHold,
+            GitaDoraPickAlgo,
+            GitaDoraSubOverlaySize,
             LoadJubeatModule,
             LoadReflecBeatModule,
             LoadShogikaiModule,
@@ -231,6 +238,7 @@ namespace launcher {
             spice2x_IIDXWindowedTDJ,
             spice2x_DRSDisableTouch,
             spice2x_DRSTransposeTouch,
+            DRSRGBCameraHook,
             spice2x_IIDXNativeTouch,
             spice2x_IIDXNoSub,
             spice2x_IIDXEmulateSubscreenKeypadTouch,

src/spice2x/launcher/signal.cpp

@@ -185,21 +185,30 @@ static LONG WINAPI TopLevelExceptionFilter(struct _EXCEPTION_POINTERS *Exception
 }
 
 static BOOL WINAPI SetConsoleCtrlHandler_hook(PHANDLER_ROUTINE pHandlerRoutine, BOOL Add) {
-    log_misc("signal", "SetConsoleCtrlHandler hook hit");
+    static std::once_flag printed;
+    std::call_once(printed, []() {
+        log_misc("signal", "SetConsoleCtrlHandler hook hit (printing once)");
+    });
 
     return TRUE;
 }
 
 static LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter_hook(
-    LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter)
-{
-    log_info("signal", "SetUnhandledExceptionFilter hook hit");
+    LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter) {
+
+    static std::once_flag printed;
+    std::call_once(printed, []() {
+        log_info("signal", "SetUnhandledExceptionFilter hook hit (printing once)");
+    });
 
     return nullptr;
 }
 
 static PVOID WINAPI AddVectoredExceptionHandler_hook(ULONG First, PVECTORED_EXCEPTION_HANDLER Handler) {
-    log_info("signal", "AddVectoredExceptionHandler hook hit");
+    static std::once_flag printed;
+    std::call_once(printed, []() {
+        log_info("signal", "AddVectoredExceptionHandler hook hit (printing once)");
+    });
 
     return launcher::signal::USE_VEH_WORKAROUND ? INVALID_HANDLE_VALUE : nullptr;
 }

src/spice2x/misc/bt5api.cpp

@@ -119,6 +119,7 @@ static std::string EAMIO_DLL_NAME = "eamio.dll";
 static robin_hood::unordered_map<int, std::thread *> BT5API_THREADS;
 static robin_hood::unordered_map<int, int> BT5API_THREAD_RESULTS;
 static uint8_t BT5API_CARD_STATES[] = {0, 0};
+static uint16_t BT5API_KEYPAD_STATES[] = {0, 0};
 
 static void bt5api_log(const char *bt5_module, const char *fmt, ...) {
 
@@ -240,46 +241,77 @@ void bt5api_hook(HINSTANCE module) {
 
 void bt5api_poll_reader_card(uint8_t unit_no) {
 
-    // check if initialized
-    if (!EAMIO_DLL) {
+    // check if initialized or out of bounds
+    if (!EAMIO_DLL || unit_no >= eamuse_get_game_keypads()) {
         return;
     }
 
     // poll
     if (!eam_io_poll(unit_no)) {
-        log_warning("bt5api", "polling bt5api reader {} returned failure",
+        log_warning("bt5api", "polling bt5api reader card {} returned failure",
                 static_cast<int>(unit_no));
+        return;
     }
 
     // get sensor state
     uint8_t sensor_state = eam_io_get_sensor_state(unit_no);
+    
+    // if we have a change in state.
+    if(sensor_state !=  BT5API_CARD_STATES[unit_no]) {
 
-    // check for card in
-    if (sensor_state > BT5API_CARD_STATES[unit_no]) {
-        uint8_t card_id[8];
-        eam_io_read_card(unit_no, card_id, 8);
-        eamuse_card_insert(unit_no, card_id);
+        // card inserted into the back.
+        if(sensor_state & (1 << EAM_IO_SENSOR_BACK)) {
+            uint8_t card_id[8];
+            
+            log_info("bt5api", "card unit {} inserted", static_cast<int>(unit_no));
+            
+            // do the bt5 dance
+            eam_io_card_slot_cmd(unit_no, EAM_IO_CARD_SLOT_CMD_CLOSE);
+            eam_io_poll(unit_no);
+            eam_io_card_slot_cmd(unit_no, EAM_IO_CARD_SLOT_CMD_READ);
+            eam_io_poll(unit_no);
+            
+            // ask the api for the card, then insert it into our engine.
+            eam_io_read_card(unit_no, card_id, 8);
+            eamuse_card_insert(unit_no, card_id);
+        }
+        
+        // if card removed entirely, do another bt5 dance!
+        if(sensor_state == 0) {
+            eam_io_card_slot_cmd(unit_no, EAM_IO_CARD_SLOT_CMD_CLOSE);
+            eam_io_poll(unit_no);
+            eam_io_card_slot_cmd(unit_no, EAM_IO_CARD_SLOT_CMD_OPEN);
+            
+            log_info("bt5api", "card unit {} removed", static_cast<int>(unit_no));
+        }
     }
-
-    // save state
+    
+    // save prev state
     BT5API_CARD_STATES[unit_no] = sensor_state;
 }
-
+    
 void bt5api_poll_reader_keypad(uint8_t unit_no) {
 
-    // check if initialized
-    if (!EAMIO_DLL) {
+    // check if initialized or out of bounds
+    if (!EAMIO_DLL || unit_no >= eamuse_get_game_keypads()) {
         return;
     }
-
-    // poll
-    if (!eam_io_poll(unit_no)) {
-        log_warning("bt5api", "polling bt5api reader {} returned failure",
-                static_cast<int>(unit_no));
+    
+    uint16_t keypad_current = eam_io_get_keypad_state(unit_no);
+    uint16_t keypad_changes = ~BT5API_KEYPAD_STATES[unit_no] & keypad_current;
+    
+    // if user has pressed decimal for the first time, eject the slotted reader.
+    if(keypad_changes & (1 << EAM_IO_KEYPAD_DECIMAL)) {
+        log_info("bt5api", "card unit {} ejecting", static_cast<int>(unit_no));
+        
+        eam_io_card_slot_cmd(unit_no, EAM_IO_CARD_SLOT_CMD_EJECT);
     }
+    
+    // save the last pressed.
+    BT5API_KEYPAD_STATES[unit_no] = keypad_current;
 
-    // get keypad
-    eamuse_set_keypad_overrides_bt5(unit_no, eam_io_get_keypad_state(unit_no));
+    // send off the state to the main engine.
+    eamuse_set_keypad_overrides_bt5(unit_no, keypad_current);
 }
 
 void bt5api_dispose() {

src/spice2x/misc/eamuse.cpp

@@ -202,7 +202,14 @@ bool eamuse_card_insert_consume(int active_count, int unit_id) {
 
     // bt5api
     if (BT5API_ENABLED) {
-        bt5api_poll_reader_card((uint8_t) index);
+        // some bt5api want to be polled in order.
+        if (eamuse_get_game_keypads() > 1) {
+            bt5api_poll_reader_card(1);
+            bt5api_poll_reader_card(0);
+        }
+        else {
+            bt5api_poll_reader_card((uint8_t) index);
+        }
     }
 
     // auto insert card

src/spice2x/misc/extdev.cpp

@@ -7,6 +7,8 @@
 #include "util/detour.h"
 #include "util/libutils.h"
 #include "util/circular_buffer.h"
+#include "util/socd_cleaner.h"
+#include "util/time.h"
 #include "misc/eamuse.h"
 #include "cfg/api.h"
 #include "acio/icca/icca.h"
@@ -336,6 +338,9 @@ static int __cdecl gfdm_unit2_boot_initialize() {
     return 1;
 }
 
+constexpr int LEFTY_X_CENTER = 2040;
+
+// this seems to be only used in the I/O test menu, not in gameplay
 static void *__cdecl gfdm_unit_get_button_p(void *a1, int a2, size_t player) {
     memset(a1, 0, 64);
 
@@ -344,31 +349,61 @@ static void *__cdecl gfdm_unit_get_button_p(void *a1, int a2, size_t player) {
         return a1;
     }
 
+    // log_info("gitadora", "gfdm_unit_get_button_p: a2={}, player={}", a2, player);
+
     // get buttons
     auto &buttons = games::gitadora::get_buttons();
     auto &analogs = games::gitadora::get_analogs();
+    const auto wail_up =
+        Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[12 + 11 * (size_t) player]));
+    const auto wail_down =
+        Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[13 + 11 * (size_t) player]));
+    const auto wail_result =
+        socd::get_guitar_wail(player, wail_up, wail_down, get_performance_milliseconds());
 
-    // X
-    ((int *) a1)[4] = a2 == 1 ? 4080 : -4080;
-    if (analogs.at(player * 3 + 0).isSet())
-        ((int *) a1)[4] = lroundf(Analogs::getState(
-                RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 0])) * 8160.f) - 4080;
+    // wail X
+    ((int *) a1)[4] = games::gitadora::is_player_lefty(player) ? LEFTY_X_CENTER : -4080;
+    auto &analog_x = analogs.at(gitadora_analog_mapping[player * 4 + 0]);
+    if (analog_x.isSet())
+        ((int *) a1)[4] = lroundf(Analogs::getState(RI_MGR, analog_x) * 8160.f) - 4080;
 
-    // Y
+    // wail Y
     ((int *) a1)[5] = 0;
-    if (analogs.at(player * 3 + 1).isSet())
-        ((int *) a1)[5] = lroundf(Analogs::getState(
-                RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 1])) * 8160.f) - 4080;
-    if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[12 + 11 * (size_t) player])))
-        ((int *) a1)[5] = -4080;
-    if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[13 + 11 * (size_t) player])))
-        ((int *) a1)[5] = 4080;
+    auto &analog_y = analogs.at(gitadora_analog_mapping[player * 4 + 1]);
+    if (analog_y.isSet()) {
+        ((int *) a1)[5] = lroundf(Analogs::getState(RI_MGR, analog_y) * 8160.f) - 4080;
+    }
 
-    // Z
+    // digital wailing
+    if (!games::gitadora::is_player_lefty(player)) {
+        // righty
+        if (wail_result == socd::TiltUp) {
+            // top center
+            ((int *) a1)[4] = 0; // X
+            ((int *) a1)[5] = -4080; // Y
+        } else if (wail_result == socd::TiltDown) {
+            // bottom left; for lefty, bottom right
+            ((int *) a1)[4] = -4080; // X
+            ((int *) a1)[5] = 4080; // Y
+        }
+    } else {
+        // lefty
+        if (wail_result == socd::TiltUp) {
+            // left
+            ((int *) a1)[4] = -4080; // X
+            ((int *) a1)[5] = 0; // Y
+        } else if (wail_result == socd::TiltDown) {
+            // right
+            ((int *) a1)[4] = 4080; // X
+            ((int *) a1)[5] = 0; // Y
+        }   
+    }
+
+    // wail Z
     ((int *) a1)[6] = 0;
-    if (analogs.at(player * 3 + 2).isSet())
-        ((int *) a1)[6] = lroundf(Analogs::getState(
-                RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 2])) * 8160.f) - 4080;
+    auto &analog_z = analogs.at(gitadora_analog_mapping[player * 4 + 2]);
+    if (analog_z.isSet())
+        ((int *) a1)[6] = lroundf(Analogs::getState(RI_MGR, analog_z) * 8160.f) - 4080;
 
     // return the same buffer
     return a1;
@@ -487,24 +522,42 @@ static long __cdecl gfdm_unit_get_input_p(int device, size_t player) {
     if (games::gitadora::is_guitar()) {
         auto offset = player * 11;
 
-        // pick up
-        if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[3 + offset]))) {
-            if (!GFDM_GF_PICK_STATE_UP[player]) {
-                GFDM_GF_PICK_STATE_UP[player] = true;
-                ret |= 0x80 | 0x20;
+        const auto pick_up = Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[3 + offset]));
+        const auto pick_down = Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[4 + offset]));
+        if (!games::gitadora::PICK_ALGO.has_value()) {
+            // legacy behavior (detect rising edges only, input for 1 frame)
+            if (pick_up) {
+                if (!GFDM_GF_PICK_STATE_UP[player]) {
+                    GFDM_GF_PICK_STATE_UP[player] = true;
+                    ret |= 0x80 | 0x20;
+                }
+            } else {
+                GFDM_GF_PICK_STATE_UP[player] = false;
             }
-        } else {
-            GFDM_GF_PICK_STATE_UP[player] = false;
-        }
 
-        // pick down
-        if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[4 + offset]))) {
-            if (!GFDM_GF_PICK_STATE_DOWN[player]) {
-                GFDM_GF_PICK_STATE_DOWN[player] = true;
-                ret |= 0x100 | 0x20;
+            if (pick_down) {
+                if (!GFDM_GF_PICK_STATE_DOWN[player]) {
+                    GFDM_GF_PICK_STATE_DOWN[player] = true;
+                    ret |= 0x100 | 0x20;
+                }
+            } else {
+                GFDM_GF_PICK_STATE_DOWN[player] = false;
             }
         } else {
-            GFDM_GF_PICK_STATE_DOWN[player] = false;
+            const auto socd = socd::socd_clean(
+                player,
+                pick_up,
+                pick_down,
+                get_performance_milliseconds(),
+                games::gitadora::PICK_ALGO.value()
+            );
+            if (socd == socd::SocdCCW) {
+                ret |= 0x80 | 0x20; // pick up
+            } else if (socd == socd::SocdCW) {
+                ret |= 0x100 | 0x20; // pick down
+            } else if (socd == socd::SocdBoth) {
+                ret |= 0x100 | 0x80 | 0x20; // up and down
+            }
         }
 
         // button R
@@ -585,63 +638,74 @@ static long __cdecl gfdm_unit2_get_input(int device) {
     return gfdm_unit_get_input_p(device, 1);
 }
 
+// this is used in gameplay
 static long __cdecl gfdm_unit_get_sensor_gf_p(int a1, int a2, size_t player) {
 
     // return if it's actually drum mania
     if (games::gitadora::is_drum())
         return 0;
 
+    // log_info("gitadora", "gfdm_unit_get_sensor_gf_p: a1={}, a2={}, player={}", a1, a2, player);
+
     // get buttons and analogs
     auto &buttons = games::gitadora::get_buttons();
     auto &analogs = games::gitadora::get_analogs();
 
-    // X
+    // figure out digital wail Y
+    const size_t offset = (size_t) player * 11;
+    const auto wail_up = Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[12 + offset]));
+    const auto wail_down = Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[13 + offset]));
+    const auto wail_result = socd::get_guitar_wail(player, wail_up, wail_down, get_performance_milliseconds());
+
+    // wail X
     if (a2 == 0) {
+        long ret = games::gitadora::is_player_lefty(player) ? LEFTY_X_CENTER : -4080;
 
         // analog override
-        if (analogs.at(gitadora_analog_mapping[player * 3 + 0]).isSet()) {
-            return lroundf(Analogs::getState(
-                    RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 0])) * 8160.f) - 4080;
+        auto &analog_x = analogs.at(gitadora_analog_mapping[player * 4 + 0]);
+        if (analog_x.isSet()) {
+            ret = lroundf(Analogs::getState(RI_MGR, analog_x) * 8160.f) - 4080;
+        }
+
+        // digital wail up/down
+        if (wail_result == socd::TiltUp) {
+            ret = games::gitadora::is_player_lefty(player) ? -4080 : 0;
+        } else if (wail_result == socd::TiltDown) {
+            ret = games::gitadora::is_player_lefty(player) ? +4080 : -4080;
         }
 
         // default
-        return a1 == 1 ? 4080 : -4080;
+        return ret;
     }
 
-    // Y
+    // wail Y
     if (a2 == 1) {
+        long ret = 0;
 
         // analog override
-        if (analogs.at(player * 3 + 1).isSet()) {
-            return lroundf(Analogs::getState(
-                    RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 1])) * 8160.f) - 4080;
+        auto &analog_y = analogs.at(gitadora_analog_mapping[player * 4 + 1]);
+        if (analog_y.isSet()) {
+            ret = lroundf(Analogs::getState(RI_MGR, analog_y) * 8160.f) - 4080;
         }
 
-        // variables
-        long ret = 0;
-        size_t offset = (size_t) player * 11;
-
-        // wail up
-        if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[12 + offset]))) {
-            ret -= 4080;
-        }
-
-        // wail down
-        if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[13 + offset]))) {
-            ret += 4080;
+        // digital wail up/down
+        if (wail_result == socd::TiltUp) {
+            ret = games::gitadora::is_player_lefty(player) ? 0 : -4080;
+        } else if (wail_result == socd::TiltDown) {
+            ret = games::gitadora::is_player_lefty(player) ? 0 : 4080;
         }
 
         // return value
         return ret;
     }
 
-    // Z
+    // wail Z
     if (a2 == 2) {
 
         // analog override
-        if (analogs.at(gitadora_analog_mapping[player * 3 + 2]).isSet()) {
-            return lroundf(Analogs::getState(
-                    RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 2])) * 8160.f) - 4080;
+        auto &analog_z = analogs.at(gitadora_analog_mapping[player * 4 + 2]);
+        if (analog_z.isSet()) {
+            return lroundf(Analogs::getState(RI_MGR, analog_z) * 8160.f) - 4080;
         }
 
         // default

src/spice2x/misc/wintouchemu.cpp

@@ -10,6 +10,7 @@
 #include <thread>
 
 #include "cfg/screen_resize.h"
+#include "games/gitadora/gitadora.h"
 #include "games/iidx/iidx.h"
 #include "hooks/graphics/graphics.h"
 #include "overlay/overlay.h"
@@ -390,7 +391,10 @@ namespace wintouchemu {
                 } else if (avs::game::is_model("LDJ") && !GENERIC_SUB_WINDOW_FULLSIZE) {
                     // overlay subscreen in IIDX
                     // use mouse position as ImGui overlay will block the touch window  
-                    log_info("wintouchemu", "use mouse cursor API for overlay subscreen");
+                    log_info("wintouchemu", "use mouse cursor API for ldj overlay subscreen");
+                    USE_MOUSE = true;
+                } else if (games::gitadora::is_arena_model() && games::gitadora::ARENA_SINGLE_WINDOW) {
+                    log_info("wintouchemu", "use mouse cursor API for gitadora overlay subscreen");
                     USE_MOUSE = true;
                 } else {
                     // create touch window - create overlay if not yet existing at this point

src/spice2x/nvapi/nvapi.cpp

@@ -236,6 +236,26 @@ namespace nvapi {
         return NvAPI_DRS_SetSetting(h_session, h_profile, &drs_setting);
     }
 
+    NvAPI_Status set_refresh_rate(NvDRSSessionHandle h_session, NvDRSProfileHandle h_profile) {
+        auto drs_setting = NVDRS_SETTING {};
+        drs_setting.version = NVDRS_SETTING_VER;
+        drs_setting.settingId = REFRESH_RATE_OVERRIDE_ID;
+        drs_setting.settingType = NVDRS_DWORD_TYPE;
+        drs_setting.u32PredefinedValue = REFRESH_RATE_OVERRIDE_APPLICATION_CONTROLLED;
+        drs_setting.u32CurrentValue = REFRESH_RATE_OVERRIDE_APPLICATION_CONTROLLED;
+        return NvAPI_DRS_SetSetting(h_session, h_profile, &drs_setting);
+    }
+
+    NvAPI_Status set_max_fps(NvDRSSessionHandle h_session, NvDRSProfileHandle h_profile) {
+        auto drs_setting = NVDRS_SETTING {};
+        drs_setting.version = NVDRS_SETTING_VER;
+        drs_setting.settingId = FRL_FPS_ID;
+        drs_setting.settingType = NVDRS_DWORD_TYPE;
+        drs_setting.u32PredefinedValue = FRL_FPS_DISABLED;
+        drs_setting.u32CurrentValue = FRL_FPS_DISABLED;
+        return NvAPI_DRS_SetSetting(h_session, h_profile, &drs_setting);
+    }
+
     void set_profile_settings() {
         if (!NVAPI_MODULE_LOAD_SUCCEEDED) {
             return;
@@ -266,22 +286,26 @@ namespace nvapi {
         log_info("nvapi", "setting VSync to Application Controlled...");
         if ((status = set_vsync_mode(h_session, h_profile)) != NVAPI_OK) {
             log_warning("nvapi", "could not set VSync mode: {}", get_error_message(status));
-            NvAPI_DRS_DestroySession(h_session);
-            return;
         }
 
         log_info("nvapi", "applying preferred PState to Maximum Performance...");
         if ((status = set_gpu_power_state(h_session, h_profile)) != NVAPI_OK) {
             log_warning("nvapi", "could not set preferred PState: {}", get_error_message(status));
-            NvAPI_DRS_DestroySession(h_session);
-            return;
         }
 
         log_info("nvapi", "disabling G-SYNC...");
         if ((status = set_gsync_mode(h_session, h_profile)) != NVAPI_OK) {
             log_warning("nvapi", "could not set G-Sync mode: {}", get_error_message(status));
-            NvAPI_DRS_DestroySession(h_session);
-            return;
+        }
+
+        log_info("nvapi", "setting preferred refresh rate to Application Controlled...");
+        if ((status = set_refresh_rate(h_session, h_profile)) != NVAPI_OK) {
+            log_warning("nvapi", "could not set preferred refresh rate: {}", get_error_message(status));
+        }
+
+        log_info("nvapi", "disabling max framerate...");
+        if ((status = set_max_fps(h_session, h_profile)) != NVAPI_OK) {
+            log_warning("nvapi", "could not disable max framerate: {}", get_error_message(status));
         }
 
         log_info("nvapi", "saving settings for DRS session...");

src/spice2x/overlay/imgui/extensions.cpp

@@ -26,7 +26,7 @@ namespace ImGui {
 
     void HelpMarker(const char* desc) {
         ImGui::TextDisabled("(?)");
-        if (ImGui::IsItemHovered()) {
+        if (ImGui::IsItemHovered(TOOLTIP_FLAGS)) {
             HelpTooltip(desc);
         }
     }
@@ -59,7 +59,7 @@ namespace ImGui {
         ImGui::PushStyleColor(ImGuiCol_TextDisabled, ImVec4(1.f, 1.f, 0.f, 1.f));
         ImGui::TextDisabled("(!)");
         ImGui::PopStyleColor();
-        if (ImGui::IsItemHovered()) {
+        if (ImGui::IsItemHovered(TOOLTIP_FLAGS)) {
             WarnTooltip(desc, warn);
         }
     }
@@ -92,4 +92,77 @@ namespace ImGui {
                 ImGui::GetColorU32(ImGuiCol_PlotHistogram),
                 thickness);
     }
+
+    std::string TruncateText(const std::string& p_text, float p_truncated_width, bool &truncated) {
+        std::string truncated_text = p_text;
+
+        const float text_width =
+                ImGui::CalcTextSize(p_text.c_str(), nullptr, true).x;
+
+        if (text_width > p_truncated_width) {
+            truncated = true;
+            constexpr const char* ELLIPSIS = " ...";
+            const float ellipsis_size = ImGui::CalcTextSize(ELLIPSIS).x;
+
+            int visible_chars = 0;
+            for (size_t i = 0; i < p_text.size(); i++) {
+                const float current_width = ImGui::CalcTextSize(
+                        p_text.substr(0, i).c_str(), nullptr, true)
+                                                    .x;
+                if (current_width + ellipsis_size > p_truncated_width) {
+                    break;
+                }
+
+                visible_chars = i;
+            }
+
+            truncated_text = (p_text.substr(0, visible_chars) + ELLIPSIS).c_str();
+        }
+
+        return truncated_text;
+    }
+
+    void TextTruncated(const std::string& p_text, float p_truncated_width) {
+        if (p_text.empty()) {
+            ImGui::TextDisabled("-");
+            return;
+        }
+        bool truncated = false;
+        ImGui::TextUnformatted(TruncateText(p_text, p_truncated_width, truncated).c_str());
+        if (truncated && ImGui::IsItemHovered(TOOLTIP_FLAGS)) {
+            ImGui::HelpTooltip(p_text.c_str());
+        }
+    }
+
+    bool DeleteButton(const std::string& tooltip) {
+        ImGui::PushID(tooltip.c_str());
+        ImGui::PushStyleColor(ImGuiCol_Button, ImGui::GetColorU32(ImGuiCol_Button, 0.7f));
+        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(3.f, 2.f));
+        bool clicked = ImGui::SmallButton("\u00D7"); // multiplication sign (×)
+        ImGui::PopStyleVar();
+        ImGui::PopStyleColor();
+        if (!tooltip.empty() && ImGui::IsItemHovered(TOOLTIP_FLAGS)) {
+            ImGui::SameLine();
+            ImGui::HelpTooltip(tooltip.c_str());
+        }
+        ImGui::PopID();
+        return clicked;
+    }
+
+    bool ClearButton(const std::string& tooltip) {
+        ImGui::PushID(tooltip.c_str());
+        // same colors as a checkbox
+        ImGui::PushStyleColor(ImGuiCol_Button, ImGui::GetColorU32(ImGuiCol_FrameBg));
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::GetColorU32(ImGuiCol_FrameBgHovered));
+        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImGui::GetColorU32(ImGuiCol_FrameBgActive));
+        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.97f, 0.97f, 0.97f, 1.00f));
+        bool clicked = ImGui::Button("\u00D7"); // multiplication sign (×)
+        ImGui::PopStyleColor(4);
+        if (!tooltip.empty() && ImGui::IsItemHovered(TOOLTIP_FLAGS)) {
+            ImGui::SameLine();
+            ImGui::HelpTooltip(tooltip.c_str());
+        }
+        ImGui::PopID();
+        return clicked;
+    }
 }

src/spice2x/overlay/imgui/extensions.h

@@ -1,12 +1,23 @@
 #pragma once
 
+#include <string>
+#include "external/imgui/imgui.h"
+
 namespace ImGui {
 
+    constexpr ImGuiHoveredFlags TOOLTIP_FLAGS =
+        (ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_AllowWhenDisabled);
+
     void HelpTooltip(const char* desc);
     void HelpMarker(const char* desc);
     void WarnTooltip(const char* desc, const char* warn);
     void WarnMarker(const char* desc, const char* warn);
     void DummyMarker();
+
     void Knob(float fraction, float size, float thickness = 2.f,
             float pos_x = -1.f, float pos_y = -1.f);
+
+    void TextTruncated(const std::string& p_text, float p_truncated_width);
+    bool DeleteButton(const std::string& tooltip);
+    bool ClearButton(const std::string& tooltip);
 }

src/spice2x/overlay/overlay.cpp

@@ -29,6 +29,7 @@
 #include "windows/generic_sub.h"
 #include "windows/iidx_seg.h"
 #include "windows/iidx_sub.h"
+#include "windows/gfdm_sub.h"
 #include "windows/drs_dancefloor.h"
 #include "windows/iopanel.h"
 #include "windows/iopanel_ddr.h"
@@ -410,7 +411,10 @@ void overlay::SpiceOverlay::init() {
             window_sub = new overlay::windows::DRSDanceFloorDisplay(this);
         } else if (avs::game::is_model("KFC")) {
             window_sub = new overlay::windows::SDVXSubScreen(this);
+        } else if (games::gitadora::is_arena_model() && games::gitadora::ARENA_SINGLE_WINDOW) {
+            window_sub = new overlay::windows::GitaDoraSubScreen(this);
         }
+
         if (window_sub) {
             this->window_add(window_sub);
             if (AUTO_SHOW_SUBSCREEN) {

src/spice2x/overlay/windows/config.h

@@ -38,7 +38,6 @@ namespace overlay::windows {
         ConfigTab tab_selected = ConfigTab::CONFIG_TAB_INVALID;
 
         // buttons tab
-        int buttons_page = 0;
         bool buttons_keyboard_state[0xFF];
         bool buttons_bind_active = false;
         bool buttons_many_active = false;
@@ -55,7 +54,6 @@ namespace overlay::windows {
         int analogs_devices_control_selected = -1;
 
         // lights tab
-        int lights_page = 0;
         std::vector<rawinput::Device *> lights_devices;
         int lights_devices_selected = -1;
         int lights_devices_control_selected = -1;
@@ -78,17 +76,33 @@ namespace overlay::windows {
         std::string search_filter = "";
         std::string search_filter_in_lower_case = "";
 
-    public:
-        Config(SpiceOverlay *overlay);
-        ~Config() override;
+        void build_buttons(const std::string &name, std::vector<Button> *buttons, int min = 0, int max = -1);
+        void build_button(
+            const std::string &name,
+            Button &primary_button,
+            Button *button,
+            const int button_it,
+            const int button_it_max,
+            const int alt_index);
+
+        void bind_button_popup(const std::string &bind_name, Button *button, const int button_it_max, const int alt_index);
+        void naive_button_popup(const std::string &naive_string, Button *button, const int button_it_max, const int alt_index);
+        void edit_button_popup(
+            const std::string &edit_name,
+            const std::string &button_display,
+            Button *button,
+            const float button_velocity,
+            const int alt_index);
+        void clear_button(Button *button, const int alt_index);
 
-        void read_card(int player = -1);
-        void write_card(int player);
-        void build_content() override;
-        void build_buttons(const std::string &name, std::vector<Button> *buttons,
-                int min = 0, int max = -1);
         void build_analogs(const std::string &name, std::vector<Analog> *analogs);
+        void edit_analog_popup(Analog &analog);
+
         void build_lights(const std::string &name, std::vector<Light> *lights);
+        void build_light(Light &primary_light, Light *light, const int light_index, const int alt_index);
+        void clear_light(Light *light, const int alt_index);
+        void edit_light_popup(Light &primary_light, Light *light, const int alt_index);
+
         void build_cards();
         void build_options(
             std::vector<Option> *options, const std::string &category, const std::string *filter=nullptr);
@@ -96,8 +110,18 @@ namespace overlay::windows {
         void build_launcher();
         void launch_shell(LPCSTR app, LPCSTR file=nullptr);
 
-        static void build_page_selector(int *page);
         void build_menu(int *game_selected);
         void shutdown_system(bool force, bool reboot_instead);
+
+        void set_alternating_row_colors(const int row_index);
+
+    public:
+        Config(SpiceOverlay *overlay);
+        ~Config() override;
+
+        void read_card(int player = -1);
+        void write_card(int player);
+        void build_content() override;
+
     };
 }

src/spice2x/overlay/windows/exitprompt.cpp

@@ -3,6 +3,7 @@
 #include "misc/eamuse.h"
 #include "util/logging.h"
 #include "games/iidx/iidx.h"
+#include "games/gitadora/gitadora.h"
 
 namespace overlay::windows {
 
@@ -69,6 +70,8 @@ namespace overlay::windows {
             sub = "Show Valkyrie Subscreen";
         } else if (avs::game::is_model("REC")) {
             sub = "Show DRS Dance Floor";
+        } else if (games::gitadora::is_arena_model() && games::gitadora::ARENA_SINGLE_WINDOW) {
+            sub = "Show GITADORA Subscreen";
         }
 
         build_button(this->overlay->window_sub, sub, size, NextItem::NEW_LINE, false);

src/spice2x/overlay/windows/fps.cpp

@@ -1,5 +1,6 @@
 #include <iomanip>
 #include <sstream>
+#include "external/fmt/include/fmt/chrono.h"
 #include "fps.h"
 
 namespace overlay::windows {
@@ -15,7 +16,8 @@ namespace overlay::windows {
                       | ImGuiWindowFlags_NoNavInputs
                       | ImGuiWindowFlags_NoDocking;
         this->bg_alpha = 0.5f;
-        this->start_time = std::chrono::system_clock::now();
+        this->start_time =
+            std::chrono::floor<std::chrono::seconds>(std::chrono::system_clock::now());
     }
 
     void FPS::calculate_initial_window() {
@@ -34,23 +36,23 @@ namespace overlay::windows {
         ImGui::Text("FPS:  %.1f", io.Framerate);
         // ImGui::Text("FT: %.2fms", 1000 / io.Framerate);
 
-        auto now = std::chrono::system_clock::now();
+        const auto now = std::chrono::system_clock::now();
+        const auto now_s = std::chrono::floor<std::chrono::seconds>(now);
 
         // current time
         {
-            auto now_t = std::chrono::system_clock::to_time_t(now);
-            static CHAR buf[48];
-            std::strftime(buf, sizeof(buf), "Time: %H:%M:%S", std::localtime(&now_t));
-            ImGui::Text(buf);
+            const std::time_t tt = std::chrono::system_clock::to_time_t(now_s);
+            std::tm local_tm{};
+            localtime_s(&local_tm, &tt);
+            ImGui::TextUnformatted(fmt::format("Time: {:%H:%M:%S}", local_tm).c_str());
         }
 
         // elapsed time
         {
-            auto d = now - this->start_time;
-            const auto h = std::chrono::duration_cast<std::chrono::hours>(d);
-            const auto m = std::chrono::duration_cast<std::chrono::minutes>(d - h);
-            const auto s = std::chrono::duration_cast<std::chrono::seconds>(d - h - m);
-            ImGui::Text("Up:   %02d:%02d:%02d", (int)h.count(), (int)m.count(), (int)s.count());
+            const auto uptime = now_s - this->start_time;
+            ImGui::TextUnformatted(
+                fmt::format("Up:   {:%H:%M:%S}",
+                    std::chrono::floor<std::chrono::seconds>(uptime)).c_str());
         }
     }
 }

src/spice2x/overlay/windows/gfdm_sub.cpp

@@ -0,0 +1,54 @@
+#include "avs/game.h"
+#include "gfdm_sub.h"
+#include "games/gitadora/gitadora.h"
+#include "hooks/graphics/graphics.h"
+#include "touch/touch.h"    
+
+namespace overlay::windows {
+
+    GitaDoraSubScreen::GitaDoraSubScreen(SpiceOverlay *overlay) : GenericSubScreen(overlay) {
+        this->title = "GITADORA Subscreen";
+
+        if (!games::gitadora::is_arena_model()) {
+            this->disabled_message = "Requires Arena Model!";
+        }
+
+        this->resize_callback = keep_10_by_16;
+
+        // medium size - perfect for "layout B" in GW Delta, though in drums it covers the pacemaker
+        float size = 0.64f;
+        if (games::gitadora::SUBSCREEN_OVERLAY_SIZE.has_value()) {
+            if (games::gitadora::SUBSCREEN_OVERLAY_SIZE.value() == "large") {
+                // enough to not cover the FPS overlay
+                size = 0.88f;
+            } else if (games::gitadora::SUBSCREEN_OVERLAY_SIZE.value() == "small") {
+                size = 0.48f;
+            }
+        }
+
+        const float height = ImGui::GetIO().DisplaySize.y * size;
+        const float width = height * 10 / 16;
+        this->init_size = ImVec2(width, height + ImGui::GetFrameHeight());
+
+        // bottom right
+        this->init_pos = ImVec2(
+            ImGui::GetIO().DisplaySize.x - ImGui::GetFrameHeight() / 4 - this->init_size.x,
+            ImGui::GetIO().DisplaySize.y - this->init_size.y - (ImGui::GetFrameHeight() / 4));
+    }
+
+    void GitaDoraSubScreen::touch_transform(const ImVec2 xy_in, LONG *x_out, LONG *y_out) {
+        if (!this->get_active()) {
+            return;
+        }
+
+        if (GRAPHICS_WINDOWED) {
+            // Touch needs to be registered on global coords
+            *x_out = SPICETOUCH_TOUCH_X + xy_in.x * SPICETOUCH_TOUCH_WIDTH;
+            *y_out = SPICETOUCH_TOUCH_Y + xy_in.y * SPICETOUCH_TOUCH_HEIGHT;
+        } else {
+            // Fullscreen mode, scale to game coords
+            *x_out = xy_in.x * ImGui::GetIO().DisplaySize.x;
+            *y_out = xy_in.y * ImGui::GetIO().DisplaySize.y;
+        }
+    }
+}

src/spice2x/overlay/windows/gfdm_sub.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "overlay/window.h"
+#include "overlay/windows/generic_sub.h"
+
+namespace overlay::windows {
+
+    class GitaDoraSubScreen : public GenericSubScreen {
+    public:
+        GitaDoraSubScreen(SpiceOverlay *overlay);
+
+    protected:
+        void touch_transform(const ImVec2 xy_in, LONG *x_out, LONG *y_out) override;
+
+    private:
+        static void keep_10_by_16(ImGuiSizeCallbackData* data) {
+            data->DesiredSize.y = (data->DesiredSize.x * 16.f / 10.f) + ImGui::GetFrameHeight();
+        }
+    };
+}

src/spice2x/overlay/windows/iidx_sub.cpp

@@ -13,7 +13,7 @@ namespace overlay::windows {
 
         if (GRAPHICS_IIDX_WSUB) {
             this->disabled_message =
-                "Close this overlay and use the second window.\n"
+                "Close this overlay and use the second window (ALT+TAB).\n"
                 "If you don't see the window, double check your DLL type and apply TDJ I/O patches as needed.";
         } else if (games::iidx::IIDX_TDJ_MONITOR_WARNING) {
             this->disabled_message = "TDJ mode subscreen overlay is not compatible with -monitor option";

src/spice2x/overlay/windows/iopanel.cpp

@@ -3,6 +3,7 @@
 #include "launcher/launcher.h"
 #include "games/io.h"
 #include "misc/eamuse.h"
+#include "overlay/imgui/extensions.h"
 
 namespace overlay::windows {
 
@@ -80,6 +81,9 @@ namespace overlay::windows {
         {
             ImGui::SetCursorPosY(ImGui::GetCursorPosY() - ImGui::GetFrameHeightWithSpacing());
             this->build_button("+", tall, this->test_button, this->service_button);
+            if (ImGui::IsItemHovered(ImGui::TOOLTIP_FLAGS)) {
+                ImGui::HelpTooltip("SERVICE + TEST");
+            }
         }
         ImGui::EndGroup();
 

src/spice2x/overlay/windows/iopanel_gfdm.cpp

@@ -3,6 +3,7 @@
 #include "games/io.h"
 #include "games/gitadora/gitadora.h"
 #include "games/gitadora/io.h"
+#include "overlay/imgui/extensions.h"
 #include "misc/eamuse.h"
 #include "util/logging.h"
 
@@ -11,6 +12,7 @@ namespace overlay::windows {
     GitadoraIOPanel::GitadoraIOPanel(SpiceOverlay *overlay) : IOPanel(overlay) {
         this->title = "GITADORA IO Panel";
 
+        this->has_menu_controls = true;
         // by default, make a safer assumption that there are two players
         this->two_players = true;
         // by default, enable the extra input only available on DX cabs...
@@ -33,6 +35,12 @@ namespace overlay::windows {
             this->has_guitar_knobs = false;
         }
 
+        if (games::gitadora::is_arena_model()) {
+            this->has_menu_controls = false;
+            this->two_players = false;
+            this->has_guitar_knobs = false;
+        }
+
         find_gfdm_buttons();
     }
 
@@ -70,23 +78,43 @@ namespace overlay::windows {
     void GitadoraIOPanel::build_io_panel() {
         ImGui::Dummy(overlay::apply_scaling_to_vector(12, 0));
 
-        ImGui::SameLine();
-        this->draw_buttons(0);
-        if (this->has_guitar_knobs) {
+        if (this->has_menu_controls) {
             ImGui::SameLine();
-            this->draw_sliders(0);
+            ImGui::PushID("P1");
+            this->draw_buttons(0);
+            if (this->has_guitar_knobs) {
+                ImGui::SameLine();
+                this->draw_sliders(0);
+            }
+            ImGui::PopID();
+
+            // draw p2 only if guitar freaks
+            if (this->two_players) {
+                ImGui::SameLine();
+                ImGui::Dummy(overlay::apply_scaling_to_vector(12, 0));
+                ImGui::SameLine();
+                ImGui::PushID("P2");
+                this->draw_buttons(1);
+                if (this->has_guitar_knobs) {
+                    ImGui::SameLine();
+                    this->draw_sliders(1);
+                }
+                ImGui::PopID();
+            }
         }
 
-        // draw p2 only if guitar freaks
-        if (this->two_players) {
+        if (games::gitadora::is_guitar()) {
             ImGui::SameLine();
             ImGui::Dummy(overlay::apply_scaling_to_vector(12, 0));
             ImGui::SameLine();
-            this->draw_buttons(1);
-            if (this->has_guitar_knobs) {
-                ImGui::SameLine();
-                this->draw_sliders(1);
+            ImGui::BeginGroup();
+            {
+                ImGui::Checkbox("P1 Lefty", &games::gitadora::P1_LEFTY);
+                if (this->two_players) {
+                    ImGui::Checkbox("P2 Lefty", &games::gitadora::P2_LEFTY);
+                }
             }
+            ImGui::EndGroup();
         }
     }
 
@@ -107,6 +135,10 @@ namespace overlay::windows {
         {
             ImGui::SetCursorPosY(ImGui::GetCursorPosY() + ImGui::GetFrameHeightWithSpacing());
             this->build_button("<", leftright_size, this->left[p], nullptr, this->leftright_light[p]);
+            this->build_button("+", tiny_size, this->help[p], this->start[p], nullptr);
+            if (ImGui::IsItemHovered(ImGui::TOOLTIP_FLAGS)) {
+                ImGui::HelpTooltip("HELP + START");
+            }
         }
         ImGui::EndGroup();
 
@@ -135,6 +167,9 @@ namespace overlay::windows {
         ImGui::BeginGroup();
         {
             this->build_button("?", tiny_size, this->help[p], nullptr, this->help_light[p]);
+            if (ImGui::IsItemHovered(ImGui::TOOLTIP_FLAGS)) {
+                ImGui::HelpTooltip("HELP");
+            }
             this->build_button(">", leftright_size, this->right[p], nullptr, this->leftright_light[p]);
         }
         ImGui::EndGroup();

src/spice2x/overlay/windows/iopanel_gfdm.h

@@ -18,6 +18,7 @@ namespace overlay::windows {
         void draw_buttons(const int player);
         void draw_sliders(const int player);
 
+        bool has_menu_controls;
         bool two_players;
         bool has_guitar_knobs;
 

src/spice2x/overlay/windows/keypad.cpp

@@ -120,7 +120,7 @@ namespace overlay::windows {
             "Lightning Model cabinets (TDJ) do not have any keypads; they use the subscreen.\n\n"
             "Fullscreen mode: bind a key in Overlay tab, and press it in game to show the subscreen, "
             "then use your mouse to click. Page Up button is the default binding.\n\n"
-            "Windowed mode: look for the second window in the taskbar.\n\n"
+            "Windowed mode: look for the second window in the taskbar (or ALT+TAB).\n\n"
             "Windowed mode with -iidxnosub: bring up the subscreen overlay (default Page Up).\n\n"
             );
 

src/spice2x/overlay/windows/patch_manager.cpp

@@ -1,11 +1,13 @@
 #include "patch_manager.h"
 
+#include <chrono>
 #include <thread>
 #include <fstream>
 #include <shellapi.h>
 #include <winhttp.h>
 #include <psapi.h>
 #include <format>
+#include "external/fmt/include/fmt/chrono.h"
 #include "external/rapidjson/document.h"
 #include "external/rapidjson/prettywriter.h"
 #include "external/rapidjson/stringbuffer.h"
@@ -719,7 +721,7 @@ namespace overlay::windows {
                     if (style_color_pushed) {
                         ImGui::PopStyleColor(style_color_pushed);
                     }
-                    if (ImGui::IsItemHovered()) {
+                    if (ImGui::IsItemHovered(ImGui::TOOLTIP_FLAGS)) {
                         show_patch_tooltip(patch);
                     }
 
@@ -760,7 +762,7 @@ namespace overlay::windows {
                         patch.last_status = is_patch_active(patch);
                     }
                     ImGui::EndDisabled();
-                    if (ImGui::IsItemHovered()) {
+                    if (ImGui::IsItemHovered(ImGui::TOOLTIP_FLAGS)) {
                         show_patch_tooltip(patch);
                     }
 
@@ -789,7 +791,7 @@ namespace overlay::windows {
                                     }
                                     ImGui::EndCombo();
                                 }
-                                if (ImGui::IsItemHovered()) {
+                                if (ImGui::IsItemHovered(ImGui::TOOLTIP_FLAGS)) {
                                     show_patch_tooltip(patch);
                                 }
                             } else if (patch.type == PatchType::Integer) {
@@ -805,7 +807,7 @@ namespace overlay::windows {
                                     apply_patch(patch, true);
                                     config_dirty = true;
                                 }
-                                if (ImGui::IsItemHovered()) {
+                                if (ImGui::IsItemHovered(ImGui::TOOLTIP_FLAGS)) {
                                     show_patch_tooltip(patch);
                                 }
                             }
@@ -822,7 +824,7 @@ namespace overlay::windows {
                                 ImGui::InputInt("##dummy_int_input", &patch.patch_number.value);
                             }
                             ImGui::EndDisabled();
-                            if (ImGui::IsItemHovered()) {
+                            if (ImGui::IsItemHovered(ImGui::TOOLTIP_FLAGS)) {
                                 show_patch_tooltip(patch);
                             }
                         }
@@ -928,6 +930,13 @@ namespace overlay::windows {
         }
     }
 
+    // match on model and ext, ignoring dest/spec/rev
+    // sample: LDJ:J:E:A:2025011400
+    bool PatchManager::is_game_id_wildcard_matched(const std::string& id_from_config) {
+        return ((id_from_config.compare(0, 3, avs::game::MODEL) == 0) &&
+                (id_from_config.compare(10, 10, avs::game::EXT) == 0));
+    }
+
     void PatchManager::config_load() {
         log_info("patchmanager", "loading config");
 
@@ -953,7 +962,7 @@ namespace overlay::windows {
                 if (auto_apply != doc.MemberEnd() && auto_apply->value.IsArray()) {
 
                     // get game id
-                    auto game_id = avs::game::get_identifier();
+                    const auto game_id = avs::game::get_identifier();
 
                     // iterate entries
                     setting_auto_apply = false;
@@ -962,15 +971,37 @@ namespace overlay::windows {
                         if (entry.IsString()) {
 
                             // check if this is our game identifier
-                            std::string entry_id = entry.GetString();
-                            if (game_id == entry_id) {
-                                setting_auto_apply = true;
+                            const std::string entry_id = entry.GetString();
+
+                            if (!setting_auto_apply) {
+                                if (game_id == entry_id) {
+                                    // exact match
+                                    setting_auto_apply = true;
+                                    log_misc(
+                                        "patchmanager",
+                                        "matched auto apply entry by full game identifier: {}",
+                                        entry_id);
+                                
+                                } else if (is_game_id_wildcard_matched(entry_id)) {
+                                    // match on model and ext, ignoring dest/spec/rev
+                                    // sample: LDJ:J:E:A:2025011400
+                                    setting_auto_apply = true;
+                                    log_misc(
+                                        "patchmanager",
+                                        "matched auto apply entry by partial game identifier: {}:?:?:?:{}",
+                                        avs::game::MODEL, avs::game::EXT);
+                                }
                             }
 
                             // move to list
                             setting_auto_apply_list.emplace_back(entry_id);
                         }
                     }
+                    if (!setting_auto_apply) {
+                        log_misc(
+                            "patchmanager",
+                            "no auto apply entry matched, patches will not load automatically");
+                    }
                 }
 
                 // read enabled patches
@@ -1058,7 +1089,7 @@ namespace overlay::windows {
         auto game_id = avs::game::get_identifier();
         bool game_id_added = false;
         for (auto &entry : setting_auto_apply_list) {
-            if (entry == game_id) {
+            if (entry == game_id || is_game_id_wildcard_matched(entry)) {
                 if (!setting_auto_apply) {
                     continue;
                 }
@@ -1150,7 +1181,7 @@ namespace overlay::windows {
         }
     }
 
-    std::string get_game_identifier(const std::filesystem::path& dll_path) {
+    std::string get_game_identifier(const std::filesystem::path& dll_path, bool print_info) {
         uint32_t time_date_stamp = 0;
         uint32_t address_of_entry_point = 0;
 
@@ -1159,7 +1190,7 @@ namespace overlay::windows {
         if (!result) {
             return "";
         }
-        
+
         // concatenate TimeDateStamp and AddressOfEntryPoint
         std::string identifier =
             fmt::format(
@@ -1168,6 +1199,16 @@ namespace overlay::windows {
                 time_date_stamp,
                 address_of_entry_point);
 
+        if (print_info) {
+            const auto time = std::chrono::system_clock::from_time_t(time_date_stamp);
+            log_info(
+                "patchmanager",
+                "file: {}, patch id: {}, build timestamp of dll: {:%Y-%m-%d %H:%M}",
+                dll_path.has_filename() ? dll_path.filename().string() : dll_path.string(),
+                identifier,
+                time);
+        }
+        
         return identifier;
     }
 
@@ -1657,14 +1698,12 @@ namespace overlay::windows {
         ACTIVE_JSON_FILE = "";
 
         std::string firstDll = avs::game::DLL_NAME;
-        std::string first_id = get_game_identifier(MODULE_PATH / firstDll);
+        std::string first_id = get_game_identifier(MODULE_PATH / firstDll, true);
         std::filesystem::path firstPath = fmt::format("patches/{}.json", first_id);
 
-        log_misc("patchmanager", "patch identifier of {}: {}", firstDll, first_id);
-
         auto extraDlls = getExtraDlls(firstDll);
         std::erase_if(extraDlls, [](const std::string& dll) {
-            auto identifier = get_game_identifier(MODULE_PATH / dll);
+            auto identifier = get_game_identifier(MODULE_PATH / dll, true);
             return identifier.empty() || !fileutils::file_exists(fmt::format("patches/{}.json", identifier));
         });
 

src/spice2x/overlay/windows/patch_manager.h

@@ -97,7 +97,7 @@ namespace overlay::windows {
 
     extern std::optional<std::string> PATCH_MANAGER_CFG_PATH_OVERRIDE;
 
-    std::string get_game_identifier(const std::filesystem::path& dll_path);
+    std::string get_game_identifier(const std::filesystem::path& dll_path, bool print_info=false);
 
     class PatchManager : public Window {
     public:
@@ -143,6 +143,8 @@ namespace overlay::windows {
             std::string pe_identifier_for_patch = "");
 
         void show_patch_tooltip(const PatchData& patch);
+
+        bool is_game_id_wildcard_matched(const std::string& id_from_config);
     };
 
     PatchStatus is_patch_active(PatchData &patch);

src/spice2x/overlay/windows/screen_resize.cpp

@@ -27,11 +27,12 @@ namespace overlay::windows {
     }
 
     HWND ScreenResize::get_first_window() {
-        // hack for gitadora arena model which races to create many windows
-        // so [0] is not always the main one
-        if (GRAPHICS_WINDOW_MAIN.has_value()) {
-            return GRAPHICS_WINDOW_MAIN.value();
+        // this is ideal
+        if (GRAPHICS_HOOKED_WINDOW.has_value()) {
+            return GRAPHICS_HOOKED_WINDOW.value();
         }
+        // we typically do not want to check GRAPHICS_WINDOWS because it may include
+        // system windows (e.g., CicMarshalWnd)
         if (GRAPHICS_WINDOWS.size() == 0) {
             return NULL;
         }
@@ -100,6 +101,21 @@ namespace overlay::windows {
     }
 
     void ScreenResize::build_fullscreen_config() {
+
+        if (avs::game::is_model("KFC")) {
+            ImGui::TextColored(ImVec4(1, 0.5f, 0.5f, 1.f),
+                "Warning: Enabling Image Resize uses more GPU\n"
+                "resources and may significantly lower framerate\n"
+                "for songs with Live2D! Results may vary, use at\n"
+                "your own risk.");
+        } else {
+            ImGui::TextColored(ImVec4(1, 0.5f, 0.5f, 1.f),
+                "Warning: Enabling Image Resize uses more GPU\n"
+                "resources and may significantly lower framerate\n"
+                "in some situations! Results may vary, use at\n"
+                "your own risk.");
+        }
+
         // enable checkbox
         ImGui::Checkbox("Enable", &cfg::SCREENRESIZE->enable_screen_resize);
         ImGui::SameLine();
@@ -141,22 +157,27 @@ namespace overlay::windows {
         // aspect ratio
         ImGui::Checkbox("Keep Aspect Ratio", &scene.keep_aspect_ratio);
         if (scene.keep_aspect_ratio) {
-            if (ImGui::SliderFloat("Scale", &scene.scale_x, 0.5f, 2.5f)) {
+
+            // we want to avoid zooming out below 0.6 as it will cause StretchRect calls to
+            // go on a slow sync path with the GPU, leading to frame drops in some situations
+            // (e.g., SDVX Live2D)
+
+            if (ImGui::SliderFloat("Scale", &scene.scale_x, 0.6f, 2.5f)) {
                 scene.scale_y = scene.scale_x;
             }
             ImGui::SameLine();
             ImGui::HelpMarker("Hint: ctrl + click on the slider to type in a numeric value.");
         } else {
-            ImGui::SliderFloat("Width Scale", &scene.scale_x, 0.5f, 2.5f);
+            ImGui::SliderFloat("Width Scale", &scene.scale_x, 0.6f, 2.5f);
             ImGui::SameLine();
             ImGui::HelpMarker("Hint: ctrl + click on the slider to type in a numeric value.");
-            ImGui::SliderFloat("Height Scale", &scene.scale_y, 0.5f, 2.5f);
+            ImGui::SliderFloat("Height Scale", &scene.scale_y, 0.6f, 2.5f);
             ImGui::SameLine();
             ImGui::HelpMarker("Hint: ctrl + click on the slider to type in a numeric value.");
         }
 
         static const char* dupe_items[] = { "None", "Copy Left", "Copy Right" };
-        ImGui::Combo(
+        const bool duplicate_changed = ImGui::Combo(
             "Duplicate",
             reinterpret_cast<int *>(&scene.duplicate),
             dupe_items,
@@ -167,6 +188,11 @@ namespace overlay::windows {
             "wrap-around effect when an offset is set.");
 
         ImGui::EndDisabled();
+
+        // tell d3d9 device to clear surface to get rid of ghost image
+        if (duplicate_changed) {
+            cfg::SCREENRESIZE->need_surface_clean = true;
+        }
     }
 
     void ScreenResize::build_windowed_config() {
@@ -176,8 +202,7 @@ namespace overlay::windows {
             return;
         }
 
-        ImGui::TextUnformatted("Warning: may cause some games to crash.");
-        ImGui::BeginDisabled(graphics_window_change_crashes_game());
+        ImGui::BeginDisabled(graphics_window_decoration_change_crashes_game());
         if (ImGui::Combo(
                 "Window Style",
                 &cfg::SCREENRESIZE->window_decoration,
@@ -202,42 +227,59 @@ namespace overlay::windows {
             "Reduces pixelated scaling artifacts. Works great on some games, but completely broken on others.\n\n"
             "This can't be changed in-game; instead, set -windowscale option in spicecfg and restart.");
 
-        ImGui::Checkbox("Keep Aspect Ratio", &cfg::SCREENRESIZE->client_keep_aspect_ratio);
-        ImGui::Checkbox("Manual window move/resize", &cfg::SCREENRESIZE->enable_window_resize);
+            
+        ImGui::BeginDisabled(graphics_window_move_and_resize_breaks_game());
+        {
+            ImGui::Checkbox("Keep Aspect Ratio", &cfg::SCREENRESIZE->client_keep_aspect_ratio);
+            ImGui::Checkbox("Manual window move/resize", &cfg::SCREENRESIZE->enable_window_resize);
+        }
+        ImGui::EndDisabled();
+
         ImGui::BeginDisabled(!cfg::SCREENRESIZE->enable_window_resize);
 
         bool changed = false;
         const uint32_t step = 1;
         const uint32_t step_fast = 10;
-        ImGui::BeginDisabled(cfg::SCREENRESIZE->client_keep_aspect_ratio);
-        ImGui::InputScalar(
-            "Width",
-            ImGuiDataType_U32,
-            &cfg::SCREENRESIZE->client_width,
-            &step, &step_fast, nullptr);
-        changed |= ImGui::IsItemDeactivatedAfterEdit();
+
+        ImGui::BeginDisabled(graphics_window_resize_breaks_game());
+        {
+            ImGui::BeginDisabled(cfg::SCREENRESIZE->client_keep_aspect_ratio);
+            {
+                ImGui::InputScalar(
+                    "Width",
+                    ImGuiDataType_U32,
+                    &cfg::SCREENRESIZE->client_width,
+                    &step, &step_fast, nullptr);
+                changed |= ImGui::IsItemDeactivatedAfterEdit();
+            }
+            ImGui::EndDisabled();
+
+            ImGui::InputScalar(
+                "Height",
+                ImGuiDataType_U32,
+                &cfg::SCREENRESIZE->client_height,
+                &step, &step_fast, nullptr);
+            changed |= ImGui::IsItemDeactivatedAfterEdit();
+        }
         ImGui::EndDisabled();
 
-        ImGui::InputScalar(
-            "Height",
-            ImGuiDataType_U32,
-            &cfg::SCREENRESIZE->client_height,
-            &step, &step_fast, nullptr);
-        changed |= ImGui::IsItemDeactivatedAfterEdit();
+        ImGui::BeginDisabled(graphics_window_move_and_resize_breaks_game());
+        {
+            ImGui::InputScalar(
+                "X Offset",
+                ImGuiDataType_S32,
+                &cfg::SCREENRESIZE->window_offset_x,
+                &step, &step_fast, nullptr);
+            changed |= ImGui::IsItemDeactivatedAfterEdit();
 
-        ImGui::InputScalar(
-            "X Offset",
-            ImGuiDataType_S32,
-            &cfg::SCREENRESIZE->window_offset_x,
-            &step, &step_fast, nullptr);
-        changed |= ImGui::IsItemDeactivatedAfterEdit();
-
-        ImGui::InputScalar(
-            "Y Offset",
-            ImGuiDataType_S32,
-            &cfg::SCREENRESIZE->window_offset_y,
-            &step, &step_fast, nullptr);
-        changed |= ImGui::IsItemDeactivatedAfterEdit();
+            ImGui::InputScalar(
+                "Y Offset",
+                ImGuiDataType_S32,
+                &cfg::SCREENRESIZE->window_offset_y,
+                &step, &step_fast, nullptr);
+            changed |= ImGui::IsItemDeactivatedAfterEdit();
+        }
+        ImGui::EndDisabled();
 
         if (changed) {
             if (cfg::SCREENRESIZE->client_keep_aspect_ratio) {

src/spice2x/overlay/windows/sdvx_sub.cpp

@@ -18,7 +18,7 @@ namespace overlay::windows {
             if (GRAPHICS_PREVENT_SECONDARY_WINDOW) {
                 this->disabled_message = "Subscreen has been disabled by the user (-sdvxnosub).";
             } else {
-                this->disabled_message = "Overlay unavailable in windowed mode! Use the second window instead.";
+                this->disabled_message = "Overlay unavailable in windowed mode! Use the second window instead. (ALT+TAB)";
             }
         }
 

src/spice2x/rawinput/rawinput.cpp

@@ -1986,7 +1986,7 @@ void CALLBACK rawinput::RawInputManager::input_midi_proc(HMIDIIN hMidiIn, UINT w
                                     device.midiInfo->v2_last_off_time[midi_index] = get_performance_milliseconds();
                                     device.updated = true;
                                 }
-                                // for v2_drum, NOTE ON is ignored
+                                // for v2_drum, NOTE OFF is ignored
                             }
                         }
 

src/spice2x/util/logging.cpp

@@ -13,8 +13,9 @@ std::string_view log_get_datetime() {
 std::string_view log_get_datetime(std::time_t now) {
     static thread_local char buf[64];
 
-    // `localtime` on Windows is thread-safe
-    strftime(buf, sizeof(buf), "[%Y/%m/%d %X]", localtime(&now));
+    std::tm local_tm{};
+    localtime_s(&local_tm, &now);
+    strftime(buf, sizeof(buf), "[%Y/%m/%d %X]", &local_tm);
 
     return buf;
 }

src/spice2x/util/socd_cleaner.cpp

@@ -15,18 +15,23 @@ namespace socd {
 
     SocdAlgorithm ALGORITHM = SocdAlgorithm::Neutral;
    
-    static double last_rising_edge[2][2] = {};
-    static bool last_button_state[2][2] = {};
+    static double last_rising_edge[4][2] = {};
+    static bool last_button_state[4][2] = {};
 
     // this has no locking, use only if you know there is only one i/o thread that will call this
-    SocdResult socd_clean(uint8_t device, bool ccw, bool cw, double time_now) {
-        if (device >= 2) {
+    SocdResult socd_clean(
+        uint8_t device, bool ccw, bool cw, double time_now,
+        std::optional<SocdAlgorithm> algorithm_override) {
+
+        if (device >= 4) {
             log_fatal("socd", "invalid device index in socd_clean: {}", device);
         }
 
-        // SOCD last input algorithm needs to keep track of rising edge times
-        if (ALGORITHM != SocdAlgorithm::Neutral) {
-            // detect rising edges
+        SocdAlgorithm algo =
+            algorithm_override.has_value() ? algorithm_override.value() : ALGORITHM;
+
+        // keep track of rising edge times
+        if (algo == SocdAlgorithm::PreferRecent || algo == SocdAlgorithm::PreferFirst) {
             if (!last_button_state[device][SocdCCW] && ccw) {
                 last_rising_edge[device][SocdCCW] = time_now;
             }
@@ -55,7 +60,7 @@ namespace socd {
         const auto cw_time = last_rising_edge[device][SocdCW];
         log_debug("socd", "ccw={}, cw ={}", ccw_time, cw_time);
 
-        if (ALGORITHM == SocdAlgorithm::PreferRecent) {
+        if (algo == SocdAlgorithm::PreferRecent) {
             // SOCD: prefer last input
             if (ccw_time < cw_time) {
                 // while CCW is being held, CW got pressed
@@ -67,7 +72,7 @@ namespace socd {
                 // it's a tie; instead of none, we'll pick a direction
                 return SocdCW;
             }
-        } else if (ALGORITHM == SocdAlgorithm::PreferFirst) {
+        } else if (algo == SocdAlgorithm::PreferFirst) {
             // SOCD: keep first input
             if (ccw_time < cw_time) {
                 // while CCW is being held, CW got pressed
@@ -79,9 +84,75 @@ namespace socd {
                 // it's a tie; instead of none, we'll pick a direction
                 return SocdCW;
             }
-        } else {
+        } else if (algo == SocdAlgorithm::Neutral) {
             // SOCD: neutral when both are pressed
             return SocdNone;
+        } else if (algo == SocdAlgorithm::None) {
+            // SOCD: both are pressed
+            return SocdBoth;
+        } else {
+            log_fatal("socd", "invalid SOCD algorithm");
+            return SocdNone;
         }
     }
+
+    // first dimension: p1/p2
+    // second dimension: TiltUp / TiltDown
+    // value: last timestamp when it was on
+    static double most_recent_active[2][2] = {};
+
+    uint32_t TILT_HOLD_MS = 100;
+
+    TiltResult get_guitar_wail(uint8_t device, bool up, bool down, double time_now) {
+        if (device >= 2) {
+            log_fatal("socd", "invalid device index in socd_clean: {}", device);
+        }
+
+        const auto socd_result = socd_clean(
+                device + 2, up, down, time_now, SocdAlgorithm::PreferRecent);
+
+        if (up) {
+            most_recent_active[device][TiltUp] = time_now;
+        }
+        if (down) {
+            most_recent_active[device][TiltDown] = time_now;
+        }
+
+        log_debug(
+            "socd",
+            "p{} wail up={}, down={}",
+            device + 1,
+            most_recent_active[device][TiltUp],
+            most_recent_active[device][TiltDown]);
+
+        const auto delta_up = time_now - most_recent_active[device][TiltUp];
+        const auto delta_down = time_now - most_recent_active[device][TiltDown];
+        const bool is_up = delta_up <= TILT_HOLD_MS;
+        const bool is_down = delta_down <= TILT_HOLD_MS;
+
+        auto result = TiltNone;
+        if (is_up && is_down) {
+            // both held recently: prefer more recently held using SOCD logic
+            if (socd_result == SocdCCW) {
+                result = TiltUp;
+            } else if (socd_result == SocdCW) {
+                result = TiltDown;
+            } else if (socd_result == SocdBoth) {
+                result = TiltUp;
+            }
+        } else if (is_up) {
+            result = TiltUp;
+        } else if (is_down) {
+            result = TiltDown;
+        }
+
+        // clear opposite direction being held
+        if (result == TiltUp) {
+            most_recent_active[device][TiltDown] = 0.f;
+        } else if (result == TiltDown) {
+            most_recent_active[device][TiltUp] = 0.f;
+        }
+
+        return result;
+    }
 }

src/spice2x/util/socd_cleaner.h

@@ -1,13 +1,17 @@
 #pragma once
 
+#include <optional>
 #include <cstdint>
 
 namespace socd {
 
+    // SOCD for knobs / turntables
+
     enum class SocdAlgorithm {
         Neutral,
         PreferRecent,
-        PreferFirst
+        PreferFirst,
+        None,
     };
 
     extern SocdAlgorithm ALGORITHM;
@@ -15,8 +19,26 @@ namespace socd {
     typedef enum _SocdResult {
         SocdCCW = 0,
         SocdCW = 1,
-        SocdNone = 2
+        SocdNone = 2,
+        SocdBoth = 3
     } SocdResult;
 
-    SocdResult socd_clean(uint8_t device, bool ccw, bool cw, double time_now);
+    SocdResult socd_clean(
+        uint8_t device,
+        bool ccw,
+        bool cw,
+        double time_now,
+        std::optional<SocdAlgorithm> algorithm = std::nullopt);
+
+    // for guitar wail (up/down only)
+
+    extern uint32_t TILT_HOLD_MS;
+
+    typedef enum _TiltResult {
+        TiltUp = 0,
+        TiltDown = 1,
+        TiltNone = 2
+    } TiltResult;
+
+    TiltResult get_guitar_wail(uint8_t device, bool up, bool down, double time_now);
 }

src/spice2x/util/sysutils.cpp

@@ -235,6 +235,12 @@ namespace sysutils {
             } else {
                 log_misc("gpuinfo", "EnumDisplaySettingsA failed");
             }
+
+            log_misc(
+                "gpuinfo", "{} {} is primary    : {}",
+                prefix.c_str(),
+                index,
+                (adapter->StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) ? "yes" : "no");
         }
     }