Struct cubeb::StreamRef

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

Implementations

impl StreamRef

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

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_stream) -> &'a mut StreamRef

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_stream

impl StreamRef

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

Start playback.

Examples found in repository

examples/tone.rs (line 57)

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

    let params = cubeb::StreamParamsBuilder::new()
        .format(STREAM_FORMAT)
        .rate(SAMPLE_FREQUENCY)
        .channels(1)
        .layout(cubeb::ChannelLayout::MONO)
        .take();

    let mut position = 0u32;

    let mut builder = cubeb::StreamBuilder::<Frame>::new();
    builder
        .name("Cubeb tone (mono)")
        .default_output(&params)
        .latency(0x1000)
        .data_callback(move |_, output| {
            // generate our test tone on the fly
            for f in output.iter_mut() {
                // North American dial tone
                let t1 = (2.0 * PI * 350.0 * position as f32 / SAMPLE_FREQUENCY as f32).sin();
                let t2 = (2.0 * PI * 440.0 * position as f32 / SAMPLE_FREQUENCY as f32).sin();

                f.m = i16::from_float(0.5 * (t1 + t2));

                position += 1;
            }
            output.len() as isize
        })
        .state_callback(|state| {
            println!("stream {:?}", state);
        });

    let stream = builder.init(&ctx).expect("Failed to create cubeb stream");

    stream.start().unwrap();
    thread::sleep(Duration::from_millis(500));
    stream.stop().unwrap();
}

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

Stop playback.

Examples found in repository

examples/tone.rs (line 59)

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

    let params = cubeb::StreamParamsBuilder::new()
        .format(STREAM_FORMAT)
        .rate(SAMPLE_FREQUENCY)
        .channels(1)
        .layout(cubeb::ChannelLayout::MONO)
        .take();

    let mut position = 0u32;

    let mut builder = cubeb::StreamBuilder::<Frame>::new();
    builder
        .name("Cubeb tone (mono)")
        .default_output(&params)
        .latency(0x1000)
        .data_callback(move |_, output| {
            // generate our test tone on the fly
            for f in output.iter_mut() {
                // North American dial tone
                let t1 = (2.0 * PI * 350.0 * position as f32 / SAMPLE_FREQUENCY as f32).sin();
                let t2 = (2.0 * PI * 440.0 * position as f32 / SAMPLE_FREQUENCY as f32).sin();

                f.m = i16::from_float(0.5 * (t1 + t2));

                position += 1;
            }
            output.len() as isize
        })
        .state_callback(|state| {
            println!("stream {:?}", state);
        });

    let stream = builder.init(&ctx).expect("Failed to create cubeb stream");

    stream.start().unwrap();
    thread::sleep(Duration::from_millis(500));
    stream.stop().unwrap();
}

pub fn position(&self) -> Result<u64, Error>

Get the current stream playback position.

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

Get the latency for this stream, in frames. This is the number of frames between the time cubeb acquires the data in the callback and the listener can hear the sound.

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

Get the input latency for this stream, in frames. This is the number of frames between the time the audio input device records the audio, and the cubeb callback delivers it. This returns an error if the stream is output-only.

pub fn set_volume(&self, volume: f32) -> Result<(), Error>

Set the volume for a stream.

pub fn set_name(&self, name: &CStr) -> Result<(), Error>

Change a stream’s name

pub fn current_device(&self) -> Result<&DeviceRef, Error>

Get the current output device for this stream.

pub fn set_input_mute(&self, mute: bool) -> Result<(), Error>

Set the mute state for an input stream.

pub fn set_input_processing_params( &self, params: InputProcessingParams ) -> Result<(), Error>

Set the processing parameters for an input stream.

pub fn device_destroy(&self, device: DeviceRef) -> Result<(), Error>

Destroy a cubeb_device structure.

pub fn register_device_changed_callback( &self, callback: Option<unsafe extern "C" fn(_: *mut c_void)> ) -> Result<(), Error>

Set a callback to be notified when the output device changes.

pub fn user_ptr(&self) -> *mut c_void

Trait Implementations

impl AsRef<StreamRef> for Stream

fn as_ref(&self) -> &StreamRef

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

impl Borrow<StreamRef> for Stream

fn borrow(&self) -> &StreamRef

Immutably borrows from an owned value.

impl Debug for StreamRef

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

Formats the value using the given formatter.