Channel names: CoreAudio and ASIO

asio-sys/src/bindings/mod.rs

@@ -7,7 +7,7 @@ pub mod errors;
 #[cfg(target_os = "windows")]
 use std::os::raw::c_long;
 use std::{
-    ffi::{CStr, CString},
+    ffi::CString,
     os::raw::{c_char, c_double, c_void},
     ptr::null_mut,
     sync::{
@@ -981,6 +981,18 @@ impl Driver {
         drop(dcb);
         drop(removed);
     }
+
+    /// Returns the name of the channel at the given index.
+    ///
+    /// `channel` is a 0-based channel index. `is_input` selects the input (`true`) or output
+    /// (`false`) direction.
+    ///
+    /// The driver must already be loaded (i.e. this `Driver` instance must be alive).
+    pub fn channel_name(&self, channel: i32, is_input: bool) -> Result<String, AsioError> {
+        let _guard = self.inner.lock_state();
+        let info = asio_channel_info(channel, is_input)?;
+        Ok(driver_name_to_utf8(&info.name).into_owned())
+    }
 }
 
 impl DriverState {
@@ -1107,6 +1119,10 @@ fn asio_get_buffer_sizes() -> Result<BufferSizes, AsioError> {
 /// Retrieve the `ASIOChannelInfo` associated with the channel at the given index on either the
 /// input or output stream (`true` for input).
 fn asio_channel_info(channel: c_long, is_input: bool) -> Result<ai::ASIOChannelInfo, AsioError> {
+    if channel < 0 {
+        return Err(AsioError::InvalidInput);
+    }
+
     let mut channel_info = ai::ASIOChannelInfo {
         // Which channel we are querying
         channel,
@@ -1137,7 +1153,15 @@ fn stream_data_type(is_input: bool) -> Result<AsioSampleType, AsioError> {
 ///
 /// This converts to utf8.
 fn driver_name_to_utf8(bytes: &[c_char]) -> std::borrow::Cow<'_, str> {
-    unsafe { CStr::from_ptr(bytes.as_ptr()).to_string_lossy() }
+    let length = bytes
+        .iter()
+        .position(|&byte| byte == 0)
+        .unwrap_or(bytes.len());
+    let bytes = bytes[..length]
+        .iter()
+        .map(|&byte| byte as u8)
+        .collect::<Vec<_>>();
+    String::from_utf8_lossy(&bytes).into_owned().into()
 }
 
 /// Convert an `ASIOTimeStamp` (high and low 32-bit halves) to a `u64` nanosecond value.

examples/custom.rs

@@ -183,6 +183,13 @@ impl DeviceTrait for MyDevice {
             handle: Some(handle),
         })
     }
+
+    fn get_channel_name(&self, channel_index: u16, input: bool) -> Result<String, Error> {
+        Ok(format!(
+            "{} {channel_index}",
+            if input { "Input" } else { "Output" }
+        ))
+    }
 }
 
 impl fmt::Display for MyDevice {

src/host/asio/device.rs

@@ -26,6 +26,8 @@ pub struct Device {
     input_sample_format: Option<SampleFormat>,
     output_sample_format: Option<SampleFormat>,
     supported_sample_rates: Box<[SampleRate]>,
+    input_channel_names: Box<[String]>,
+    output_channel_names: Box<[String]>,
 
     pub(super) current_callback_flag: Arc<AtomicU32>,
 }
@@ -123,6 +125,26 @@ impl Device {
         }
         configs
     }
+
+    pub fn get_channel_name(&self, channel_index: u16, input: bool) -> Result<String, Error> {
+        let names = if input {
+            &self.input_channel_names
+        } else {
+            &self.output_channel_names
+        };
+
+        names.get(channel_index as usize).cloned().ok_or_else(|| {
+            Error::with_message(
+                ErrorKind::InvalidInput,
+                format!(
+                    "channel index {} is out of range (device has {} {} channels)",
+                    channel_index,
+                    names.len(),
+                    if input { "input" } else { "output" },
+                ),
+            )
+        })
+    }
 }
 
 impl PartialEq for Device {
@@ -185,6 +207,12 @@ impl Iterator for Devices {
                     if channels.ins == 0 && channels.outs == 0 {
                         continue;
                     }
+                    let Ok(channels_in) = ChannelCount::try_from(channels.ins) else {
+                        continue;
+                    };
+                    let Ok(channels_out) = ChannelCount::try_from(channels.outs) else {
+                        continue;
+                    };
 
                     // Some drivers (e.g. Realtek ASIO) return 0 for sample_rate() until a
                     // stream is active. Treat 0 as "not yet known" rather than skipping.
@@ -209,18 +237,39 @@ impl Iterator for Devices {
                         .filter(|&r| driver.can_sample_rate(r.into()).unwrap_or(false))
                         .collect();
 
+                    let input_channel_names: Box<[String]> = (0..channels_in)
+                        .map(|ch| {
+                            driver
+                                .channel_name(ch.into(), true)
+                                .ok()
+                                .filter(|name| !name.is_empty())
+                                .unwrap_or_else(|| format!("Input {ch}"))
+                        })
+                        .collect();
+                    let output_channel_names: Box<[String]> = (0..channels_out)
+                        .map(|ch| {
+                            driver
+                                .channel_name(ch.into(), false)
+                                .ok()
+                                .filter(|name| !name.is_empty())
+                                .unwrap_or_else(|| format!("Output {ch}"))
+                        })
+                        .collect();
+
                     self.current_driver = Some(driver);
 
                     return Some(Device {
                         name,
-                        channels_in: channels.ins as ChannelCount,
-                        channels_out: channels.outs as ChannelCount,
+                        channels_in,
+                        channels_out,
                         sample_rate: sample_rate as SampleRate,
                         buffer_size_min: buffer_size_range.min as FrameCount,
                         buffer_size_max: buffer_size_range.max as FrameCount,
                         input_sample_format,
                         output_sample_format,
                         supported_sample_rates,
+                        input_channel_names,
+                        output_channel_names,
                         // Initialize with sentinel value so it never matches global flag state (0 or 1).
                         current_callback_flag: Arc::new(AtomicU32::new(u32::MAX)),
                     });

src/host/asio/mod.rs

@@ -143,6 +143,10 @@ impl DeviceTrait for Device {
             timeout,
         )
     }
+
+    fn get_channel_name(&self, channel_index: u16, input: bool) -> Result<String, Error> {
+        Device::get_channel_name(self, channel_index, input)
+    }
 }
 
 impl StreamTrait for Stream {