Merge pull request #83 from HEnquist/hogmode

Add helpers for hog mode

Author: MichaelHills

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "coreaudio-rs"
-version = "0.11.0"
+version = "0.11.1"
 authors = ["mitchmindtree <mitchell.nordine@gmail.com>", "yupferris <jake@fusetools.com>"]
 description = "A friendly rust interface for Apple's CoreAudio API."
 keywords = ["core", "audio", "unit", "osx", "ios"]

examples/feedback.rs

@@ -6,9 +6,9 @@ use std::collections::VecDeque;
 use std::sync::{Arc, Mutex};
 
 use coreaudio::audio_unit::audio_format::LinearPcmFlags;
+use coreaudio::audio_unit::macos_helpers::{audio_unit_from_device_id, get_default_device_id};
 use coreaudio::audio_unit::render_callback::{self, data};
 use coreaudio::audio_unit::{Element, SampleFormat, Scope, StreamFormat};
-use coreaudio::audio_unit::macos_helpers::{audio_unit_from_device_id, get_default_device_id};
 use coreaudio::sys::*;
 
 const SAMPLE_RATE: f64 = 44100.0;
@@ -20,8 +20,10 @@ const SAMPLE_FORMAT: SampleFormat = SampleFormat::F32;
 // type S = i8; const SAMPLE_FORMAT: SampleFormat = SampleFormat::I8;
 
 fn main() -> Result<(), coreaudio::Error> {
-    let mut input_audio_unit = audio_unit_from_device_id(get_default_device_id(true).unwrap(), true)?;
-    let mut output_audio_unit = audio_unit_from_device_id(get_default_device_id(false).unwrap(), false)?;
+    let mut input_audio_unit =
+        audio_unit_from_device_id(get_default_device_id(true).unwrap(), true)?;
+    let mut output_audio_unit =
+        audio_unit_from_device_id(get_default_device_id(false).unwrap(), false)?;
 
     let format_flag = match SAMPLE_FORMAT {
         SampleFormat::F32 => LinearPcmFlags::IS_FLOAT,

examples/feedback_interleaved.rs

@@ -6,8 +6,10 @@ use std::collections::VecDeque;
 use std::sync::{Arc, Mutex};
 
 use coreaudio::audio_unit::audio_format::LinearPcmFlags;
+use coreaudio::audio_unit::macos_helpers::{
+    audio_unit_from_device_id, get_default_device_id, get_device_name, RateListener,
+};
 use coreaudio::audio_unit::render_callback::{self, data};
-use coreaudio::audio_unit::macos_helpers::{audio_unit_from_device_id, get_default_device_id, get_device_name, RateListener};
 use coreaudio::audio_unit::{Element, SampleFormat, Scope, StreamFormat};
 use coreaudio::sys::*;
 

examples/sine_advanced.rs

@@ -1,17 +1,19 @@
-//! A basic output stream example, using an Output AudioUnit to generate a sine wave.
+//! An output stream example showing more advanced usage.
+//! Tries to use hog mode to get exclusive access to the device.
 
 extern crate coreaudio;
 
 use coreaudio::audio_unit::audio_format::LinearPcmFlags;
-use coreaudio::audio_unit::render_callback::{self, data};
 use coreaudio::audio_unit::macos_helpers::{
-    audio_unit_from_device_id, find_matching_physical_format, get_default_device_id,
+    audio_unit_from_device_id, find_matching_physical_format, get_default_device_id, get_hogging_pid,
     get_supported_physical_stream_formats, set_device_physical_stream_format,
-    set_device_sample_rate, AliveListener, RateListener,
+    set_device_sample_rate, toggle_hog_mode, AliveListener, RateListener,
 };
+use coreaudio::audio_unit::render_callback::{self, data};
 use coreaudio::audio_unit::{Element, SampleFormat, Scope, StreamFormat};
 use coreaudio::sys::kAudioUnitProperty_StreamFormat;
 use std::f64::consts::PI;
+use std::process;
 
 const SAMPLE_FORMAT: SampleFormat = SampleFormat::F32;
 // type S = i32; const SAMPLE_FORMAT: SampleFormat = SampleFormat::I32;
@@ -60,6 +62,23 @@ fn main() -> Result<(), coreaudio::Error> {
     let audio_unit_id = get_default_device_id(false).unwrap();
     let mut audio_unit = audio_unit_from_device_id(audio_unit_id, false)?;
 
+    let pid = get_hogging_pid(audio_unit_id)?;
+    if pid != -1 {
+        println!("Device is owned by another process with pid {}!", pid);
+    } else {
+        println!("Device is free, trying to get exclusive access..");
+        let new_pid = toggle_hog_mode(audio_unit_id)?;
+        let process_id = process::id();
+        if new_pid == process_id as i32 {
+            println!("We have exclusive access.");
+        } else {
+            println!(
+                "Could not get exclusive access. Process pid: {}, new pid value: {}",
+                process_id, new_pid
+            );
+        }
+    }
+
     let mut format_flag = match SAMPLE_FORMAT {
         SampleFormat::F32 => LinearPcmFlags::IS_FLOAT | LinearPcmFlags::IS_PACKED,
         SampleFormat::I32 | SampleFormat::I16 | SampleFormat::I8 => {
@@ -101,7 +120,7 @@ fn main() -> Result<(), coreaudio::Error> {
     println!("setting hardware (physical) format");
     let hw_stream_format = StreamFormat {
         sample_rate: SAMPLE_RATE,
-        sample_format: SampleFormat::I24,
+        sample_format: SampleFormat::I16,
         flags: LinearPcmFlags::empty(),
         channels: 2,
     };
@@ -178,5 +197,21 @@ fn main() -> Result<(), coreaudio::Error> {
         println!("rate events: {:?}", rate_listener.copy_values());
         println!("alive state: {}", alive_listener.is_alive());
     }
+
+    // Release exclusive access, not really needed as the process exits anyway after this.
+    let owner_pid = get_hogging_pid(audio_unit_id)?;
+    let process_id = process::id();
+    if owner_pid == process_id as i32 {
+        println!("Releasing exclusive access");
+        let new_pid = toggle_hog_mode(audio_unit_id)?;
+        if new_pid == -1 {
+            println!("Exclusive access released.");
+        } else {
+            println!(
+                "Could not release exclusive access. Process pid: {}, new pid value: {}",
+                process_id, new_pid
+            );
+        }
+    }
     Ok(())
 }

src/audio_unit/macos_helpers.rs

@@ -13,10 +13,11 @@ use std::{mem, thread};
 
 use core_foundation_sys::string::{CFStringGetCString, CFStringGetCStringPtr, CFStringRef};
 use sys;
+use sys::pid_t;
 use sys::{
     kAudioDevicePropertyAvailableNominalSampleRates, kAudioDevicePropertyDeviceIsAlive,
-    kAudioDevicePropertyDeviceNameCFString, kAudioDevicePropertyNominalSampleRate,
-    kAudioDevicePropertyScopeOutput, kAudioHardwareNoError,
+    kAudioDevicePropertyDeviceNameCFString, kAudioDevicePropertyHogMode,
+    kAudioDevicePropertyNominalSampleRate, kAudioDevicePropertyScopeOutput, kAudioHardwareNoError,
     kAudioHardwarePropertyDefaultInputDevice, kAudioHardwarePropertyDefaultOutputDevice,
     kAudioHardwarePropertyDevices, kAudioObjectPropertyElementMaster,
     kAudioObjectPropertyScopeGlobal, kAudioObjectSystemObject,
@@ -603,7 +604,7 @@ impl RateListener {
     }
 
     /// Get the number of sample rate values received (equals the number of change events).
-    /// Not used if the RateListener was created with a `std::sync::mpsc::Sender`. 
+    /// Not used if the RateListener was created with a `std::sync::mpsc::Sender`.
     pub fn get_nbr_values(&self) -> usize {
         self.queue.lock().unwrap().len()
     }
@@ -726,3 +727,68 @@ impl AliveListener {
         self.alive.load(Ordering::SeqCst)
     }
 }
+
+/// Helper for hog mode (exclusive access).
+/// Get the pid of the process that currently owns exclusive access to a device.
+/// A pid value of -1 means no process owns exclusive access.
+pub fn get_hogging_pid(device_id: AudioDeviceID) -> Result<pid_t, Error> {
+    let property_address = AudioObjectPropertyAddress {
+        mSelector: kAudioDevicePropertyHogMode,
+        mScope: kAudioObjectPropertyScopeGlobal,
+        mElement: kAudioObjectPropertyElementMaster,
+    };
+    let pid = unsafe {
+        let temp_pid: pid_t = 0;
+        let data_size = mem::size_of::<pid_t>();
+        let status = AudioObjectGetPropertyData(
+            device_id,
+            &property_address as *const _,
+            0,
+            null(),
+            &data_size as *const _ as *mut _,
+            &temp_pid as *const _ as *mut _,
+        );
+        Error::from_os_status(status)?;
+        temp_pid
+    };
+    Ok(pid)
+}
+
+/// Helper for hog mode (exclusive access).
+/// Toggle hog mode for a device.
+/// If no process owns exclusive access, then the calling process takes ownership.
+/// If the calling process already has ownership, this is released.
+/// If another process owns access, then nothing will happen.
+/// Returns the pid of the new owning process.
+/// A pid value of -1 means no process owns exclusive access.
+pub fn toggle_hog_mode(device_id: AudioDeviceID) -> Result<pid_t, Error> {
+    let property_address = AudioObjectPropertyAddress {
+        mSelector: kAudioDevicePropertyHogMode,
+        mScope: kAudioObjectPropertyScopeGlobal,
+        mElement: kAudioObjectPropertyElementMaster,
+    };
+    let pid = unsafe {
+        let temp_pid: pid_t = -1;
+        let data_size = mem::size_of::<pid_t>();
+        let status = AudioObjectSetPropertyData(
+            device_id,
+            &property_address as *const _,
+            0,
+            null(),
+            data_size as u32,
+            &temp_pid as *const _ as *mut _,
+        );
+        Error::from_os_status(status)?;
+        let status = AudioObjectGetPropertyData(
+            device_id,
+            &property_address as *const _,
+            0,
+            null(),
+            &data_size as *const _ as *mut _,
+            &temp_pid as *const _ as *mut _,
+        );
+        Error::from_os_status(status)?;
+        temp_pid
+    };
+    Ok(pid)
+}