Struct Host 

pub struct Host { /* private fields */ }

An RtAudio Host instance. This is used to enumerate audio devices before opening a stream.

Implementations

impl Host

pub fn new(api: Api) -> Result<Self, RtAudioError>

Create a new RtAudio Host with the given API. This host is used to enumerate audio devices before opening a stream.

If Api::Unspecified is used, then the best one for the system will automatically be chosen.

Examples found in repository

examples/enumerate.rs (line 7)

fn main() {
    dbg!(rtaudio::version());

    for api in rtaudio::compiled_apis() {
        dbg!(api.get_display_name());

        match rtaudio::Host::new(api) {
            Ok(rt) => {
                for device_info in rt.iter_devices() {
                    dbg!(device_info);
                }
            }
            Err(e) => {
                eprintln!("{}", e);
            }
        }

        println!("---------------------------------------------");
    }
}

examples/loopback.rs (line 4)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    dbg!(host.api());

    let out_device = host.default_output_device().unwrap();
    let in_device = host.default_input_device().unwrap();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            Some(DeviceParams {
                device_id: in_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            |error| eprintln!("{}", error),
        )
        .unwrap();
    dbg!(stream_handle.info());

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input } = buffers {
                    // Copy the input to the output.
                    output.copy_from_slice(input);
                }
            },
        )
        .unwrap();

    // Wait 3 seconds before closing.
    std::thread::sleep(std::time::Duration::from_millis(3000));
}

examples/playback_sine.rs (line 7)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    dbg!(host.api());

    let out_device = host.default_output_device().unwrap();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            None,
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            |error| eprintln!("{}", error),
        )
        .unwrap();
    dbg!(stream_handle.info());

    let mut phasor = 0.0;
    let phasor_inc = FREQ_HZ / stream_handle.info().sample_rate as f32;

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input: _ } = buffers {
                    // By default, buffers are interleaved.
                    for frame in output.chunks_mut(2) {
                        // Generate a sine wave at 440 Hz at 50% volume.
                        let val = (phasor * std::f32::consts::TAU).sin() * AMPLITUDE;
                        phasor = (phasor + phasor_inc).fract();

                        frame[0] = val;
                        frame[1] = val;
                    }
                }
            },
        )
        .unwrap();

    // Wait 3 seconds before closing.
    std::thread::sleep(std::time::Duration::from_millis(3000));
}

examples/handle_error.rs (line 7)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    let out_device = host.default_output_device().unwrap();

    let (error_tx, error_rx) = std::sync::mpsc::channel();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            None,
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            move |error| error_tx.send(error).unwrap(),
        )
        .unwrap();

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input: _ } = buffers {
                    // Fill the output with silence.
                    output.fill(0.0);
                }
            },
        )
        .unwrap();

    // Play for 5 seconds and then close.
    let t = Instant::now();
    while t.elapsed() < Duration::from_secs(5) {
        // Periodically poll to see if an error has happened.
        if let Ok(error) = error_rx.try_recv() {
            // An error occured that caused the stream to close (for example a
            // device was unplugged). Now our stream_handle object should be
            // manually closed or dropped.
            eprintln!("{}", error);

            break;
        }

        std::thread::sleep(Duration::from_millis(16));
    }
}

pub fn show_warnings(&self, show: bool)

Whether or not to print extra warnings to the terminal output.

By default this is set to false.

pub fn api(&self) -> Api

The API being used by this instance.

Examples found in repository

examples/loopback.rs (line 5)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    dbg!(host.api());

    let out_device = host.default_output_device().unwrap();
    let in_device = host.default_input_device().unwrap();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            Some(DeviceParams {
                device_id: in_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            |error| eprintln!("{}", error),
        )
        .unwrap();
    dbg!(stream_handle.info());

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input } = buffers {
                    // Copy the input to the output.
                    output.copy_from_slice(input);
                }
            },
        )
        .unwrap();

    // Wait 3 seconds before closing.
    std::thread::sleep(std::time::Duration::from_millis(3000));
}

examples/playback_sine.rs (line 8)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    dbg!(host.api());

    let out_device = host.default_output_device().unwrap();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            None,
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            |error| eprintln!("{}", error),
        )
        .unwrap();
    dbg!(stream_handle.info());

    let mut phasor = 0.0;
    let phasor_inc = FREQ_HZ / stream_handle.info().sample_rate as f32;

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input: _ } = buffers {
                    // By default, buffers are interleaved.
                    for frame in output.chunks_mut(2) {
                        // Generate a sine wave at 440 Hz at 50% volume.
                        let val = (phasor * std::f32::consts::TAU).sin() * AMPLITUDE;
                        phasor = (phasor + phasor_inc).fract();

                        frame[0] = val;
                        frame[1] = val;
                    }
                }
            },
        )
        .unwrap();

    // Wait 3 seconds before closing.
    std::thread::sleep(std::time::Duration::from_millis(3000));
}

pub fn num_devices(&self) -> usize

Retrieve the number of available audio devices.

pub fn get_device_info_by_index( &self, index: usize, ) -> Result<DeviceInfo, RtAudioError>

Retrieve information about an audio device by its index.

pub fn get_device_info_by_id( &self, id: DeviceID, ) -> Result<DeviceInfo, RtAudioError>

Retrieve info about an audio device by its ID.

pub fn iter_devices_complete<'a>(&'a self) -> DeviceIter<'a>

Retrieve an iterator over all the available audio devices (including ones that have failed to scan properly).

pub fn iter_devices<'a>(&'a self) -> impl Iterator<Item = DeviceInfo> + 'a

Retrieve an iterator over the available audio devices.

If there was a problem scanning a device, a warning will be printed to the log.

Examples found in repository

examples/enumerate.rs (line 9)

fn main() {
    dbg!(rtaudio::version());

    for api in rtaudio::compiled_apis() {
        dbg!(api.get_display_name());

        match rtaudio::Host::new(api) {
            Ok(rt) => {
                for device_info in rt.iter_devices() {
                    dbg!(device_info);
                }
            }
            Err(e) => {
                eprintln!("{}", e);
            }
        }

        println!("---------------------------------------------");
    }
}

pub fn iter_output_devices<'a>( &'a self, ) -> impl Iterator<Item = DeviceInfo> + 'a

Retrieve an iterator over the available output audio devices.

If there was a problem scanning a device, a warning will be printed to the log.

pub fn iter_input_devices<'a>(&'a self) -> impl Iterator<Item = DeviceInfo> + 'a

Retrieve an iterator over the available input audio devices.

If there was a problem scanning a device, a warning will be printed to the log.

pub fn iter_duplex_devices<'a>( &'a self, ) -> impl Iterator<Item = DeviceInfo> + 'a

Retrieve an iterator over the available duplex audio devices.

If there was a problem scanning a device, a warning will be printed to the log.

pub fn default_output_device_id(&self) -> Option<DeviceID>

Returns the device ID (not index) of the default output device.

pub fn default_input_device_id(&self) -> Option<DeviceID>

Returns the device ID (not index) of the default input device.

pub fn default_output_device(&self) -> Result<DeviceInfo, RtAudioError>

Returns information about the default output device.

Examples found in repository

examples/loopback.rs (line 7)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    dbg!(host.api());

    let out_device = host.default_output_device().unwrap();
    let in_device = host.default_input_device().unwrap();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            Some(DeviceParams {
                device_id: in_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            |error| eprintln!("{}", error),
        )
        .unwrap();
    dbg!(stream_handle.info());

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input } = buffers {
                    // Copy the input to the output.
                    output.copy_from_slice(input);
                }
            },
        )
        .unwrap();

    // Wait 3 seconds before closing.
    std::thread::sleep(std::time::Duration::from_millis(3000));
}

examples/playback_sine.rs (line 10)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    dbg!(host.api());

    let out_device = host.default_output_device().unwrap();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            None,
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            |error| eprintln!("{}", error),
        )
        .unwrap();
    dbg!(stream_handle.info());

    let mut phasor = 0.0;
    let phasor_inc = FREQ_HZ / stream_handle.info().sample_rate as f32;

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input: _ } = buffers {
                    // By default, buffers are interleaved.
                    for frame in output.chunks_mut(2) {
                        // Generate a sine wave at 440 Hz at 50% volume.
                        let val = (phasor * std::f32::consts::TAU).sin() * AMPLITUDE;
                        phasor = (phasor + phasor_inc).fract();

                        frame[0] = val;
                        frame[1] = val;
                    }
                }
            },
        )
        .unwrap();

    // Wait 3 seconds before closing.
    std::thread::sleep(std::time::Duration::from_millis(3000));
}

examples/handle_error.rs (line 8)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    let out_device = host.default_output_device().unwrap();

    let (error_tx, error_rx) = std::sync::mpsc::channel();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            None,
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            move |error| error_tx.send(error).unwrap(),
        )
        .unwrap();

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input: _ } = buffers {
                    // Fill the output with silence.
                    output.fill(0.0);
                }
            },
        )
        .unwrap();

    // Play for 5 seconds and then close.
    let t = Instant::now();
    while t.elapsed() < Duration::from_secs(5) {
        // Periodically poll to see if an error has happened.
        if let Ok(error) = error_rx.try_recv() {
            // An error occured that caused the stream to close (for example a
            // device was unplugged). Now our stream_handle object should be
            // manually closed or dropped.
            eprintln!("{}", error);

            break;
        }

        std::thread::sleep(Duration::from_millis(16));
    }
}

pub fn default_input_device(&self) -> Result<DeviceInfo, RtAudioError>

Returns information about the default input device.

Examples found in repository

examples/loopback.rs (line 8)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    dbg!(host.api());

    let out_device = host.default_output_device().unwrap();
    let in_device = host.default_input_device().unwrap();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            Some(DeviceParams {
                device_id: in_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            |error| eprintln!("{}", error),
        )
        .unwrap();
    dbg!(stream_handle.info());

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input } = buffers {
                    // Copy the input to the output.
                    output.copy_from_slice(input);
                }
            },
        )
        .unwrap();

    // Wait 3 seconds before closing.
    std::thread::sleep(std::time::Duration::from_millis(3000));
}

pub fn open_stream<E>( self, output_device: Option<DeviceParams>, input_device: Option<DeviceParams>, sample_format: SampleFormat, sample_rate: u32, buffer_frames: u32, options: StreamOptions, error_callback: E, ) -> Result<StreamHandle, (Self, RtAudioError)>

where E: FnOnce(RtAudioError) + Send + 'static,

Open a new audio stream.

• output_device - The parameters for the output device to use. If you do not wish to use an output device, set this to None.
• input_device - The parameters for the input device to use. If you do not wish to use an input device, set this to None.
• sample_format - The sample format to use. If the device doesn’t natively support the given format, then it will automatically be converted to/from that format.
• sample_rate - The sample rate to use. The stream may decide to use a different sample rate if it’s not supported.
• buffer_frames - The desired maximum number of frames that can appear in a single process call. The stream may decide to use a different value if it’s not supported. The given value should be a power of 2.
• options - Additional options for the stream.
• error_callback - This will be called if there was an error that caused the stream to close. If this happens, the returned Stream struct should be manually closed or dropped.

Only one stream can be opened at a time (this is a limitation with RtAudio).

Examples found in repository

examples/loopback.rs (lines 11-27)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    dbg!(host.api());

    let out_device = host.default_output_device().unwrap();
    let in_device = host.default_input_device().unwrap();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            Some(DeviceParams {
                device_id: in_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            |error| eprintln!("{}", error),
        )
        .unwrap();
    dbg!(stream_handle.info());

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input } = buffers {
                    // Copy the input to the output.
                    output.copy_from_slice(input);
                }
            },
        )
        .unwrap();

    // Wait 3 seconds before closing.
    std::thread::sleep(std::time::Duration::from_millis(3000));
}

examples/playback_sine.rs (lines 13-25)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    dbg!(host.api());

    let out_device = host.default_output_device().unwrap();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            None,
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            |error| eprintln!("{}", error),
        )
        .unwrap();
    dbg!(stream_handle.info());

    let mut phasor = 0.0;
    let phasor_inc = FREQ_HZ / stream_handle.info().sample_rate as f32;

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input: _ } = buffers {
                    // By default, buffers are interleaved.
                    for frame in output.chunks_mut(2) {
                        // Generate a sine wave at 440 Hz at 50% volume.
                        let val = (phasor * std::f32::consts::TAU).sin() * AMPLITUDE;
                        phasor = (phasor + phasor_inc).fract();

                        frame[0] = val;
                        frame[1] = val;
                    }
                }
            },
        )
        .unwrap();

    // Wait 3 seconds before closing.
    std::thread::sleep(std::time::Duration::from_millis(3000));
}

examples/handle_error.rs (lines 13-25)

fn main() {
    let host = rtaudio::Host::new(Api::Unspecified).unwrap();
    let out_device = host.default_output_device().unwrap();

    let (error_tx, error_rx) = std::sync::mpsc::channel();

    let mut stream_handle = host
        .open_stream(
            Some(DeviceParams {
                device_id: out_device.id,
                num_channels: 2,
                first_channel: 0,
            }),
            None,
            SampleFormat::Float32,
            out_device.preferred_sample_rate,
            256,
            StreamOptions::default(),
            move |error| error_tx.send(error).unwrap(),
        )
        .unwrap();

    stream_handle
        .start(
            move |buffers: Buffers<'_>, _info: &StreamInfo, _status: StreamStatus| {
                if let Buffers::Float32 { output, input: _ } = buffers {
                    // Fill the output with silence.
                    output.fill(0.0);
                }
            },
        )
        .unwrap();

    // Play for 5 seconds and then close.
    let t = Instant::now();
    while t.elapsed() < Duration::from_secs(5) {
        // Periodically poll to see if an error has happened.
        if let Ok(error) = error_rx.try_recv() {
            // An error occured that caused the stream to close (for example a
            // device was unplugged). Now our stream_handle object should be
            // manually closed or dropped.
            eprintln!("{}", error);

            break;
        }

        std::thread::sleep(Duration::from_millis(16));
    }
}

Trait Implementations

impl Debug for Host

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Host

fn drop(&mut self)

Executes the destructor for this type.