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
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
|
/* 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 implements the 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 V4L2DeviceFormat
* \brief The V4L2 device image format and sizes
*
* Describes the image format and image sizes to be programmed on a V4L2
* video device. The image format is defined by fourcc code as defined by
* the V4L2 APIs with the V4L2_PIX_FMT_ macros, a visible width and height
* and a variable number of planes (1 to 3) with variable sizes and line
* strides.
*
* Formats defined as 'single planar' by the V4L2 APIs are represented with
* V4L2DeviceFormat instances with a single plane
* (V4L2DeviceFormat::planes = 1). Semi-planar and multiplanar formats use
* 2 and 3 planes respectively.
*
* V4L2DeviceFormat defines the exchange format between components that
* receive image configuration requests from applications and a V4L2Device.
* The V4L2Device validates and applies the requested size and format to
* the device driver.
*/
/**
* \var V4L2DeviceFormat::width
* \brief The image width
*/
/**
* \var V4L2DeviceFormat::height
* \brief The image height
*/
/**
* \var V4L2DeviceFormat::fourcc
* \brief The pixel encoding scheme
*
* The fourcc code, as defined by the V4L2 APIs with the V4L2_PIX_FMT_ macros,
* that identifies the image format pixel encoding scheme.
*/
/**
* \var V4L2DeviceFormat::planesFmt
* \brief The per-plane size information
*
* Images are stored in memory in one or more data planes. Each data plane
* has a specific size and line length, which could differ from the image
* visible sizes to accommodate line or plane padding data.
*
* Only the first V4L2DeviceFormat::planes entries are considered valid.
*
*/
/**
* \var V4L2DeviceFormat::planes
* \brief The number of valid data planes
*/
/**
* \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 */
|
