v4l2r 0.0.7

Safe and flexible abstraction over V4L2
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

//! Safe wrapper for the `VIDIOC_STREAM(ON|OFF)` ioctls.
use crate::QueueType;
use nix::errno::Errno;
use std::os::unix::io::AsRawFd;
use thiserror::Error;

#[doc(hidden)]
mod ioctl {
    nix::ioctl_write_ptr!(vidioc_streamon, b'V', 18, u32);
    nix::ioctl_write_ptr!(vidioc_streamoff, b'V', 19, u32);
}

#[derive(Debug, Error)]
pub enum StreamOnError {
    #[error("queue type ({0}) not supported, or no buffers allocated or enqueued")]
    InvalidQueue(QueueType),
    #[error("invalid pad configuration")]
    InvalidPadConfig,
    #[error("invalid pipeline link configuration")]
    InvalidPipelineConfig,
    #[error("ioctl error: {0}")]
    IoctlError(Errno),
}

impl From<StreamOnError> for Errno {
    fn from(err: StreamOnError) -> Self {
        match err {
            StreamOnError::InvalidQueue(_) => Errno::EINVAL,
            StreamOnError::InvalidPadConfig => Errno::EPIPE,
            StreamOnError::InvalidPipelineConfig => Errno::ENOLINK,
            StreamOnError::IoctlError(e) => e,
        }
    }
}

/// Safe wrapper around the `VIDIOC_STREAMON` ioctl.
pub fn streamon(fd: &impl AsRawFd, queue: QueueType) -> Result<(), StreamOnError> {
    match unsafe { ioctl::vidioc_streamon(fd.as_raw_fd(), &(queue as u32)) } {
        Ok(_) => Ok(()),
        Err(Errno::EINVAL) => Err(StreamOnError::InvalidQueue(queue)),
        Err(Errno::EPIPE) => Err(StreamOnError::InvalidPadConfig),
        Err(Errno::ENOLINK) => Err(StreamOnError::InvalidPipelineConfig),
        Err(e) => Err(StreamOnError::IoctlError(e)),
    }
}

#[derive(Debug, Error)]
pub enum StreamOffError {
    #[error("queue type not supported")]
    InvalidQueue,
    #[error("ioctl error: {0}")]
    IoctlError(Errno),
}

impl From<StreamOffError> for Errno {
    fn from(err: StreamOffError) -> Self {
        match err {
            StreamOffError::InvalidQueue => Errno::EINVAL,
            StreamOffError::IoctlError(e) => e,
        }
    }
}

/// Safe wrapper around the `VIDIOC_STREAMOFF` ioctl.
pub fn streamoff(fd: &impl AsRawFd, queue: QueueType) -> Result<(), StreamOffError> {
    match unsafe { ioctl::vidioc_streamoff(fd.as_raw_fd(), &(queue as u32)) } {
        Ok(_) => Ok(()),
        Err(Errno::EINVAL) => Err(StreamOffError::InvalidQueue),
        Err(e) => Err(StreamOffError::IoctlError(e)),
    }
}