use crate::error::CameraError;
use crate::types::{CameraDeviceInfo, CameraResult};
use std::mem::MaybeUninit;
use windows::core::PWSTR;
use windows::Win32::Media::MediaFoundation::{
IMFActivate, IMFAttributes, IMFMediaSource, IMFSourceReader, MFCreateAttributes,
MFCreateSourceReaderFromMediaSource, MFEnumDeviceSources, MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME,
MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID,
MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, MF_READWRITE_DISABLE_CONVERTERS,
};
use super::com::MFGuard;
pub(crate) fn query_activate_pointers() -> CameraResult<Vec<IMFActivate>> {
let attributes = unsafe {
let mut attr: Option<IMFAttributes> = None;
MFCreateAttributes(&mut attr, 1).map_err(|e| {
super::native_error(
crate::CameraErrorKind::BackendFailure,
crate::OperationStage::Enumeration,
"create enumeration attributes",
e,
)
})?;
let attr = attr.ok_or_else(|| {
CameraError::backend_failure(
crate::BackendId::MEDIA_FOUNDATION,
crate::OperationStage::Enumeration,
"MFCreateAttributes returned no enumeration attributes".into(),
)
})?;
attr.SetGUID(
&MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
&MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID,
)
.map_err(|e| {
super::native_error(
crate::CameraErrorKind::BackendFailure,
crate::OperationStage::Enumeration,
"set device source type",
e,
)
})?;
attr
};
let mut count: u32 = 0;
let mut devices_ptr: MaybeUninit<*mut Option<IMFActivate>> = MaybeUninit::uninit();
unsafe {
MFEnumDeviceSources(&attributes, devices_ptr.as_mut_ptr(), &mut count).map_err(|e| {
super::native_error(
crate::CameraErrorKind::BackendFailure,
crate::OperationStage::Enumeration,
"enumerate devices",
e,
)
})?;
}
if count == 0 {
return Ok(Vec::new());
}
let devices_ptr = unsafe { devices_ptr.assume_init() };
let mut device_list = Vec::with_capacity(count as usize);
unsafe {
let slice = std::slice::from_raw_parts(devices_ptr, count as usize);
device_list.extend(slice.iter().flatten().cloned());
windows::Win32::System::Com::CoTaskMemFree(Some(devices_ptr as *const _));
}
Ok(device_list)
}
pub(crate) fn activate_to_device_info(
index: u32,
activate: &IMFActivate,
) -> CameraResult<CameraDeviceInfo> {
let name = get_device_string(activate, &MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME)?;
let symlink = get_device_string(
activate,
&MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK,
)?;
Ok(CameraDeviceInfo {
index,
name,
description: format!("Media Foundation Camera: {}", symlink),
vendor_id: None,
product_id: None,
serial_number: None,
device_path: Some(symlink),
})
}
fn get_device_string(activate: &IMFActivate, key: &windows::core::GUID) -> CameraResult<String> {
let mut pwstr = PWSTR::null();
let mut len = 0u32;
unsafe {
activate
.GetAllocatedString(key, &mut pwstr, &mut len)
.map_err(|e| {
super::native_error(
crate::CameraErrorKind::BackendFailure,
crate::OperationStage::Enumeration,
"get device string",
e,
)
})?;
if pwstr.is_null() {
return Err(CameraError::backend_failure(
crate::BackendId::MEDIA_FOUNDATION,
crate::OperationStage::Enumeration,
"Device string is null".into(),
));
}
let result = pwstr.to_string().map_err(|e| {
CameraError::backend_failure(
crate::BackendId::MEDIA_FOUNDATION,
crate::OperationStage::Enumeration,
"Failed to convert device string".into(),
)
.with_operation("convert device string")
.with_source(e)
})?;
windows::Win32::System::Com::CoTaskMemFree(Some(pwstr.0 as *const _));
Ok(result)
}
}
pub(crate) fn create_source_reader(
activate: &IMFActivate,
callback: &windows::Win32::Media::MediaFoundation::IMFSourceReaderCallback,
) -> CameraResult<(IMFSourceReader, IMFMediaSource)> {
unsafe {
let media_source: IMFMediaSource = activate.ActivateObject().map_err(|e| {
super::native_error(
crate::CameraErrorKind::DeviceOpenFailed,
crate::OperationStage::Open,
"activate device",
e,
)
})?;
let result = (|| -> CameraResult<_> {
let mut attr: Option<IMFAttributes> = None;
MFCreateAttributes(&mut attr, 1).map_err(|e| {
super::native_error(
crate::CameraErrorKind::DeviceOpenFailed,
crate::OperationStage::Open,
"create source reader attributes",
e,
)
})?;
let attr = attr.ok_or_else(|| {
CameraError::backend_failure(
crate::BackendId::MEDIA_FOUNDATION,
crate::OperationStage::Open,
"MFCreateAttributes returned no source reader attributes".into(),
)
})?;
attr.SetUINT32(&MF_READWRITE_DISABLE_CONVERTERS, 1)
.map_err(|e| {
super::native_error(
crate::CameraErrorKind::DeviceOpenFailed,
crate::OperationStage::Open,
"disable source reader converters",
e,
)
})?;
attr.SetUnknown(
&windows::Win32::Media::MediaFoundation::MF_SOURCE_READER_ASYNC_CALLBACK,
callback,
)
.map_err(|e| {
super::native_error(
crate::CameraErrorKind::DeviceOpenFailed,
crate::OperationStage::Open,
"set source reader callback",
e,
)
})?;
let source_reader =
MFCreateSourceReaderFromMediaSource(&media_source, &attr).map_err(|e| {
super::native_error(
crate::CameraErrorKind::DeviceOpenFailed,
crate::OperationStage::Open,
"create source reader",
e,
)
})?;
Ok((source_reader, media_source.clone()))
})();
if result.is_err() {
let _ = media_source.Shutdown();
}
result
}
}
pub fn list_devices() -> CameraResult<Vec<CameraDeviceInfo>> {
let _guard = MFGuard::new()?;
let activates = query_activate_pointers()?;
let mut devices = Vec::with_capacity(activates.len());
for (index, activate) in activates.iter().enumerate() {
match activate_to_device_info(index as u32, activate) {
Ok(info) => devices.push(info),
Err(e) => {
log::warn!("Failed to get device info for index {}: {}", index, e);
}
}
}
Ok(devices)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_list_devices() {
if cfg!(target_os = "windows") {
let result = list_devices();
assert!(result.is_ok());
println!("Found {} devices", result.unwrap().len());
}
}
}