Struct Driver 

pub struct Driver { /* private fields */ }

A handle to a single ASIO driver.

Creating an instance of this type loads and initialises the driver.

Dropping all Driver instances will automatically dispose of any resources and de-initialise the driver.

Implementations

impl Driver

pub fn name(&self) -> &str

The name used to uniquely identify this driver.

pub fn channels(&self) -> Result<Channels, AsioError>

Returns the number of input and output channels available on the driver.

Examples found in repository

examples/test.rs (line 10)

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 41)

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 buffersize_range(&self) -> Result<(c_long, c_long), AsioError>

Get the min and max supported buffersize of the driver.

pub fn sample_rate(&self) -> Result<c_double, AsioError>

Get current sample rate of the driver.

Examples found in repository

examples/test.rs (line 14)

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 44)

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 can_sample_rate(&self, sample_rate: c_double) -> Result<bool, AsioError>

Can the driver accept the given sample rate.

pub fn set_sample_rate(&self, sample_rate: c_double) -> Result<(), AsioError>

Set the sample rate for the driver.

pub fn input_data_type(&self) -> Result<AsioSampleType, AsioError>

Get the current data type of the driver’s input stream.

This queries a single channel’s type assuming all channels have the same sample type.

pub fn output_data_type(&self) -> Result<AsioSampleType, AsioError>

Get the current data type of the driver’s output stream.

This queries a single channel’s type assuming all channels have the same sample type.

pub fn prepare_input_stream( &self, output: Option<AsioStream>, num_channels: usize, buffer_size: Option<i32>, ) -> Result<AsioStreams, AsioError>

Prepare the input stream.

Because only the latest call to ASIOCreateBuffers is relevant this call will destroy all past active buffers and recreate them.

For this reason we take the output stream if it exists.

num_channels is the desired number of input channels.

buffer_size sets the desired buffer_size. If None is passed in, then the default buffersize for the device is used.

This returns a full AsioStreams with both input and output if output was active.

pub fn prepare_output_stream( &self, input: Option<AsioStream>, num_channels: usize, buffer_size: Option<i32>, ) -> Result<AsioStreams, AsioError>

Prepare the output stream.

Because only the latest call to ASIOCreateBuffers is relevant this call will destroy all past active buffers and recreate them.

For this reason we take the input stream if it exists.

num_channels is the desired number of output channels.

buffer_size sets the desired buffer_size. If None is passed in, then the default buffersize for the device is used.

This returns a full AsioStreams with both input and output if input was active.

pub fn dispose_buffers(&self) -> Result<(), AsioError>

Releases buffers allocations.

This will stop the stream if the driver is Running.

No-op if no buffers are allocated.

pub fn start(&self) -> Result<(), AsioError>

Starts ASIO streams playing.

The driver must be in the Prepared state

If called successfully, the driver will be in the Running state.

No-op if already Running.

pub fn stop(&self) -> Result<(), AsioError>

Stops ASIO streams playing.

No-op if the state is not Running.

If the state was Running and the stream is stopped successfully, the driver will be in the Prepared state.

pub fn add_callback<F>(&self, callback: F) -> CallbackId

where F: 'static + FnMut(&CallbackInfo) + Send,

Adds a callback to the list of active callbacks.

The given function receives the index of the buffer currently ready for processing.

Returns an ID uniquely associated with the given callback so that it may be removed later.

pub fn remove_callback(&self, rem_id: CallbackId)

Remove the callback with the given ID.

pub fn destroy(self) -> Result<bool, AsioError>

Consumes and destroys the Driver, stopping the streams if they are running and releasing any associated resources.

Returns Ok(true) if the driver was successfully destroyed.

Returns Ok(false) if the driver was not destroyed because another handle to the driver still exists.

Returns Err if some switching driver states failed or if ASIO returned an error on exit.

pub fn add_message_callback<F>(&self, callback: F) -> MessageCallbackId

where F: Fn(AsioMessageSelectors) + Send + Sync + 'static,

Adds a callback to the list of message listeners.

Returns an ID uniquely associated with the given callback so that it may be removed later.

pub fn remove_message_callback(&self, rem_id: MessageCallbackId)

Remove the callback with the given ID.

Trait Implementations

impl Clone for Driver

fn clone(&self) -> Driver

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Driver

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

Formats the value using the given formatter.