Add support for 24-bit formats

Author: HEnquist

examples/feedback.rs

@@ -29,6 +29,9 @@ fn main() -> Result<(), coreaudio::Error> {
         SampleFormat::I32 | SampleFormat::I16 | SampleFormat::I8 => {
             LinearPcmFlags::IS_SIGNED_INTEGER
         }
+        _ => {
+            unimplemented!("Other formats are not implemented for this example.");
+        }
     };
 
     // Using IS_NON_INTERLEAVED everywhere because data::Interleaved is commented out / not implemented

examples/feedback_interleaved.rs

@@ -35,9 +35,10 @@ fn main() -> Result<(), coreaudio::Error> {
 
     let format_flag = match SAMPLE_FORMAT {
         SampleFormat::F32 => LinearPcmFlags::IS_FLOAT,
-        SampleFormat::I32 | SampleFormat::I16 | SampleFormat::I8 => {
-            LinearPcmFlags::IS_SIGNED_INTEGER
+        SampleFormat::I32 | SampleFormat::I24_3 | SampleFormat::I16 | SampleFormat::I8 => {
+            LinearPcmFlags::IS_SIGNED_INTEGER | LinearPcmFlags::IS_PACKED
         }
+        SampleFormat::I24_4 => LinearPcmFlags::IS_SIGNED_INTEGER,
     };
 
     let in_stream_format = StreamFormat {

examples/sine_advanced.rs

@@ -5,8 +5,8 @@ extern crate coreaudio;
 use coreaudio::audio_unit::audio_format::LinearPcmFlags;
 use coreaudio::audio_unit::render_callback::{self, data};
 use coreaudio::audio_unit::{
-    audio_unit_from_device_id, get_default_device_id, set_device_sample_format,
-    set_device_sample_rate, AliveListener, RateListener,
+    audio_unit_from_device_id, get_default_device_id, get_supported_physical_stream_formats,
+    set_device_physical_stream_format, set_device_sample_rate, AliveListener, RateListener,
 };
 use coreaudio::audio_unit::{Element, SampleFormat, Scope, StreamFormat};
 use coreaudio::sys::kAudioUnitProperty_StreamFormat;
@@ -17,7 +17,7 @@ const SAMPLE_FORMAT: SampleFormat = SampleFormat::F32;
 // type S = i16; const SAMPLE_FORMAT: SampleFormat = SampleFormat::I16;
 // type S = i8; const SAMPLE_FORMAT: SampleFormat = SampleFormat::I8;
 
-const SAMPLE_RATE: f64 = 48000.0;
+const SAMPLE_RATE: f64 = 44100.0;
 
 const INTERLEAVED: bool = true;
 
@@ -61,9 +61,10 @@ fn main() -> Result<(), coreaudio::Error> {
 
     let mut format_flag = match SAMPLE_FORMAT {
         SampleFormat::F32 => LinearPcmFlags::IS_FLOAT,
-        SampleFormat::I32 | SampleFormat::I16 | SampleFormat::I8 => {
-            LinearPcmFlags::IS_SIGNED_INTEGER
+        SampleFormat::I32 | SampleFormat::I24_3 | SampleFormat::I16 | SampleFormat::I8 => {
+            LinearPcmFlags::IS_SIGNED_INTEGER | LinearPcmFlags::IS_PACKED
         }
+        SampleFormat::I24_4 => LinearPcmFlags::IS_SIGNED_INTEGER,
     };
 
     if !INTERLEAVED {
@@ -81,23 +82,38 @@ fn main() -> Result<(), coreaudio::Error> {
     println!("stream format={:#?}", &stream_format);
     println!("asbd={:#?}", &stream_format.to_asbd());
 
+    // Lets print all supported formats, disabled for now since it often crashes.
+    //println!("All supported formats");
+    //let formats = get_supported_physical_stream_formats(audio_unit_id)?;
+    //for fmt in formats {
+    //    println!("{:?}", &fmt);
+    //}
+
     // set the sample rate. This isn't actually needed since the sample rate
     // will anyway be changed when setting the sample format later.
-    println!("set device sample rate");
-    set_device_sample_rate(audio_unit_id, SAMPLE_RATE)?;
+    //println!("set device sample rate");
+    //set_device_sample_rate(audio_unit_id, SAMPLE_RATE)?;
+
+    println!("setting hardware (physical) format");
+
+    // use this for packed formats (most of them)
+    //let hw_format_flag = LinearPcmFlags::IS_PACKED | LinearPcmFlags::IS_SIGNED_INTEGER;
+
+    // use for non-packed formats (only I24_4)
+    let hw_format_flag = LinearPcmFlags::IS_SIGNED_INTEGER;
 
-    println!("setting hardware format to i16");
-    let hw_format_flag = LinearPcmFlags::IS_PACKED | LinearPcmFlags::IS_SIGNED_INTEGER;
     let hw_stream_format = StreamFormat {
         sample_rate: SAMPLE_RATE,
-        sample_format: SampleFormat::I16,
+        sample_format: SampleFormat::I24_4,
         flags: hw_format_flag,
         channels: 2,
     };
 
+    println!("asbd: {:?}", hw_stream_format.to_asbd());
+
     // Note that using a StreamFormat here is convenient, but it only supports a few sample formats.
     // Setting the format to for example 24 bit integers requires using an ASBD.
-    set_device_sample_format(audio_unit_id, hw_stream_format.to_asbd())?;
+    set_device_physical_stream_format(audio_unit_id, hw_stream_format.to_asbd())?;
 
     println!("write audio unit StreamFormat property");
     let id = kAudioUnitProperty_StreamFormat;

src/audio_unit/macos_helpers.rs

@@ -8,7 +8,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{channel, Sender};
 use std::sync::Mutex;
 use std::time::Duration;
-use std::{mem, slice, thread};
+use std::{mem, thread};
 
 use core_foundation_sys::string::{CFStringGetCString, CFStringGetCStringPtr, CFStringRef};
 use sys;
@@ -144,6 +144,7 @@ pub fn get_audio_device_ids() -> Result<Vec<AudioDeviceID>, Error> {
     let device_count = data_size / mem::size_of::<AudioDeviceID>() as u32;
     let mut audio_devices = vec![];
     audio_devices.reserve_exact(device_count as usize);
+    unsafe { audio_devices.set_len(device_count as usize) };
 
     let status = unsafe {
         AudioObjectGetPropertyData(
@@ -156,9 +157,6 @@ pub fn get_audio_device_ids() -> Result<Vec<AudioDeviceID>, Error> {
         )
     };
     try_status_or_return!(status);
-
-    unsafe { audio_devices.set_len(device_count as usize) };
-
     Ok(audio_devices)
 }
 
@@ -259,8 +257,9 @@ pub fn set_device_sample_rate(device_id: AudioDeviceID, new_rate: f64) -> Result
             );
             Error::from_os_status(status)?;
             let n_ranges = data_size as usize / mem::size_of::<AudioValueRange>();
-            let mut ranges: Vec<u8> = vec![];
-            ranges.reserve_exact(data_size as usize);
+            let mut ranges: Vec<AudioValueRange> = vec![];
+            ranges.reserve_exact(n_ranges as usize);
+            ranges.set_len(n_ranges);
             let status = AudioObjectGetPropertyData(
                 device_id,
                 &property_address as *const _,
@@ -270,8 +269,6 @@ pub fn set_device_sample_rate(device_id: AudioDeviceID, new_rate: f64) -> Result
                 ranges.as_mut_ptr() as *mut _,
             );
             Error::from_os_status(status)?;
-            let ranges: *mut AudioValueRange = ranges.as_mut_ptr() as *mut _;
-            let ranges: &'static [AudioValueRange] = slice::from_raw_parts(ranges, n_ranges);
 
             // Now that we have the available ranges, pick the one matching the desired rate.
             let new_rate_integer = new_rate as u32;
@@ -322,9 +319,9 @@ pub fn set_device_sample_rate(device_id: AudioDeviceID, new_rate: f64) -> Result
     }
 }
 
-/// Change the sample rate and format of a device.
+/// Change the physical stream format (sample rate and format) of a device.
 /// Only implemented for macOS, not iOS.
-pub fn set_device_sample_format(
+pub fn set_device_physical_stream_format(
     device_id: AudioDeviceID,
     new_asbd: AudioStreamBasicDescription,
 ) -> Result<(), Error> {
@@ -413,9 +410,11 @@ fn asbds_are_equal(
         && left.mBitsPerChannel == right.mBitsPerChannel
 }
 
-/// Get a vector with all supported formats as AudioBasicStreamDescriptions.
+/// Get a vector with all supported physical formats as AudioBasicStreamDescriptions.
 /// Only implemented for macOS, not iOS.
-pub fn get_supported_stream_formats(
+/// TODO: figure out why this sometimes crashes with:
+/// malloc: Incorrect checksum for freed object 0x7fca6bc3c538: probably modified after being freed.
+pub fn get_supported_physical_stream_formats(
     device_id: AudioDeviceID,
 ) -> Result<Vec<AudioStreamBasicDescription>, Error> {
     // Get available formats.
@@ -427,20 +426,22 @@ pub fn get_supported_stream_formats(
         //mScope: kAudioDevicePropertyScopeOutput,
         mElement: kAudioObjectPropertyElementMaster,
     };
-    let formats = unsafe {
+    let allformats = unsafe {
         property_address.mSelector = kAudioStreamPropertyAvailablePhysicalFormats;
-        let data_size = 0u32;
+        let mut data_size = 0u32;
         let status = AudioObjectGetPropertyDataSize(
             device_id,
             &property_address as *const _,
             0,
             null(),
-            &data_size as *const _ as *mut _,
+            &mut data_size as *mut _,
         );
         Error::from_os_status(status)?;
         let n_formats = data_size as usize / mem::size_of::<AudioStreamBasicDescription>();
-        let mut formats: Vec<u8> = vec![];
-        formats.reserve_exact(data_size as usize);
+        println!("n_formats {}", n_formats);
+        let mut formats: Vec<AudioStreamBasicDescription> = vec![];
+        formats.reserve_exact(n_formats as usize);
+        formats.set_len(n_formats);
         let status = AudioObjectGetPropertyData(
             device_id,
             &property_address as *const _,
@@ -450,8 +451,7 @@ pub fn get_supported_stream_formats(
             formats.as_mut_ptr() as *mut _,
         );
         Error::from_os_status(status)?;
-        let formats: *mut AudioStreamBasicDescription = formats.as_mut_ptr() as *mut _;
-        Vec::from_raw_parts(formats, n_formats, n_formats)
+        formats
     };
     /*
     println!("---- All supported formats ----");
@@ -462,7 +462,7 @@ pub fn get_supported_stream_formats(
         }
     }
     */
-    Ok(formats)
+    Ok(allformats)
 }
 
 /// Changing the sample rate is an asynchonous process.

src/audio_unit/sample_format.rs

@@ -3,42 +3,53 @@ use super::audio_format::{self, LinearPcmFlags};
 /// Dynamic representation of audio data sample format.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum SampleFormat {
+    /// 32-bit float.
     F32,
+    /// 32-bit signed integer.
     I32,
+    /// 24-bit signed integer, packed in 3 bytes.
+    I24_3,
+    /// 24-bit signed integer, stored in 4 bytes where one is padding.
+    I24_4,
+    // 16-bit signed integer.
     I16,
+    // 8-bit signed integer.
     I8,
 }
 
 impl SampleFormat {
+    /// Check if the format flags are appropriate for the given format.
     pub fn does_match_flags(&self, flags: audio_format::LinearPcmFlags) -> bool {
         let is_float = flags.contains(LinearPcmFlags::IS_FLOAT);
         let is_signed_integer = flags.contains(LinearPcmFlags::IS_SIGNED_INTEGER);
+        let is_packed = flags.contains(LinearPcmFlags::IS_PACKED);
         match *self {
-            SampleFormat::F32 => is_float && !is_signed_integer,
-            SampleFormat::I32 | SampleFormat::I16 | SampleFormat::I8 => {
-                is_signed_integer && !is_float
+            SampleFormat::F32 => is_float && !is_signed_integer && is_packed,
+            SampleFormat::I32 | SampleFormat::I24_3 | SampleFormat::I16 | SampleFormat::I8 => {
+                is_signed_integer && !is_float && is_packed
             }
+            SampleFormat::I24_4 => is_signed_integer && !is_float && !is_packed,
         }
     }
 
+    /// Convert format flags and bits_per_sample to a SampleFormat.
     pub fn from_flags_and_bits_per_sample(
         flags: audio_format::LinearPcmFlags,
         bits_per_sample: u32,
     ) -> Option<Self> {
-        // All the currently supported formats are packed.
-        if !flags.contains(LinearPcmFlags::IS_PACKED) {
-            return None;
-        }
+        let packed = flags.contains(LinearPcmFlags::IS_PACKED);
         let sample_format = if flags.contains(LinearPcmFlags::IS_FLOAT) {
-            match bits_per_sample {
-                32 => SampleFormat::F32,
+            match (bits_per_sample, packed) {
+                (32, true) => SampleFormat::F32,
                 _ => return None,
             }
         } else if flags.contains(LinearPcmFlags::IS_SIGNED_INTEGER) {
-            match bits_per_sample {
-                8 => SampleFormat::I8,
-                16 => SampleFormat::I16,
-                32 => SampleFormat::I32,
+            match (bits_per_sample, packed) {
+                (8, true) => SampleFormat::I8,
+                (16, true) => SampleFormat::I16,
+                (24, true) => SampleFormat::I24_3,
+                (24, false) => SampleFormat::I24_4,
+                (32, true) => SampleFormat::I32,
                 _ => return None,
             }
         } else {
@@ -48,15 +59,30 @@ impl SampleFormat {
         Some(sample_format)
     }
 
+    /// Return the size of one sample in bytes.
     pub fn size_in_bytes(&self) -> usize {
         use std::mem::size_of;
         match *self {
             SampleFormat::F32 => size_of::<f32>(),
             SampleFormat::I32 => size_of::<i32>(),
+            SampleFormat::I24_3 => 3 * size_of::<u8>(),
+            SampleFormat::I24_4 => 4 * size_of::<u8>(),
             SampleFormat::I16 => size_of::<i16>(),
             SampleFormat::I8 => size_of::<i8>(),
         }
     }
+
+    /// Return the number of valid bits for one sample.
+    pub fn size_in_bits(&self) -> u32 {
+        match *self {
+            SampleFormat::F32 => 32,
+            SampleFormat::I32 => 32,
+            SampleFormat::I24_3 => 24,
+            SampleFormat::I24_4 => 24,
+            SampleFormat::I16 => 16,
+            SampleFormat::I8 => 8,
+        }
+    }
 }
 
 /// Audio data sample types.
@@ -66,6 +92,7 @@ pub trait Sample {
 }
 
 /// Simplified implementation of the `Sample` trait for sample types.
+/// This is only implemented for the types that map directly to a numeric type.
 macro_rules! impl_sample {
     ($($T:ident $format:ident),* $(,)*) => {
         $(

src/audio_unit/stream_format.rs

@@ -40,14 +40,16 @@ pub struct StreamFormat {
     pub sample_rate: f64,
     /// The sample format used to represent the audio data.
     ///
-    /// In OS X, Core Audio xpects audio data to be in native-endian, 32-bit floating-point,
+    /// In OS X, Core Audio expects audio data to be in native-endian, 32-bit floating-point,
     /// linear PCM format.
     ///
     /// iOS uses integer and fixed-point audio data. The result is faster calculations and less
     /// battery drain when processing audio. iOS provides a Converter audio unit and inclues the
     /// interfaces from Audio Converter Services (TODO: look into exposing this).
     pub sample_format: SampleFormat,
+    /// The format flags for the given StreamFormat.
     pub flags: super::audio_format::LinearPcmFlags,
+    /// The number of channels.
     pub channels: u32,
 }
 
@@ -64,7 +66,7 @@ impl StreamFormat {
     ///
     /// Returns an `Error` if the `AudioFormat` inferred by the ASBD is not `LinearPCM`.
     ///
-    /// Returns an `Error` if the sample format type kkkkkkkkkkkkkkkkkkkkkk
+    /// Returns an `Error` if the sample format of the asbd cannot be matched to a format supported by SampleFormat.
     #[allow(non_snake_case)]
     pub fn from_asbd(asbd: sys::AudioStreamBasicDescription) -> Result<StreamFormat, Error> {
         const NOT_SUPPORTED: Error = Error::AudioUnit(error::audio_unit::Error::FormatNotSupported);
@@ -123,11 +125,12 @@ impl StreamFormat {
         const FRAMES_PER_PACKET: u32 = 1;
         let bytes_per_packet = bytes_per_frame * FRAMES_PER_PACKET;
         //let bits_per_channel = bytes_per_frame / channels * 8;
-        let bits_per_channel = if non_interleaved {
-            bytes_per_frame * 8
-        } else {
-            bytes_per_frame / channels * 8
-        };
+        //let bits_per_channel = if non_interleaved {
+        //    bytes_per_frame * 8
+        //} else {
+        //    bytes_per_frame / channels * 8
+        //};
+        let bits_per_channel = sample_format.size_in_bits();
         //let bits_per_channel = bytes_per_frame * 8;
 
         sys::AudioStreamBasicDescription {