iidx: fix play record feature broken by new NVIDIA driver update (#444)

## Link to GitHub Issue, if one exists
fixes #442

## Description of change
New NVIDIA driver update (591.44) dropped support for older NVENC API.
Specifically,

* TDJ uses `NV_ENC_PRESET_HQ_GUID` but this is no longer supported; must
be swapped with new encoder presets
* `NvEncGetEncodePresetConfig` does not take new encoder presets, the
-Ex version must be used

All of this happens because bm2dx.dll takes code from an older NVENC
sample.

To address this,

* Install additional hooks for NVENC API
* Hijack calls to `NvEncGetEncodePresetConfig` and instead swap with
`NvEncGetEncodePresetConfigEx` (only if the initial call fails, which is
how we detect old vs new driver), replacing `NV_ENC_PRESET_HQ_GUID` with
`NV_ENC_PRESET_P4_GUID` and `NV_ENC_TUNING_INFO_HIGH_QUALITY`
(functionally equivalent according to NVIDIA docs -
https://docs.nvidia.com/video-technologies/video-codec-sdk/11.1/nvenc-preset-migration-guide/index.html)
* When calling `nvEncInitializeEncoder`, hijack and swap in the preset
GUID again.

## Testing
Tested on 591.44 driver on a RTX 4070.

The resulting videos were compared as well, and they are practically
identical from encoder perspective.

src/spice2x/acio/mdxf/mdxf.cpp

@@ -11,13 +11,14 @@
 const size_t STATUS_BUFFER_SIZE = 32;
 
 // static stuff
-static uint8_t COUNTER = 0;
+static uint8_t HEAD_P1 = 0;
+static uint8_t HEAD_P2 = 0;
 
 // buffers
 #pragma pack(push, 1)
 static struct {
-    uint8_t STATUS_BUFFER_P1[7][STATUS_BUFFER_SIZE] {};
-    uint8_t STATUS_BUFFER_P2[7][STATUS_BUFFER_SIZE] {};
+    uint8_t STATUS_BUFFER_P1[16][STATUS_BUFFER_SIZE] {};
+    uint8_t STATUS_BUFFER_P2[16][STATUS_BUFFER_SIZE] {};
 } BUFFERS {};
 #pragma pack(pop)
 
@@ -40,29 +41,50 @@ static uint64_t arkGetTickTime64() {
  * Implementations
  */
 
-static bool __cdecl ac_io_mdxf_get_control_status_buffer(int node, void *buffer, uint8_t a3, uint8_t a4) {
+static uint64_t __cdecl ac_io_mdxf_get_control_status_buffer(int node, void *out, uint8_t index, uint8_t head_in) {
+
+	// Default error value (matches original mask behavior)
+    auto error_ret = static_cast<uint64_t>(node - 0x11) & 0xFFFFFFFFFFFFFF00;
 	
     // Dance Dance Revolution
     if (avs::game::is_model("MDX")) {
 
-        // get buffer index
-        auto i = (COUNTER + a3) % std::size(BUFFERS.STATUS_BUFFER_P1);
+        // Select player-specific state
+		uint8_t head;
+		uint8_t (*buffer)[STATUS_BUFFER_SIZE];
+		size_t size;
 		
-        // copy buffer
-        if (node == 17 || node == 25) {
-            memcpy(buffer, BUFFERS.STATUS_BUFFER_P1[i], STATUS_BUFFER_SIZE);
-        } else if (node == 18 || node == 26) {
-            memcpy(buffer, BUFFERS.STATUS_BUFFER_P2[i], STATUS_BUFFER_SIZE);
-        } else {
+		if (node == 17 || node == 25) {
+			head = HEAD_P1;
+			buffer = BUFFERS.STATUS_BUFFER_P1;
+			size = std::size(BUFFERS.STATUS_BUFFER_P1);
+		} else if (node == 18 || node == 26) {
+			head = HEAD_P2;
+			buffer = BUFFERS.STATUS_BUFFER_P2;
+			size = std::size(BUFFERS.STATUS_BUFFER_P2);
+		} else {
+			memset(out, 0, STATUS_BUFFER_SIZE);
+			return error_ret;
+		}
 
-            // fill with zeros on unknown node
-            memset(buffer, 0, STATUS_BUFFER_SIZE);
-            return false;
-        }
+		if (head_in != 0xFF) {
+			head = head_in;
+		}
+
+		// Compute ring index: walk backwards from head as index increases
+		// Assumes ring buffer size is a power of two
+		const size_t mask = size - 1;
+		const size_t offset = static_cast<size_t>(index) & mask;
+		const size_t i = (static_cast<size_t>(head) - offset + size) & mask;
+
+		// Copy the chosen entry
+		memcpy(out, buffer[i], STATUS_BUFFER_SIZE);
+
+		// Return the head value actually used
+		return static_cast<uint64_t>(head);
     }
 
-    // return success
-    return true;
+    return error_ret;
 }
 
 static bool __cdecl ac_io_mdxf_set_output_level(unsigned int a1, unsigned int a2, uint8_t value) {
@@ -106,9 +128,6 @@ static bool __cdecl ac_io_mdxf_set_output_level(unsigned int a1, unsigned int a2
 
 static bool __cdecl ac_io_mdxf_update_control_status_buffer(int node) {
 
-    // increase counter
-    COUNTER = (COUNTER + 1) % std::size(BUFFERS.STATUS_BUFFER_P1);
-
     // check freeze
     if (STATUS_BUFFER_FREEZE) {
         return true;
@@ -119,11 +138,15 @@ static bool __cdecl ac_io_mdxf_update_control_status_buffer(int node) {
     switch (node) {
         case 17:
         case 25:
-            buffer = BUFFERS.STATUS_BUFFER_P1[COUNTER];
+			// increase counter
+			HEAD_P1 = (HEAD_P1 + 1) % std::size(BUFFERS.STATUS_BUFFER_P1);
+            buffer = BUFFERS.STATUS_BUFFER_P1[HEAD_P1];
             break;
         case 18:
         case 26:
-            buffer = BUFFERS.STATUS_BUFFER_P2[COUNTER];
+			// increase counter
+			HEAD_P2 = (HEAD_P2 + 1) % std::size(BUFFERS.STATUS_BUFFER_P2);
+            buffer = BUFFERS.STATUS_BUFFER_P2[HEAD_P2];
             break;
         default:
 

src/spice2x/avs/ea3.cpp

@@ -8,6 +8,7 @@
 #include "games/mfc/mfc.h"
 #include "hooks/avshook.h"
 #include "util/detour.h"
+#include "util/deferlog.h"
 #include "util/fileutils.h"
 #include "util/libutils.h"
 #include "util/logging.h"
@@ -282,6 +283,7 @@ namespace avs {
 
             // read software nodes
             if (ea3_soft != nullptr) {
+                log_misc("avs-ea3", "reading soft id from {}...", ea3_config_name);
                 avs::core::property_node_refer(ea3_config, ea3_soft, "model",
                         avs::core::NODE_TYPE_str, EA3_MODEL, 4);
                 avs::core::property_node_refer(ea3_config, ea3_soft, "dest",
@@ -293,6 +295,7 @@ namespace avs {
                 avs::core::property_node_refer(ea3_config, ea3_soft, "ext",
                         avs::core::NODE_TYPE_str, EA3_EXT, 11);
             } else if (fileutils::file_exists("prop/ea3-ident.xml")) {
+                log_misc("avs-ea3", "reading soft id from prop/ea3-ident.xml...");
 
                 // read ident config
                 auto ea3_ident = avs::core::config_read("prop/ea3-ident.xml");
@@ -316,7 +319,14 @@ namespace avs {
                 // clean up
                 avs::core::config_destroy(ea3_ident);
             } else {
-                log_fatal("avs-ea3", "node not found in '{}': /ea3/soft", ea3_config_name);
+                // <ea3><soft> node missing error
+                log_warning("avs-ea3", "soft id (datecode) not found in prop XML files");
+                log_warning("avs-ea3", "get fixed prop files and try again - you have incomplete data");
+                log_warning("avs-ea3", "for experts only:");
+                log_warning("avs-ea3", "  * add the missing <soft>...</soft> node to {}", ea3_config_name);
+                log_warning("avs-ea3", "  * alternatively, provide ea3-ident.xml with <ea3_conf><soft>...");
+
+                log_fatal("avs-ea3", "datecode missing in '{}'; 'prop/ea3-ident.xml' also missing", ea3_config_name);
             }
 
             // set account id (`EA3_PCBID` is valid if and only if `/ea3/id` is present)
@@ -484,8 +494,13 @@ namespace avs {
             std::ostringstream init_code;
             init_code << EA3_MODEL;
             init_code << EA3_DEST;
-            init_code << EA3_SPEC;
-            init_code << EA3_REV;
+            if (strcmp(EA3_MODEL, "MDX") == 0 && strcmp(EA3_SPEC, "I") == 0) {
+                init_code << "G";
+                init_code << "B";
+            } else {
+                init_code << EA3_SPEC;
+                init_code << EA3_REV;
+            }
             init_code << EA3_EXT;
             std::string init_code_str = init_code.str();
 
@@ -563,6 +578,7 @@ namespace avs {
             soft_id_code << EA3_EXT;
             std::string soft_id_code_str = soft_id_code.str();
             log_info("avs-ea3", "soft id code: {}", soft_id_code_str);
+            deferredlogs::set_softid(soft_id_code_str);
 
             // set soft ID code
             avs::core::avs_std_setenv("/env/profile/soft_id_code", soft_id_code_str.c_str());

src/spice2x/cfg/analog.h

@@ -82,18 +82,23 @@ public:
         return this->index != 0xFF;
     }
 
-    inline void clearBindings() {
-        device_identifier = "";
-        index = 0xFF;
+    inline void resetValues() {
         setSensitivity(1.f);
         setDeadzone(0.f);
         invert = false;
         smoothing = false;
+        deadzone_mirror = false;
         setMultiplier(1);
         setRelativeMode(false);
         setDelayBufferDepth(0);
     }
 
+    inline void clearBindings() {
+        device_identifier = "";
+        index = 0xFF;
+        resetValues();
+    }
+
     inline const std::string &getName() const {
         return this->name;
     }

src/spice2x/games/ddr/ddr.cpp

@@ -2,6 +2,8 @@
 
 #include "acioemu/handle.h"
 #include "avs/game.h"
+#include "hooks/avshook.h"
+#include "hooks/cfgmgr32hook.h"
 #include "hooks/devicehook.h"
 #include "hooks/setupapihook.h"
 #include "hooks/sleephook.h"
@@ -183,10 +185,37 @@ namespace games::ddr {
         // init device hook
         devicehook_init();
 
+        // init SETUP API
+        setupapihook_init(avs::game::DLL_INSTANCE);
+
+        // DDR ACE actually uses another DLL for things
+        if (game_mdx != nullptr) {
+            setupapihook_init(game_mdx);
+        }
+
         // add fake devices
         if (avs::game::DLL_NAME == "arkmdxbio2.dll") {
             devicehook_add(new acioemu::ACIOHandle(L"COM1"));
-        } else if(avs::game::DLL_NAME == "arkmdxp4.dll") {
+
+            if (avs::game::SPEC[0] == 'I') {
+                // settings (bio2)
+                SETUPAPI_SETTINGS settingsbio2 {};
+                const char property2[] = "BIO2(VIDEO)";
+                settingsbio2.class_guid[0] = 0x4D36E978;
+                settingsbio2.class_guid[1] = 0x11CEE325;
+                settingsbio2.class_guid[2] = 0x8C1BF;
+                settingsbio2.class_guid[3] = 0x1803E12B;
+                memcpy(settingsbio2.property_devicedesc, property2, sizeof(property2));
+                setupapihook_add(settingsbio2);
+
+                // cfgmgr (bio2)
+                CFGMGR32_HOOK_SETTING settingbio2 {};
+                settingbio2.device_id = "USB\\VID_1CCF&PID_804C";
+                settingbio2.device_node_id = "USB\\VID_1CCF&PID_804C&MI_00\\?&????????&?&????";
+                cfgmgr32hook_init(avs::game::DLL_INSTANCE);
+                cfgmgr32hook_add(settingbio2);
+            }
+        } else if (avs::game::DLL_NAME == "arkmdxp4.dll") {
             devicehook_add(new DDRP4IOHandle());
         } else {
             devicehook_add(new DDRFOOTHandle());
@@ -228,14 +257,6 @@ namespace games::ddr {
         memcpy(settingsp4io.property_devicedesc, settings_property, strlen(settings_property) + 1);
         memcpy(settingsp4io.interface_detail, settings_detail_p4io, sizeof(settings_detail_p4io));
 
-        // init SETUP API
-        setupapihook_init(avs::game::DLL_INSTANCE);
-
-        // DDR ACE actually uses another DLL for things
-        if (game_mdx != nullptr) {
-            setupapihook_init(game_mdx);
-        }
-
         // add settings
         setupapihook_add(settings1);
         setupapihook_add(settings2);

src/spice2x/games/iidx/camera.cpp

@@ -22,35 +22,31 @@
 static std::filesystem::path dll_path;
 static HMODULE iidx_module;
 static uintptr_t addr_hook_a = 0;
-static uintptr_t addr_hook_b = 0;
 static uintptr_t addr_textures = 0;
+static uintptr_t addr_camera_manager = 0;
 static uintptr_t addr_device_offset = 0;
+static uintptr_t addr_afp_texture_offset = 0;
 
 typedef void **(__fastcall *camera_hook_a_t)(PBYTE);
-typedef LPDIRECT3DTEXTURE9 (*camera_hook_b_t)(void*, int);
 static camera_hook_a_t camera_hook_a_orig = nullptr;
-static camera_hook_b_t camera_hook_b_orig = nullptr;
 auto static hook_a_init = std::once_flag {};
 
 static LPDIRECT3DDEVICE9EX device;
-static LPDIRECT3DTEXTURE9 *texture_a = nullptr;
-static LPDIRECT3DTEXTURE9 *texture_b = nullptr;
+static LPDIRECT3DTEXTURE9 *camera_texture_a = nullptr;
+static LPDIRECT3DTEXTURE9 *camera_texture_b = nullptr;
+static LPDIRECT3DTEXTURE9 *preview_texture_a = nullptr;
+static LPDIRECT3DTEXTURE9 *preview_texture_b = nullptr;
 
 struct PredefinedHook {
     std::string     pe_identifier;
     uintptr_t       hook_a;
-    uintptr_t       hook_b;
     uintptr_t       hook_textures;
+    uintptr_t       hook_camera_manager;
     uintptr_t       hook_device_offset;
+    uintptr_t       hook_afp_texture_offset;
 };
 
-PredefinedHook g_predefinedHooks[] =
-{
-    // 27 003
-    { "5f713b52_6d4090", 0x005971b0, 0x005fb2c0, 0x04e49898, 0x000000d0 },
-    // 27 010
-    { "5f713946_7f52b0", 0x006b89e0, 0x0071c950, 0x04fd08b8, 0x000000d0 },
-};
+PredefinedHook g_predefinedHooks[] = {};
 
 const DWORD   g_predefinedHooksLength = ARRAYSIZE(g_predefinedHooks);
 
@@ -75,8 +71,8 @@ namespace games::iidx {
 
         if (sscanf(
                 s.c_str(),
-                "%i,%i,%i,%i",
-                (int*)&addr_hook_a, (int*)&addr_hook_b, (int*)&addr_textures, (int*)&addr_device_offset) == 4) {
+                "%i,%i,%i,%i,%i",
+                (int*)&addr_hook_a, (int*)&addr_textures, (int*)&addr_camera_manager, (int*)&addr_device_offset, (int*)&addr_afp_texture_offset) == 5) {
 
             return true;
 
@@ -101,8 +97,8 @@ namespace games::iidx {
 
         // there are three different ways we try to hook the camera entry points
         // 1) user-provided override via cmd line
-        // 2) predefined offsets using PE header matching (needed for iidx27 and few others)
-        // 3) signature match (should work for most iidx28-31)
+        // 2) predefined offsets using PE header matching
+        // 3) signature match (should work for most iidx27-33)
 
         // method 1: user provided
         if (TDJ_CAMERA_OVERRIDE.has_value() && parse_cmd_params()) {
@@ -117,10 +113,11 @@ namespace games::iidx {
         for (DWORD i = 0; i < g_predefinedHooksLength; i++) {
             if (pe.compare(g_predefinedHooks[i].pe_identifier) == 0) {
                 log_misc("iidx:camhook", "Found predefined addresses");
-                addr_hook_a        = g_predefinedHooks[i].hook_a;
-                addr_hook_b        = g_predefinedHooks[i].hook_b;
-                addr_textures      = g_predefinedHooks[i].hook_textures;
-                addr_device_offset = g_predefinedHooks[i].hook_device_offset;
+                addr_hook_a             = g_predefinedHooks[i].hook_a;
+                addr_textures           = g_predefinedHooks[i].hook_textures;
+                addr_camera_manager     = g_predefinedHooks[i].hook_camera_manager;
+                addr_device_offset      = g_predefinedHooks[i].hook_device_offset;
+                addr_afp_texture_offset = g_predefinedHooks[i].hook_afp_texture_offset;
                 return TRUE;
             }
         }
@@ -131,8 +128,8 @@ namespace games::iidx {
         // --- addr_hook_a ---
         uint8_t *addr_hook_a_ptr = reinterpret_cast<uint8_t *>(find_pattern(
             iidx_module,
-            "488BC4565741564883EC5048C740D8FEFFFFFF",
-            "XXXXXXXXXXXXXXXXXXX",
+            "E800000000488B8F0000000048894D",
+            "X????XXX????XXX",
             0, 0));
 
         if (addr_hook_a_ptr == nullptr) {
@@ -141,24 +138,10 @@ namespace games::iidx {
             return FALSE;
         }
 
-        addr_hook_a = (uint64_t) (addr_hook_a_ptr - (uint8_t*) iidx_module);
-
-        // addr_hook_b
-        uint8_t* addr_hook_b_ptr = reinterpret_cast<uint8_t *>(find_pattern(
-            iidx_module,
-            "E8000000004885C07439E8",
-            "X????XXXXXX",
-            0, 0));
-
-        if (addr_hook_b_ptr == nullptr) {
-            log_warning("iidx:camhook", "failed to find hook: addr_hook_b");
-            return FALSE;
-        }
-
         // displace with the content of wildcard bytes
-        int32_t disp_b = *((int32_t *) (addr_hook_b_ptr + 1));
+        int32_t disp_a = *((int32_t *) (addr_hook_a_ptr + 1));
 
-        addr_hook_b = (addr_hook_b_ptr - (uint8_t*) iidx_module) + disp_b + 5;
+        addr_hook_a = (addr_hook_a_ptr - (uint8_t*) iidx_module) + disp_a + 5;
 
         // --- addr_textures ---
         uint8_t* addr_textures_ptr = reinterpret_cast<uint8_t *>(find_pattern(
@@ -194,6 +177,28 @@ namespace games::iidx {
 
         addr_textures = (addr_textures_ptr - (uint8_t*) iidx_module) + disp_textures + 7;
 
+        // --- addr_camera_manager ---
+        uint8_t *addr_camera_manager_ptr = reinterpret_cast<uint8_t *>(find_pattern(
+            iidx_module,
+            "E80000000033FF488B58",
+            "X????XXXXX",
+            0, 0));
+
+        if (addr_camera_manager_ptr == nullptr) {
+            log_warning("iidx:camhook", "failed to find hook: addr_get_camera_manager");
+            return FALSE;
+        }
+
+        // displace with the content of wildcard bytes
+        int32_t disp_camera_manager = *((int32_t *) (addr_camera_manager_ptr + 1));
+
+        addr_camera_manager_ptr = addr_camera_manager_ptr + disp_camera_manager + 5;
+
+        // once more to get the final address
+        disp_camera_manager = *((int32_t *) (addr_camera_manager_ptr + 3));
+
+        addr_camera_manager = (addr_camera_manager_ptr - (uint8_t*) iidx_module) + disp_camera_manager + 7;
+
         // addr_device_offset
         search_from = (addr_hook_a_ptr - (uint8_t*) iidx_module);
         uint8_t *addr_device_ptr = reinterpret_cast<uint8_t *>(find_pattern_from(
@@ -201,39 +206,47 @@ namespace games::iidx {
                 "488B89",
                 "XXX",
                 3, 0, search_from));
-        addr_device_offset = *addr_device_ptr;
 
-        if (addr_textures_ptr == nullptr) {
-            log_warning("iidx:camhook", "failed to find hook: addr_textures (part 3)");
+        if (addr_device_ptr == nullptr) {
+            log_warning("iidx:camhook", "failed to find hook: addr_device_ptr");
             return FALSE;
         }
 
+        addr_device_offset = *addr_device_ptr;
+
+        // --- addr_afp_texture_offset ---
+        uint8_t *addr_afp_texture_ptr = reinterpret_cast<uint8_t *>(find_pattern(
+            iidx_module,
+            "488B41004885C07400488D5424",
+            "XXX?XXXX?XXXX",
+            0, 0));
+
+        if (addr_afp_texture_ptr == nullptr) {
+            log_warning("iidx:camhook", "failed to find hook: addr_afp_texture_offset");
+            return FALSE;
+        }
+
+        addr_afp_texture_offset = *(addr_afp_texture_ptr + 3);
+
         return TRUE;
     }
 
     static void **__fastcall camera_hook_a(PBYTE a1) {
         std::call_once(hook_a_init, [&]{           
             device = *reinterpret_cast<LPDIRECT3DDEVICE9EX*>(a1 + addr_device_offset);
-            auto const textures = *reinterpret_cast<LPDIRECT3DTEXTURE9**>((uint8_t*)iidx_module + addr_textures);
+            auto const preview = *reinterpret_cast<LPDIRECT3DTEXTURE9**>((uint8_t*)iidx_module + addr_textures);
+            auto const manager = reinterpret_cast<Camera::CCameraManager2*>((uint8_t*)iidx_module + addr_camera_manager);
 
-            texture_a = textures;
-            texture_b = textures + 2;
+            camera_texture_a = manager->cameras->a->d3d9_texture(addr_afp_texture_offset);
+            camera_texture_b = manager->cameras->b->d3d9_texture(addr_afp_texture_offset);
+            preview_texture_a = preview;
+            preview_texture_b = preview + 2;
 
             init_local_camera();
         });
         return camera_hook_a_orig(a1);
     }
 
-    static LPDIRECT3DTEXTURE9 camera_hook_b(void* a1, int idx) {
-        if (idx == 0 && top_camera) {
-            return top_camera->GetTexture();
-        }
-        if (idx == 1 && front_camera) {
-            return front_camera->GetTexture();
-        }
-        return camera_hook_b_orig(a1, idx);
-    }
-
     bool create_hooks() {
         auto *hook_a_ptr = reinterpret_cast<uint16_t *>(
                 reinterpret_cast<intptr_t>(iidx_module) + addr_hook_a);
@@ -246,17 +259,6 @@ namespace games::iidx {
             return FALSE;
         }
 
-        auto *hook_b_ptr = reinterpret_cast<uint16_t *>(
-                reinterpret_cast<intptr_t>(iidx_module) + addr_hook_b);
-
-        if (!detour::trampoline(
-                    reinterpret_cast<camera_hook_b_t>(hook_b_ptr),
-                    camera_hook_b,
-                    &camera_hook_b_orig)) {
-            log_warning("iidx:camhook", "failed to trampoline hook_b");
-            return FALSE;
-        }
-
         return TRUE;
     }
 
@@ -443,7 +445,7 @@ namespace games::iidx {
     }
 
     IIDXLocalCamera* add_top_camera(IMFActivate* pActivate) {
-        auto top_camera = new IIDXLocalCamera("top", TDJ_CAMERA_PREFER_16_9, pActivate, s_pD3DManager, device, texture_a);
+        auto top_camera = new IIDXLocalCamera("top", TDJ_CAMERA_PREFER_16_9, pActivate, s_pD3DManager, device, camera_texture_a, preview_texture_a);
         if (top_camera->m_initialized) {
             LOCAL_CAMERA_LIST.push_back(top_camera);
         } else {
@@ -454,7 +456,7 @@ namespace games::iidx {
     }
 
     IIDXLocalCamera* add_front_camera(IMFActivate* pActivate) {
-        auto front_camera = new IIDXLocalCamera("front", TDJ_CAMERA_PREFER_16_9, pActivate, s_pD3DManager, device, texture_b);
+        auto front_camera = new IIDXLocalCamera("front", TDJ_CAMERA_PREFER_16_9, pActivate, s_pD3DManager, device, camera_texture_b, preview_texture_b);
         if (front_camera->m_initialized) {
             LOCAL_CAMERA_LIST.push_back(front_camera);
         } else {
@@ -469,8 +471,8 @@ namespace games::iidx {
         if (result) {
             log_misc(
                 "iidx:camhook",
-                "found hooks:\n    hook_a        0x{:x}\n    hook_b        0x{:x}\n    textures      0x{:x}\n    device_offset 0x{:x}",
-                addr_hook_a, addr_hook_b, addr_textures, addr_device_offset);
+                "found hooks:\n    hook_a             0x{:x}\n    textures           0x{:x}\n    camera_manager     0x{:x}\n    device_offset      0x{:x}\n    afp_texture_offset 0x{:x}",
+                addr_hook_a, addr_textures, addr_camera_manager, addr_device_offset, addr_afp_texture_offset);
             result = create_hooks();
             if (result) {
                 init_mf_library();

src/spice2x/games/iidx/iidx.cpp

@@ -53,7 +53,7 @@ namespace games::iidx {
 
     // settings
     bool FLIP_CAMS = false;
-    bool DISABLE_CAMS = false;
+    std::optional<bool> DISABLE_CAMS;
     bool TDJ_CAMERA = false;
     bool TDJ_CAMERA_PREFER_16_9 = true;
     bool TDJ_MODE = false;
@@ -334,11 +334,6 @@ namespace games::iidx {
                     wintouchemu::INJECT_MOUSE_AS_WM_TOUCH = true;
                     wintouchemu::hook_title_ends("beatmania IIDX", "main", avs::game::DLL_INSTANCE);
                 }
-
-                // prevent crash on TDJ mode without correct DLL
-                if (!GetModuleHandle("nvcuda.dll")) {
-                    DISABLE_CAMS = true;
-                }
             }
 
             // insert BI2X hooks
@@ -399,7 +394,10 @@ namespace games::iidx {
                 "RegQueryValueExA", RegQueryValueExA_hook, avs::game::DLL_INSTANCE);
 
         // check if cam hook should be enabled
-        if (!DISABLE_CAMS) {
+        if (!DISABLE_CAMS.has_value()) {
+            log_fatal("iidx", "assertion failure - DISABLE_CAMS not set during attach");
+        }
+        if (!DISABLE_CAMS.value()) {
             init_legacy_camera_hook(FLIP_CAMS);
         }
 
@@ -409,15 +407,31 @@ namespace games::iidx {
 
     void IIDXGame::pre_attach() {
         Game::pre_attach();
+        auto options = games::get_options(eamuse_get_game());
 
         // environment variables must be set before the DLL is loaded as the VC++ runtime copies all
         // environment variables at startup
         if (SCREEN_MODE.has_value()) {
+            log_misc("iidx", "SCREEN_MODE env var set to {}", SCREEN_MODE.value().c_str());
             SetEnvironmentVariable("SCREEN_MODE", SCREEN_MODE.value().c_str());
         }
 
+        // check for cab camera access for the second time (first time was in launcher.cpp)
+        // this time, we are inside -iidx module hook, which means the user is likely NOT on a cab
+        // therefore, start with cams OFF by default, and allow user to forcibly override to ON
+        if (!games::iidx::DISABLE_CAMS.has_value()) {
+            games::iidx::DISABLE_CAMS = true;
+            if (options->at(launcher::Options::IIDXCabCamAccess).is_active() &&
+                options->at(launcher::Options::IIDXCabCamAccess).value_text() == "on") {
+                games::iidx::DISABLE_CAMS = false;
+            }
+            if (games::iidx::DISABLE_CAMS.value()) {
+                log_misc("iidx", "CONNECT_CAMERA env var set to 0");
+                SetEnvironmentVariable("CONNECT_CAMERA", "0");
+            }
+        }
+
         // windowed subscreen, enabled by default, unless turned off by user
-        auto options = games::get_options(eamuse_get_game());
         if (GRAPHICS_WINDOWED && !options->at(launcher::Options::spice2x_IIDXNoSub).value_bool()) {
             GRAPHICS_IIDX_WSUB = true;
         }
@@ -437,7 +451,7 @@ namespace games::iidx {
                 "!!! please do the following instead:                              !!!\n"
                 "!!!                                                               !!!\n"
                 "!!! Revert your changes to XML file so it says                    !!!\n"
-                "!!!     <model __type=\"str\">LDJ</model>                           !!!\n" 
+                "!!!     <model __type=\"str\">LDJ</model>                         !!!\n" 
                 "!!!                                                               !!!\n"
                 "!!! In SpiceCfg, enable 'IIDX TDJ Mode' or provide -iidxtdj flag  !!!\n"
                 "!!! in command line                                               !!!\n"
@@ -449,6 +463,32 @@ namespace games::iidx {
 
             log_fatal("iidx", "BAD MODEL NAME ERROR - TDJ specified, must be LDJ instead");
         }
+
+        // check -monitor + TDJ mode
+        if (!GRAPHICS_WINDOWED &&
+            options->at(launcher::Options::DisplayAdapter).is_active() &&
+            TDJ_MODE) {
+            log_warning(
+                "iidx",
+                "\n\n!!! using -monitor option with TDJ is NOT recommended due to known  !!!\n"
+                "!!! compatibility issues with the game                              !!!\n"
+                "!!!                                                                 !!!\n"
+                "!!!   * game may launch in wrong resolution or refresh rate         !!!\n"
+                "!!!   * touch / mouse input may stop working in subscreen / overlay !!!\n"
+                "!!!                                                                 !!!\n"
+                "!!! recommendation is to NOT use -monitor and instead set the       !!!\n"
+                "!!! primary monitor in Windows settings before launching the game   !!!\n\n"
+                );
+
+            deferredlogs::defer_error_messages({
+                "-monitor option is NOT recommended when running with TDJ mode",
+                "    due to known compatibility issues with the game:",
+                "      * game may launch in wrong resolution or refresh rate",
+                "      * touch / mouse input may stop working in subscreen / overlay",
+                "    recommended fix is to NOT use -monitor and instead set the primary",
+                "    monitor in Windows settings before launching the game"
+                });
+        }
     }
 
     void IIDXGame::detach() {
@@ -773,7 +813,15 @@ namespace games::iidx {
         // <=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)
+        // 31-32: only has XONAR (ASIO by default, signature patch can be used to force WASAPI - for now)
+        // 33   : early versions only have XONAR, but later datecodes have both; SOUND_OUTPUT_DEVICE
+        //        returned and it works again when set as env var
+
+        log_info(
+            "iidx",
+            "has_SOUND_OUTPUT_DEVICE: {}, has_XONAR_SOUND_CARD: {}",
+            (has_SOUND_OUTPUT_DEVICE != 0),
+            (has_XONAR_SOUND_CARD != 0));
 
         if (!has_SOUND_OUTPUT_DEVICE && !has_XONAR_SOUND_CARD) {
             // iidx 25-26
@@ -781,16 +829,10 @@ namespace games::iidx {
             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") {
+        // if the game doesn't accept SOUND_OUTPUT_DEVICE, patch game to force wasapi
+        if (!has_SOUND_OUTPUT_DEVICE &&
+            SOUND_OUTPUT_DEVICE_IN_EFFECT.has_value() &&
+            SOUND_OUTPUT_DEVICE_IN_EFFECT.value() == "wasapi") {
             intptr_t result = replace_pattern(
                 avs::game::DLL_INSTANCE,
                 "FF5008E8??????FF83780803740D",
@@ -808,8 +850,6 @@ 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
@@ -817,7 +857,8 @@ namespace games::iidx {
         // 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")) {
+            !(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

src/spice2x/games/iidx/iidx.h

@@ -14,7 +14,7 @@ namespace games::iidx {
     // settings
 
     extern bool FLIP_CAMS;
-    extern bool DISABLE_CAMS;
+    extern std::optional<bool> DISABLE_CAMS;
     extern bool TDJ_CAMERA;
     extern bool TDJ_CAMERA_PREFER_16_9;
     extern std::optional<std::string> TDJ_CAMERA_OVERRIDE;

src/spice2x/games/iidx/legacy_camera.cpp

@@ -213,6 +213,8 @@ namespace games::iidx {
     }
 
     void init_legacy_camera_hook(bool flip_cams) {
+        log_info("iidx::cam", "initializing legacy camera hook");
+
         should_flip_cams = flip_cams;
 
         // camera media framework hook

src/spice2x/games/iidx/local_camera.cpp

@@ -46,14 +46,17 @@ namespace games::iidx {
         IMFActivate *pActivate,
         IDirect3DDeviceManager9 *pD3DManager,
         LPDIRECT3DDEVICE9EX device,
-        LPDIRECT3DTEXTURE9 *texture_target
+        LPDIRECT3DTEXTURE9 *camera_texture_target,
+        LPDIRECT3DTEXTURE9 *preview_texture_target
     ):
         m_nRefCount(1),
         m_name(name),
         m_prefer_16_by_9(prefer_16_by_9),
         m_device(device),
-        m_texture_target(texture_target),
-        m_texture_original(*texture_target)
+        m_camera_texture_target(camera_texture_target),
+        m_preview_texture_target(preview_texture_target),
+        m_camera_texture_original(*camera_texture_target),
+        m_preview_texture_original(*preview_texture_target)
     {
         InitializeCriticalSection(&m_critsec);
 
@@ -691,7 +694,8 @@ namespace games::iidx {
         if (FAILED(hr)) { goto done; }
 
         // Make the game use this new texture as camera stream source
-        *m_texture_target = m_texture;
+        *m_camera_texture_target = m_texture;
+        *m_preview_texture_target = m_texture;
         m_active = TRUE;
 
         // Create texture for colour conversion
@@ -860,7 +864,8 @@ namespace games::iidx {
 
         ULONG uCount = InterlockedDecrement(&m_nRefCount);
 
-        *m_texture_target = m_texture_original;
+        *m_camera_texture_target = m_camera_texture_original;
+        *m_preview_texture_target = m_preview_texture_original;
 
         for (size_t i = 0; i < m_mediaTypeInfos.size(); i++) {
             SafeRelease(&(m_mediaTypeInfos.at(i).p_mediaType));

src/spice2x/games/iidx/local_camera.h

@@ -66,6 +66,25 @@ extern std::string CAMERA_CONTROL_LABELS[];
 extern std::string DRAW_MODE_LABELS[];
 
 namespace games::iidx {
+    namespace Camera {
+        struct PlayVideoCamera {
+            IDirect3DTexture9** d3d9_texture(const uintptr_t offset) {
+                auto const afp_texture = *reinterpret_cast<uint8_t**>
+                    (reinterpret_cast<uint8_t*>(this) + offset);
+                return reinterpret_cast<IDirect3DTexture9**>(afp_texture + 0x8);
+            }
+        };
+
+        struct CCameraManager2 {
+            using camera_pointers = struct {
+                PlayVideoCamera* a;
+                PlayVideoCamera* b;
+            };
+            void* vftbl;
+            camera_pointers* cameras;
+        };
+    }
+
     class IIDXLocalCamera {
     protected:
         virtual ~IIDXLocalCamera() {};
@@ -98,8 +117,9 @@ namespace games::iidx {
         // DirectX9 DeviceEx
         LPDIRECT3DDEVICE9EX m_device;
 
-        // Address to hook camera texture onto the game
-        LPDIRECT3DTEXTURE9 *m_texture_target = nullptr;
+        // Address to hook camera textures onto the game
+        LPDIRECT3DTEXTURE9 *m_camera_texture_target = nullptr;
+        LPDIRECT3DTEXTURE9 *m_preview_texture_target = nullptr;
 
         // Target texture (to be shown in the game)
         LPDIRECT3DTEXTURE9 m_texture = nullptr;
@@ -117,8 +137,9 @@ namespace games::iidx {
         LPDIRECT3DTEXTURE9 m_transformResultTexture = nullptr;
         IDirect3DSurface9 *m_pTransformResultSurf = nullptr;
 
-        // Storing original texture for clean up
-        LPDIRECT3DTEXTURE9 m_texture_original = nullptr;
+        // Storing original textures for clean up
+        LPDIRECT3DTEXTURE9 m_camera_texture_original = nullptr;
+        LPDIRECT3DTEXTURE9 m_preview_texture_original = nullptr;
 
         IAMCameraControl *m_pCameraControl = nullptr;
 
@@ -154,7 +175,8 @@ namespace games::iidx {
             IMFActivate *pActivate,
             IDirect3DDeviceManager9 *pD3DManager,
             LPDIRECT3DDEVICE9EX device,
-            LPDIRECT3DTEXTURE9 *texture_target
+            LPDIRECT3DTEXTURE9 *camera_texture_target,
+            LPDIRECT3DTEXTURE9 *preview_texture_target
         );
         LPDIRECT3DTEXTURE9 GetTexture();
         ULONG Release();

src/spice2x/games/mfc/mfc.cpp

@@ -4,6 +4,7 @@
 #include "avs/game.h"
 #include "hooks/graphics/graphics.h"
 #include "misc/eamuse.h"
+#include "misc/wintouchemu.h"
 #include "touch/touch.h"
 #include "util/detour.h"
 #include "util/libutils.h"
@@ -32,6 +33,8 @@ namespace games::mfc {
     static uint8_t CARD_TYPE = 0;
     static uint8_t CARD_UID[8];
 
+    bool HG_MODE = false;
+
     typedef int (__cdecl *inifile_param_num_t)(const char *, int *);
     static inifile_param_num_t inifile_param_num_real;
 
@@ -50,8 +53,10 @@ namespace games::mfc {
     static void __cdecl touch_init(int width, int height) {
         log_info("mfc", "call touch_init(width: {}, height: {})", width, height);
 
-        // attach touch module
-        if (!TOUCH_ATTACHED) {
+        if (HG_MODE) {
+            wintouchemu::ADD_TOUCH_FLAG_PRIMARY = true;
+            wintouchemu::hook("MFC9", avs::game::DLL_INSTANCE);
+        } else if (!TOUCH_ATTACHED) { // attach touch module
 
             // store touch size specification
             TOUCH_MAX_X = width;
@@ -328,6 +333,10 @@ namespace games::mfc {
         if (allinone_module == nullptr) {
             log_misc("mfc", "using system.dll instead of allinone.dll for i/o hooks");
             allinone_module = system_module;
+
+            if (avs::game::SPEC[0] == 'F') {
+                HG_MODE = true;
+            }
         }
 
         // network fix

src/spice2x/games/mfc/mfc.h

@@ -4,6 +4,8 @@
 
 namespace games::mfc {
 
+    extern bool HG_MODE;
+
     struct joystick_state {
         bool up = false;
         bool down = false;

src/spice2x/games/sdvx/sdvx.cpp

@@ -4,6 +4,7 @@
 
 #include "avs/game.h"
 #include "games/shared/lcdhandle.h"
+#include "games/io.h"
 #include "hooks/audio/audio.h"
 #include "hooks/graphics/graphics.h"
 #include "hooks/devicehook.h"
@@ -12,6 +13,7 @@
 #include "hooks/powrprof.h"
 #include "hooks/sleephook.h"
 #include "hooks/winuser.h"
+#include "launcher/options.h"
 #include "touch/touch.h"
 #include "util/deferlog.h"
 #include "util/detour.h"
@@ -106,8 +108,8 @@ namespace games::sdvx {
         if (ENABLE_COM_PORT_SCAN_HOOK &&
             lpSubKey != nullptr && phkResult != nullptr &&
 	        _stricmp(lpSubKey, "HARDWARE\\DEVICEMAP\\SERIALCOMM") == 0) {
-            log_info("sdvx::io", "failing HKLM\\HARDWARE\\DEVICEMAP\\SERIALCOMM to force COM1 ICCA");
-            return 2; //ERROR_FILE_NOT_FOUND
+            log_info("sdvx::io", "hook access to HKLM\\HARDWARE\\DEVICEMAP\\SERIALCOMM to force COM1 ICCA");
+            return 2; // ERROR_FILE_NOT_FOUND
         }
 
         return RegOpenKeyExA_orig(hKey, lpSubKey, ulOptions, samDesired, phkResult);
@@ -291,6 +293,37 @@ namespace games::sdvx {
                 "sdvx",
                 "BAD MODEL NAME ERROR - model name set to UFC, must be KFC instead");
         }
+
+#ifdef SPICE64 // SDVX5+ specific code
+        bool isValkyrieCabinetMode = avs::game::SPEC[0] == 'G' || avs::game::SPEC[0] == 'H';
+        auto options = games::get_options(eamuse_get_game());
+        // check -monitor + UFC mode
+        if (!GRAPHICS_WINDOWED &&
+            options->at(launcher::Options::DisplayAdapter).is_active() &&
+            isValkyrieCabinetMode) {
+            log_warning(
+                "sdvx",
+                "\n\n!!! using -monitor option with VM mode is NOT recommended due to    !!!\n"
+                "!!! known compatibility issues with the game                        !!!\n"
+                "!!!                                                                 !!!\n"
+                "!!!   * game may launch in wrong resolution or refresh rate         !!!\n"
+                "!!!   * touch / mouse input may stop working in subscreen / overlay !!!\n"
+                "!!!                                                                 !!!\n"
+                "!!! recommendation is to NOT use -monitor and instead set the       !!!\n"
+                "!!! primary monitor in Windows settings before launching the game   !!!\n\n"
+                );
+
+            deferredlogs::defer_error_messages({
+                "-monitor option is NOT recommended when running with Valkyrie mode",
+                "    due to known compatibility issues with the game:",
+                "      * game may launch in wrong resolution or refresh rate",
+                "      * touch / mouse input may stop working in subscreen / overlay",
+                "    recommended fix is to NOT use -monitor and instead set the primary",
+                "    monitor in Windows settings before launching the game"
+                });
+        }
+#endif
+
     }
 
     void SDVXGame::attach() {

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

@@ -15,6 +15,7 @@
 #include "cfg/screen_resize.h"
 #include "games/iidx/iidx.h"
 #include "games/sdvx/sdvx.h"
+#include "games/mfc/mfc.h"
 #include "games/io.h"
 #include "hooks/graphics/graphics.h"
 #include "launcher/launcher.h"
@@ -1360,6 +1361,11 @@ void graphics_d3d9_on_present(
         graphics_d3d9_ldj_on_present(wrapped_device);
     }
 
+    const bool is_mfc = avs::game::is_model("KK9") && games::mfc::HG_MODE;
+    if (is_mfc) {
+        wintouchemu::update();
+    }
+
     // check screenshot key
     static bool trigger_last = false;
     auto buttons = games::get_buttons_overlay(eamuse_get_game());

src/spice2x/hooks/graphics/nvenc_hook.cpp

@@ -9,6 +9,7 @@
 #include "util/detour.h"
 #include "util/libutils.h"
 #include "util/logging.h"
+#include "util/utils.h"
 
 #include "nvenc_hook.h"
 
@@ -16,9 +17,13 @@
 
 typedef NVENCSTATUS(NVENCAPI *NvEncodeAPICreateInstance_Type)(NV_ENCODE_API_FUNCTION_LIST*);
 static NvEncodeAPICreateInstance_Type NvEncodeAPICreateInstance_orig = nullptr;
+
 static PNVENCOPENENCODESESSIONEX nvEncOpenEncodeSessionEx_orig = nullptr;
 static PNVENCINITIALIZEENCODER nvEncInitializeEncoder_orig = nullptr;
+static PNVENCGETENCODEPRESETCONFIG nvEncGetEncodePresetConfig_orig = nullptr;
+static PNVENCGETENCODEPRESETCONFIGEX nvEncGetEncodePresetConfigEx_orig = nullptr;
 static BOOL initialized = false;
+static BOOL new_preset_guids = false;
 
 namespace nvenc_hook {
 
@@ -27,6 +32,37 @@ namespace nvenc_hook {
 
     void parse_qcp_params();
 
+    void dump_init_params(NV_ENC_INITIALIZE_PARAMS* encode) {
+        log_misc("nvenc_hook", "NV_ENC_INITIALIZE_PARAMS:");
+        log_misc("nvenc_hook", "  version: {:x}", encode->version);
+        log_misc("nvenc_hook", "  encodeGUID: {}", guid2s(encode->encodeGUID));
+        log_misc("nvenc_hook", "  presetGUID: {}", guid2s(encode->presetGUID));
+        log_misc("nvenc_hook", "  encodeWidth: {}", encode->encodeWidth);
+        log_misc("nvenc_hook", "  encodeHeight: {}", encode->encodeHeight);
+        log_misc("nvenc_hook", "  darWidth: {}", encode->darWidth);
+        log_misc("nvenc_hook", "  darHeight: {}", encode->darHeight);
+        log_misc("nvenc_hook", "  frameRateNum: {}", encode->frameRateNum);
+        log_misc("nvenc_hook", "  frameRateDen: {}", encode->frameRateDen);
+        log_misc("nvenc_hook", "  enableEncodeAsync: {}", encode->enableEncodeAsync);
+        log_misc("nvenc_hook", "  enablePTD: {}", encode->enablePTD);
+        log_misc("nvenc_hook", "  maxEncodeWidth: {}", encode->maxEncodeWidth);
+        log_misc("nvenc_hook", "  maxEncodeHeight: {}", encode->maxEncodeHeight);
+        log_misc("nvenc_hook", "  tuningInfo: {}", static_cast<uint32_t>(encode->tuningInfo));
+        log_misc("nvenc_hook", "  bufferFormat: {}", static_cast<uint32_t>(encode->bufferFormat));
+        log_misc("nvenc_hook", "  encodeConfig.version: {:x}", encode->encodeConfig->version);
+        log_misc("nvenc_hook", "  encodeConfig.profileGUID: {}", guid2s(encode->encodeConfig->profileGUID));
+        log_misc("nvenc_hook", "  encodeConfig.gopLength: {}", encode->encodeConfig->gopLength);
+        log_misc("nvenc_hook", "  encodeConfig.frameIntervalP: {}", encode->encodeConfig->frameIntervalP);
+        log_misc("nvenc_hook", "  encodeConfig.monoChromeEncoding: {}", encode->encodeConfig->monoChromeEncoding);
+
+        const auto rc = &encode->encodeConfig->rcParams;
+        const auto h264 = &encode->encodeConfig->encodeCodecConfig.h264Config;
+        log_misc("nvenc_hook", "  encodeConfig.encodeCodecConfig.h264Config.sliceMode: {}", h264->sliceMode);
+        log_misc("nvenc_hook", "  encodeConfig.encodeCodecConfig.h264Config.sliceModeData: {}", h264->sliceModeData);
+        log_misc("nvenc_hook", "  encodeConfig.rcParams.version: {:x}", rc->version);
+        log_misc("nvenc_hook", "  encodeConfig.rcParams.rateControlMode: {}", static_cast<uint32_t>(rc->rateControlMode));
+    }
+
     NVENCSTATUS NVENCAPI nvEncOpenEncodeSessionEx_hook(
         NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS *openSessionExParams, 
         void **encoder
@@ -51,38 +87,105 @@ namespace nvenc_hook {
         try {
             // check input params
             if (createEncodeParams == nullptr || createEncodeParams->encodeConfig == nullptr) {
+                log_warning("nvenc_hook", "nvEncInitializeEncoder called with invalid params");
                 goto done;
             }
+
             const auto rc = &createEncodeParams->encodeConfig->rcParams;
-            if (rc->rateControlMode != NV_ENC_PARAMS_RC_CONSTQP) {
+
+            log_misc("nvenc_hook", "nvEncInitializeEncoder hook hit with expected params");
+            dump_init_params(createEncodeParams);
+            if (new_preset_guids) {
+                log_misc("nvenc_hook", "swapping out encoder preset for newer NVENC SDK");
+                memcpy(&createEncodeParams->presetGUID, &NV_ENC_PRESET_P4_GUID, sizeof(GUID));
+                createEncodeParams->tuningInfo = NV_ENC_TUNING_INFO_HIGH_QUALITY;
+            }
+
+            // cqp p/b/i override
+            if (rc->rateControlMode == NV_ENC_PARAMS_RC_CONSTQP) {
+                // print out most relevant video quality settings
+                // note: NvEncoder.cpp sample uses {28, 31, 25} (and that's what some hex edits modify)
+                //       but bm2dx later adds 8 to each value, before calling this routine
+                log_misc(
+                    "nvenc_hook", "nvEncInitializeEncoder: original constQP p={}, b={}, i={}",
+                    rc->constQP.qpInterP, rc->constQP.qpInterB, rc->constQP.qpIntra);
+
+                // video quality override
+                if (VIDEO_CQP_OVERRIDE.has_value()) {
+                    rc->constQP = VIDEO_CQP_OVERRIDE.value();
+                    log_misc(
+                        "nvenc_hook", "nvEncInitializeEncoder: user overriden constQP p={}, b={}, i={}",
+                        rc->constQP.qpInterP, rc->constQP.qpInterB, rc->constQP.qpIntra);
+                }
+            } else {
                 log_warning(
                     "nvenc_hook",
                     "nvEncInitializeEncoder: unexpected rateControlMode, expected: NV_ENC_PARAMS_RC_CONSTQP, actual: {}",
                     rc->rateControlMode);
-                goto done;
-            }
-
-            log_misc("nvenc_hook", "nvEncInitializeEncoder hook hit with expected params");
-
-            // print out most relevant video quality settings
-            // note: NvEncoder.cpp sample uses {28, 31, 25} (and that's what some hex edits modify)
-            //       but bm2dx later adds 8 to each value, before calling this routine
-            log_misc(
-                "nvenc_hook", "nvEncInitializeEncoder: original constQP p={}, b={}, i={}",
-                rc->constQP.qpInterP, rc->constQP.qpInterB, rc->constQP.qpIntra);
-
-            // video quality override
-            if (VIDEO_CQP_OVERRIDE.has_value()) {
-                rc->constQP = VIDEO_CQP_OVERRIDE.value();
-                log_misc(
-                    "nvenc_hook", "nvEncInitializeEncoder: user overriden constQP p={}, b={}, i={}",
-                    rc->constQP.qpInterP, rc->constQP.qpInterB, rc->constQP.qpIntra);
             }
 
         } catch (const std::exception &ex) {}
 
     done:
-        return nvEncInitializeEncoder_orig(encoder, createEncodeParams);
+        const auto status = nvEncInitializeEncoder_orig(encoder, createEncodeParams);
+        log_misc(
+            "nvenc_hook",
+            "nvEncInitializeEncoder returned 0x{:x}",
+            static_cast<uint32_t>(status));
+
+        return status;
+    }
+
+    NVENCSTATUS NVENCAPI nvEncGetEncodePresetConfig_hook (
+        void* encoder, GUID encodeGUID, GUID presetGUID, NV_ENC_PRESET_CONFIG* presetConfig) {
+
+        // IIDX32 calls this with
+        // presetGUID = {34DBA71D-A77B-4B8F-9C3E-B6D5DA24C012} (NV_ENC_PRESET_HQ_GUID) (for h264)
+        // this preset is deprecated according to NVIDIA
+
+        const auto status = nvEncGetEncodePresetConfig_orig(
+            encoder, encodeGUID, presetGUID, presetConfig);
+
+        log_misc(
+            "nvenc_hook",
+            "NvEncGetEncodePresetConfig called with encodeGUID = {}, presetGUID = {}. and returned 0x{:x}",
+            guid2s(encodeGUID),
+            guid2s(presetGUID),
+            static_cast<uint32_t>(status));
+
+        if (status == NV_ENC_SUCCESS) {
+            return status;
+        }
+
+        // in NVIDIA driver 591.44 released in December 2025,
+        // NvEncGetEncodePresetConfig started to fail with NV_ENC_ERR_UNSUPPORTED_PARAM and
+        // eventually cause a crash
+        //
+        // IIDX32 calls this with
+        // presetGUID = {34DBA71D-A77B-4B8F-9C3E-B6D5DA24C012} (NV_ENC_PRESET_HQ_GUID) (for h264)
+        // this preset is deprecated according to NVIDIA
+        // https://docs.nvidia.com/video-technologies/video-codec-sdk/13.0/deprecation-notices/index.html
+        //
+        // references:
+        //   https://github.com/NVIDIA/video-sdk-samples/tree/aa3544dcea2fe63122e4feb83bf805ea40e58dbe/Samples/NvCodec/NvEncoder
+        //   https://forums.developer.nvidia.com/t/drivers-591-44-broke-nvenc-getencodepresetconfig-no-longer-works/353613
+        //   https://docs.nvidia.com/video-technologies/video-codec-sdk/11.1/nvenc-preset-migration-guide/index.html
+
+        new_preset_guids = true;
+        const auto status_ex =
+            nvEncGetEncodePresetConfigEx_orig(
+                encoder,
+                encodeGUID,
+                NV_ENC_PRESET_P4_GUID,
+                NV_ENC_TUNING_INFO_HIGH_QUALITY,
+                presetConfig);
+
+        log_misc(
+            "nvenc_hook",
+            "called NvEncGetEncodePresetConfigEx instead; returned 0x{:x}",
+            static_cast<uint32_t>(status_ex));
+
+        return status_ex;
     }
 
     NVENCSTATUS NVENCAPI NvEncodeAPICreateInstance_hook(NV_ENCODE_API_FUNCTION_LIST *pFunctionList) {        
@@ -101,6 +204,11 @@ namespace nvenc_hook {
                 pFunctionList->nvEncInitializeEncoder,
                 nvEncInitializeEncoder_hook,
                 &nvEncInitializeEncoder_orig);
+            detour::trampoline_try(
+                pFunctionList->nvEncGetEncodePresetConfig,
+                nvEncGetEncodePresetConfig_hook,
+                &nvEncGetEncodePresetConfig_orig);
+            nvEncGetEncodePresetConfigEx_orig = pFunctionList->nvEncGetEncodePresetConfigEx;
             log_misc("nvenc_hook", "NvEncodeAPICreateInstance_hook called and functions hooked");
             initialized = true;
         }
@@ -123,6 +231,7 @@ namespace nvenc_hook {
         } else {
             log_warning("nvenc_hook", "failed to hook NvEncodeAPICreateInstance");
         }
+
         parse_qcp_params();
     }
 

src/spice2x/launcher/launcher.cpp

@@ -3,6 +3,7 @@
 #include <memory>
 #include <vector>
 
+#include <assert.h>
 #include <shlwapi.h>
 #include <cfg/configurator.h>
 
@@ -299,10 +300,14 @@ int main_implementation(int argc, char *argv[]) {
         cfg::CONFIGURATOR_TYPE = cfg::ConfigType::Config;
         cfg_run = true;
     }
-    if (options[launcher::Options::EAmusementEmulation].value_bool()) {
+
+    // -ea, but ignored if -url is set
+    if (options[launcher::Options::EAmusementEmulation].value_bool() &&
+        !options[launcher::Options::ServiceURL].is_active()) {
         avs::ea3::URL_SLASH = 1;
         easrv_port = 8080;
     }
+
     if (options[launcher::Options::SmartEAmusement].value_bool()) {
         easrv_smart = true;
     }
@@ -458,17 +463,26 @@ int main_implementation(int argc, char *argv[]) {
     if (options[launcher::Options::IIDXCameraOrderFlip].value_bool()) {
         games::iidx::FLIP_CAMS = true;
     }
+
+    // IIDX CONNECT_CAMERA logic here for cases where user is running without -iidx module
+    // for now, we assume that user may be running on a cab
+    // (games::iidx::DISABLE_CAMS starts out as false unless user overrides)
+    // we will check again in IIDX module with a different default
+    assert(!games::iidx::DISABLE_CAMS.has_value());
     if (options[launcher::Options::IIDXDisableCameras].value_bool()) {
         games::iidx::DISABLE_CAMS = true;
     }
+    if (options[launcher::Options::IIDXCabCamAccess].is_active() &&
+        options[launcher::Options::IIDXCabCamAccess].value_text() == "off") {
+        games::iidx::DISABLE_CAMS = true;
+    }
     if (options[launcher::Options::IIDXCamHook].value_bool()) {
         games::iidx::TDJ_CAMERA = true;
         // Disable legacy behaviour to avoid conflict
         games::iidx::DISABLE_CAMS = true;
     }
-    if (games::iidx::DISABLE_CAMS) {
-        SetEnvironmentVariable("CONNECT_CAMERA", "0");
-    }
+    // CONNECT_CAMERA env var will be set once logging is enabled
+
     if (options[launcher::Options::IIDXCamHookOverride].is_active()) {
         games::iidx::TDJ_CAMERA_OVERRIDE = options[launcher::Options::IIDXCamHookOverride].value_text();
     }
@@ -1303,25 +1317,6 @@ int main_implementation(int argc, char *argv[]) {
             );
     }
 
-    if (options[launcher::Options::EAmusementEmulation].value_bool() &&
-        options[launcher::Options::ServiceURL].is_active() &&
-        !cfg::CONFIGURATOR_STANDALONE) {
-        log_warning(
-            "launcher",
-            "BAD EAMUSE SETTINGS ERROR\n\n\n"
-            "-------------------------------------------------------------------\n"
-            "WARNING - WARNING - WARNING - WARNING - WARNING - WARNING - WARNING\n"
-            "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
-            "A service URL is set **AND** E-Amusement emulation is enabled.\n"
-            "Either remove the service URL, or disable E-Amusement emulation.\n"
-            "Otherwise you may experience problems logging in.\n"
-            "-------------------------------------------------------------------\n\n\n"
-            );
-        log_fatal(
-            "launcher",
-            "BAD EAMUSE SETTINGS ERROR: both -ea and -url are set");
-    }
-
     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)) {
@@ -1333,7 +1328,7 @@ int main_implementation(int argc, char *argv[]) {
 
     // SDVXFullscreenLandscape disabled due to it messing with in-game camera angle
     // FullscreenOrientationFlip continues to live on, however.
-    if (options[launcher::Options::SDVXFullscreenLandscape].value_bool()) {
+    if (options[launcher::Options::SDVXFullscreenLandscape].value_bool() && !cfg::CONFIGURATOR_STANDALONE) {
         log_fatal("launcher", "-sdvxlandscape removed due to a camera bug in SDVX!");
     }
 //  if (options[launcher::Options::SDVXFullscreenLandscape].value_bool() && !GRAPHICS_WINDOWED) {
@@ -1348,8 +1343,15 @@ int main_implementation(int argc, char *argv[]) {
         GRAPHICS_FS_ORIENTATION_SWAP = true;
     }
 
+    if (games::iidx::DISABLE_CAMS.has_value() &&
+        games::iidx::DISABLE_CAMS.value() &&
+        !cfg::CONFIGURATOR_STANDALONE) {
+        log_misc("launcher", "CONNECT_CAMERA env var set to 0");
+        SetEnvironmentVariable("CONNECT_CAMERA", "0");
+    }
+
     // deleted options
-    if (options[launcher::Options::OpenKFControl].value_bool()) {
+    if (options[launcher::Options::OpenKFControl].value_bool() && !cfg::CONFIGURATOR_STANDALONE) {
         log_fatal("launcher", "KFControl has been removed from spice2x; please use an older version.");
     }
     if (options[launcher::Options::VREnable].value_bool()) {

src/spice2x/launcher/options.cpp

@@ -456,13 +456,30 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .category = "Game Options (Advanced)",
     },
     {
-        .title = "IIDX Disable Cameras",
+        // IIDXDisableCameras
+        .title = "IIDX Disable Cameras (DEPRECATED - no longer needed)",
         .name = "iidxdisablecams",
         .desc = "Disables cameras",
         .type = OptionType::Bool,
+        .hidden = true,
         .game_name = "Beatmania IIDX",
         .category = "Game Options",
     },
+    {
+        // IIDXCabCamAccess
+        .title = "IIDX Use Official AC Cams",
+        .name = "iidxcabcams",
+        .desc = "For IIDX25+, allow direct access to cameras from real arcade cabinets. "
+            "Only turn this on if you have OFFICIAL arcade cameras connected to the correct USB ports. Default: auto",
+        .type = OptionType::Enum,
+        .game_name = "Beatmania IIDX",
+        .category = "Game Options (Advanced)",
+        .elements = {
+            {"auto", ""},
+            {"off", ""},
+            {"on", ""}
+        },
+    },
     {
         // IIDXCamHook
         .title = "IIDX Cam Hook",
@@ -497,10 +514,10 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .display_name = "iidxcamhookoffset",
         .aliases = "iidxcamhookoffset",
         .desc = "Override DLL offsets for camera hook; "
-            "format: 4 hex values separated by commas "
-            "(offset_hook_a, offset_hook_b, offset_textures, offset_d3d_device)",
+            "format: 5 hex values separated by commas "
+            "(offset_hook_a, offset_textures, offset_camera_manager, offset_d3d_device, offset_afp_texture)",
         .type = OptionType::Text,
-        .setting_name = "0x5817a0,0x5ea3b0,0x6fffbd8,0xe0",
+        .setting_name = "0x5817a0,0x6fffbd8,0xbbae40,0xe0,0x30",
         .game_name = "Beatmania IIDX",
         .category = "Game Options (Advanced)",
     },

src/spice2x/launcher/options.h

@@ -55,6 +55,7 @@ namespace launcher {
             LoadIIDXModule,
             IIDXCameraOrderFlip,
             IIDXDisableCameras,
+            IIDXCabCamAccess,
             IIDXCamHook,
             IIDXCamHookRatio,
             IIDXCamHookOverride,

src/spice2x/misc/wintouchemu.cpp

@@ -34,6 +34,7 @@ namespace wintouchemu {
     bool FORCE = false;
     bool INJECT_MOUSE_AS_WM_TOUCH = false;
     bool LOG_FPS = false;
+    bool ADD_TOUCH_FLAG_PRIMARY = false;
 
     static inline bool is_emu_enabled() {
         return FORCE || !is_touch_available("wintouchemu::is_emu_enabled") || GRAPHICS_SHOW_CURSOR;
@@ -187,16 +188,28 @@ namespace wintouchemu {
                 switch (touch_event->type) {
                     case TOUCH_DOWN:
                         if (valid) {
+                            if (ADD_TOUCH_FLAG_PRIMARY) {
+                                touch_input->dwFlags |= TOUCHEVENTF_PRIMARY;
+                            }
+
                             touch_input->dwFlags |= TOUCHEVENTF_DOWN;
                         }
                         break;
                     case TOUCH_MOVE:
                         if (valid) {
+                            if (ADD_TOUCH_FLAG_PRIMARY) {
+                                touch_input->dwFlags |= TOUCHEVENTF_PRIMARY;
+                            }
+
                             touch_input->dwFlags |= TOUCHEVENTF_MOVE;
                         }
                         break;
                     case TOUCH_UP:
                         // don't check valid so that this touch ID can be released
+                        if (ADD_TOUCH_FLAG_PRIMARY) {
+                            touch_input->dwFlags |= TOUCHEVENTF_PRIMARY;
+                        }
+
                         touch_input->dwFlags |= TOUCHEVENTF_UP;
                         break;
                 }
@@ -238,16 +251,28 @@ namespace wintouchemu {
                     switch (mouse_state.touch_event) {
                         case TOUCHEVENTF_DOWN:
                             if (valid) {
+                                if (ADD_TOUCH_FLAG_PRIMARY) {
+                                    touch_input->dwFlags |= TOUCHEVENTF_PRIMARY;
+                                }
+
                                 touch_input->dwFlags |= TOUCHEVENTF_DOWN;
                             }
                             break;
                         case TOUCHEVENTF_MOVE:
                             if (valid) {
+                                if (ADD_TOUCH_FLAG_PRIMARY) {
+                                    touch_input->dwFlags |= TOUCHEVENTF_PRIMARY;
+                                }
+
                                 touch_input->dwFlags |= TOUCHEVENTF_MOVE;
                             }
                             break;
                         case TOUCHEVENTF_UP:
                             // don't check valid so that this touch ID can be released
+                            if (ADD_TOUCH_FLAG_PRIMARY) {
+                                touch_input->dwFlags |= TOUCHEVENTF_PRIMARY;
+                            }
+
                             touch_input->dwFlags |= TOUCHEVENTF_UP;
                             break;
                     }

src/spice2x/misc/wintouchemu.h

@@ -8,6 +8,7 @@ namespace wintouchemu {
     extern bool FORCE;
     extern bool INJECT_MOUSE_AS_WM_TOUCH;
     extern bool LOG_FPS;
+    extern bool ADD_TOUCH_FLAG_PRIMARY;
 
     void hook(const char *window_title, HMODULE module = nullptr, int delay_in_s=0);
     void hook_title_ends(

src/spice2x/overlay/windows/config.cpp

@@ -1727,6 +1727,13 @@ namespace overlay::windows {
                         std::vector<int> analogs_midi_indices;
                         if (this->analogs_devices_selected >= 0) {
                             auto device = this->analogs_devices.at(this->analogs_devices_selected);
+
+                            // add a tooltip to devices selector
+                            if (!device->name.empty()) {
+                                ImGui::SameLine();
+                                ImGui::HelpMarker(device->name.c_str());
+                            }
+                            
                             switch (device->type) {
                                 case rawinput::MOUSE: {
 
@@ -2036,6 +2043,11 @@ namespace overlay::windows {
                             ImGui::CloseCurrentPopup();
                         }
 
+                        ImGui::SameLine();
+                        if (ImGui::Button("Reset")) {
+                            analog.resetValues();
+                        }
+
                         // clean up
                         ImGui::EndPopup();
                     }
@@ -2828,7 +2840,10 @@ namespace overlay::windows {
                         std::string current_item = option.value_text();
                         for (auto &element : definition.elements) {
                             if (element.first == current_item) {
-                                current_item += fmt::format(" ({})", element.second);
+                                if (!element.second.empty()) {
+                                    current_item += fmt::format(" ({})", element.second);
+                                }
+                                break;
                             }
                         }
                         if (current_item.empty()) {
@@ -2836,11 +2851,12 @@ namespace overlay::windows {
                         }
                         if (ImGui::BeginCombo("##combo", current_item.c_str(), 0)) {
                             for (auto &element : definition.elements) {
-                                bool selected = current_item == element.first;
                                 std::string label = element.first;
                                 if (!element.second.empty()) {
                                     label += fmt::format(" ({})", element.second);
                                 }
+                                
+                                bool selected = current_item == label;
                                 if (ImGui::Selectable(label.c_str(), selected)) {
                                     this->options_dirty = true;
                                     option.value = element.first;

src/spice2x/overlay/windows/patch_manager.cpp

@@ -288,6 +288,12 @@ namespace overlay::windows {
             this->reload_local_patches();
         }
 
+        if (avs::game::DLL_NAME == "kamunity.dll") {
+            ImGui::TextColored(ImVec4(1.f, 0.f, 0.f, 1.f), "Patches are not supported for Unity-based games.");
+            ImGui::TextColored(ImVec4(1.f, 0.f, 0.f, 1.f), "Instead, look for downloads of pre-patched DLLs.");
+            return;
+        }
+
         // game code info
         std::string identifiers;
         identifiers += avs::game::get_identifier() + "\n\n";

src/spice2x/rawinput/rawinput.cpp

@@ -347,40 +347,38 @@ void rawinput::RawInputManager::devices_scan_rawinput(RAWINPUTDEVICELIST *device
             if (hid_handle != INVALID_HANDLE_VALUE) {
 
                 // check manufacturer string
-                std::wstring man_ws;
+                std::string man_ws;
                 wchar_t man_str_buffer[256] {};
                 if (HidD_GetManufacturerString(hid_handle, man_str_buffer, sizeof(man_str_buffer))) {
-                    man_ws = std::wstring(man_str_buffer);
+                    man_ws = wchar_to_u8(man_str_buffer);
                 }
 
                 // get product string
-                std::wstring prod_ws;
+                std::string prod_ws;
                 wchar_t prod_str_buffer[256] {};
                 if (HidD_GetProductString(hid_handle, prod_str_buffer, sizeof(prod_str_buffer))) {
-                    prod_ws = std::wstring(prod_str_buffer);
+                    prod_ws = wchar_to_u8(prod_str_buffer);
                 }
 
                 // For Bluetooth LE HID devices (e.g., newer Xbox controllers) HidD_GetProductString
                 // and HidD_GetManufacturerString will return blank strings.
                 // https://docs.microsoft.com/en-us/answers/questions/401236/hidd-getproductstring-with-ble-hid-device.html
                 if (man_ws.empty() && prod_ws.empty()) {
-                    prod_ws = s2ws(device_description);
+                    prod_ws = device_description;
                 }
 
                 // build desc string
-                std::wstring desc_ws;
+                std::string desc_ws;
                 if (string_begins_with(prod_ws, man_ws)) {
                     desc_ws = prod_ws;
                 } else {
                     desc_ws = man_ws;
                     if (!man_ws.empty() && !prod_ws.empty()) {
-                        desc_ws += L" ";
+                        desc_ws += " ";
                     }
                     desc_ws += prod_ws;
                 }
-
-                // convert to normal string
-                new_device.desc = ws2s(desc_ws);
+                new_device.desc = desc_ws;
 
                 // get attributes
                 if (!HidD_GetAttributes(hid_handle, &hid_attributes)) {
@@ -1148,7 +1146,7 @@ std::string rawinput::RawInputManager::rawinput_get_device_description(const raw
 
                 // get property
                 DWORD desc_size = 0;
-                if (SetupDiGetDeviceRegistryProperty(
+                if (SetupDiGetDeviceRegistryPropertyW(
                         devinfo, &devinfo_data, SPDRP_DEVICEDESC, nullptr, nullptr, 0, &desc_size))
                 {
                     continue;
@@ -1160,14 +1158,14 @@ std::string rawinput::RawInputManager::rawinput_get_device_description(const raw
                 // allocate buffer
                 auto desc_data = std::make_unique<BYTE[]>(desc_size);
 
-                if (!SetupDiGetDeviceRegistryProperty(
+                if (!SetupDiGetDeviceRegistryPropertyW(
                         devinfo, &devinfo_data, SPDRP_DEVICEDESC, nullptr, desc_data.get(), desc_size, nullptr))
                 {
                     continue;
                 }
 
                 // kthxbye
-                device_description = std::string(reinterpret_cast<char *>(desc_data.get()));
+                device_description = wchar_to_u8(reinterpret_cast<PWCHAR>(desc_data.get()));
             }
         }
     }

src/spice2x/util/deferlog.cpp

@@ -18,6 +18,14 @@ namespace deferredlogs {
     std::mutex deferred_errors_mutex;
     std::vector<std::vector<std::string>> deferred_errors;
 
+    std::mutex softid_mutex;
+    std::string softid;
+
+    void set_softid(const std::string& softid_new) {
+        std::lock_guard<std::mutex> lock(softid_mutex);
+        softid = softid_new;
+    }
+
     void defer_error_messages(std::initializer_list<std::string> messages) {
         std::lock_guard<std::mutex> lock(deferred_errors_mutex);
         deferred_errors.emplace_back(messages);
@@ -45,12 +53,25 @@ namespace deferredlogs {
             msg += "/-------------------------- spice2x auto-troubleshooter -----------------------\\\n";
             msg += "\n";
             msg += "  spice2x version: " + to_string(VERSION_STRING_CFG) + "\n";
+
+            // soft ID
+            {
+                std::lock_guard<std::mutex> lock(softid_mutex);
+                if (!softid.empty()) {
+                    msg += "  game version: " + softid + "\n";
+                } else {
+                    msg += "  game version: unknown\n";
+                }
+            }
+
             msg += "\n";
             
             if (is_crash) {
                 msg += "  the game has crashed\n";
-                msg += "      share this entire log file with someone for troubleshooting (log.txt)\n";
-                msg += "      spice will also attempt to create a minidump (minidump.dmp)\n";
+                msg += "    * share this entire log file with someone for troubleshooting (log.txt)\n";
+                msg += "    * spice will also attempt to create a minidump (minidump.dmp)\n";
+                msg += "        minidump should only be shared with people you trust as it may contain\n";
+                msg += "        sensitive data (PCBID, card ID, etc)\n";
                 msg += "\n";
             }
 

src/spice2x/util/deferlog.h

@@ -9,6 +9,7 @@ namespace deferredlogs {
     // some shared error messages
     extern const std::initializer_list<std::string> SUPERSTEP_SOUND_ERROR_MESSAGE;
 
+    void set_softid(const std::string& softid);
     void defer_error_messages(std::initializer_list<std::string> messages);
     void dump_to_logger(bool is_crash=false);
 }

src/spice2x/util/dependencies.cpp

@@ -12,7 +12,7 @@ namespace {
         {
             "msvcr100.dll",
             "Visual Studio 2010 (VC++ 10.0) SP1 Redistributable",
-            "Download and install VisualCppRedist_AIO_x86_x64.exe from https://github.com/abbodi1406/vcredist/releases/latest",
+            "Download and install from https://github.com/spice2x/spice2x.github.io/wiki/Visual-Cpp-Redistributable-Runtimes",
         },
         {
             "d3dx9_43.dll",

src/spice2x/util/utils.h

@@ -340,3 +340,13 @@ static inline bool parse_width_height(const std::string wh, std::pair<uint32_t,
         return false;
     }
 }
+
+static inline std::string wchar_to_u8(const wchar_t* wstr) {
+    int size = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, nullptr, 0, nullptr, nullptr);
+    if (size <= 1) {
+        return "";
+    }
+    std::string out(size - 1, 0);
+    WideCharToMultiByte(CP_UTF8, 0, wstr, -1, out.data(), size - 1, nullptr, nullptr);
+    return out;
+}