Struct v4l::io::dmabuf::stream::Stream

pub struct Stream {
    handle: Arc<Handle>,
    arena: Arena<DmaBuf>,
    arena_index: usize,
    buf_type: Type,
    buf_meta: Vec<Metadata>,
    timeout: Option<i32>,
    active: bool,
}

Stream of user buffers. Exposes the borrowing API

Fields

handle: Arc<Handle>

arena: Arena<DmaBuf>

arena_index: usize

buf_type: Type

buf_meta: Vec<Metadata>

timeout: Option<i32>

active: bool

Implementations

impl Stream

pub fn new(dev: &Device, buf_type: Type) -> Result<Self>

Returns a stream for frame capturing

Arguments

• dev - Device ref to get its file descriptor
• buf_type - Type of the buffers

Example

use v4l::buffer::Type;
use v4l::device::Device;
use v4l::io::userptr::Stream;

let dev = Device::new(0);
if let Ok(dev) = dev {
    let stream = Stream::new(&dev, Type::VideoCapture);
}

pub fn with_buffers( dev: &Device, buf_type: Type, buf_count: u32, ) -> Result<Self>

pub fn handle(&self) -> Arc<Handle>

Returns the raw device handle

pub fn set_timeout(&mut self, duration: Duration)

Sets a timeout of the v4l file handle.

pub fn clear_timeout(&mut self)

Clears the timeout of the v4l file handle.

fn buffer_desc(&self) -> v4l2_buffer

impl<'a> Stream

where Self: CaptureStream<'a>,

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

Waits for a buffer to be ready

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

Waits for a buffer to be ready

Trait Implementations

impl<'a> CaptureStream<'a> for Stream

fn queue(&mut self, index: usize) -> Result<()>

Insert a buffer into the drivers’ incoming queue

fn dequeue(&mut self) -> Result<usize>

Remove a buffer from the drivers’ outgoing queue

fn next(&'a mut self) -> Result<(&Self::Item, &Metadata, bool)>

Fetch a new frame by first queueing and then dequeueing. First time initialization is performed if necessary. The last item in the tuple is True if another frame is pending.

impl Drop for Stream

fn drop(&mut self)

Executes the destructor for this type.

impl Stream for Stream

type Item = DmaBuf

fn start(&mut self) -> Result<()>

Start streaming, takes exclusive ownership of a device

fn stop(&mut self) -> Result<()>

Stop streaming, frees all buffers