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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use std::ffi::c_int;
use std::os::unix::io::AsRawFd;

use nix::errno::Errno;
use thiserror::Error;

use crate::bindings::v4l2_input;
use crate::bindings::v4l2_output;

#[doc(hidden)]
mod ioctl {
    use std::ffi::c_int;

    use crate::bindings::v4l2_input;
    use crate::bindings::v4l2_output;

    nix::ioctl_readwrite!(vidioc_enuminput, b'V', 26, v4l2_input);
    nix::ioctl_read!(vidioc_g_input, b'V', 38, c_int);
    nix::ioctl_readwrite!(vidioc_s_input, b'V', 39, c_int);

    nix::ioctl_read!(vidioc_g_output, b'V', 46, c_int);
    nix::ioctl_readwrite!(vidioc_s_output, b'V', 47, c_int);
    nix::ioctl_readwrite!(vidioc_enumoutput, b'V', 48, v4l2_output);
}

#[derive(Debug, Error)]
pub enum SelectionError {
    #[error("selection {0} is out of range")]
    OutOfRange(usize),
    #[error("ioctl error: {0}")]
    IoctlError(Errno),
}

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

/// Safe wrapper around the `VIDIOC_ENUMINPUT` ioctl.
pub fn enuminput<R: From<v4l2_input>>(
    fd: &impl AsRawFd,
    index: usize,
) -> Result<R, SelectionError> {
    let mut input = v4l2_input {
        index: index as u32,
        ..Default::default()
    };

    match unsafe { ioctl::vidioc_enuminput(fd.as_raw_fd(), &mut input) } {
        Ok(_) => Ok(R::from(input)),
        Err(Errno::EINVAL) => Err(SelectionError::OutOfRange(index)),
        Err(e) => Err(SelectionError::IoctlError(e)),
    }
}

/// Safe wrapper around the `VIDIOC_G_INPUT` ioctl.
pub fn g_input(fd: &impl AsRawFd) -> Result<usize, Errno> {
    let mut input: c_int = 0;

    unsafe { ioctl::vidioc_g_input(fd.as_raw_fd(), &mut input) }.map(|r| r as usize)
}

/// Safe wrapper around the `VIDIOC_S_INPUT` ioctl.
///
/// Returns the updated `index` upon success.
pub fn s_input(fd: &impl AsRawFd, index: usize) -> Result<usize, SelectionError> {
    let mut input: c_int = index as c_int;

    match unsafe { ioctl::vidioc_s_input(fd.as_raw_fd(), &mut input) } {
        Ok(_) => Ok(input as usize),
        Err(Errno::EINVAL) => Err(SelectionError::OutOfRange(index)),
        Err(e) => Err(SelectionError::IoctlError(e)),
    }
}

/// Safe wrapper around the `VIDIOC_ENUMOUTPUT` ioctl.
pub fn enumoutput<R: From<v4l2_output>>(
    fd: &impl AsRawFd,
    index: usize,
) -> Result<R, SelectionError> {
    let mut output = v4l2_output {
        index: index as u32,
        ..Default::default()
    };

    match unsafe { ioctl::vidioc_enumoutput(fd.as_raw_fd(), &mut output) } {
        Ok(_) => Ok(R::from(output)),
        Err(Errno::EINVAL) => Err(SelectionError::OutOfRange(index)),
        Err(e) => Err(SelectionError::IoctlError(e)),
    }
}

/// Safe wrapper around the `VIDIOC_G_OUTPUT` ioctl.
pub fn g_output(fd: &impl AsRawFd) -> Result<usize, Errno> {
    let mut output: c_int = 0;

    unsafe { ioctl::vidioc_g_output(fd.as_raw_fd(), &mut output) }.map(|r| r as usize)
}

/// Safe wrapper around the `VIDIOC_S_OUTPUT` ioctl.
pub fn s_output(fd: &impl AsRawFd, index: usize) -> Result<(), SelectionError> {
    let mut output: c_int = index as c_int;

    match unsafe { ioctl::vidioc_s_output(fd.as_raw_fd(), &mut output) } {
        Ok(_) => Ok(()),
        Err(Errno::EINVAL) => Err(SelectionError::OutOfRange(index)),
        Err(e) => Err(SelectionError::IoctlError(e)),
    }
}