use std::ffi::c_void;
use std::sync::atomic::{AtomicPtr, AtomicU64, Ordering};
use std::sync::{Arc, OnceLock};
use windows::core::Interface;
use windows::Win32::Graphics::Direct3D11::ID3D11Device;
static DEVICE: AtomicPtr<c_void> = AtomicPtr::new(std::ptr::null_mut());
static GENERATION: AtomicU64 = AtomicU64::new(0);
static PROVIDER: OnceLock<SharedDeviceProvider> = OnceLock::new();
pub struct SharedVideoDevice {
pub device: *mut c_void,
pub generation: u64,
pub keep_alive: Arc<dyn std::any::Any + Send + Sync>,
}
pub type SharedDeviceProvider = fn() -> Result<Option<SharedVideoDevice>, String>;
pub unsafe fn install_provider(provider: SharedDeviceProvider) -> Result<(), &'static str> {
PROVIDER
.set(provider)
.map_err(|_| "video device provider already installed")?;
forward_to_video();
Ok(())
}
pub unsafe fn set_device(ptr: *mut c_void, generation: u64) {
DEVICE.store(ptr, Ordering::Release);
GENERATION.store(generation, Ordering::Release);
forward_to_video();
}
pub fn renderer_device() -> Result<Option<SharedVideoDevice>, String> {
if let Some(provider) = PROVIDER.get() {
return provider();
}
let raw = DEVICE.load(Ordering::Acquire);
if raw.is_null() {
return Ok(None);
}
let Some(device) = (unsafe { ID3D11Device::from_raw_borrowed(&raw) }) else {
return Ok(None);
};
let device = device.clone();
Ok(Some(SharedVideoDevice {
device: device.as_raw(),
generation: GENERATION.load(Ordering::Acquire),
keep_alive: Arc::new(SendDevice(device)),
}))
}
struct SendDevice(#[allow(dead_code)] ID3D11Device);
unsafe impl Send for SendDevice {}
unsafe impl Sync for SendDevice {}
#[cfg(feature = "video")]
fn forward_to_video() {
fn lease() -> Result<Option<sk_video::mf::SharedVideoDevice>, String> {
renderer_device().map(|lease| {
lease.map(|l| sk_video::mf::SharedVideoDevice {
device: l.device,
generation: l.generation,
keep_alive: l.keep_alive,
})
})
}
static ONCE: std::sync::Once = std::sync::Once::new();
ONCE.call_once(|| unsafe {
let _ = sk_video::mf::install_shared_device_provider(lease);
});
}
#[cfg(not(feature = "video"))]
fn forward_to_video() {}