Struct v4l::io::dmabuf::stream::StreamManual

pub struct StreamManual {
    io: StreamIo,
    arena: Arena<EntryDmaBufProtected>,
}

A stream using the manual buffer management API, where owned buffers are handed to the user, to be enqueued and dequeued explicitly, rather than only borrowed.

Fields

io: StreamIo

arena: Arena<EntryDmaBufProtected>

Bufers in the arena are always locked for writing.

Implementations

impl StreamManual

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

Returns an advanced, buffer-owning stream for frame capturing.

Currently allows only one buffer to be in flight.

Arguments

• dev - Device ref to get its file descriptor
• buf_type - Type of the buffers
• buf_count - the number of buffers to allocate. Too many buffers will hog memory, too few will give less processing time for each buffer (although that doesn’t matter with this API). A safe number is 4.

Example

use v4l::buffer::Type;
use v4l::device::Device;
use v4l::io::dmabuf::StreamManual;

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

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

Returns an uninitialized buffer for immediate queueing in cycle_buffer and starts the stream.

pub fn finish( self, buf: DmaBufProtected, ) -> Result<(), (Error, DmaBufProtected, Self)>

Stops the stream and deallocates buffers.

pub fn cycle_buffer( &mut self, buf: DmaBufProtected, ) -> Result<(DmaBufProtected, Metadata)>

Returns a buffer and removes a new buffer once it’s ready.

This will lock the buffer passed in for writing, so the buffer must be unlocked in a timely fashion. Watch out for deadlocks!

FIXME: if this fails, the buffer is swallowed and streaming can’t continue due to no free buffers.

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

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