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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

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

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

use crate::bindings::v4l2_standard;
use crate::bindings::v4l2_std_id;
use crate::bindings::v4l2_streamparm;
use crate::QueueType;

#[doc(hidden)]
mod ioctl {
    use crate::bindings::v4l2_standard;
    use crate::bindings::v4l2_std_id;
    use crate::bindings::v4l2_streamparm;

    nix::ioctl_readwrite!(vidioc_g_parm, b'V', 21, v4l2_streamparm);
    nix::ioctl_readwrite!(vidioc_s_parm, b'V', 22, v4l2_streamparm);
    nix::ioctl_read!(vidioc_g_std, b'V', 23, v4l2_std_id);
    nix::ioctl_write_ptr!(vidioc_s_std, b'V', 24, v4l2_std_id);
    nix::ioctl_readwrite!(vidioc_enumstd, b'V', 25, v4l2_standard);
    nix::ioctl_read!(vidioc_querystd, b'V', 63, v4l2_std_id);
}

#[derive(Debug, Error)]
pub enum GParmError {
    #[error("ioctl error: {0}")]
    IoctlError(Errno),
}

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

/// Safe wrapper around the `VIDIOC_G_PARM` ioctl.
pub fn g_parm<O: From<v4l2_streamparm>>(
    fd: &impl AsRawFd,
    queue: QueueType,
) -> Result<O, GParmError> {
    let mut parm = v4l2_streamparm {
        type_: queue as u32,
        ..Default::default()
    };

    match unsafe { ioctl::vidioc_g_parm(fd.as_raw_fd(), &mut parm) } {
        Ok(_) => Ok(O::from(parm)),
        Err(e) => Err(GParmError::IoctlError(e)),
    }
}

/// Safe wrapper around the `VIDIOC_S_PARM` ioctl.
pub fn s_parm<I: Into<v4l2_streamparm>, O: From<v4l2_streamparm>>(
    fd: &impl AsRawFd,
    parm: I,
) -> Result<O, GParmError> {
    let mut parm = parm.into();

    match unsafe { ioctl::vidioc_s_parm(fd.as_raw_fd(), &mut parm) } {
        Ok(_) => Ok(O::from(parm)),
        Err(e) => Err(GParmError::IoctlError(e)),
    }
}

/// Safe wrapper around the `VIDIOC_G_STD` ioctl.
pub fn g_std<O: From<v4l2_std_id>>(fd: &impl AsRawFd) -> Result<O, GParmError> {
    let mut std_id: v4l2_std_id = 0;

    match unsafe { ioctl::vidioc_g_std(fd.as_raw_fd(), &mut std_id) } {
        Ok(_) => Ok(O::from(std_id)),
        Err(e) => Err(GParmError::IoctlError(e)),
    }
}

#[derive(Debug, Error)]
pub enum SStdError {
    #[error("unsupported standard requested")]
    Unsupported,
    #[error("ioctl error: {0}")]
    IoctlError(Errno),
}

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

/// Safe wrapper around the `VIDIOC_S_STD` ioctl.
pub fn s_std<I: Into<v4l2_std_id>>(fd: &impl AsRawFd, std_id: I) -> Result<(), SStdError> {
    let std_id = std_id.into();

    match unsafe { ioctl::vidioc_s_std(fd.as_raw_fd(), &std_id) } {
        Ok(_) => Ok(()),
        Err(Errno::EINVAL) => Err(SStdError::Unsupported),
        Err(e) => Err(SStdError::IoctlError(e)),
    }
}

#[derive(Debug, Error)]
pub enum EnumStdError {
    #[error("requested index is out of bounds")]
    OutOfBounds,
    #[error("standard video timings are not supported for this input or output")]
    Unsupported,
    #[error("ioctl error: {0}")]
    IoctlError(Errno),
}

impl From<EnumStdError> for Errno {
    fn from(err: EnumStdError) -> Self {
        match err {
            EnumStdError::OutOfBounds => Errno::EINVAL,
            EnumStdError::Unsupported => Errno::ENODATA,
            EnumStdError::IoctlError(e) => e,
        }
    }
}

/// Safe wrapper around the `VIDIOC_ENUMSTD` ioctl.
pub fn enumstd<O: From<v4l2_standard>>(fd: &impl AsRawFd, index: u32) -> Result<O, EnumStdError> {
    let mut standard = v4l2_standard {
        index,
        ..Default::default()
    };

    match unsafe { ioctl::vidioc_enumstd(fd.as_raw_fd(), &mut standard) } {
        Ok(_) => Ok(O::from(standard)),
        Err(Errno::EINVAL) => Err(EnumStdError::OutOfBounds),
        Err(Errno::ENODATA) => Err(EnumStdError::Unsupported),
        Err(e) => Err(EnumStdError::IoctlError(e)),
    }
}

/// Safe wrapper around the `VIDIOC_QUERYSTD` ioctl.
pub fn querystd<O: From<v4l2_std_id>>(fd: &impl AsRawFd) -> Result<O, GParmError> {
    let mut std_id: v4l2_std_id = 0;

    match unsafe { ioctl::vidioc_querystd(fd.as_raw_fd(), &mut std_id) } {
        Ok(_) => Ok(O::from(std_id)),
        Err(e) => Err(GParmError::IoctlError(e)),
    }
}