Libargus API Libargus Camera API

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
CameraDevice.h
Go to the documentation of this file.
1 /*
2 * Copyright (c) 2016-2020, NVIDIA CORPORATION. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * * Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * * Neither the name of NVIDIA CORPORATION nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
20 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
24 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 /**
30 * @file
31 * <b>Libargus API: Camera Device API</b>
32 *
33 * @b Description: This file defines objects representing a single camera device.
34 */
35
36 #ifndef _ARGUS_CAMERA_DEVICE_H
37 #define _ARGUS_CAMERA_DEVICE_H
38
39 namespace Argus
40 {
41
42 /**
43 * Object representing a single camera device.
44 *
45 * CameraDevices are provided by a CameraProvider and are used to
46 * access the camera devices available within the system.
47 * Each device is based on a single sensor or a set of synchronized sensors.
48 *
49 * @see ICameraProvider::getCameraDevices
50 *
51 * @defgroup ArgusCameraDevice CameraDevice
52 * @ingroup ArgusObjects
53 */
54 class CameraDevice : public InterfaceProvider
55 {
56 protected:
57 ~CameraDevice() {}
58 };
59
60 /**
61 * @class ICameraProperties
62 *
63 * Interface to the core CameraDevice properties.
64 *
65 * @ingroup ArgusCameraDevice
66 */
67 DEFINE_UUID(InterfaceID, IID_CAMERA_PROPERTIES, 436d2a73,c85b,4a29,bce5,15,60,6e,35,86,91);
68 class ICameraProperties : public Interface
69 {
70 public:
71 static const InterfaceID& id() { return IID_CAMERA_PROPERTIES; }
72
73 /**
74 * Returns the camera UUID.
75 *
76 * In UUID, clock_seq contains low 16 bits of GUID,
77 * node[6] contains high 48 bits of GUID.
78 */
79 virtual UUID getUUID() const = 0;
80
81 /**
82 * Returns the camera sensor placement position on the module.
83 */
84 virtual SensorPlacement getSensorPlacement() const = 0;
85
86 /**
87 * Returns the maximum number of regions of interest supported by AE.
88 * A value of 0 means that the entire image is the only supported region of interest.
89 *
90 * @see IAutoControlSettings::setAeRegions()
91 */
92 virtual uint32_t getMaxAeRegions() const = 0;
93
94 /**
95 * Returns the minimum size of resultant region required by AE.
96 *
97 * @see IAutoControlSettings::setAeRegions()
98 */
99 virtual Size2D<uint32_t> getMinAeRegionSize() const = 0;
100
101 /**
102 * Returns the maximum number of regions of interest supported by AWB.
103 * A value of 0 means that the entire image is the only supported region of interest.
104 *
105 * @see IAutoControlSettings::setAwbRegions()
106 */
107 virtual uint32_t getMaxAwbRegions() const = 0;
108
109 /**
110 * Returns the maximum number of regions of interest supported by AF.
111 * A value of 0 means that the entire image is the only supported region of interest.
112 *
113 * @see IAutoControlSettings::setAfRegions()
114 */
115 virtual uint32_t getMaxAfRegions() const = 0;
116
117 /**
118 * Returns only the basic available sensor modes that do not have an associated
119 * extension. Basic mode types include Depth, RGB, YUV and Bayer types.
120 *
121 * @param[out] modes A vector that will be populated with the sensor modes.
122 *
123 * @returns success/status of the call.
124 */
125 virtual Status getBasicSensorModes(std::vector<SensorMode*>* modes) const = 0;
126
127 /**
128 * Returns all the available sensor modes including the ones that have extensions.
129 * The extended modes support some form of Wide Dynamic Range (WDR) technology.
130 *
131 * All the returned modes will support the basic sensor mode interface.
132 * @see ISensorMode
133 *
134 * @param[out] modes A vector that will be populated with the sensor modes.
135 *
136 * @returns success/status of the call.
137 */
138 virtual Status getAllSensorModes(std::vector<SensorMode*>* modes) const = 0;
139
140 /**
141 * Returns all the recommended aperture positions.
142 *
143 * @param[out] positions a vector that will be populated with the aperture positions.
144 *
145 * @returns success/status of the call.
146 */
147 virtual Status getAperturePositions(std::vector<int32_t>* positions) const = 0;
148
149 /**
150 * Returns all the available aperture f-numbers.
151 *
152 * @param[out] fnumbers A pointer to a vector to be populated with the
153 * aperture f-numbers.
154 *
155 * @returns success/status of the call.
156 */
157 virtual Status getAvailableApertureFNumbers(std::vector<float>* fnumbers) const = 0;
158
159 /**
160 * Returns the valid range of focuser positions.
161 * The units are focuser steps.
162 */
163 virtual Range<int32_t> getFocusPositionRange() const = 0;
164
165 /**
166 * Returns the valid range of aperture positions.
167 * The units are aperture positions.
168 */
169 virtual Range<int32_t> getAperturePositionRange() const = 0;
170
171 /**
172 * Returns the valid range of aperture step positions per second.
173 * The units are aperture motor steps/second.
174 */
175 virtual Range<float> getApertureMotorSpeedRange() const = 0;
176
177 /**
178 * Returns the supported range of ISP digital gain.
179 */
180 virtual Range<float> getIspDigitalGainRange() const = 0;
181
182 /**
183 * Returns the supported range of Exposure Compensation.
184 */
185 virtual Range<float> getExposureCompensationRange() const = 0;
186
187 /**
188 * Returns the model name of the device.
189 */
190 virtual const std::string& getModelName() const = 0;
191
192 /**
193 * Returns the module string for the device.
194 * Contains the device's name, position, and partial model number.
195 * This string is unique for each device on the system.
196 */
197 virtual const std::string& getModuleString() const = 0;
198
199 protected:
200 ~ICameraProperties() {}
201 };
202
203 /**
204 * Child object representing a CameraDevice's sensor mode, returned by
205 * ICameraProperties::getAllSensorModes
206 *
207 * @defgroup ArgusSensorMode SensorMode
208 * @ingroup ArgusCameraDevice
209 */
210 class SensorMode : public InterfaceProvider
211 {
212 protected:
213 ~SensorMode() {}
214 };
215
216 /**
217 * @class ISensorMode
218 *
219 * Interface to the core properties of a SensorMode.
220 *
221 * @ingroup ArgusSensorMode
222 */
223 DEFINE_UUID(InterfaceID, IID_SENSOR_MODE, e69015e0,db2a,11e5,a837,18,00,20,0c,9a,66);
224 class ISensorMode : public Interface
225 {
226 public:
227 static const InterfaceID& id() { return IID_SENSOR_MODE; }
228
229 /**
230 * Returns the image resolution, in pixels.
231 */
232 virtual Size2D<uint32_t> getResolution() const = 0;
233
234 /**
235 * Returns the supported exposure time range (in nanoseconds).
236 */
237 virtual Range<uint64_t> getExposureTimeRange() const = 0;
238
239 /**
240 * Returns the hdr ratio range, it is the ratio of long exposure vs short exposure.
241 * When min and/or max is greater than 1, long exposure range is given by getExposureTimeRange()
242 * and short exposure range is computed as following:
243 * short exposure min = getExposureTimeRange().min() / getHdrRatioRange().max()
244 * short exposure max = getExposureTimeRange().max() / getHdrRatioRange().min().
245 */
246 virtual Range<float> getHdrRatioRange() const = 0;
247
248 /**
249 * Returns the supported frame duration range (in nanoseconds).
250 */
251 virtual Range<uint64_t> getFrameDurationRange() const = 0;
252
253 /**
254 * Returns the supported analog gain range.
255 */
256 virtual Range<float> getAnalogGainRange() const = 0;
257
258 /**
259 * Returns the bit depth of the image captured by the image sensor in the
260 * current mode. For example, a wide dynamic range image sensor capturing
261 * 16 bits per pixel would have an input bit depth of 16.
262 */
263 virtual uint32_t getInputBitDepth() const = 0;
264
265 /**
266 * Returns the bit depth of the image returned from the image sensor in the
267 * current mode. For example, a wide dynamic range image sensor capturing
268 * 16 bits per pixel might be connected through a Camera Serial Interface
269 * (CSI-3) which is limited to 12 bits per pixel. The sensor would have to
270 * compress the image internally and would have an output bit depth not
271 * exceeding 12.
272 */
273 virtual uint32_t getOutputBitDepth() const = 0;
274
275 /**
276 * Describes the type of the sensor (Bayer, Yuv, etc.) and key modes of
277 * operation which are enabled in the sensor mode (Wide-dynamic range,
278 * Piecewise Linear Compressed output, etc.)
279 */
280 virtual SensorModeType getSensorModeType() const = 0;
281
282 /**
283 * Describes the bayer phase of Bayer mode
284 */
285 virtual BayerPhase getBayerPhase() const = 0;
286
287 /**
288 * Checks if the buffer provided is supported by the camera device.
289 */
290 virtual bool isBufferFormatSupported(Buffer* buffer) const = 0;
291 protected:
292 ~ISensorMode() {}
293 };
294
295 } // namespace Argus
296
297 #endif // _ARGUS_CAMERA_DEVICE_H