Struct AudioDeviceManager 

pub struct AudioDeviceManager { /* private fields */ }

Manages the state of an audio device.

Implementations

impl AudioDeviceManager

pub fn new(juce: &JUCE) -> Self

Create a new AudioDeviceManager.

Examples found in repository

examples/audio_callback.rs (line 81)

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

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

    sleep(Duration::from_secs(2));

    device_manager.remove_audio_callback(handle);

    Ok(())
}

examples/devices.rs (line 8)

fn main() -> Result<()> {
    let juce = JUCE::initialise();
    let mut audio_device_manager = AudioDeviceManager::new(&juce);
    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 juce = JUCE::initialise();
    let mut audio_device_manager = AudioDeviceManager::new(&juce);
    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 82)

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

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

    sleep(Duration::from_secs(2));

    device_manager.remove_audio_callback(handle);

    Ok(())
}

examples/devices.rs (line 9)

fn main() -> Result<()> {
    let juce = JUCE::initialise();
    let mut audio_device_manager = AudioDeviceManager::new(&juce);
    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 12)

fn main() -> Result<()> {
    let juce = JUCE::initialise();
    let mut audio_device_manager = AudioDeviceManager::new(&juce);
    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 31)

fn main() -> Result<()> {
    let juce = JUCE::initialise();
    let mut audio_device_manager = AudioDeviceManager::new(&juce);
    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 11)

fn main() -> Result<()> {
    let juce = JUCE::initialise();
    let mut audio_device_manager = AudioDeviceManager::new(&juce);
    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 15)

fn main() -> Result<()> {
    let juce = JUCE::initialise();
    let mut audio_device_manager = AudioDeviceManager::new(&juce);
    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.

Examples found in repository

examples/audio_callback.rs (line 84)

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

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

    sleep(Duration::from_secs(2));

    device_manager.remove_audio_callback(handle);

    Ok(())
}

pub fn remove_audio_callback(&mut self, handle: AudioCallbackHandle)

Removes an audio callback.

Examples found in repository

examples/audio_callback.rs (line 88)

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

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

    sleep(Duration::from_secs(2));

    device_manager.remove_audio_callback(handle);

    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.