update changelog

## Link to GitHub Issue, if one exists
#345 

## Description of change
When the directory specified in the mounttable (in avs-config.xml) lead
to bad path, remember this and show a warning message block before the
game crashes.

## Testing
Tested with simulated bad mounttable set up.

src/spice2x/CMakeLists.txt

@@ -80,6 +80,25 @@ if(MSVC)
 
     # enable COMDAT folding for even smaller release builds
     add_link_options("$<$<CONFIG:RELEASE,MINSIZEREL>:/OPT:ICF>")
+
+    # always use UTF-8 (fix 4819)
+    add_compile_options("/utf-8")
+
+    # spectre mitigation warning
+    add_compile_options("/wd5045")
+
+    # implicit type convert warnings
+    add_compile_options("/wd4244")
+    add_compile_options("/wd4267")
+    add_compile_options("/wd4305")
+
+    # unreferenced local variable
+    add_compile_options("/wd4101")
+
+    # warning in winbase.h??
+    add_compile_options("/wd5039")
+
+
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     # disable warnings about using non _s variants like strncpy
     add_compile_definitions(_CRT_SECURE_NO_WARNINGS)

src/spice2x/acioemu/icca.cpp

@@ -373,7 +373,7 @@ void ICCADevice::update_card(int unit) {
     bool kb_insert_press = false;
 
     // eamio keypress
-    kb_insert_press |= eamuse_get_keypad_state((size_t) unit) & (1 << EAM_IO_INSERT);
+    kb_insert_press |= static_cast<bool>(eamuse_get_keypad_state((size_t) unit) & (1 << EAM_IO_INSERT));
 
     // check for card
     if (this->cards[unit] == nullptr && (eamuse_card_insert_consume(this->node_count, unit) || kb_insert_press)) {

src/spice2x/avs/core.cpp

@@ -8,6 +8,7 @@
 
 #include "external/robin_hood.h"
 #include "launcher/logger.h"
+#include "launcher/signal.h"
 #include "util/detour.h"
 #include "util/fileutils.h"
 #include "util/libutils.h"
@@ -1736,7 +1737,13 @@ namespace avs {
             return;
         }
 
-        static void create_dir(
+        static void avs_dir_err(const std::filesystem::path &src_path)
+        {
+            launcher::signal::AVS_DIR_CREATION_FAILURE = TRUE;
+            launcher::signal::AVS_SRC_PATH = src_path.string();
+        }
+
+        static void create_avs_dir(
                 const std::string_view &avs_path,
                 const std::string_view &src_path)
         {
@@ -1745,6 +1752,7 @@ namespace avs {
             auto real_path = std::filesystem::absolute(src_path, err);
 
             if (err) {
+                avs_dir_err(real_path);
                 log_warning("avs-core", "failed to resolve '{}' path: {}", avs_path, err.message());
                 return;
             }
@@ -1754,7 +1762,9 @@ namespace avs {
             if (created) {
                 log_info("avs-core", "created '{}' at '{}'", avs_path, real_path.string());
             }
+
             if (err) {
+                avs_dir_err(real_path);
                 log_warning("avs-core", "failed to create '{}' folder at '{}': {}",
                         avs_path,
                         real_path.string(),
@@ -1815,7 +1825,7 @@ namespace avs {
                 return;
             }
 
-            create_dir(avs_path, device_path);
+            create_avs_dir(avs_path, device_path);
         }
 
         static void create_avs_config_fs_table(
@@ -1870,7 +1880,7 @@ namespace avs {
                     continue;
                 }
 
-                create_dir(dst_path, src_path);
+                create_avs_dir(dst_path, src_path);
             } while ((vfs_node = property_node_traversal(vfs_node, TRAVERSE_NEXT_SEARCH_RESULT)));
         }
 

src/spice2x/changelog.txt

@@ -1,3 +1,16 @@
+09/28/2025 [spice2x]
+    IIDX: auto apply ASIO compatibility fix for IIDX32+
+    Misc diagnosability updates
+
+09/22/2025 [spice2x]
+    Add Polaris Chord lights
+    Add boot.dll to Gitadora patches target
+    Misc fixes
+
+09/20/2025 [spice2x]
+    Polaris Chord support for knobs/turntables/mouse as fader input
+    Misc fixes
+
 09/18/2025 [spice2x]
     Polaris Chord windowed mode fixes
     UI tweaks

src/spice2x/external/fmt/include/fmt/core.h

@@ -1527,8 +1527,10 @@ FMT_CONSTEXPR auto make_arg(const T& value) -> basic_format_arg<Context> {
   return arg;
 }
 
+#ifdef __GNUC__
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdangling-reference"
+#endif
 
 // The type template parameter is there to avoid an ODR violation when using
 // a fallback formatter in one translation unit and an implicit conversion in
@@ -1544,7 +1546,9 @@ FMT_CONSTEXPR FMT_INLINE auto make_arg(const T& val) -> value<Context> {
   return arg;
 }
 
+#ifdef __GNUC__
 #pragma GCC diagnostic pop
+#endif
 
 template <bool IS_PACKED, typename Context, type, typename T,
           FMT_ENABLE_IF(!IS_PACKED)>

src/spice2x/games/ccj/trackball.cpp

@@ -14,7 +14,7 @@ namespace games::ccj {
     bool MOUSE_TRACKBALL_USE_TOGGLE = false;
     uint8_t TRACKBALL_SENSITIVITY = 10;
 
-    static HANDLE fakeHandle = (HANDLE)0xDEADBEEF;
+    static HANDLE fakeHandle = (HANDLE)0xDEADBEEFull;
     static HWND hWnd = nullptr;
     static WNDPROC wndProc = nullptr;
     static std::thread *tbThread = nullptr;

src/spice2x/games/iidx/iidx.cpp

@@ -8,6 +8,7 @@
 
 #include "games/iidx/legacy_camera.h"
 
+#include "hooks/audio/audio.h"
 #include "hooks/avshook.h"
 #include "hooks/cfgmgr32hook.h"
 #include "hooks/devicehook.h"
@@ -27,6 +28,7 @@
 #include "util/memutils.h"
 #include "util/sigscan.h"
 #include "util/utils.h"
+#include "launcher/signal.h"
 
 #include "external/robin_hood.h"
 
@@ -232,6 +234,9 @@ namespace games::iidx {
         } else if (data.find(" W:touch: missing trigger:") != std::string::npos) {
             out.clear();
             return true;
+        } else if (data.find("SuperstepSound: Audio device is not available") != std::string::npos) {
+            launcher::signal::SUPERSTEP_SOUND_ERROR = TRUE;
+            return false;
         } else {
             return false;
         }
@@ -372,7 +377,11 @@ namespace games::iidx {
             }
         }
 
-        apply_audio_hacks();
+        if (hooks::audio::ENABLED) {
+            apply_audio_hacks();
+        } else {
+            log_warning("iidx", "skipping audio hooks; disabled by user");
+        }
 
         // ASIO device hook
         RegCloseKey_orig = detour::iat_try(
@@ -762,26 +771,30 @@ namespace games::iidx {
                 0);
 
         // attempt to detect ASIO support
+        // <=24 : 32-bit only
         // 25-26: has neither (no patch needed - WASAPI Exclusive by default)
         // 27-30: has both (envvar will be respected, ASIO or WASAPI)
         // 31+: only has XONAR (ASIO by default, signature patch can be used to force WASAPI - for now)
 
         if (!has_SOUND_OUTPUT_DEVICE && !has_XONAR_SOUND_CARD) {
+            // iidx 25-26
             log_info("iidx", "This game only uses WASAPI audio engine");
             return;
         }
 
         if (has_SOUND_OUTPUT_DEVICE && has_XONAR_SOUND_CARD) {
+            // iidx 27-30
             log_info("iidx", "This game accepts SOUND_OUTPUT_DEVICE environment variable");
             return;
         }
 
         log_info("iidx", "This game supports ASIO but does not accept SOUND_OUTPUT_DEVICE environment variable");
 
+        // patch game to force wasapi
         if (SOUND_OUTPUT_DEVICE_IN_EFFECT.has_value() && SOUND_OUTPUT_DEVICE_IN_EFFECT.value() == "wasapi") {
             intptr_t result = replace_pattern(
                 avs::game::DLL_INSTANCE,
-                "FF5008E8????ECFF83780803740D",
+                "FF5008E8??????FF83780803740D",
                 "??????BB00000000EB169090????",
                 0, 0);
 
@@ -796,6 +809,41 @@ namespace games::iidx {
                     "Successfully forced WASAPI as audio engine using signature matching @ 0x{:x}.",
                     result);
             }
+        } else {
+            log_info("iidx", "Not applying force wasapi patch; game will use ASIO");
+        }
+
+        // patch iidx32+ for asio compatibility
+        // only do this if NOT wasapi (as opposed to checking if it's asio)
+        // the patch is only really needed for (some) non-XONAR devices but since people sometimes disguise 
+        // other devices as a XONAR, don't check for the exact string (common ASIO workaround for INF)
+        if (avs::game::is_ext(2024090100, MAXINT) &&
+            !(SOUND_OUTPUT_DEVICE_IN_EFFECT.has_value() && SOUND_OUTPUT_DEVICE_IN_EFFECT.value() == "wasapi")) {
+                
+            // in iidx32 final:
+            // ff 50 08      call   QWORD PTR [rax+0x8]     ; ASIO instance AddRef
+            // 48 8b 4b 08   mov    rcx,QWORD PTR [rbx+0x8]
+            // 48 8b 01      mov    rax,QWORD PTR [rcx]
+            // ff 50 08      call   QWORD PTR [rax+0x8]     ; ASIO instance AddRef
+
+            intptr_t result = replace_pattern(
+                avs::game::DLL_INSTANCE,
+                "FF50????????????????FF50??4533C94533C0418D51",
+                "????????????????????909090??????????????????",
+                0, 0);
+
+            if (result == 0) {
+                log_warning(
+                    "iidx",
+                    "Failed to apply ASIO compatibility fix for iidx32+. "
+                    "Unless patches are applied, your ASIO device ({}) may hang or fail to work",
+                    ASIO_DRIVER->c_str());
+            } else {
+                log_info(
+                    "iidx",
+                    "Successfully applied ASIO compatibility fix for iidx32+ using signature matching @ 0x{:x}.",
+                    result);
+            }
         }
 
 #endif

src/spice2x/games/iidx/local_camera.cpp

@@ -85,12 +85,19 @@ namespace games::iidx {
             &m_pwszSymbolicLink,
             &m_cchSymbolicLink
         );
-        if (FAILED(hr)) { goto done; }
+        if (FAILED(hr)) {
+            log_warning("iidx:camhook", "[{}] GetAllocatedString failed with {:#x}", m_name, (ULONG)hr);
+            goto done;
+        }
+
         log_misc("iidx:camhook", "[{}] Symlink: {}", m_name, GetSymLink());
 
         // Create the media source object.
         hr = pActivate->ActivateObject(IID_PPV_ARGS(&m_pSource));
-        if (FAILED(hr)) { goto done; }
+        if (FAILED(hr)) {
+            log_warning("iidx:camhook", "[{}] ActivateObject failed with {:#x}", m_name, (ULONG)hr);
+            goto done;
+        }
 
         // Retain reference to the camera
         m_pSource->AddRef();
@@ -98,13 +105,22 @@ namespace games::iidx {
 
         // Create an attribute store to hold initialization settings.
         hr = WrappedMFCreateAttributes(&pAttributes, 2);
-        if (FAILED(hr)) { goto done; }
+        if (FAILED(hr)) {
+            log_warning("iidx:camhook", "[{}] MFCreateAttributes failed with {:#x}", m_name, (ULONG)hr);
+            goto done;
+        }
 
         hr = pAttributes->SetUnknown(MF_SOURCE_READER_D3D_MANAGER, pD3DManager);
-        if (FAILED(hr)) { goto done; }
+        if (FAILED(hr)) {
+            log_warning("iidx:camhook", "[{}] SetUnknown(MF_SOURCE_READER_D3D_MANAGER) failed with {:#x}", m_name, (ULONG)hr);
+            goto done;
+        }
 
         hr = pAttributes->SetUINT32(MF_SOURCE_READER_DISABLE_DXVA, FALSE);
-        if (FAILED(hr)) { goto done; }
+        if (FAILED(hr)) {
+            log_warning("iidx:camhook", "[{}] SetUINT32(MF_SOURCE_READER_DISABLE_DXVA) failed with {:#x}", m_name, (ULONG)hr);
+            goto done;
+        }
 
         // TODO: Color space conversion
         // if (SUCCEEDED(hr)) {
@@ -120,11 +136,18 @@ namespace games::iidx {
             pAttributes,
             &m_pSourceReader
         );
-        if (FAILED(hr)) { goto done; }
+        if (FAILED(hr)) {
+            log_warning("iidx:camhook", "[{}] MFCreateSourceReaderFromMediaSource failed with {:#x}", m_name, (ULONG)hr);
+            goto done;
+        }
+
         log_misc("iidx:camhook", "[{}] Created source reader", m_name);
 
         hr = InitTargetTexture();
-        if (FAILED(hr)) { goto done; }
+        if (FAILED(hr)) {
+            log_warning("iidx:camhook", "[{}] InitTargetTexture failed with {:#x}", m_name, (ULONG)hr);
+            goto done;
+        }
 
         // Camera should be still usable even if camera control is not supported
         InitCameraControl();
@@ -134,7 +157,7 @@ namespace games::iidx {
             m_initialized = true;
             log_misc("iidx:camhook", "[{}] Initialized", m_name);
         } else {
-            log_warning("iidx:camhook", "[{}] Failed to create camera: {}", m_name, hr);
+            log_warning("iidx:camhook", "[{}] Failed to create camera: {:#x}", m_name, (ULONG)hr);
         }
         SafeRelease(&pAttributes);
         LeaveCriticalSection(&m_critsec);
@@ -165,7 +188,7 @@ namespace games::iidx {
 
             if (FAILED(hr)) { 
                 if (hr != MF_E_NO_MORE_TYPES) {
-                    log_warning("iidx:camhook", "[{}] Cannot get media type {} {}", m_name, i, hr);
+                    log_warning("iidx:camhook", "[{}] Cannot get media type {} {:#x}", m_name, i, (ULONG)hr);
                 }
                 break; 
             }
@@ -584,7 +607,7 @@ namespace games::iidx {
      * Return values:
      *   S_OK:      this is a "better" media type than the existing one
      *   S_FALSE:   valid media type, but not "better"
-     *   E_*:       invalid meia type
+     *   E_*:       invalid media type
      */
     HRESULT IIDXLocalCamera::TryMediaType(IMFMediaType *pType, UINT32 *pBestWidth, double *pBestFrameRate) {
         HRESULT hr = S_OK;
@@ -595,13 +618,13 @@ namespace games::iidx {
         hr = pType->GetGUID(MF_MT_SUBTYPE, &subtype);
 
         if (FAILED(hr))  { 
-            log_warning("iidx:camhook", "[{}] Failed to get subtype: {}", m_name, hr);
+            log_warning("iidx:camhook", "[{}] Failed to get subtype: {:#x}", m_name, (ULONG)hr);
             return hr;    
         }
 
         hr = MFGetAttributeSize(pType, MF_MT_FRAME_SIZE, &width, &height);
         if (FAILED(hr))  { 
-            log_warning("iidx:camhook", "[{}] Failed to get frame size: {}", m_name, hr);
+            log_warning("iidx:camhook", "[{}] Failed to get frame size: {:#x}", m_name, (ULONG)hr);
             return hr;
         }
         
@@ -619,7 +642,7 @@ namespace games::iidx {
             (UINT32*)&frameRate.Denominator
         );
         if (FAILED(hr))  { 
-            log_warning("iidx:camhook", "[{}] Failed to get frame rate: {}", m_name, hr);
+            log_warning("iidx:camhook", "[{}] Failed to get frame rate: {:#x}", m_name, (ULONG)hr);
             return hr;
         }
         double frameRateValue = frameRate.Numerator / frameRate.Denominator;
@@ -696,7 +719,7 @@ namespace games::iidx {
         if (SUCCEEDED(hr)) {
             log_misc("iidx:camhook", "[{}] Created texture", m_name);
         } else {
-            log_warning("iidx:camhook", "[{}] Failed to create texture: {}", m_name, hr);
+            log_warning("iidx:camhook", "[{}] Failed to create texture: {:#x}", m_name, (ULONG)hr);
         }
         return hr;
     }
@@ -785,7 +808,7 @@ namespace games::iidx {
         FlushDrawCommands();
 
         if (FAILED(hr)) {
-            log_warning("iidx:camhook", "Error in DrawSample {}", hr);
+            log_warning("iidx:camhook", "Error in DrawSample {:#x}", (ULONG)hr);
         }
         SafeRelease(&pCameraSurf);
         LeaveCriticalSection(&m_critsec);

src/spice2x/games/otoca/p4io.cpp

@@ -94,7 +94,7 @@ namespace games::otoca {
         bool kb_insert_press = false;
 
         // eamio keypress
-        kb_insert_press |= eamuse_get_keypad_state(0) & (1 << EAM_IO_INSERT);
+        kb_insert_press |= static_cast<bool>(eamuse_get_keypad_state(0) & (1 << EAM_IO_INSERT));
 
         // check for card
         if (CARD_DATA == nullptr && (eamuse_card_insert_consume(1, 0) || kb_insert_press)) {

src/spice2x/games/pc/bi2x_hook.cpp

@@ -7,8 +7,68 @@
 #include "games/io.h"
 #include "io.h"
 #include "util/tapeled.h"
+#include "pc.h"
+#include "util/utils.h"
 
 namespace games::pc {
+    bool PC_KNOB_MODE = false;
+
+    constexpr float RELATIVE_DECAY = 0.02f;
+    struct FADER_RELATIVE {
+        // ranges from 0.f to 1.f
+        float previous_raw = 0.5f;
+
+        // ranges from -1.f to +1.f
+        float effective_value = 0.f;
+    };
+
+    FADER_RELATIVE fader_l_relative;
+    FADER_RELATIVE fader_r_relative;
+
+    float calculate_analog_raw_delta(float old_value, float new_value) {
+        // assumed that values are between 0.f and 1.f
+
+        float delta = 0.f;
+        if ((old_value < 0.25f) && (0.75f < new_value)) {
+            // wrapped around: going left
+            delta = -((1.f - new_value) + old_value);
+            
+        } else if ((new_value < 0.25f) && (0.75f < old_value)) {
+            // wrapped around: going right
+            delta = (1.f - old_value) + new_value;
+
+        } else {
+            delta = new_value - old_value;
+        }
+        return delta;
+    }
+
+    float apply_decay(float val) {
+        // return to center over time
+        if (RELATIVE_DECAY < val) {
+            return val - RELATIVE_DECAY;
+        } else if (val < -RELATIVE_DECAY) {
+            return val + RELATIVE_DECAY;
+        } else {
+            return 0.f;
+        }
+    }
+
+    float get_fader_knob_mode_value(float raw_analog, FADER_RELATIVE &fader) {
+        // add new value...
+        const float delta = calculate_analog_raw_delta(fader.previous_raw, raw_analog);
+        fader.effective_value += (delta * 20.f);
+        fader.previous_raw = raw_analog;
+
+        // capture the result after adding new input value
+        fader.effective_value = CLAMP(fader.effective_value, -1.f, 1.f);
+        const float result = fader.effective_value;
+
+        // post-process for next iteration: apply decay (return to center over time)
+        fader.effective_value = apply_decay(fader.effective_value);
+
+        return result;
+    }
 
     /*
      * class definitions
@@ -270,7 +330,13 @@ namespace games::pc {
         // FADER-L
         float val = 0.f;
         if (analogs[Analogs::FaderL].isSet()) {
-            val = (GameAPI::Analogs::getState(RI_MGR, analogs[Analogs::FaderL]) - 0.5f) * 2;
+            if (PC_KNOB_MODE) {
+                val = get_fader_knob_mode_value(
+                    GameAPI::Analogs::getState(RI_MGR, analogs[Analogs::FaderL]),
+                    fader_l_relative);
+            } else {
+                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])) {
@@ -289,7 +355,13 @@ namespace games::pc {
         // FADER-R
         val = 0.f;
         if (analogs[Analogs::FaderR].isSet()) {
-            val = (GameAPI::Analogs::getState(RI_MGR, analogs[Analogs::FaderR]) - 0.5f) * 2;
+            if (PC_KNOB_MODE) {
+                val = get_fader_knob_mode_value(
+                    GameAPI::Analogs::getState(RI_MGR, analogs[Analogs::FaderR]),
+                    fader_r_relative);
+            } else {
+                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])) {
@@ -343,6 +415,19 @@ namespace games::pc {
         }
     }
 
+    struct PolarisChordLight {
+        int data_index;
+        games::pc::Lights::pc_lights_t light;
+        PolarisChordLight(
+            int data_index, games::pc::Lights::pc_lights_t light) :
+                data_index(data_index), light(light) {}
+    };
+
+    static void set_led_value(games::pc::Lights::pc_lights_t light, uint8_t value) {
+        auto &lights = games::pc::get_lights();
+        GameAPI::Lights::writeLight(RI_MGR, lights.at(light), value / 255.f);
+    }
+
     void __fastcall aioIob2Bi2xAC1_SetTapeLedDataPart(AIO_IOB2_BI2X_AC1 *i_pNodeCtl, uint32_t i_TapeLedCh,
                                                       uint32_t i_Offset, uint8_t *i_pData,
                                                       uint32_t i_cntTapeLed, bool i_bReverse) {
@@ -350,8 +435,82 @@ namespace games::pc {
             return aioIob2Bi2xAC1_SetTapeLedDataPart_orig(i_pNodeCtl, i_TapeLedCh, i_Offset, i_pData, i_cntTapeLed, i_bReverse);
         }
 
-        // TODO implement tape led
-        //  there are >200 lights in total, adding each one separately probably isn't the best idea...
+        // log_info(
+        //     "pc",
+        //     "lamp [{}] [{}] = {},{},{}, cnt={}",
+        //     i_TapeLedCh,
+        //     i_Offset,
+        //     i_pData[0], i_pData[1], i_pData[2],
+        //     i_cntTapeLed);
+
+        // [channel 0]
+        // these are button lamps; there are 12 buttons (columns) with this layout:
+        //
+        // 0  5   8  11  14  16  |  18  20  22  25  28  31
+        // 1  6   9  12  15  17  |  19  21  23  26  29  32
+        // 2  7  10  13          |          24  27  30  33
+        // 3                     |                      34
+        // 4                     |                      35 
+        //
+        // 36 RGB lamps * 3 = 108 LEDs
+        // each value ranges from [0, 255]
+        // (we only care about the top row)
+
+        static PolarisChordLight button_lights_mapping[] = {
+            {(0 * 3) + 0, games::pc::Lights::pc_lights_t::Button1_R},
+            {(0 * 3) + 1, games::pc::Lights::pc_lights_t::Button1_G},
+            {(0 * 3) + 2, games::pc::Lights::pc_lights_t::Button1_B},
+
+            {(5 * 3) + 0, games::pc::Lights::pc_lights_t::Button2_R},
+            {(5 * 3) + 1, games::pc::Lights::pc_lights_t::Button2_G},
+            {(5 * 3) + 2, games::pc::Lights::pc_lights_t::Button2_B},
+
+            {(8 * 3) + 0, games::pc::Lights::pc_lights_t::Button3_R},
+            {(8 * 3) + 1, games::pc::Lights::pc_lights_t::Button3_G},
+            {(8 * 3) + 2, games::pc::Lights::pc_lights_t::Button3_B},
+
+            {(11 * 3) + 0, games::pc::Lights::pc_lights_t::Button4_R},
+            {(11 * 3) + 1, games::pc::Lights::pc_lights_t::Button4_G},
+            {(11 * 3) + 2, games::pc::Lights::pc_lights_t::Button4_B},
+
+            {(14 * 3) + 0, games::pc::Lights::pc_lights_t::Button5_R},
+            {(14 * 3) + 1, games::pc::Lights::pc_lights_t::Button5_G},
+            {(14 * 3) + 2, games::pc::Lights::pc_lights_t::Button5_B},
+
+            {(16 * 3) + 0, games::pc::Lights::pc_lights_t::Button6_R},
+            {(16 * 3) + 1, games::pc::Lights::pc_lights_t::Button6_G},
+            {(16 * 3) + 2, games::pc::Lights::pc_lights_t::Button6_B},
+
+            {(18 * 3) + 0, games::pc::Lights::pc_lights_t::Button7_R},
+            {(18 * 3) + 1, games::pc::Lights::pc_lights_t::Button7_G},
+            {(18 * 3) + 2, games::pc::Lights::pc_lights_t::Button7_B},
+
+            {(20 * 3) + 0, games::pc::Lights::pc_lights_t::Button8_R},
+            {(20 * 3) + 1, games::pc::Lights::pc_lights_t::Button8_G},
+            {(20 * 3) + 2, games::pc::Lights::pc_lights_t::Button8_B},
+
+            {(22 * 3) + 0, games::pc::Lights::pc_lights_t::Button9_R},
+            {(22 * 3) + 1, games::pc::Lights::pc_lights_t::Button9_G},
+            {(22 * 3) + 2, games::pc::Lights::pc_lights_t::Button9_B},
+
+            {(25 * 3) + 0, games::pc::Lights::pc_lights_t::Button10_R},
+            {(25 * 3) + 1, games::pc::Lights::pc_lights_t::Button10_G},
+            {(25 * 3) + 2, games::pc::Lights::pc_lights_t::Button10_B},
+
+            {(28 * 3) + 0, games::pc::Lights::pc_lights_t::Button11_R},
+            {(28 * 3) + 1, games::pc::Lights::pc_lights_t::Button11_G},
+            {(28 * 3) + 2, games::pc::Lights::pc_lights_t::Button11_B},
+
+            {(31 * 3) + 0, games::pc::Lights::pc_lights_t::Button12_R},
+            {(31 * 3) + 1, games::pc::Lights::pc_lights_t::Button12_G},
+            {(31 * 3) + 2, games::pc::Lights::pc_lights_t::Button12_B},
+        };
+
+        if (i_TapeLedCh == 0 && i_Offset == 0 && i_cntTapeLed == 108) {
+            for (const auto &map : button_lights_mapping) {
+                set_led_value(map.light, i_pData[map.data_index]);
+            }
+        }
     }
 
     void __fastcall aioIob2Bi2x_SetTapeLedDataGroup(AIO_IOB2_BI2X_AC1* i_pNodeCtl, uint32_t i_bfGroup) {

src/spice2x/games/pc/io.cpp

@@ -71,7 +71,55 @@ std::vector<Light> &games::pc::get_lights() {
                 &lights,
                 "IC Reader R",
                 "IC Reader G",
-                "IC Reader B"
+                "IC Reader B",
+
+                "Button 1 R",
+                "Button 1 G",
+                "Button 1 B",
+
+                "Button 2 R",
+                "Button 2 G",
+                "Button 2 B",
+
+                "Button 3 R",
+                "Button 3 G",
+                "Button 3 B",
+
+                "Button 4 R",
+                "Button 4 G",
+                "Button 4 B",
+
+                "Button 5 R",
+                "Button 5 G",
+                "Button 5 B",
+
+                "Button 6 R",
+                "Button 6 G",
+                "Button 6 B",
+
+                "Button 7 R",
+                "Button 7 G",
+                "Button 7 B",
+
+                "Button 8 R",
+                "Button 8 G",
+                "Button 8 B",
+
+                "Button 9 R",
+                "Button 9 G",
+                "Button 9 B",
+
+                "Button 10 R",
+                "Button 10 G",
+                "Button 10 B",
+
+                "Button 11 R",
+                "Button 11 G",
+                "Button 11 B",
+
+                "Button 12 R",
+                "Button 12 G",
+                "Button 12 B"
         );
     }
 

src/spice2x/games/pc/io.h

@@ -41,6 +41,55 @@ namespace games::pc {
             IC_READER_R,
             IC_READER_G,
             IC_READER_B,
+
+            Button1_R,
+            Button1_G,
+            Button1_B,
+
+            Button2_R,
+            Button2_G,
+            Button2_B,
+
+            Button3_R,
+            Button3_G,
+            Button3_B,
+
+            Button4_R,
+            Button4_G,
+            Button4_B,
+
+            Button5_R,
+            Button5_G,
+            Button5_B,
+
+            Button6_R,
+            Button6_G,
+            Button6_B,
+           
+            Button7_R,
+            Button7_G,
+            Button7_B,
+
+            Button8_R,
+            Button8_G,
+            Button8_B,
+
+            Button9_R,
+            Button9_G,
+            Button9_B,
+
+            Button10_R,
+            Button10_G,
+            Button10_B,
+
+            Button11_R,
+            Button11_G,
+            Button11_B,
+
+            Button12_R,
+            Button12_G,
+            Button12_B
+            
         } pc_lights_t;
     }
 

src/spice2x/games/pc/pc.h

@@ -5,6 +5,7 @@
 namespace games::pc {
     extern std::string PC_INJECT_ARGS;
     extern bool PC_NO_IO;
+    extern bool PC_KNOB_MODE;
 
     class PCGame : public games::Game {
     public:

src/spice2x/games/sdvx/sdvx.cpp

@@ -24,6 +24,7 @@
 #include "io.h"
 #include "acioemu/handle.h"
 #include "cfg/configurator.h"
+#include "launcher/signal.h"
 
 static decltype(RegCloseKey) *RegCloseKey_orig = nullptr;
 static decltype(RegEnumKeyA) *RegEnumKeyA_orig = nullptr;
@@ -209,6 +210,10 @@ namespace games::sdvx {
             out = "";
             return true;
         }
+        if (data.find("SuperstepSound: Audio device is not available") != std::string::npos) {
+            launcher::signal::SUPERSTEP_SOUND_ERROR = TRUE;
+            return false;
+        }
         return false;
     }
 

src/spice2x/hooks/networkhook.cpp

@@ -141,13 +141,17 @@ static ULONG WINAPI GetAdaptersInfo_hook(PIP_ADAPTER_INFO pAdapterInfo, PULONG p
 
 static int WINAPI bind_hook(SOCKET s, const struct sockaddr *name, int namelen) {
 
+#ifdef __clang__
 #pragma clang diagnostic push
 #pragma ide diagnostic ignored "OCDFAInspection"
+#endif
 
     // cast to sockaddr_in
     struct sockaddr_in *in_name = (struct sockaddr_in *) name;
 
+#ifdef __clang__
 #pragma clang diagnostic pop
+#endif
 
     // override bind to allow all hosts
     in_name->sin_addr.s_addr = inet_addr("0.0.0.0");

src/spice2x/launcher/launcher.cpp

@@ -1112,6 +1112,9 @@ int main_implementation(int argc, char *argv[]) {
     if (options[launcher::Options::PCNoIO].is_active()) {
         games::pc::PC_NO_IO = options[launcher::Options::PCNoIO].value_bool();
     }
+    if (options[launcher::Options::PCKnobMode].value_bool()) {
+        games::pc::PC_KNOB_MODE = true;
+    }
     if (options[launcher::Options::spice2x_EnableSMXStage].value_bool()) {
         rawinput::ENABLE_SMX_STAGE = true;
     }
@@ -1964,6 +1967,7 @@ int main_implementation(int argc, char *argv[]) {
     libutils::warn_if_dll_exists("nvcuvid.dll");
     libutils::warn_if_dll_exists("nvEncodeAPI64.dll");
     libutils::warn_if_dll_exists("msvcr100.dll");
+    libutils::warn_if_dll_exists("dsound.dll");
 
     // complain loudly & early about dll load ordering issue
     libutils::check_duplicate_dlls();

src/spice2x/launcher/options.cpp

@@ -1049,7 +1049,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
     },
     {
         // LoadCCJModule
-        .title = "Force Load Chase Chase Jokers",
+        .title = "Force Load Chase Chase Jokers Module",
         .name = "ccj",
         .desc = "manually enable Chase Chase Jokers module",
         .type = OptionType::Bool,
@@ -1058,7 +1058,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
     },
     {
         // LoadQKSModule
-        .title = "Force Load QuizKnock STADIUM",
+        .title = "Force Load QuizKnock STADIUM Module",
         .name = "qks",
         .desc = "manually enable QuizKnock STADIUM module",
         .type = OptionType::Bool,
@@ -1067,7 +1067,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
     },
     {
         // LoadMFGModule
-        .title = "Force Load Mahjong Fight Girl",
+        .title = "Force Load Mahjong Fight Girl Module",
         .name = "mfg",
         .desc = "manually enable Mahjong Fight Girl module",
         .type = OptionType::Bool,
@@ -1076,7 +1076,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
     },
     {
         // LoadPCModule
-        .title = "Force Load Polaris Chord",
+        .title = "Force Load Polaris Chord Module",
         .name = "pc",
         .desc = "manually enable Polaris Chord module",
         .type = OptionType::Bool,
@@ -1085,7 +1085,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
     },
     {
         // LoadMusecaModule
-        .title = "Force Load Museca",
+        .title = "Force Load Museca Module",
         .name = "museca",
         .desc = "manually enable Museca module",
         .type = OptionType::Bool,
@@ -1806,6 +1806,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .category = "Game Options (Advanced)"
     },
     {
+        // PCArgs
         .title = "PC Arguments Override",
         .name = "pcargs",
         .desc = "Command line arguments passed to the game.",
@@ -1815,6 +1816,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .category = "Game Options (Advanced)",
     },
     {
+        // PCNoIO
         .title = "PC Disable IO Emulation",
         .name = "pcnoio",
         .desc = "Disables BI2X hooks for PC",
@@ -1823,6 +1825,15 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .game_name = "Polaris Chord",
         .category = "Game Options (Advanced)"
     },
+    {
+        // PCKnobMode
+        .title = "PC Fader Knobs Mode",
+        .name = "pcknobs",
+        .desc = "Allows SDVX knobs and IIDX turntables to be bound as Polaris Chord faders",
+        .type = OptionType::Bool,
+        .game_name = "Polaris Chord",
+        .category = "Game Options",
+    },
     {
         // spice2x_LightsOverallBrightness
         .title = "Lights Brightness Adjustment",
@@ -2445,7 +2456,7 @@ std::unique_ptr<std::vector<Option>> launcher::parse_options(int argc, char *arg
                             } else {
                                 // validate it is an integer
                                 try {
-                                    std::stoull(argv[i], nullptr, 16);
+                                    auto _ = std::stoull(argv[i], nullptr, 16);
                                 } catch (const std::exception &ex) {
                                     log_fatal("options", "parameter for -{} is not a hex number: {}", alias, argv[i]);
                                 }

src/spice2x/launcher/options.h

@@ -205,6 +205,7 @@ namespace launcher {
             MFGNoIO,
             PCArgs,
             PCNoIO,
+            PCKnobMode,
             spice2x_LightsOverallBrightness,
             spice2x_WindowBorder,
             spice2x_WindowSize,

src/spice2x/launcher/signal.cpp

@@ -1,11 +1,11 @@
 #include "signal.h"
 
 #include <exception>
-#include <string>
 
 #include <windows.h>
 #include <dbghelp.h>
 
+#include "avs/core.h"
 #include "acio/acio.h"
 #include "external/stackwalker/stackwalker.h"
 #include "hooks/libraryhook.h"
@@ -29,6 +29,11 @@ namespace launcher::signal {
     // settings
     bool DISABLE = false;
     bool USE_VEH_WORKAROUND = false;
+
+    // states
+    bool SUPERSTEP_SOUND_ERROR = false;
+    bool AVS_DIR_CREATION_FAILURE = false;
+    std::string AVS_SRC_PATH;
 }
 
 #define V(variant) case variant: return #variant
@@ -111,6 +116,25 @@ static LONG WINAPI TopLevelExceptionFilter(struct _EXCEPTION_POINTERS *Exception
                 "    RivaTuner Statistics Server (RTSS), MSI Afterburner, kernel mode anti-cheat");
         }
 
+        if (launcher::signal::SUPERSTEP_SOUND_ERROR) {
+            log_warning("signal", "audio initialization error was previously detected during boot!");
+            log_warning("signal", "    (W:SuperstepSound: Audio device is not available!!!)");
+            log_warning("signal", "    this crash is most likely related to audio init failure");
+            log_warning("signal", "    fix your audio device, double check your audio options/patches, and try again");
+        }
+
+        if (launcher::signal::AVS_DIR_CREATION_FAILURE) {
+            log_warning("signal",
+                "AVS filesystem initialization failure was previously detected during boot!");
+            log_warning("signal",
+                "    ERROR: directory could not be created: {}",
+                launcher::signal::AVS_SRC_PATH.c_str());
+            log_warning("signal",
+                "    this crash may have been caused by bad <mounttable> contents in {}",
+                avs::core::CFG_PATH.c_str());
+            log_warning("signal", "    fix the XML file and try again");
+        }
+
         // walk the exception chain
         struct _EXCEPTION_RECORD *record_cause = ExceptionRecord->ExceptionRecord;
         while (record_cause != nullptr) {

src/spice2x/launcher/signal.h

@@ -1,10 +1,16 @@
 #pragma once
 
+#include <string>
+
 namespace launcher::signal {
 
     // settings
     extern bool DISABLE;
     extern bool USE_VEH_WORKAROUND;
+    extern bool SUPERSTEP_SOUND_ERROR;
+    extern bool AVS_DIR_CREATION_FAILURE;
+    extern std::string AVS_XML_PATH;
+    extern std::string AVS_SRC_PATH;
 
     //void print_stacktrace();
     void attach();

src/spice2x/misc/extdev.cpp

@@ -162,7 +162,7 @@ static void __cdecl cardunit_update() {
         bool kb_insert_press = false;
 
         // eamio keypress
-        kb_insert_press |= eamuse_get_keypad_state(unit) & (1 << EAM_IO_INSERT);
+        kb_insert_press |= static_cast<bool>(eamuse_get_keypad_state(unit) & (1 << EAM_IO_INSERT));
 
         // update card inserts
         if (eamuse_card_insert_consume((int) EXTDEV_CARDUNIT_COUNT, unit) ||

src/spice2x/overlay/windows/generic_sub.cpp

@@ -4,6 +4,7 @@
 
 #include <fmt/format.h>
 
+#include "avs/game.h"
 #include "games/io.h"
 #include "cfg/screen_resize.h"
 #include "hooks/graphics/backends/d3d9/d3d9_backend.h"
@@ -88,13 +89,32 @@ namespace overlay::windows {
     void GenericSubScreen::touch_transform(const ImVec2 xy_in, LONG *x_out, LONG *y_out) {}
 
     void GenericSubScreen::build_content() {
+        this->flags |= ImGuiWindowFlags_NoBackground;
+        
         if (this->disabled_message.has_value()) {
             this->flags &= ~ImGuiWindowFlags_NoBackground;
             ImGui::TextColored(YELLOW, "%s", this->disabled_message.value().c_str());
             return;
         }
+
         this->draw_texture();
 
+        if (!this->texture) {
+            this->flags &= ~ImGuiWindowFlags_NoBackground;
+            ImGui::TextColored(YELLOW, "Failed to acquire surface texture for subscreen.");
+            if (avs::game::is_model("LDJ")) {
+                ImGui::TextColored(
+                    YELLOW,
+                    "Ensure that you are using the correct DLL type, \n"
+                    "or patch the DLL to properly enable TDJ mode.");
+            } else if (avs::game::is_model("KFC")) {
+                ImGui::TextColored(
+                    YELLOW,
+                    "Ensure that you did not accidentally enable a patch \n"
+                    "that turns off subscreen rendering.");
+            }
+        }
+
 #if OVERLAYDBG
         if (this->status_message.has_value()) {
             log_warning("sub::overlay", "{}", this->status_message.value().c_str());

src/spice2x/overlay/windows/iidx_sub.cpp

@@ -14,7 +14,7 @@ namespace overlay::windows {
         if (GRAPHICS_IIDX_WSUB) {
             this->disabled_message =
                 "Close this overlay and use the second window.\n"
-                "Or, turn on -iidxnosub to use the overlay instead.";
+                "If you don't see the window, double check your DLL type and apply TDJ I/O patches as needed.";
             this->draws_window = false;
         }
 

src/spice2x/overlay/windows/patch_manager.cpp

@@ -80,7 +80,7 @@ namespace overlay::windows {
         {"arkmmd.dll", {"gamemmd.dll"}},
         {"arkklp.dll", {"lpac.dll"}},
         {"arknck.dll", {"weac.dll"}},
-        {"gdxg.dll", {"game.dll", "libshare-pj.dll"}}
+        {"gdxg.dll", {"game.dll", "libshare-pj.dll", "boot.dll"}}
     };
 
     static size_t url_recent_idx = -1;

src/spice2x/util/detour.cpp

@@ -106,8 +106,10 @@ bool detour::inline_restore(void *address, char *data) {
 #endif
 }
 
+#ifdef __clang__
 #pragma clang diagnostic push
 #pragma ide diagnostic ignored "OCDFAInspection"
+#endif
 
 static void *pe_offset(void *ptr, size_t offset) {
     if (offset == 0) {
@@ -282,7 +284,9 @@ void **detour::iat_find_proc(const char *iid_name, void *proc, HMODULE module) {
     return nullptr;
 }
 
+#ifdef __clang__
 #pragma clang diagnostic pop
+#endif
 
 void *detour::iat_try(const char *function, void *new_func, HMODULE module, const char *iid_name) {
 

src/spice2x/util/libutils.cpp

@@ -29,19 +29,17 @@ std::filesystem::path libutils::module_file_name(HMODULE module) {
 
 static inline void load_library_fail(const std::string &file_name, bool fatal) {
     std::string info_str { fmt::format(
-        "\n\nPlease check if {} exists and the permissions are fine.\n"
-        "\n"
-        "* If the problem still persists, try installing things on this list:\n"
-        "    https://github.com/spice2x/spice2x.github.io/wiki/DLL-Dependencies \n"
-        "\n"
-        "* Still have problems after installing from above and rebooting PC?\n"
-        "    Avoid manually specifying DLL path (-exec) and module directory (-modules); let spice2x auto-detect unless you have a good reason not to\n"
-        "    Ensure you do NOT have multiple copies of the game DLLs (e.g., in contents and in contents\\modules)\n"
-        "    Certain games require specific NVIDIA DLLs when running with AMD/Intel GPUs (hint: look inside stub directory for DLLs)\n"
-        "\n"
-        "* (For advanced users) if none of the above helps, find the missing dependency using:\n"
-        "    https://github.com/lucasg/Dependencies (recommended for most) \n"
-        "    http://www.dependencywalker.com/ (for old OS) \n"
+        "DLL failed to load - this is a common error. Please carefully read ALL of the following steps for a fix:\n"
+        " 1. Confirm if the file ({}) exists on the disk and check the file permissions.\n"
+        " 2. Follow this link and install DLL prerequisites on this list:\n"
+        "        https://github.com/spice2x/spice2x.github.io/wiki/DLL-Dependencies \n"
+        " 3. Still have problems after installing from above and rebooting PC?\n"
+        "     a. Avoid manually specifying DLL path (-exec) and module directory (-modules); let spice2x auto-detect unless you have a good reason not to\n"
+        "     b. Ensure you do NOT have multiple copies of the game DLLs (e.g., in contents and in contents\\modules)\n"
+        "     c. Certain games require specific NVIDIA DLLs when running with AMD/Intel GPUs (hint: look inside stub directory for DLLs)\n"
+        " 4. (For advanced users) if none of the above helps, find the missing dependency using:\n"
+        "     a. https://github.com/lucasg/Dependencies (recommended for most) \n"
+        "     b. http://www.dependencywalker.com/ (for old OS) \n"
     , file_name) };
     if (fatal) {
         log_fatal("libutils", "{}", info_str);