Struct cubeb::ContextRef

pub struct ContextRef(/* private fields */);

Implementations

impl ContextRef

pub unsafe fn from_ptr<'a>(ptr: *mut cubeb) -> &'a ContextRef

Safety

This function is unsafe because it dereferences the given ptr pointer. The caller should ensure that pointer is valid.

pub unsafe fn from_ptr_mut<'a>(ptr: *mut cubeb) -> &'a mut ContextRef

Safety

This function is unsafe because it dereferences the given ptr pointer. The caller should ensure that pointer is valid.

pub fn as_ptr(&self) -> *mut cubeb

impl ContextRef

pub fn backend_id(&self) -> &str

Examples found in repository

examples/common/mod.rs (line 16)

pub fn init<T: Into<Vec<u8>>>(ctx_name: T) -> Result<Context> {
    let backend = match env::var("CUBEB_BACKEND") {
        Ok(s) => Some(s),
        Err(_) => None,
    };

    let ctx_name = CString::new(ctx_name).unwrap();
    let ctx = Context::init(Some(ctx_name.as_c_str()), None);
    if let Ok(ref ctx) = ctx {
        if let Some(ref backend) = backend {
            let ctx_backend = ctx.backend_id();
            if backend != ctx_backend {
                let stderr = io::stderr();
                let mut handle = stderr.lock();

                writeln!(
                    handle,
                    "Requested backend `{}', got `{}'",
                    backend, ctx_backend
                )
                .unwrap();
            }
        }
    }

    ctx
}

examples/devices.rs (line 94)

fn main() {
    let ctx = common::init("Cubeb audio test").expect("Failed to create cubeb context");

    println!("Enumerating input devices for backend {}", ctx.backend_id());

    let devices = match ctx.enumerate_devices(DeviceType::INPUT) {
        Ok(devices) => devices,
        Err(e) if e.code() == cubeb::ErrorCode::NotSupported => {
            println!("Device enumeration not support for this backend.");
            return;
        }
        Err(e) => {
            println!("Error enumerating devices: {}", e);
            return;
        }
    };

    println!("Found {} input devices", devices.len());
    for d in devices.iter() {
        print_device_info(d);
    }

    println!(
        "Enumerating output devices for backend {}",
        ctx.backend_id()
    );

    let devices = match ctx.enumerate_devices(DeviceType::OUTPUT) {
        Ok(devices) => devices,
        Err(e) => {
            println!("Error enumerating devices: {}", e);
            return;
        }
    };

    println!("Found {} output devices", devices.len());
    for d in devices.iter() {
        print_device_info(d);
    }
}

pub fn backend_id_bytes(&self) -> &[u8]

pub fn max_channel_count(&self) -> Result<u32, Error>

pub fn min_latency(&self, params: &StreamParamsRef) -> Result<u32, Error>

pub fn preferred_sample_rate(&self) -> Result<u32, Error>

pub fn supported_input_processing_params( &self ) -> Result<InputProcessingParams, Error>

pub unsafe fn stream_init( &self, stream_name: Option<&CStr>, input_device: *const c_void, input_stream_params: Option<&StreamParamsRef>, output_device: *const c_void, output_stream_params: Option<&StreamParamsRef>, latency_frames: u32, data_callback: Option<unsafe extern "C" fn(_: *mut cubeb_stream, _: *mut c_void, _: *const c_void, _: *mut c_void, _: i64) -> i64>, state_callback: Option<unsafe extern "C" fn(_: *mut cubeb_stream, _: *mut c_void, _: u32)>, user_ptr: *mut c_void ) -> Result<Stream, Error>

Safety

This function is unsafe because it dereferences the given data_callback, state_callback, and user_ptr pointers. The caller should ensure those pointers are valid.

pub fn enumerate_devices( &self, devtype: DeviceType ) -> Result<DeviceCollection<'_>, Error>

Examples found in repository

examples/devices.rs (line 96)

fn main() {
    let ctx = common::init("Cubeb audio test").expect("Failed to create cubeb context");

    println!("Enumerating input devices for backend {}", ctx.backend_id());

    let devices = match ctx.enumerate_devices(DeviceType::INPUT) {
        Ok(devices) => devices,
        Err(e) if e.code() == cubeb::ErrorCode::NotSupported => {
            println!("Device enumeration not support for this backend.");
            return;
        }
        Err(e) => {
            println!("Error enumerating devices: {}", e);
            return;
        }
    };

    println!("Found {} input devices", devices.len());
    for d in devices.iter() {
        print_device_info(d);
    }

    println!(
        "Enumerating output devices for backend {}",
        ctx.backend_id()
    );

    let devices = match ctx.enumerate_devices(DeviceType::OUTPUT) {
        Ok(devices) => devices,
        Err(e) => {
            println!("Error enumerating devices: {}", e);
            return;
        }
    };

    println!("Found {} output devices", devices.len());
    for d in devices.iter() {
        print_device_info(d);
    }
}

pub unsafe fn register_device_collection_changed( &self, devtype: DeviceType, callback: Option<unsafe extern "C" fn(_: *mut cubeb, _: *mut c_void)>, user_ptr: *mut c_void ) -> Result<(), Error>

Safety

This function is unsafe because it dereferences the given callback and user_ptr pointers. The caller should ensure those pointers are valid.

Trait Implementations

impl AsRef<ContextRef> for Context

fn as_ref(&self) -> &ContextRef

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<ContextRef> for Context

fn borrow(&self) -> &ContextRef

Immutably borrows from an owned value.

impl Debug for ContextRef

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

Formats the value using the given formatter.