Struct Asio 

pub struct Asio { /* private fields */ }

A handle to the ASIO API.

There should only be one instance of this type at any point in time.

Implementations

impl Asio

pub fn new() -> Self

Initialise the ASIO API.

Examples found in repository

examples/test.rs (line 4)

fn main() {
    let asio = sys::Asio::new();
    for driver in asio.driver_names() {
        println!("Driver: {}", driver);
        let driver = asio.load_driver(&driver).expect("failed to load drivers");
        println!(
            "  Channels: {:?}",
            driver.channels().expect("failed to get channels")
        );
        println!(
            "  Sample rate: {:?}",
            driver.sample_rate().expect("failed to get sample rate")
        );
    }
}

examples/enumerate.rs (line 36)

fn main() {
    let asio = sys::Asio::new();
    for name in asio.driver_names() {
        println!("Driver: {:?}", name);
        let driver = asio.load_driver(&name).expect("failed to load driver");
        let channels = driver
            .channels()
            .expect("failed to retrieve channel counts");
        let sample_rate = driver
            .sample_rate()
            .expect("failed to retrieve sample rate");
        let in_fmt = Format {
            channels: channels.ins as _,
            sample_rate: sample_rate as _,
            data_type: SampleFormat::F32,
        };
        let out_fmt = Format {
            channels: channels.outs as _,
            sample_rate: sample_rate as _,
            data_type: SampleFormat::F32,
        };
        println!("  Input {:?}", in_fmt);
        println!("  Output {:?}", out_fmt);
    }
}

pub fn driver_names(&self) -> Vec<String>

Returns the name for each available driver.

This is used at the start to allow the user to choose which driver they want.

Examples found in repository

examples/test.rs (line 5)

fn main() {
    let asio = sys::Asio::new();
    for driver in asio.driver_names() {
        println!("Driver: {}", driver);
        let driver = asio.load_driver(&driver).expect("failed to load drivers");
        println!(
            "  Channels: {:?}",
            driver.channels().expect("failed to get channels")
        );
        println!(
            "  Sample rate: {:?}",
            driver.sample_rate().expect("failed to get sample rate")
        );
    }
}

examples/enumerate.rs (line 37)

fn main() {
    let asio = sys::Asio::new();
    for name in asio.driver_names() {
        println!("Driver: {:?}", name);
        let driver = asio.load_driver(&name).expect("failed to load driver");
        let channels = driver
            .channels()
            .expect("failed to retrieve channel counts");
        let sample_rate = driver
            .sample_rate()
            .expect("failed to retrieve sample rate");
        let in_fmt = Format {
            channels: channels.ins as _,
            sample_rate: sample_rate as _,
            data_type: SampleFormat::F32,
        };
        let out_fmt = Format {
            channels: channels.outs as _,
            sample_rate: sample_rate as _,
            data_type: SampleFormat::F32,
        };
        println!("  Input {:?}", in_fmt);
        println!("  Output {:?}", out_fmt);
    }
}

pub fn loaded_driver(&self) -> Option<Driver>

If a driver has already been loaded, this will return that driver.

Returns None if no driver is currently loaded.

This can be useful to check before calling load_driver as ASIO only supports loading a single driver at a time.

pub fn load_driver(&self, driver_name: &str) -> Result<Driver, LoadDriverError>

Load a driver from the given name.

Driver names compatible with this method can be produced via the asio.driver_names() method.

NOTE: Despite many requests from users, ASIO only supports loading a single driver at a time. Calling this method while a previously loaded Driver instance exists will result in an error. That said, if this method is called with the name of a driver that has already been loaded, that driver will be returned successfully.

Examples found in repository

examples/test.rs (line 7)

fn main() {
    let asio = sys::Asio::new();
    for driver in asio.driver_names() {
        println!("Driver: {}", driver);
        let driver = asio.load_driver(&driver).expect("failed to load drivers");
        println!(
            "  Channels: {:?}",
            driver.channels().expect("failed to get channels")
        );
        println!(
            "  Sample rate: {:?}",
            driver.sample_rate().expect("failed to get sample rate")
        );
    }
}

examples/enumerate.rs (line 39)

fn main() {
    let asio = sys::Asio::new();
    for name in asio.driver_names() {
        println!("Driver: {:?}", name);
        let driver = asio.load_driver(&name).expect("failed to load driver");
        let channels = driver
            .channels()
            .expect("failed to retrieve channel counts");
        let sample_rate = driver
            .sample_rate()
            .expect("failed to retrieve sample rate");
        let in_fmt = Format {
            channels: channels.ins as _,
            sample_rate: sample_rate as _,
            data_type: SampleFormat::F32,
        };
        let out_fmt = Format {
            channels: channels.outs as _,
            sample_rate: sample_rate as _,
            data_type: SampleFormat::F32,
        };
        println!("  Input {:?}", in_fmt);
        println!("  Output {:?}", out_fmt);
    }
}

Trait Implementations

impl Debug for Asio

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

Formats the value using the given formatter.

impl Default for Asio

fn default() -> Asio

Returns the “default value” for a type.