Struct cxx_juce::juce_audio_devices::AudioDeviceManager

pub struct AudioDeviceManager { /* private fields */ }

Manages the state of an audio device.

Implementations

impl AudioDeviceManager

pub fn new() -> Self

Create a new AudioDeviceManager.

Examples found in repository

examples/audio_callback.rs (line 80)

fn main() -> Result<()> {
    let mut device_manager = AudioDeviceManager::new();
    device_manager.initialise(0, 2)?;

    let _handle = device_manager.add_audio_callback(AudioCallback::default());

    sleep(Duration::from_secs(2));

    Ok(())
}

examples/devices.rs (line 7)

fn main() -> Result<()> {
    let mut audio_device_manager = AudioDeviceManager::new();
    audio_device_manager.initialise(2, 2)?;

    let device_type = audio_device_manager.current_device_type().unwrap();

    println!("Inputs:");
    for input in device_type.input_devices() {
        println!("  {}", input);
    }

    println!("Outputs:");
    for output in device_type.output_devices() {
        println!("  {}", output);
    }

    Ok(())
}

examples/test_tone.rs (line 10)

fn main() -> Result<()> {
    let mut audio_device_manager = AudioDeviceManager::new();
    audio_device_manager.initialise(0, 2)?;

    {
        let mut device = audio_device_manager.current_device().unwrap();

        println!("Name: {}", device.name());
        println!("Type: {}", device.type_name());
        println!("Sample rate: {}", device.sample_rate());
        println!("Buffer size: {}", device.buffer_size());
        println!(
            "Available sample rates: {:?}",
            device.available_sample_rates()
        );
        println!(
            "Available buffer sizes: {:?}",
            device.available_buffer_sizes()
        );
    }

    audio_device_manager.play_test_sound();
    sleep(Duration::from_secs(1));

    Ok(())
}

pub fn initialise(
&mut self,
input_channels: usize,
output_channels: usize
) -> Result<()>

Resets to a default device setup.

Examples found in repository

examples/audio_callback.rs (line 81)

fn main() -> Result<()> {
    let mut device_manager = AudioDeviceManager::new();
    device_manager.initialise(0, 2)?;

    let _handle = device_manager.add_audio_callback(AudioCallback::default());

    sleep(Duration::from_secs(2));

    Ok(())
}

examples/devices.rs (line 8)

fn main() -> Result<()> {
    let mut audio_device_manager = AudioDeviceManager::new();
    audio_device_manager.initialise(2, 2)?;

    let device_type = audio_device_manager.current_device_type().unwrap();

    println!("Inputs:");
    for input in device_type.input_devices() {
        println!("  {}", input);
    }

    println!("Outputs:");
    for output in device_type.output_devices() {
        println!("  {}", output);
    }

    Ok(())
}

examples/test_tone.rs (line 11)

fn main() -> Result<()> {
    let mut audio_device_manager = AudioDeviceManager::new();
    audio_device_manager.initialise(0, 2)?;

    {
        let mut device = audio_device_manager.current_device().unwrap();

        println!("Name: {}", device.name());
        println!("Type: {}", device.type_name());
        println!("Sample rate: {}", device.sample_rate());
        println!("Buffer size: {}", device.buffer_size());
        println!(
            "Available sample rates: {:?}",
            device.available_sample_rates()
        );
        println!(
            "Available buffer sizes: {:?}",
            device.available_buffer_sizes()
        );
    }

    audio_device_manager.play_test_sound();
    sleep(Duration::from_secs(1));

    Ok(())
}

pub fn audio_device_setup(&self) -> AudioDeviceSetup

Get the current device setup.

pub fn set_audio_device_setup(&mut self, setup: &AudioDeviceSetup)

Changes the current device or its settings.

pub fn play_test_sound(&mut self)

Play a test sound.

Examples found in repository

examples/test_tone.rs (line 30)

fn main() -> Result<()> {
    let mut audio_device_manager = AudioDeviceManager::new();
    audio_device_manager.initialise(0, 2)?;

    {
        let mut device = audio_device_manager.current_device().unwrap();

        println!("Name: {}", device.name());
        println!("Type: {}", device.type_name());
        println!("Sample rate: {}", device.sample_rate());
        println!("Buffer size: {}", device.buffer_size());
        println!(
            "Available sample rates: {:?}",
            device.available_sample_rates()
        );
        println!(
            "Available buffer sizes: {:?}",
            device.available_buffer_sizes()
        );
    }

    audio_device_manager.play_test_sound();
    sleep(Duration::from_secs(1));

    Ok(())
}

pub fn device_types(&mut self) -> Vec<impl AudioIODeviceType + '_>

Get the available device types.

pub fn current_device_type(&self) -> Option<impl AudioIODeviceType + '_>

Get the current device type.

Examples found in repository

examples/devices.rs (line 10)

fn main() -> Result<()> {
    let mut audio_device_manager = AudioDeviceManager::new();
    audio_device_manager.initialise(2, 2)?;

    let device_type = audio_device_manager.current_device_type().unwrap();

    println!("Inputs:");
    for input in device_type.input_devices() {
        println!("  {}", input);
    }

    println!("Outputs:");
    for output in device_type.output_devices() {
        println!("  {}", output);
    }

    Ok(())
}

pub fn current_device(&self) -> Option<impl AudioIODevice + '_>

Get the current AudioIODevice.

Examples found in repository

examples/test_tone.rs (line 14)

fn main() -> Result<()> {
    let mut audio_device_manager = AudioDeviceManager::new();
    audio_device_manager.initialise(0, 2)?;

    {
        let mut device = audio_device_manager.current_device().unwrap();

        println!("Name: {}", device.name());
        println!("Type: {}", device.type_name());
        println!("Sample rate: {}", device.sample_rate());
        println!("Buffer size: {}", device.buffer_size());
        println!(
            "Available sample rates: {:?}",
            device.available_sample_rates()
        );
        println!(
            "Available buffer sizes: {:?}",
            device.available_buffer_sizes()
        );
    }

    audio_device_manager.play_test_sound();
    sleep(Duration::from_secs(1));

    Ok(())
}

pub fn add_audio_callback(
&mut self,
callback: impl AudioIODeviceCallback + 'static
) -> AudioCallbackHandle<'_>

Registers an audio callback.

When the returned AudioCallbackHandle is dropped the callback is removed.

Examples found in repository

examples/audio_callback.rs (line 83)

fn main() -> Result<()> {
    let mut device_manager = AudioDeviceManager::new();
    device_manager.initialise(0, 2)?;

    let _handle = device_manager.add_audio_callback(AudioCallback::default());

    sleep(Duration::from_secs(2));

    Ok(())
}

pub fn add_audio_device_type(
&mut self,
device_type: impl AudioIODeviceType + 'static
)

Registers an audio device type.

pub fn set_current_audio_device_type(&mut self, device_type: &str)

Set the current audio device type to use.

Trait Implementations

impl Default for AudioDeviceManager

fn default() -> Self

Returns the “default value” for a type.

impl Send for AudioDeviceManager