Odin/crates/sleipnir-daemon/examples/xinput_edge_observer.rs
2026-07-17 11:20:07 +01:00

127 lines
3.8 KiB
Rust

#[cfg(windows)]
fn main() -> anyhow::Result<()> {
use anyhow::Context;
use std::{
env, fs, thread,
time::{Duration, Instant},
};
#[repr(C)]
#[derive(Clone, Copy, Default)]
struct XInputGamepad {
buttons: u16,
left_trigger: u8,
right_trigger: u8,
thumb_lx: i16,
thumb_ly: i16,
thumb_rx: i16,
thumb_ry: i16,
}
#[repr(C)]
#[derive(Clone, Copy, Default)]
struct XInputState {
packet_number: u32,
gamepad: XInputGamepad,
}
#[link(name = "xinput")]
unsafe extern "system" {
fn XInputGetState(user_index: u32, state: *mut XInputState) -> u32;
}
#[link(name = "winmm")]
unsafe extern "system" {
fn timeBeginPeriod(period_ms: u32) -> u32;
fn timeEndPeriod(period_ms: u32) -> u32;
}
struct TimerResolution;
impl Drop for TimerResolution {
fn drop(&mut self) {
unsafe {
let _ = timeEndPeriod(1);
}
}
}
let index = env::args().nth(1).and_then(|v| v.parse().ok()).unwrap_or(0);
let duration_seconds = env::args()
.nth(2)
.and_then(|v| v.parse().ok())
.unwrap_or(30);
let output = env::args()
.nth(3)
.context("usage: xinput_edge_observer INDEX SECONDS OUTPUT")?;
unsafe {
let _ = timeBeginPeriod(1);
}
let _timer_resolution = TimerResolution;
let started = Instant::now();
let deadline = started + Duration::from_secs(duration_seconds);
let mut next_sample = started;
let mut last_sample = started;
let mut max_sample_gap = Duration::ZERO;
let mut connected_samples = 0_u64;
let mut presses = 0_u64;
let mut releases = 0_u64;
let mut seen = false;
let mut last_pressed = false;
let mut press_started = None;
let mut durations_ms = Vec::new();
while Instant::now() < deadline {
let now = Instant::now();
max_sample_gap = max_sample_gap.max(now.saturating_duration_since(last_sample));
last_sample = now;
let mut state = XInputState::default();
if unsafe { XInputGetState(index, &mut state) } == 0 {
connected_samples += 1;
let pressed = state.gamepad.buttons & 0x1000 != 0;
if seen && pressed && !last_pressed {
presses += 1;
press_started = Some(now);
}
if seen && !pressed && last_pressed {
releases += 1;
if let Some(pressed_at) = press_started.take() {
durations_ms
.push(now.saturating_duration_since(pressed_at).as_secs_f64() * 1000.0);
}
}
last_pressed = pressed;
seen = true;
}
next_sample += Duration::from_millis(1);
let now = Instant::now();
if next_sample > now + Duration::from_micros(250) {
thread::sleep(next_sample - now - Duration::from_micros(250));
}
while Instant::now() < next_sample {
std::hint::spin_loop();
}
if Instant::now().saturating_duration_since(next_sample) > Duration::from_millis(5) {
next_sample = Instant::now();
}
}
let durations = durations_ms
.iter()
.map(|v| format!("{v:.3}"))
.collect::<Vec<_>>()
.join(",");
let result = format!(
"presses={presses} releases={releases} connected_samples={connected_samples} final_pressed={last_pressed} max_sample_gap_us={} durations_ms={durations}\n",
max_sample_gap.as_micros()
);
fs::write(&output, &result).with_context(|| format!("writing {output}"))?;
print!("{result}");
Ok(())
}
#[cfg(not(windows))]
fn main() {
eprintln!("xinput_edge_observer is Windows-only");
std::process::exit(2);
}