Struct v4l::io::mmap::stream::Stream

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

Stream of mapped buffers

An arena instance is used internally for buffer handling.

Fields

handle: Arc<Handle>

arena: Arena<'a>

arena_index: usize

buf_type: Type

buf_meta: Vec<Metadata>

timeout: Option<i32>

active: bool

Implementations

impl<'a> Stream<'a>

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

Returns a stream for frame capturing

Arguments

• dev - Capture 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::mmap::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

Trait Implementations

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

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(&'b 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<'a> Drop for Stream<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, 'b> OutputStream<'b> for Stream<'a>

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(&'b mut self) -> Result<(&mut Self::Item, &mut Metadata)>

Dump a new frame by first queueing and then dequeueing. First time initialization is performed if necessary.

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

type Item = [u8]

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

Start streaming, takes exclusive ownership of a device

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

Stop streaming, frees all buffers