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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2019, Google Inc.
*
* v4l2_device.cpp - V4L2 Device
*/
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <unistd.h>
#include "log.h"
#include "media_object.h"
#include "v4l2_device.h"
/**
* \file v4l2_device.h
* \brief V4L2 Device API
*/
namespace libcamera {
LOG_DEFINE_CATEGORY(V4L2)
/**
* \struct V4L2Capability
* \brief struct v4l2_capability object wrapper and helpers
*
* The V4L2Capability structure manages the information returned by the
* VIDIOC_QUERYCAP ioctl.
*/
/**
* \fn const char *V4L2Capability::driver()
* \brief Retrieve the driver module name
* \return The string containing the name of the driver module
*/
/**
* \fn const char *V4L2Capability::card()
* \brief Retrieve the device card name
* \return The string containing the device name
*/
/**
* \fn const char *V4L2Capability::bus_info()
* \brief Retrieve the location of the device in the system
* \return The string containing the device location
*/
/**
* \fn unsigned int V4L2Capability::device_caps()
* \brief Retrieve the capabilities of the device
* \return The device specific capabilities if V4L2_CAP_DEVICE_CAPS is set or
* driver capabilities otherwise
*/
/**
* \fn bool V4L2Capability::isMultiplanar()
* \brief Identify if the device implement V4L2 multiplanar APIs
* \return True if the device supports multiplanar APIs
*/
/**
* \fn bool V4L2Capability::isCapture()
* \brief Identify if the device is capable of capturing video
* \return True if the device can capture video frames
*/
/**
* \fn bool V4L2Capability::isOutput()
* \brief Identify if the device is capable of outputting video
* \return True if the device can output video frames
*/
/**
* \fn bool V4L2Capability::hasStreaming()
* \brief Determine if the device can perform Streaming I/O
* \return True if the device provides Streaming I/O IOCTLs
*/
/**
* \class V4L2Device
* \brief V4L2Device object and API
*
* The V4L2 Device API class models an instance of a V4L2 device node.
* It is constructed with the path to a V4L2 video device node. The device node
* is only opened upon a call to open() which must be checked for success.
*
* The device capabilities are validated when the device is opened and the
* device is rejected if it is not a suitable V4L2 capture or output device, or
* if the device does not support streaming I/O.
*
* No API call other than open(), isOpen() and close() shall be called on an
* unopened device instance.
*
* Upon destruction any device left open will be closed, and any resources
* released.
*/
/**
* \brief Construct a V4L2Device
* \param deviceNode The file-system path to the video device node
*/
V4L2Device::V4L2Device(const std::string &deviceNode)
: deviceNode_(deviceNode), fd_(-1)
{
}
/**
* \brief Construct a V4L2Device from a MediaEntity
* \param entity The MediaEntity to build the device from
*
* Construct a V4L2Device from a MediaEntity's device node path.
*/
V4L2Device::V4L2Device(const MediaEntity &entity)
: V4L2Device(entity.deviceNode())
{
}
V4L2Device::~V4L2Device()
{
close();
}
/**
* \brief Open a V4L2 device and query its capabilities
* \return 0 on success, or a negative error code otherwise
*/
int V4L2Device::open()
{
int ret;
if (isOpen()) {
LOG(V4L2, Error) << "Device already open";
return -EBUSY;
}
ret = ::open(deviceNode_.c_str(), O_RDWR);
if (ret < 0) {
ret = -errno;
LOG(V4L2, Error)
<< "Failed to open V4L2 device '" << deviceNode_
<< "': " << strerror(-ret);
return ret;
}
fd_ = ret;
ret = ioctl(fd_, VIDIOC_QUERYCAP, &caps_);
if (ret < 0) {
ret = -errno;
LOG(V4L2, Error)
<< "Failed to query device capabilities: "
<< strerror(-ret);
return ret;
}
LOG(V4L2, Debug)
<< "Opened '" << deviceNode_ << "' "
<< caps_.bus_info() << ": " << caps_.driver()
<< ": " << caps_.card();
if (!caps_.isCapture() && !caps_.isOutput()) {
LOG(V4L2, Debug) << "Device is not a supported type";
return -EINVAL;
}
if (!caps_.hasStreaming()) {
LOG(V4L2, Error) << "Device does not support streaming I/O";
return -EINVAL;
}
return 0;
}
/**
* \brief Check if device is successfully opened
* \return True if the device is open, false otherwise
*/
bool V4L2Device::isOpen() const
{
return fd_ != -1;
}
/**
* \brief Close the device, releasing any resources acquired by open()
*/
void V4L2Device::close()
{
if (fd_ < 0)
return;
::close(fd_);
fd_ = -1;
}
/**
* \fn const char *V4L2Device::driverName()
* \brief Retrieve the name of the V4L2 device driver
* \return The string containing the driver name
*/
/**
* \fn const char *V4L2Device::deviceName()
* \brief Retrieve the name of the V4L2 device
* \return The string containing the device name
*/
/**
* \fn const char *V4L2Device::busName()
* \brief Retrieve the location of the device in the system
* \return The string containing the device location
*/
} /* namespace libcamera */
|
