// ── WebSocket server ──────────────────────────────────────────────────────

static readonly List<WebSocket> Clients = new();

static readonly Dictionary<WebSocket, SemaphoreSlim> SendLocks = new();

static readonly object ClientLock = new();

// ── Per-player state (slots 0–3) ──────────────────────────────────────────

static GuitarState[] PlayerStates = new GuitarState[4] {

new GuitarState { Player = 0 }, new GuitarState { Player = 1 },

new GuitarState { Player = 2 }, new GuitarState { Player = 3 },

};

static readonly object[] StateLocks = new object[4] { new(), new(), new(), new() };

static bool[] EverConnected = new bool[4];

static async Task Main(string[] args)

{

Console.WriteLine("[CHEAPO] Starting on ws://localhost:2828");

Console.WriteLine("[CHEAPO] Reading XInput + HID instruments");

Console.WriteLine("[CHEAPO] Keep this window open while using the overlay.");

// Start WebSocket server

var wsTask = RunWebSocketServer();

// Start guitar polling

var xinputTask = Task.Run(PollXInput);

var hidTask = Task.Run(PollHID);

var soloTask = Task.Run(PollSoloFrets);

var micTask = Task.Run(PollMic);

var midiTask = Task.Run(PollMIDI);

var ghwtdeTask = Task.Run(PollGHWTDE);

var rb3dxTask = Task.Run(PollRB3DX);

var yargTask = Task.Run(PollYARG);

var ps2Task = Task.Run(PollPS2);

await Task.WhenAll(wsTask, xinputTask, hidTask, soloTask, micTask, midiTask, ghwtdeTask, rb3dxTask, yargTask, ps2Task);

}

// =========================================================================

// WEBSOCKET SERVER

// =========================================================================

static async Task RunWebSocketServer()

{

var listener = new HttpListener();

listener.Prefixes.Add("http://localhost:2828/");

listener.Start();

while (true)

{

var ctx = await listener.GetContextAsync();

if (ctx.Request.IsWebSocketRequest)

{

_ = HandleClient(ctx);

}

else

{

ctx.Response.StatusCode = 400;

ctx.Response.Close();

}

}

}

static async Task HandleClient(HttpListenerContext ctx)

{

var wsCtx = await ctx.AcceptWebSocketAsync(null);

var ws = wsCtx.WebSocket;

lock (ClientLock) { Clients.Add(ws); SendLocks[ws] = new SemaphoreSlim(1, 1); }

Console.WriteLine("[CHEAPO] Overlay connected");

// Send current state for all players immediately

for (int p = 0; p < 4; p++) await SendState(ws, PlayerStates[p]);

// Keep alive until disconnected

var buf = new byte[1024];

try

{

while (ws.State == WebSocketState.Open)

{

var result = await ws.ReceiveAsync(new ArraySegment<byte>(buf), CancellationToken.None);

if (result.MessageType == WebSocketMessageType.Close)

break;

}

}

catch { }

finally

{

lock (ClientLock) { Clients.Remove(ws); SendLocks.Remove(ws); }

try { ws.Dispose(); } catch { }

}

}

static async Task SendState(WebSocket ws, GuitarState state)

{

if (ws.State != WebSocketState.Open) return;

var json = JsonSerializer.Serialize(state);

var bytes = Encoding.UTF8.GetBytes(json);

try

{

await ws.SendAsync(new ArraySegment<byte>(bytes),

WebSocketMessageType.Text, true, CancellationToken.None);

}

catch { }

}

static void BroadcastPlayerState(int player, GuitarState state)

{

state.Player = player;

BroadcastState(state);

}

static void BroadcastState(GuitarState state)

{

List<WebSocket> snapshot;

lock (ClientLock) snapshot = new List<WebSocket>(Clients);

var json = JsonSerializer.Serialize(state);

var bytes = Encoding.UTF8.GetBytes(json);

foreach (var ws in snapshot)

{

if (ws.State != WebSocketState.Open) continue;

SemaphoreSlim sem;

lock (ClientLock) { if (!SendLocks.TryGetValue(ws, out sem)) continue; }

ThreadPool.QueueUserWorkItem(_ =>

{

sem.Wait();

try

{

if (ws.State == WebSocketState.Open)

ws.SendAsync(new ArraySegment<byte>(bytes),

WebSocketMessageType.Text, true,

CancellationToken.None).GetAwaiter().GetResult();

}

catch { }

finally { sem.Release(); }

});

}

}

// Sends a raw JSON string to all connected overlay clients (used for

// non-GuitarState messages such as calibration state).

static void BroadcastRaw(string json)

{

var bytes = Encoding.UTF8.GetBytes(json);

List<WebSocket> snapshot;

lock (ClientLock) snapshot = new List<WebSocket>(Clients);

foreach (var ws in snapshot)

{

if (ws.State != WebSocketState.Open) continue;

SemaphoreSlim sem;

lock (ClientLock) { if (!SendLocks.TryGetValue(ws, out sem)) continue; }

ThreadPool.QueueUserWorkItem(_ =>

{

sem.Wait();

try

{

if (ws.State == WebSocketState.Open)

ws.SendAsync(new ArraySegment<byte>(bytes),

WebSocketMessageType.Text, true,

CancellationToken.None).GetAwaiter().GetResult();

}

catch { }

finally { sem.Release(); }

});

}

}

static void UpdatePlayerState(int player, GuitarState newState)

{

newState.Player = player;

// Once connected, never go back to disconnected

if (EverConnected[player] && !newState.Connected) return;

if (newState.Connected) EverConnected[player] = true;

lock (StateLocks[player])

{

var cur = PlayerStates[player];

newState.MouthOpen = cur.MouthOpen;

newState.Kick = cur.Kick;

newState.DrumR = cur.DrumR;

newState.DrumY = cur.DrumY;

newState.DrumB = cur.DrumB;

newState.DrumG = cur.DrumG;

// Drum extras — managed by MIDI polling, always preserve here

newState.DrumO = cur.DrumO;

newState.DrumYCym = cur.DrumYCym;

newState.DrumBCym = cur.DrumBCym;

newState.DrumGCym = cur.DrumGCym;

newState.DrumMode = cur.DrumMode;

// Solo frets are managed by UpdatePlayerSoloFrets — always preserve them here.

newState.SoloG = cur.SoloG;

newState.SoloR = cur.SoloR;

newState.SoloY = cur.SoloY;

newState.SoloB = cur.SoloB;

newState.SoloO = cur.SoloO;

// Star power is managed by PollGHWTDE — always preserve here.

newState.StarPower = cur.StarPower;

if (newState.Equals(cur)) return;

PlayerStates[player] = newState;

}

BroadcastPlayerState(player, newState);

}

// Solo fret state is maintained independently and never overwritten by UpdatePlayerState.

// Both PollHID (non-IG_ hasSolo devices) and PollSoloFrets (IG_ hasSolo devices)

// call this to push changes.

static void UpdatePlayerSoloFrets(int player, bool sg, bool sr, bool sy, bool sb, bool so)

{

lock (StateLocks[player])

{

var cur = PlayerStates[player];

if (cur.SoloG == sg && cur.SoloR == sr &&

cur.SoloY == sy && cur.SoloB == sb &&

cur.SoloO == so) return;

cur.SoloG = sg;

cur.SoloR = sr;

cur.SoloY = sy;

cur.SoloB = sb;

cur.SoloO = so;

BroadcastPlayerState(player, cur);

}

}

// =========================================================================

// XINPUT PATH - reads Xbox 360 style instruments (Xplorer, Les Paul, etc.)

// =========================================================================

[StructLayout(LayoutKind.Sequential)]

struct XINPUT_GAMEPAD

{

public ushort wButtons;

public byte bLeftTrigger;

public byte bRightTrigger;

public short sThumbLX;

public short sThumbLY;

public short sThumbRX;

public short sThumbRY;

}

[StructLayout(LayoutKind.Sequential)]

struct XINPUT_STATE

{

public uint dwPacketNumber;

public XINPUT_GAMEPAD Gamepad;

}

[StructLayout(LayoutKind.Sequential)]

struct XINPUT_VIBRATION

{

public ushort wLeftMotorSpeed;

public ushort wRightMotorSpeed;

}

[StructLayout(LayoutKind.Sequential)]

struct XINPUT_CAPABILITIES

{

public byte Type;

public byte SubType;

public ushort Flags;

public XINPUT_GAMEPAD Gamepad;

public XINPUT_VIBRATION Vibration;

}

[DllImport("xinput1_4.dll", EntryPoint = "XInputGetState")]

static extern uint XInputGetState(uint dwUserIndex, ref XINPUT_STATE pState);

[DllImport("xinput1_4.dll", EntryPoint = "XInputGetCapabilities")]

static extern uint XInputGetCapabilities(uint dwUserIndex, uint dwFlags, ref XINPUT_CAPABILITIES pCapabilities);

// XInput button constants

const ushort XINPUT_DPAD_UP = 0x0001;

const ushort XINPUT_DPAD_DOWN = 0x0002;

const ushort XINPUT_BTN_A = 0x1000; // Green fret / Green drum pad

const ushort XINPUT_BTN_B = 0x2000; // Red fret / Red drum pad

const ushort XINPUT_BTN_X = 0x4000; // Blue fret / Blue drum pad

const ushort XINPUT_BTN_Y = 0x8000; // Yellow fret/ Yellow drum pad

const ushort XINPUT_BTN_LB = 0x0100; // Orange fret / Kick pedal

const ushort XINPUT_BTN_RB = 0x0200; // (unused for guitars) / 2nd kick or extra pad

// XInput device subtypes

const byte XINPUT_DEVSUBTYPE_DRUM_KIT = 0x08;

const byte XINPUT_DEVSUBTYPE_KEYBOARD = 0x0F;

const byte XINPUT_DEVSUBTYPE_PRO_GUITAR = 0x19;

static void PollXInput()

{

var prevPacket = new uint[4];

var prevBtns = new ushort[4];

// null = unknown; 0 = guitar/gamepad; 1 = drum kit; 2 = keyboard

var slotType = new byte?[4];

Console.WriteLine("[XInput] polling started (controllers 0-3)");

while (true)

{

for (uint i = 0; i < 4; i++)

{

var state = new XINPUT_STATE();

uint result = XInputGetState(i, ref state);

if (result != 0)

{

if (slotType[i] != null) // slot was occupied, now disconnected

{

lock (StateLocks[i])

{

if (PlayerStates[i].Connected &&

PlayerStates[i].GuitarName?.StartsWith("XInput") == true)

UpdatePlayerState((int)i, new GuitarState { Connected = false });

}

slotType[i] = null;

}

prevBtns[i] = 0;

continue;

}

// First time we see this slot: check capabilities to identify device type

if (slotType[i] == null)

{

var caps = new XINPUT_CAPABILITIES();

if (XInputGetCapabilities(i, 0, ref caps) == 0)

{

if (caps.SubType == XINPUT_DEVSUBTYPE_DRUM_KIT) slotType[i] = 1;

else if (caps.SubType == XINPUT_DEVSUBTYPE_KEYBOARD) slotType[i] = 2;

else if (caps.SubType == XINPUT_DEVSUBTYPE_PRO_GUITAR) slotType[i] = 3;

else slotType[i] = 0;

Console.WriteLine(

$"[XInput] slot {i}: SubType=0x{caps.SubType:X2} " +

$"→ {(slotType[i] == 1 ? "drum kit" : slotType[i] == 2 ? "keyboard" : slotType[i] == 3 ? "pro guitar" : "guitar/gamepad")}");

}

else

{

slotType[i] = 0; // can't identify → treat as guitar

}

}

if (slotType[i] == 1)

{

// ── XInput drum kit ─────────────────────────────────────────

// Set drum mode + connected on first hit (or if mode changed)

lock (StateLocks[i])

{

var ps = PlayerStates[i];

if (!ps.Connected || ps.DrumMode != "rb")

{

EverConnected[i] = true;

ps.Connected = true;

ps.GuitarName = $"XInput Drum Kit {i}";

ps.DrumMode = "rb";

ps.InstrumentType = "drums";

BroadcastPlayerState((int)i, ps);

}

}

// Only process rising edges so each hit is a discrete 120ms flash

if (state.dwPacketNumber == prevPacket[i]) continue;

prevPacket[i] = state.dwPacketNumber;

var gp = state.Gamepad;

ushort pressed = (ushort)(gp.wButtons & ~prevBtns[i]);

prevBtns[i] = gp.wButtons;

// RB drums: Green=A, Red=B, Yellow=Y, Blue=X, Kick=LB

if ((pressed & XINPUT_BTN_A) != 0) FlashPlayerDrumPad((int)i, 'G');

if ((pressed & XINPUT_BTN_B) != 0) FlashPlayerDrumPad((int)i, 'R');

if ((pressed & XINPUT_BTN_Y) != 0) FlashPlayerDrumPad((int)i, 'Y');

if ((pressed & XINPUT_BTN_X) != 0) FlashPlayerDrumPad((int)i, 'B');

if ((pressed & XINPUT_BTN_LB) != 0) FlashPlayerDrumPad((int)i, 'K');

}

else if (slotType[i] == 2)

{

// ── XInput keyboard (RB3 keys) ───────────────────────────────

if (state.dwPacketNumber == prevPacket[i]) continue;

prevPacket[i] = state.dwPacketNumber;

var gp = state.Gamepad;

// Key bit positions (PlasticBand spec, 5-fret mapping):

// C2 = G : bRightTrigger bit 3 (0x08)

// D2 = R : bRightTrigger bit 1 (0x02)

// E2 = Y : sThumbLX bit 7 (0x0080)

// F2 = B : sThumbLX bit 6 (0x0040)

// G2 = O : sThumbLX bit 4 (0x0010)

bool g = (gp.bRightTrigger & 0x08) != 0;

bool r = (gp.bRightTrigger & 0x02) != 0;

bool y = ((ushort)gp.sThumbLX & 0x0080) != 0;

bool b = ((ushort)gp.sThumbLX & 0x0040) != 0;

bool o = ((ushort)gp.sThumbLX & 0x0010) != 0;

UpdatePlayerState((int)i, new GuitarState

{

Connected = true,

GuitarName = $"XInput Keyboard {i}",

InstrumentType = "keys",

G = g, R = r, Y = y, B = b, O = o,

Strum = "neutral"

});

}

else if (slotType[i] == 3)

{

// ── XInput pro guitar (RB3 Mustang) ─────────────────────────

if (state.dwPacketNumber == prevPacket[i]) continue;

prevPacket[i] = state.dwPacketNumber;

var gp = state.Gamepad;

// Per-string fret numbers (5 bits each, 0=open, 1–17 = fret)

// Strings 1–3 (Low E, A, D) packed into combined triggers

// Strings 4–6 (G, B, High E) packed into sThumbLX

ushort trig = (ushort)(gp.bLeftTrigger | (gp.bRightTrigger << 8));

ushort lx = (ushort)gp.sThumbLX;

int fLowE = trig & 0x1F;

int fA = (trig >> 5) & 0x1F;

int fD = (trig >> 10) & 0x1F;

int fG = lx & 0x1F;

int fB = (lx >> 5) & 0x1F;

int fHighE = (lx >> 10) & 0x1F;

// Frets 13–17 are the solo zone (upper neck, same as solo buttons

// on a standard RB guitar). Any string there = solo mode.

bool anySolo = (fLowE >= 13 && fLowE <= 17) ||

(fA >= 13 && fA <= 17) ||

(fD >= 13 && fD <= 17) ||

(fG >= 13 && fG <= 17) ||

(fB >= 13 && fB <= 17) ||

(fHighE >= 13 && fHighE <= 17);

// 5-fret color flags — high bits of velocity byte pairs

// Green = sThumbLY bit 7 (0x0080)

// Red = sThumbLY bit 15 (0x8000)

// Yellow = sThumbRX bit 7 (0x0080)

// Blue = sThumbRX bit 15 (0x8000)

// Orange = sThumbRY bit 7 (0x0080)

bool g = ((ushort)gp.sThumbLY & 0x0080) != 0;

bool r = ((ushort)gp.sThumbLY & 0x8000) != 0;

bool y = ((ushort)gp.sThumbRX & 0x0080) != 0;

bool b = ((ushort)gp.sThumbRX & 0x8000) != 0;

bool o = ((ushort)gp.sThumbRY & 0x0080) != 0;

// Strum: D-pad up/down

string strum = "neutral";

if ((gp.wButtons & XINPUT_DPAD_UP) != 0) strum = "up";

if ((gp.wButtons & XINPUT_DPAD_DOWN) != 0) strum = "down";

// Route color flags: solo zone → solo frets, regular zone → frets

UpdatePlayerState((int)i, new GuitarState

{

Connected = true,

GuitarName = $"XInput Pro Guitar {i}",

InstrumentType = "guitar",

G = !anySolo && g,

R = !anySolo && r,

Y = !anySolo && y,

B = !anySolo && b,

O = !anySolo && o,

Strum = strum

});

UpdatePlayerSoloFrets((int)i,

anySolo && g,

anySolo && r,

anySolo && y,

anySolo && b,

anySolo && o);

}

else

{

// ── XInput guitar / gamepad ──────────────────────────────────

// Packet number not used — some controllers (e.g. Santroller)

// don't increment it reliably. Use button-state change instead.

var gp = state.Gamepad;

if (gp.wButtons == prevBtns[i] && state.dwPacketNumber == prevPacket[i]) continue;

prevPacket[i] = state.dwPacketNumber;

prevBtns[i] = gp.wButtons;

// Fret mapping: Green=A, Red=B, Yellow=Y, Blue=X, Orange=LB

bool g = (gp.wButtons & XINPUT_BTN_A) != 0;

bool r = (gp.wButtons & XINPUT_BTN_B) != 0;

bool y = (gp.wButtons & XINPUT_BTN_Y) != 0;

bool b = (gp.wButtons & XINPUT_BTN_X) != 0;

bool o = (gp.wButtons & XINPUT_BTN_LB) != 0;

// Strum: D-pad up/down, or left stick Y

string strum = "neutral";

if ((gp.wButtons & XINPUT_DPAD_UP) != 0) strum = "up";

if ((gp.wButtons & XINPUT_DPAD_DOWN) != 0) strum = "down";

if (strum == "neutral" && gp.sThumbLY < -20000) strum = "down";

if (strum == "neutral" && gp.sThumbLY > 20000) strum = "up";

UpdatePlayerState((int)i, new GuitarState

{

Connected = true,

GuitarName = $"XInput Controller {i}",

InstrumentType = "guitar",

G = g, R = r, Y = y, B = b, O = o,

Strum = strum

});

}

}

Thread.Sleep(4); // ~250hz polling

}

}

// Shared by XInput drum path and MIDI path — flash a drum pad for 120 ms

static void FlashPlayerDrumPad(int player, char pad)

{

long now = Environment.TickCount64;

lock (StateLocks[player]) {

_drumHitTime[player][pad] = now;

SetPlayerDrumPad(player, pad, true);

BroadcastPlayerState(player, PlayerStates[player]);

}

ThreadPool.QueueUserWorkItem(_ => {

Thread.Sleep(120);

lock (StateLocks[player]) {

if (_drumHitTime[player].TryGetValue(pad, out long t) && Environment.TickCount64 - t >= 120) {

SetPlayerDrumPad(player, pad, false);

BroadcastPlayerState(player, PlayerStates[player]);

}

}

});

}

// =========================================================================

// HID PATH - reads HID guitars (Santroller, RCM, RB wireless)

// =========================================================================

// Known guitar VID/PIDs

static readonly (int vid, int pid, bool hasSolo, string name)[] KnownGuitars = {

(0x1430, 0x4748, false, "GH Xplorer"),

(0x1430, 0x474C, false, "GH Les Paul"),

(0x1430, 0x4750, false, "GH World Tour"),

(0x1BAD, 0x0002, true, "RB1/RB2 Guitar"),

(0x1BAD, 0x02AA, true, "RB2 Guitar (wireless)"),

(0x1BAD, 0x0203, true, "RB3 Guitar"),

(0x1BAD, 0x0004, true, "RB4 Guitar"),

};

[DllImport("hid.dll")]

static extern bool HidD_GetHidGuid(out Guid HidGuid);

[DllImport("setupapi.dll", CharSet = CharSet.Auto)]

static extern IntPtr SetupDiGetClassDevs(ref Guid ClassGuid, string Enumerator,

IntPtr hwndParent, uint Flags);

[DllImport("setupapi.dll", CharSet = CharSet.Auto)]

static extern bool SetupDiEnumDeviceInterfaces(IntPtr DeviceInfoSet,

IntPtr DeviceInfoData, ref Guid InterfaceClassGuid,

uint MemberIndex, ref SP_DEVICE_INTERFACE_DATA DeviceInterfaceData);

[DllImport("setupapi.dll", CharSet = CharSet.Auto)]

static extern bool SetupDiGetDeviceInterfaceDetail(IntPtr DeviceInfoSet,

ref SP_DEVICE_INTERFACE_DATA DeviceInterfaceData,

IntPtr DeviceInterfaceDetailData, uint DeviceInterfaceDetailDataSize,

out uint RequiredSize, IntPtr DeviceInfoData);

[DllImport("setupapi.dll")]

static extern bool SetupDiDestroyDeviceInfoList(IntPtr DeviceInfoSet);

[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]

static extern IntPtr CreateFile(string lpFileName, uint dwDesiredAccess,

uint dwShareMode, IntPtr lpSecurityAttributes, uint dwCreationDisposition,

uint dwFlagsAndAttributes, IntPtr hTemplateFile);

[DllImport("kernel32.dll")]

static extern bool ReadFile(IntPtr hFile, byte[] lpBuffer, uint nNumberOfBytesToRead,

out uint lpNumberOfBytesRead, IntPtr lpOverlapped);

[DllImport("kernel32.dll")]

static extern bool CloseHandle(IntPtr hObject);

[DllImport("hid.dll")]

static extern bool HidD_GetAttributes(IntPtr HidDeviceObject,

ref HIDD_ATTRIBUTES Attributes);

[DllImport("hid.dll", CharSet = CharSet.Auto)]

static extern bool HidD_GetProductString(IntPtr HidDeviceObject,

byte[] Buffer, uint BufferLength);

[StructLayout(LayoutKind.Sequential)]

struct SP_DEVICE_INTERFACE_DATA

{

public uint cbSize;

public Guid InterfaceClassGuid;

public uint Flags;

public IntPtr Reserved;

}

[StructLayout(LayoutKind.Sequential)]

struct HIDD_ATTRIBUTES

{

public uint Size;

public ushort VendorID;

public ushort ProductID;

public ushort VersionNumber;

}

const uint DIGCF_PRESENT = 0x02;

const uint DIGCF_DEVICEINTERFACE = 0x10;

const uint GENERIC_READ = 0x80000000;

const uint FILE_SHARE_READ = 0x01;

const uint FILE_SHARE_WRITE = 0x02;

const uint OPEN_EXISTING = 3;

const uint FILE_FLAG_OVERLAPPED = 0x40000000;

static readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);

static void PollHID()

{

Console.WriteLine("[HID] polling started");

while (true)

{

// Don't compete with XInput player 0 if it has an active guitar

bool xinputActive;

lock (StateLocks[0])

xinputActive = PlayerStates[0].Connected &&

PlayerStates[0].GuitarName?.StartsWith("XInput") == true;

if (xinputActive)

{

Thread.Sleep(500);

continue;

}

IntPtr handle = INVALID_HANDLE_VALUE;

string guitarName = null;

bool hasSolo = false;

try

{

HidD_GetHidGuid(out Guid hidGuid);

var devInfoSet = SetupDiGetClassDevs(ref hidGuid, null,

IntPtr.Zero, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);

if (devInfoSet == INVALID_HANDLE_VALUE)

{

Thread.Sleep(2000);

continue;

}

uint idx = 0;

var devIfaceData = new SP_DEVICE_INTERFACE_DATA();

devIfaceData.cbSize = (uint)Marshal.SizeOf(devIfaceData);

while (SetupDiEnumDeviceInterfaces(devInfoSet, IntPtr.Zero,

ref hidGuid, idx++, ref devIfaceData))

{

SetupDiGetDeviceInterfaceDetail(devInfoSet, ref devIfaceData,

IntPtr.Zero, 0, out uint reqSize, IntPtr.Zero);

if (reqSize == 0) continue;

var detailBuf = Marshal.AllocHGlobal((int)reqSize);

Marshal.WriteInt32(detailBuf, IntPtr.Size == 8 ? 8 : 6);

SetupDiGetDeviceInterfaceDetail(devInfoSet, ref devIfaceData,

detailBuf, reqSize, out _, IntPtr.Zero);

string path = Marshal.PtrToStringAuto(

IntPtr.Add(detailBuf, 4));

Marshal.FreeHGlobal(detailBuf);

if (string.IsNullOrEmpty(path)) continue;

// Skip XInput interfaces

if (path.ToUpper().Contains("IG_")) continue;

var tmpHandle = CreateFile(path,

GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,

IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);

if (tmpHandle == INVALID_HANDLE_VALUE) continue;

var attrs = new HIDD_ATTRIBUTES();

attrs.Size = (uint)Marshal.SizeOf(attrs);

if (!HidD_GetAttributes(tmpHandle, ref attrs))

{

CloseHandle(tmpHandle);

continue;

}

int vid = attrs.VendorID;

int pid = attrs.ProductID;

bool matched = false;

foreach (var (kv, kp, ks, kn) in KnownGuitars)

{

if (kv == vid && kp == pid)

{

handle = tmpHandle;

guitarName = kn;

hasSolo = ks;

matched = true;

Console.WriteLine($"[HID] found: {kn} ({vid:X4}:{pid:X4})");

break;

}

}

if (!matched)

{

CloseHandle(tmpHandle);

}

else

{

Console.WriteLine($"[HID] matched: {guitarName} path: {path}");

break;

}

}

SetupDiDestroyDeviceInfoList(devInfoSet);

}

catch (Exception ex)

{

Console.WriteLine($"[HID] scan error: {ex.Message}");

Thread.Sleep(2000);

continue;

}

if (handle == INVALID_HANDLE_VALUE || handle == IntPtr.Zero)

{

Thread.Sleep(2000);

continue;

}

// Read loop

UpdatePlayerState(0, new GuitarState { Connected = true, GuitarName = guitarName, InstrumentType = "guitar" });

var buf = new byte[64];

while (true)

{

if (!ReadFile(handle, buf, (uint)buf.Length, out uint bytesRead, IntPtr.Zero)

|| bytesRead == 0)

{

var err = Marshal.GetLastWin32Error();

Console.WriteLine($"[HID] read failed (error {err}), reconnecting...");

break;

}

int regularFrets = buf[6];

// buf[7] contains combined fret state (regular + solo); mask out regular to isolate solo-only bits

int soloFrets = hasSolo ? (buf[7] & ~regularFrets) : 0;