1/*M///////////////////////////////////////////////////////////////////////////////////////
2//
3// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4//
5// By downloading, copying, installing or using the software you agree to this license.
6// If you do not agree to this license, do not download, install,
7// copy or use the software.
8//
9//
10// License Agreement
11// For Open Source Computer Vision Library
12//
13// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15// Third party copyrights are property of their respective owners.
16//
17// Redistribution and use in source and binary forms, with or without modification,
18// are permitted provided that the following conditions are met:
19//
20// * Redistribution's of source code must retain the above copyright notice,
21// this list of conditions and the following disclaimer.
22//
23// * Redistribution's in binary form must reproduce the above copyright notice,
24// this list of conditions and the following disclaimer in the documentation
25// and/or other materials provided with the distribution.
26//
27// * The name of the copyright holders may not be used to endorse or promote products
28// derived from this software without specific prior written permission.
29//
30// This software is provided by the copyright holders and contributors "as is" and
31// any express or implied warranties, including, but not limited to, the implied
32// warranties of merchantability and fitness for a particular purpose are disclaimed.
33// In no event shall the Intel Corporation or contributors be liable for any direct,
34// indirect, incidental, special, exemplary, or consequential damages
35// (including, but not limited to, procurement of substitute goods or services;
36// loss of use, data, or profits; or business interruption) however caused
37// and on any theory of liability, whether in contract, strict liability,
38// or tort (including negligence or otherwise) arising in any way out of
39// the use of this software, even if advised of the possibility of such damage.
40//
41//M*/
42
43#ifndef OPENCV_VIDEOIO_HPP
44#define OPENCV_VIDEOIO_HPP
45
46#include "opencv2/core.hpp"
47
48/**
49 @defgroup videoio Video I/O
50
51 @brief Read and write video or images sequence with OpenCV
52
53 ### See also:
54 - @ref videoio_overview
55 - Tutorials: @ref tutorial_table_of_content_app
56 @{
57 @defgroup videoio_flags_base Flags for video I/O
58 @defgroup videoio_flags_others Additional flags for video I/O API backends
59 @defgroup videoio_hwaccel Hardware-accelerated video decoding and encoding
60 @defgroup videoio_c C API for video I/O
61 @defgroup videoio_ios iOS glue for video I/O
62 @defgroup videoio_winrt WinRT glue for video I/O
63 @defgroup videoio_registry Query I/O API backends registry
64 @}
65*/
66
67////////////////////////////////// video io /////////////////////////////////
68
69typedef struct CvCapture CvCapture;
70typedef struct CvVideoWriter CvVideoWriter;
71
72namespace cv
73{
74
75//! @addtogroup videoio
76//! @{
77
78//! @addtogroup videoio_flags_base
79//! @{
80
81
82/** @brief cv::VideoCapture API backends identifier.
83
84Select preferred API for a capture object.
85To be used in the VideoCapture::VideoCapture() constructor or VideoCapture::open()
86
87@note
88- Backends are available only if they have been built with your OpenCV binaries.
89See @ref videoio_overview for more information.
90- Microsoft Media Foundation backend tries to use hardware accelerated transformations
91if possible. Environment flag "OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS" set to 0
92disables it and may improve initialization time. More details:
93https://learn.microsoft.com/en-us/windows/win32/medfound/mf-readwrite-enable-hardware-transforms
94*/
95enum VideoCaptureAPIs {
96 CAP_ANY = 0, //!< Auto detect == 0
97 CAP_VFW = 200, //!< Video For Windows (obsolete, removed)
98 CAP_V4L = 200, //!< V4L/V4L2 capturing support
99 CAP_V4L2 = CAP_V4L, //!< Same as CAP_V4L
100 CAP_FIREWIRE = 300, //!< IEEE 1394 drivers
101 CAP_FIREWARE = CAP_FIREWIRE, //!< Same value as CAP_FIREWIRE
102 CAP_IEEE1394 = CAP_FIREWIRE, //!< Same value as CAP_FIREWIRE
103 CAP_DC1394 = CAP_FIREWIRE, //!< Same value as CAP_FIREWIRE
104 CAP_CMU1394 = CAP_FIREWIRE, //!< Same value as CAP_FIREWIRE
105 CAP_QT = 500, //!< QuickTime (obsolete, removed)
106 CAP_UNICAP = 600, //!< Unicap drivers (obsolete, removed)
107 CAP_DSHOW = 700, //!< DirectShow (via videoInput)
108 CAP_PVAPI = 800, //!< PvAPI, Prosilica GigE SDK
109 CAP_OPENNI = 900, //!< OpenNI (for Kinect)
110 CAP_OPENNI_ASUS = 910, //!< OpenNI (for Asus Xtion)
111 CAP_ANDROID = 1000, //!< MediaNDK (API Level 21+) and NDK Camera (API level 24+) for Android
112 CAP_XIAPI = 1100, //!< XIMEA Camera API
113 CAP_AVFOUNDATION = 1200, //!< AVFoundation framework for iOS (OS X Lion will have the same API)
114 CAP_GIGANETIX = 1300, //!< Smartek Giganetix GigEVisionSDK
115 CAP_MSMF = 1400, //!< Microsoft Media Foundation (via videoInput). See platform specific notes above.
116 CAP_WINRT = 1410, //!< Microsoft Windows Runtime using Media Foundation
117 CAP_INTELPERC = 1500, //!< RealSense (former Intel Perceptual Computing SDK)
118 CAP_REALSENSE = 1500, //!< Synonym for CAP_INTELPERC
119 CAP_OPENNI2 = 1600, //!< OpenNI2 (for Kinect)
120 CAP_OPENNI2_ASUS = 1610, //!< OpenNI2 (for Asus Xtion and Occipital Structure sensors)
121 CAP_OPENNI2_ASTRA= 1620, //!< OpenNI2 (for Orbbec Astra)
122 CAP_GPHOTO2 = 1700, //!< gPhoto2 connection
123 CAP_GSTREAMER = 1800, //!< GStreamer
124 CAP_FFMPEG = 1900, //!< Open and record video file or stream using the FFMPEG library
125 CAP_IMAGES = 2000, //!< OpenCV Image Sequence (e.g. img_%02d.jpg)
126 CAP_ARAVIS = 2100, //!< Aravis SDK
127 CAP_OPENCV_MJPEG = 2200, //!< Built-in OpenCV MotionJPEG codec
128 CAP_INTEL_MFX = 2300, //!< Intel MediaSDK
129 CAP_XINE = 2400, //!< XINE engine (Linux)
130 CAP_UEYE = 2500, //!< uEye Camera API
131 CAP_OBSENSOR = 2600, //!< For Orbbec 3D-Sensor device/module (Astra+, Femto, Astra2, Gemini2, Gemini2L, Gemini2XL, Femto Mega) attention: Astra2, Gemini2, and Gemini2L cameras currently only support Windows and Linux kernel versions no higher than 4.15, and higher versions of Linux kernel may have exceptions.
132 };
133
134
135/** @brief cv::VideoCapture generic properties identifier.
136
137 Reading / writing properties involves many layers. Some unexpected result might happens along this chain.
138 Effective behaviour depends from device hardware, driver and API Backend.
139 @sa videoio_flags_others, VideoCapture::get(), VideoCapture::set()
140*/
141enum VideoCaptureProperties {
142 CAP_PROP_POS_MSEC =0, //!< Current position of the video file in milliseconds.
143 CAP_PROP_POS_FRAMES =1, //!< 0-based index of the frame to be decoded/captured next. When the index i is set in RAW mode (CAP_PROP_FORMAT == -1) this will seek to the key frame k, where k <= i.
144 CAP_PROP_POS_AVI_RATIO =2, //!< Relative position of the video file: 0=start of the film, 1=end of the film.
145 CAP_PROP_FRAME_WIDTH =3, //!< Width of the frames in the video stream.
146 CAP_PROP_FRAME_HEIGHT =4, //!< Height of the frames in the video stream.
147 CAP_PROP_FPS =5, //!< Frame rate.
148 CAP_PROP_FOURCC =6, //!< 4-character code of codec. see VideoWriter::fourcc .
149 CAP_PROP_FRAME_COUNT =7, //!< Number of frames in the video file.
150 CAP_PROP_FORMAT =8, //!< Format of the %Mat objects (see Mat::type()) returned by VideoCapture::retrieve().
151 //!< Set value -1 to fetch undecoded RAW video streams (as Mat 8UC1).
152 CAP_PROP_MODE =9, //!< Backend-specific value indicating the current capture mode.
153 CAP_PROP_BRIGHTNESS =10, //!< Brightness of the image (only for those cameras that support).
154 CAP_PROP_CONTRAST =11, //!< Contrast of the image (only for cameras).
155 CAP_PROP_SATURATION =12, //!< Saturation of the image (only for cameras).
156 CAP_PROP_HUE =13, //!< Hue of the image (only for cameras).
157 CAP_PROP_GAIN =14, //!< Gain of the image (only for those cameras that support).
158 CAP_PROP_EXPOSURE =15, //!< Exposure (only for those cameras that support).
159 CAP_PROP_CONVERT_RGB =16, //!< Boolean flags indicating whether images should be converted to RGB. <br/>
160 //!< *GStreamer note*: The flag is ignored in case if custom pipeline is used. It's user responsibility to interpret pipeline output.
161 CAP_PROP_WHITE_BALANCE_BLUE_U =17, //!< Currently unsupported.
162 CAP_PROP_RECTIFICATION =18, //!< Rectification flag for stereo cameras (note: only supported by DC1394 v 2.x backend currently).
163 CAP_PROP_MONOCHROME =19,
164 CAP_PROP_SHARPNESS =20,
165 CAP_PROP_AUTO_EXPOSURE =21, //!< DC1394: exposure control done by camera, user can adjust reference level using this feature.
166 CAP_PROP_GAMMA =22,
167 CAP_PROP_TEMPERATURE =23,
168 CAP_PROP_TRIGGER =24,
169 CAP_PROP_TRIGGER_DELAY =25,
170 CAP_PROP_WHITE_BALANCE_RED_V =26,
171 CAP_PROP_ZOOM =27,
172 CAP_PROP_FOCUS =28,
173 CAP_PROP_GUID =29,
174 CAP_PROP_ISO_SPEED =30,
175 CAP_PROP_BACKLIGHT =32,
176 CAP_PROP_PAN =33,
177 CAP_PROP_TILT =34,
178 CAP_PROP_ROLL =35,
179 CAP_PROP_IRIS =36,
180 CAP_PROP_SETTINGS =37, //!< Pop up video/camera filter dialog (note: only supported by DSHOW backend currently. The property value is ignored)
181 CAP_PROP_BUFFERSIZE =38,
182 CAP_PROP_AUTOFOCUS =39,
183 CAP_PROP_SAR_NUM =40, //!< Sample aspect ratio: num/den (num)
184 CAP_PROP_SAR_DEN =41, //!< Sample aspect ratio: num/den (den)
185 CAP_PROP_BACKEND =42, //!< Current backend (enum VideoCaptureAPIs). Read-only property
186 CAP_PROP_CHANNEL =43, //!< Video input or Channel Number (only for those cameras that support)
187 CAP_PROP_AUTO_WB =44, //!< enable/ disable auto white-balance
188 CAP_PROP_WB_TEMPERATURE=45, //!< white-balance color temperature
189 CAP_PROP_CODEC_PIXEL_FORMAT =46, //!< (read-only) codec's pixel format. 4-character code - see VideoWriter::fourcc . Subset of [AV_PIX_FMT_*](https://github.com/FFmpeg/FFmpeg/blob/master/libavcodec/raw.c) or -1 if unknown
190 CAP_PROP_BITRATE =47, //!< (read-only) Video bitrate in kbits/s
191 CAP_PROP_ORIENTATION_META=48, //!< (read-only) Frame rotation defined by stream meta (applicable for FFmpeg and AVFoundation back-ends only)
192 CAP_PROP_ORIENTATION_AUTO=49, //!< if true - rotates output frames of CvCapture considering video file's metadata (applicable for FFmpeg and AVFoundation back-ends only) (https://github.com/opencv/opencv/issues/15499)
193 CAP_PROP_HW_ACCELERATION=50, //!< (**open-only**) Hardware acceleration type (see #VideoAccelerationType). Setting supported only via `params` parameter in cv::VideoCapture constructor / .open() method. Default value is backend-specific.
194 CAP_PROP_HW_DEVICE =51, //!< (**open-only**) Hardware device index (select GPU if multiple available). Device enumeration is acceleration type specific.
195 CAP_PROP_HW_ACCELERATION_USE_OPENCL=52, //!< (**open-only**) If non-zero, create new OpenCL context and bind it to current thread. The OpenCL context created with Video Acceleration context attached it (if not attached yet) for optimized GPU data copy between HW accelerated decoder and cv::UMat.
196 CAP_PROP_OPEN_TIMEOUT_MSEC=53, //!< (**open-only**) timeout in milliseconds for opening a video capture (applicable for FFmpeg and GStreamer back-ends only)
197 CAP_PROP_READ_TIMEOUT_MSEC=54, //!< (**open-only**) timeout in milliseconds for reading from a video capture (applicable for FFmpeg and GStreamer back-ends only)
198 CAP_PROP_STREAM_OPEN_TIME_USEC =55, //!< (read-only) time in microseconds since Jan 1 1970 when stream was opened. Applicable for FFmpeg backend only. Useful for RTSP and other live streams
199 CAP_PROP_VIDEO_TOTAL_CHANNELS = 56, //!< (read-only) Number of video channels
200 CAP_PROP_VIDEO_STREAM = 57, //!< (**open-only**) Specify video stream, 0-based index. Use -1 to disable video stream from file or IP cameras. Default value is 0.
201 CAP_PROP_AUDIO_STREAM = 58, //!< (**open-only**) Specify stream in multi-language media files, -1 - disable audio processing or microphone. Default value is -1.
202 CAP_PROP_AUDIO_POS = 59, //!< (read-only) Audio position is measured in samples. Accurate audio sample timestamp of previous grabbed fragment. See CAP_PROP_AUDIO_SAMPLES_PER_SECOND and CAP_PROP_AUDIO_SHIFT_NSEC.
203 CAP_PROP_AUDIO_SHIFT_NSEC = 60, //!< (read only) Contains the time difference between the start of the audio stream and the video stream in nanoseconds. Positive value means that audio is started after the first video frame. Negative value means that audio is started before the first video frame.
204 CAP_PROP_AUDIO_DATA_DEPTH = 61, //!< (open, read) Alternative definition to bits-per-sample, but with clear handling of 32F / 32S
205 CAP_PROP_AUDIO_SAMPLES_PER_SECOND = 62, //!< (open, read) determined from file/codec input. If not specified, then selected audio sample rate is 44100
206 CAP_PROP_AUDIO_BASE_INDEX = 63, //!< (read-only) Index of the first audio channel for .retrieve() calls. That audio channel number continues enumeration after video channels.
207 CAP_PROP_AUDIO_TOTAL_CHANNELS = 64, //!< (read-only) Number of audio channels in the selected audio stream (mono, stereo, etc)
208 CAP_PROP_AUDIO_TOTAL_STREAMS = 65, //!< (read-only) Number of audio streams.
209 CAP_PROP_AUDIO_SYNCHRONIZE = 66, //!< (open, read) Enables audio synchronization.
210 CAP_PROP_LRF_HAS_KEY_FRAME = 67, //!< FFmpeg back-end only - Indicates whether the Last Raw Frame (LRF), output from VideoCapture::read() when VideoCapture is initialized with VideoCapture::open(CAP_FFMPEG, {CAP_PROP_FORMAT, -1}) or VideoCapture::set(CAP_PROP_FORMAT,-1) is called before the first call to VideoCapture::read(), contains encoded data for a key frame.
211 CAP_PROP_CODEC_EXTRADATA_INDEX = 68, //!< Positive index indicates that returning extra data is supported by the video back end. This can be retrieved as cap.retrieve(data, <returned index>). E.g. When reading from a h264 encoded RTSP stream, the FFmpeg backend could return the SPS and/or PPS if available (if sent in reply to a DESCRIBE request), from calls to cap.retrieve(data, <returned index>).
212 CAP_PROP_FRAME_TYPE = 69, //!< (read-only) FFmpeg back-end only - Frame type ascii code (73 = 'I', 80 = 'P', 66 = 'B' or 63 = '?' if unknown) of the most recently read frame.
213 CAP_PROP_N_THREADS = 70, //!< (**open-only**) Set the maximum number of threads to use. Use 0 to use as many threads as CPU cores (applicable for FFmpeg back-end only).
214#ifndef CV_DOXYGEN
215 CV__CAP_PROP_LATEST
216#endif
217 };
218
219/** @brief cv::VideoWriter generic properties identifier.
220 @sa VideoWriter::get(), VideoWriter::set()
221*/
222enum VideoWriterProperties {
223 VIDEOWRITER_PROP_QUALITY = 1, //!< Current quality (0..100%) of the encoded videostream. Can be adjusted dynamically in some codecs.
224 VIDEOWRITER_PROP_FRAMEBYTES = 2, //!< (Read-only): Size of just encoded video frame. Note that the encoding order may be different from representation order.
225 VIDEOWRITER_PROP_NSTRIPES = 3, //!< Number of stripes for parallel encoding. -1 for auto detection.
226 VIDEOWRITER_PROP_IS_COLOR = 4, //!< If it is not zero, the encoder will expect and encode color frames, otherwise it
227 //!< will work with grayscale frames.
228 VIDEOWRITER_PROP_DEPTH = 5, //!< Defaults to \ref CV_8U.
229 VIDEOWRITER_PROP_HW_ACCELERATION = 6, //!< (**open-only**) Hardware acceleration type (see #VideoAccelerationType). Setting supported only via `params` parameter in VideoWriter constructor / .open() method. Default value is backend-specific.
230 VIDEOWRITER_PROP_HW_DEVICE = 7, //!< (**open-only**) Hardware device index (select GPU if multiple available). Device enumeration is acceleration type specific.
231 VIDEOWRITER_PROP_HW_ACCELERATION_USE_OPENCL= 8, //!< (**open-only**) If non-zero, create new OpenCL context and bind it to current thread. The OpenCL context created with Video Acceleration context attached it (if not attached yet) for optimized GPU data copy between cv::UMat and HW accelerated encoder.
232 VIDEOWRITER_PROP_RAW_VIDEO = 9, //!< (**open-only**) Set to non-zero to enable encapsulation of an encoded raw video stream. Each raw encoded video frame should be passed to VideoWriter::write() as single row or column of a \ref CV_8UC1 Mat. \note If the key frame interval is not 1 then it must be manually specified by the user. This can either be performed during initialization passing \ref VIDEOWRITER_PROP_KEY_INTERVAL as one of the extra encoder params to \ref VideoWriter::VideoWriter(const String &, int, double, const Size &, const std::vector< int > &params) or afterwards by setting the \ref VIDEOWRITER_PROP_KEY_FLAG with \ref VideoWriter::set() before writing each frame. FFMpeg backend only.
233 VIDEOWRITER_PROP_KEY_INTERVAL = 10, //!< (**open-only**) Set the key frame interval using raw video encapsulation (\ref VIDEOWRITER_PROP_RAW_VIDEO != 0). Defaults to 1 when not set. FFMpeg backend only.
234 VIDEOWRITER_PROP_KEY_FLAG = 11, //!< Set to non-zero to signal that the following frames are key frames or zero if not, when encapsulating raw video (\ref VIDEOWRITER_PROP_RAW_VIDEO != 0). FFMpeg backend only.
235#ifndef CV_DOXYGEN
236 CV__VIDEOWRITER_PROP_LATEST
237#endif
238};
239
240//! @} videoio_flags_base
241
242//! @addtogroup videoio_flags_others
243//! @{
244
245/** @name Hardware acceleration support
246 @{
247*/
248
249/** @brief Video Acceleration type
250 *
251 * Used as value in #CAP_PROP_HW_ACCELERATION and #VIDEOWRITER_PROP_HW_ACCELERATION
252 *
253 * @note In case of FFmpeg backend, it translated to enum AVHWDeviceType (https://github.com/FFmpeg/FFmpeg/blob/master/libavutil/hwcontext.h)
254 */
255enum VideoAccelerationType
256{
257 VIDEO_ACCELERATION_NONE = 0, //!< Do not require any specific H/W acceleration, prefer software processing.
258 //!< Reading of this value means that special H/W accelerated handling is not added or not detected by OpenCV.
259
260 VIDEO_ACCELERATION_ANY = 1, //!< Prefer to use H/W acceleration. If no one supported, then fallback to software processing.
261 //!< @note H/W acceleration may require special configuration of used environment.
262 //!< @note Results in encoding scenario may differ between software and hardware accelerated encoders.
263
264 VIDEO_ACCELERATION_D3D11 = 2, //!< DirectX 11
265 VIDEO_ACCELERATION_VAAPI = 3, //!< VAAPI
266 VIDEO_ACCELERATION_MFX = 4, //!< libmfx (Intel MediaSDK/oneVPL)
267};
268
269//! @} Hardware acceleration support
270
271/** @name IEEE 1394 drivers
272 @{
273*/
274
275/** @brief Modes of the IEEE 1394 controlling registers
276(can be: auto, manual, auto single push, absolute Latter allowed with any other mode)
277every feature can have only one mode turned on at a time
278*/
279enum { CAP_PROP_DC1394_OFF = -4, //!< turn the feature off (not controlled manually nor automatically).
280 CAP_PROP_DC1394_MODE_MANUAL = -3, //!< set automatically when a value of the feature is set by the user.
281 CAP_PROP_DC1394_MODE_AUTO = -2,
282 CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1,
283 CAP_PROP_DC1394_MAX = 31
284 };
285
286//! @} IEEE 1394 drivers
287
288/** @name OpenNI (for Kinect)
289 @{
290*/
291
292//! OpenNI map generators
293enum { CAP_OPENNI_DEPTH_GENERATOR = 1 << 31,
294 CAP_OPENNI_IMAGE_GENERATOR = 1 << 30,
295 CAP_OPENNI_IR_GENERATOR = 1 << 29,
296 CAP_OPENNI_GENERATORS_MASK = CAP_OPENNI_DEPTH_GENERATOR + CAP_OPENNI_IMAGE_GENERATOR + CAP_OPENNI_IR_GENERATOR
297 };
298
299//! Properties of cameras available through OpenNI backend
300enum { CAP_PROP_OPENNI_OUTPUT_MODE = 100,
301 CAP_PROP_OPENNI_FRAME_MAX_DEPTH = 101, //!< In mm
302 CAP_PROP_OPENNI_BASELINE = 102, //!< In mm
303 CAP_PROP_OPENNI_FOCAL_LENGTH = 103, //!< In pixels
304 CAP_PROP_OPENNI_REGISTRATION = 104, //!< Flag that synchronizes the remapping depth map to image map
305 //!< by changing depth generator's view point (if the flag is "on") or
306 //!< sets this view point to its normal one (if the flag is "off").
307 CAP_PROP_OPENNI_REGISTRATION_ON = CAP_PROP_OPENNI_REGISTRATION,
308 CAP_PROP_OPENNI_APPROX_FRAME_SYNC = 105,
309 CAP_PROP_OPENNI_MAX_BUFFER_SIZE = 106,
310 CAP_PROP_OPENNI_CIRCLE_BUFFER = 107,
311 CAP_PROP_OPENNI_MAX_TIME_DURATION = 108,
312 CAP_PROP_OPENNI_GENERATOR_PRESENT = 109,
313 CAP_PROP_OPENNI2_SYNC = 110,
314 CAP_PROP_OPENNI2_MIRROR = 111
315 };
316
317#ifdef _MSC_VER
318#pragma warning( push )
319#pragma warning( disable: 5054 )
320#endif
321//! OpenNI shortcuts
322enum { CAP_OPENNI_IMAGE_GENERATOR_PRESENT = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
323 CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_OUTPUT_MODE,
324 CAP_OPENNI_DEPTH_GENERATOR_PRESENT = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
325 CAP_OPENNI_DEPTH_GENERATOR_BASELINE = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_BASELINE,
326 CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_FOCAL_LENGTH,
327 CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_REGISTRATION,
328 CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION,
329 CAP_OPENNI_IR_GENERATOR_PRESENT = CAP_OPENNI_IR_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
330 };
331#ifdef _MSC_VER
332#pragma warning( pop )
333#endif
334
335//! OpenNI data given from depth generator
336enum { CAP_OPENNI_DEPTH_MAP = 0, //!< Depth values in mm (CV_16UC1)
337 CAP_OPENNI_POINT_CLOUD_MAP = 1, //!< XYZ in meters (CV_32FC3)
338 CAP_OPENNI_DISPARITY_MAP = 2, //!< Disparity in pixels (CV_8UC1)
339 CAP_OPENNI_DISPARITY_MAP_32F = 3, //!< Disparity in pixels (CV_32FC1)
340 CAP_OPENNI_VALID_DEPTH_MASK = 4, //!< CV_8UC1
341
342 CAP_OPENNI_BGR_IMAGE = 5, //!< Data given from RGB image generator
343 CAP_OPENNI_GRAY_IMAGE = 6, //!< Data given from RGB image generator
344
345 CAP_OPENNI_IR_IMAGE = 7 //!< Data given from IR image generator
346 };
347
348//! Supported output modes of OpenNI image generator
349enum { CAP_OPENNI_VGA_30HZ = 0,
350 CAP_OPENNI_SXGA_15HZ = 1,
351 CAP_OPENNI_SXGA_30HZ = 2,
352 CAP_OPENNI_QVGA_30HZ = 3,
353 CAP_OPENNI_QVGA_60HZ = 4
354 };
355
356//! @} OpenNI
357
358/** @name GStreamer
359 @{
360*/
361
362enum { CAP_PROP_GSTREAMER_QUEUE_LENGTH = 200 //!< Default is 1
363 };
364
365//! @} GStreamer
366
367/** @name PvAPI, Prosilica GigE SDK
368 @{
369*/
370
371//! PVAPI
372enum { CAP_PROP_PVAPI_MULTICASTIP = 300, //!< IP for enable multicast master mode. 0 for disable multicast.
373 CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE = 301, //!< FrameStartTriggerMode: Determines how a frame is initiated.
374 CAP_PROP_PVAPI_DECIMATIONHORIZONTAL = 302, //!< Horizontal sub-sampling of the image.
375 CAP_PROP_PVAPI_DECIMATIONVERTICAL = 303, //!< Vertical sub-sampling of the image.
376 CAP_PROP_PVAPI_BINNINGX = 304, //!< Horizontal binning factor.
377 CAP_PROP_PVAPI_BINNINGY = 305, //!< Vertical binning factor.
378 CAP_PROP_PVAPI_PIXELFORMAT = 306 //!< Pixel format.
379 };
380
381//! PVAPI: FrameStartTriggerMode
382enum { CAP_PVAPI_FSTRIGMODE_FREERUN = 0, //!< Freerun
383 CAP_PVAPI_FSTRIGMODE_SYNCIN1 = 1, //!< SyncIn1
384 CAP_PVAPI_FSTRIGMODE_SYNCIN2 = 2, //!< SyncIn2
385 CAP_PVAPI_FSTRIGMODE_FIXEDRATE = 3, //!< FixedRate
386 CAP_PVAPI_FSTRIGMODE_SOFTWARE = 4 //!< Software
387 };
388
389//! PVAPI: DecimationHorizontal, DecimationVertical
390enum { CAP_PVAPI_DECIMATION_OFF = 1, //!< Off
391 CAP_PVAPI_DECIMATION_2OUTOF4 = 2, //!< 2 out of 4 decimation
392 CAP_PVAPI_DECIMATION_2OUTOF8 = 4, //!< 2 out of 8 decimation
393 CAP_PVAPI_DECIMATION_2OUTOF16 = 8 //!< 2 out of 16 decimation
394 };
395
396//! PVAPI: PixelFormat
397enum { CAP_PVAPI_PIXELFORMAT_MONO8 = 1, //!< Mono8
398 CAP_PVAPI_PIXELFORMAT_MONO16 = 2, //!< Mono16
399 CAP_PVAPI_PIXELFORMAT_BAYER8 = 3, //!< Bayer8
400 CAP_PVAPI_PIXELFORMAT_BAYER16 = 4, //!< Bayer16
401 CAP_PVAPI_PIXELFORMAT_RGB24 = 5, //!< Rgb24
402 CAP_PVAPI_PIXELFORMAT_BGR24 = 6, //!< Bgr24
403 CAP_PVAPI_PIXELFORMAT_RGBA32 = 7, //!< Rgba32
404 CAP_PVAPI_PIXELFORMAT_BGRA32 = 8, //!< Bgra32
405 };
406
407//! @} PvAPI
408
409/** @name XIMEA Camera API
410 @{
411*/
412
413//! Properties of cameras available through XIMEA SDK backend
414enum { CAP_PROP_XI_DOWNSAMPLING = 400, //!< Change image resolution by binning or skipping.
415 CAP_PROP_XI_DATA_FORMAT = 401, //!< Output data format.
416 CAP_PROP_XI_OFFSET_X = 402, //!< Horizontal offset from the origin to the area of interest (in pixels).
417 CAP_PROP_XI_OFFSET_Y = 403, //!< Vertical offset from the origin to the area of interest (in pixels).
418 CAP_PROP_XI_TRG_SOURCE = 404, //!< Defines source of trigger.
419 CAP_PROP_XI_TRG_SOFTWARE = 405, //!< Generates an internal trigger. PRM_TRG_SOURCE must be set to TRG_SOFTWARE.
420 CAP_PROP_XI_GPI_SELECTOR = 406, //!< Selects general purpose input.
421 CAP_PROP_XI_GPI_MODE = 407, //!< Set general purpose input mode.
422 CAP_PROP_XI_GPI_LEVEL = 408, //!< Get general purpose level.
423 CAP_PROP_XI_GPO_SELECTOR = 409, //!< Selects general purpose output.
424 CAP_PROP_XI_GPO_MODE = 410, //!< Set general purpose output mode.
425 CAP_PROP_XI_LED_SELECTOR = 411, //!< Selects camera signalling LED.
426 CAP_PROP_XI_LED_MODE = 412, //!< Define camera signalling LED functionality.
427 CAP_PROP_XI_MANUAL_WB = 413, //!< Calculates White Balance(must be called during acquisition).
428 CAP_PROP_XI_AUTO_WB = 414, //!< Automatic white balance.
429 CAP_PROP_XI_AEAG = 415, //!< Automatic exposure/gain.
430 CAP_PROP_XI_EXP_PRIORITY = 416, //!< Exposure priority (0.5 - exposure 50%, gain 50%).
431 CAP_PROP_XI_AE_MAX_LIMIT = 417, //!< Maximum limit of exposure in AEAG procedure.
432 CAP_PROP_XI_AG_MAX_LIMIT = 418, //!< Maximum limit of gain in AEAG procedure.
433 CAP_PROP_XI_AEAG_LEVEL = 419, //!< Average intensity of output signal AEAG should achieve(in %).
434 CAP_PROP_XI_TIMEOUT = 420, //!< Image capture timeout in milliseconds.
435 CAP_PROP_XI_EXPOSURE = 421, //!< Exposure time in microseconds.
436 CAP_PROP_XI_EXPOSURE_BURST_COUNT = 422, //!< Sets the number of times of exposure in one frame.
437 CAP_PROP_XI_GAIN_SELECTOR = 423, //!< Gain selector for parameter Gain allows to select different type of gains.
438 CAP_PROP_XI_GAIN = 424, //!< Gain in dB.
439 CAP_PROP_XI_DOWNSAMPLING_TYPE = 426, //!< Change image downsampling type.
440 CAP_PROP_XI_BINNING_SELECTOR = 427, //!< Binning engine selector.
441 CAP_PROP_XI_BINNING_VERTICAL = 428, //!< Vertical Binning - number of vertical photo-sensitive cells to combine together.
442 CAP_PROP_XI_BINNING_HORIZONTAL = 429, //!< Horizontal Binning - number of horizontal photo-sensitive cells to combine together.
443 CAP_PROP_XI_BINNING_PATTERN = 430, //!< Binning pattern type.
444 CAP_PROP_XI_DECIMATION_SELECTOR = 431, //!< Decimation engine selector.
445 CAP_PROP_XI_DECIMATION_VERTICAL = 432, //!< Vertical Decimation - vertical sub-sampling of the image - reduces the vertical resolution of the image by the specified vertical decimation factor.
446 CAP_PROP_XI_DECIMATION_HORIZONTAL = 433, //!< Horizontal Decimation - horizontal sub-sampling of the image - reduces the horizontal resolution of the image by the specified vertical decimation factor.
447 CAP_PROP_XI_DECIMATION_PATTERN = 434, //!< Decimation pattern type.
448 CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR = 587, //!< Selects which test pattern generator is controlled by the TestPattern feature.
449 CAP_PROP_XI_TEST_PATTERN = 588, //!< Selects which test pattern type is generated by the selected generator.
450 CAP_PROP_XI_IMAGE_DATA_FORMAT = 435, //!< Output data format.
451 CAP_PROP_XI_SHUTTER_TYPE = 436, //!< Change sensor shutter type(CMOS sensor).
452 CAP_PROP_XI_SENSOR_TAPS = 437, //!< Number of taps.
453 CAP_PROP_XI_AEAG_ROI_OFFSET_X = 439, //!< Automatic exposure/gain ROI offset X.
454 CAP_PROP_XI_AEAG_ROI_OFFSET_Y = 440, //!< Automatic exposure/gain ROI offset Y.
455 CAP_PROP_XI_AEAG_ROI_WIDTH = 441, //!< Automatic exposure/gain ROI Width.
456 CAP_PROP_XI_AEAG_ROI_HEIGHT = 442, //!< Automatic exposure/gain ROI Height.
457 CAP_PROP_XI_BPC = 445, //!< Correction of bad pixels.
458 CAP_PROP_XI_WB_KR = 448, //!< White balance red coefficient.
459 CAP_PROP_XI_WB_KG = 449, //!< White balance green coefficient.
460 CAP_PROP_XI_WB_KB = 450, //!< White balance blue coefficient.
461 CAP_PROP_XI_WIDTH = 451, //!< Width of the Image provided by the device (in pixels).
462 CAP_PROP_XI_HEIGHT = 452, //!< Height of the Image provided by the device (in pixels).
463 CAP_PROP_XI_REGION_SELECTOR = 589, //!< Selects Region in Multiple ROI which parameters are set by width, height, ... ,region mode.
464 CAP_PROP_XI_REGION_MODE = 595, //!< Activates/deactivates Region selected by Region Selector.
465 CAP_PROP_XI_LIMIT_BANDWIDTH = 459, //!< Set/get bandwidth(datarate)(in Megabits).
466 CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH = 460, //!< Sensor output data bit depth.
467 CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH = 461, //!< Device output data bit depth.
468 CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH = 462, //!< bitdepth of data returned by function xiGetImage.
469 CAP_PROP_XI_OUTPUT_DATA_PACKING = 463, //!< Device output data packing (or grouping) enabled. Packing could be enabled if output_data_bit_depth > 8 and packing capability is available.
470 CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE = 464, //!< Data packing type. Some cameras supports only specific packing type.
471 CAP_PROP_XI_IS_COOLED = 465, //!< Returns 1 for cameras that support cooling.
472 CAP_PROP_XI_COOLING = 466, //!< Start camera cooling.
473 CAP_PROP_XI_TARGET_TEMP = 467, //!< Set sensor target temperature for cooling.
474 CAP_PROP_XI_CHIP_TEMP = 468, //!< Camera sensor temperature.
475 CAP_PROP_XI_HOUS_TEMP = 469, //!< Camera housing temperature.
476 CAP_PROP_XI_HOUS_BACK_SIDE_TEMP = 590, //!< Camera housing back side temperature.
477 CAP_PROP_XI_SENSOR_BOARD_TEMP = 596, //!< Camera sensor board temperature.
478 CAP_PROP_XI_CMS = 470, //!< Mode of color management system.
479 CAP_PROP_XI_APPLY_CMS = 471, //!< Enable applying of CMS profiles to xiGetImage (see XI_PRM_INPUT_CMS_PROFILE, XI_PRM_OUTPUT_CMS_PROFILE).
480 CAP_PROP_XI_IMAGE_IS_COLOR = 474, //!< Returns 1 for color cameras.
481 CAP_PROP_XI_COLOR_FILTER_ARRAY = 475, //!< Returns color filter array type of RAW data.
482 CAP_PROP_XI_GAMMAY = 476, //!< Luminosity gamma.
483 CAP_PROP_XI_GAMMAC = 477, //!< Chromaticity gamma.
484 CAP_PROP_XI_SHARPNESS = 478, //!< Sharpness Strength.
485 CAP_PROP_XI_CC_MATRIX_00 = 479, //!< Color Correction Matrix element [0][0].
486 CAP_PROP_XI_CC_MATRIX_01 = 480, //!< Color Correction Matrix element [0][1].
487 CAP_PROP_XI_CC_MATRIX_02 = 481, //!< Color Correction Matrix element [0][2].
488 CAP_PROP_XI_CC_MATRIX_03 = 482, //!< Color Correction Matrix element [0][3].
489 CAP_PROP_XI_CC_MATRIX_10 = 483, //!< Color Correction Matrix element [1][0].
490 CAP_PROP_XI_CC_MATRIX_11 = 484, //!< Color Correction Matrix element [1][1].
491 CAP_PROP_XI_CC_MATRIX_12 = 485, //!< Color Correction Matrix element [1][2].
492 CAP_PROP_XI_CC_MATRIX_13 = 486, //!< Color Correction Matrix element [1][3].
493 CAP_PROP_XI_CC_MATRIX_20 = 487, //!< Color Correction Matrix element [2][0].
494 CAP_PROP_XI_CC_MATRIX_21 = 488, //!< Color Correction Matrix element [2][1].
495 CAP_PROP_XI_CC_MATRIX_22 = 489, //!< Color Correction Matrix element [2][2].
496 CAP_PROP_XI_CC_MATRIX_23 = 490, //!< Color Correction Matrix element [2][3].
497 CAP_PROP_XI_CC_MATRIX_30 = 491, //!< Color Correction Matrix element [3][0].
498 CAP_PROP_XI_CC_MATRIX_31 = 492, //!< Color Correction Matrix element [3][1].
499 CAP_PROP_XI_CC_MATRIX_32 = 493, //!< Color Correction Matrix element [3][2].
500 CAP_PROP_XI_CC_MATRIX_33 = 494, //!< Color Correction Matrix element [3][3].
501 CAP_PROP_XI_DEFAULT_CC_MATRIX = 495, //!< Set default Color Correction Matrix.
502 CAP_PROP_XI_TRG_SELECTOR = 498, //!< Selects the type of trigger.
503 CAP_PROP_XI_ACQ_FRAME_BURST_COUNT = 499, //!< Sets number of frames acquired by burst. This burst is used only if trigger is set to FrameBurstStart.
504 CAP_PROP_XI_DEBOUNCE_EN = 507, //!< Enable/Disable debounce to selected GPI.
505 CAP_PROP_XI_DEBOUNCE_T0 = 508, //!< Debounce time (x * 10us).
506 CAP_PROP_XI_DEBOUNCE_T1 = 509, //!< Debounce time (x * 10us).
507 CAP_PROP_XI_DEBOUNCE_POL = 510, //!< Debounce polarity (pol = 1 t0 - falling edge, t1 - rising edge).
508 CAP_PROP_XI_LENS_MODE = 511, //!< Status of lens control interface. This shall be set to XI_ON before any Lens operations.
509 CAP_PROP_XI_LENS_APERTURE_VALUE = 512, //!< Current lens aperture value in stops. Examples: 2.8, 4, 5.6, 8, 11.
510 CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE = 513, //!< Lens current focus movement value to be used by XI_PRM_LENS_FOCUS_MOVE in motor steps.
511 CAP_PROP_XI_LENS_FOCUS_MOVE = 514, //!< Moves lens focus motor by steps set in XI_PRM_LENS_FOCUS_MOVEMENT_VALUE.
512 CAP_PROP_XI_LENS_FOCUS_DISTANCE = 515, //!< Lens focus distance in cm.
513 CAP_PROP_XI_LENS_FOCAL_LENGTH = 516, //!< Lens focal distance in mm.
514 CAP_PROP_XI_LENS_FEATURE_SELECTOR = 517, //!< Selects the current feature which is accessible by XI_PRM_LENS_FEATURE.
515 CAP_PROP_XI_LENS_FEATURE = 518, //!< Allows access to lens feature value currently selected by XI_PRM_LENS_FEATURE_SELECTOR.
516 CAP_PROP_XI_DEVICE_MODEL_ID = 521, //!< Returns device model id.
517 CAP_PROP_XI_DEVICE_SN = 522, //!< Returns device serial number.
518 CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA = 529, //!< The alpha channel of RGB32 output image format.
519 CAP_PROP_XI_IMAGE_PAYLOAD_SIZE = 530, //!< Buffer size in bytes sufficient for output image returned by xiGetImage.
520 CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT = 531, //!< Current format of pixels on transport layer.
521 CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ = 532, //!< Sensor clock frequency in Hz.
522 CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX = 533, //!< Sensor clock frequency index. Sensor with selected frequencies have possibility to set the frequency only by this index.
523 CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT = 534, //!< Number of output channels from sensor used for data transfer.
524 CAP_PROP_XI_FRAMERATE = 535, //!< Define framerate in Hz.
525 CAP_PROP_XI_COUNTER_SELECTOR = 536, //!< Select counter.
526 CAP_PROP_XI_COUNTER_VALUE = 537, //!< Counter status.
527 CAP_PROP_XI_ACQ_TIMING_MODE = 538, //!< Type of sensor frames timing.
528 CAP_PROP_XI_AVAILABLE_BANDWIDTH = 539, //!< Calculate and returns available interface bandwidth(int Megabits).
529 CAP_PROP_XI_BUFFER_POLICY = 540, //!< Data move policy.
530 CAP_PROP_XI_LUT_EN = 541, //!< Activates LUT.
531 CAP_PROP_XI_LUT_INDEX = 542, //!< Control the index (offset) of the coefficient to access in the LUT.
532 CAP_PROP_XI_LUT_VALUE = 543, //!< Value at entry LUTIndex of the LUT.
533 CAP_PROP_XI_TRG_DELAY = 544, //!< Specifies the delay in microseconds (us) to apply after the trigger reception before activating it.
534 CAP_PROP_XI_TS_RST_MODE = 545, //!< Defines how time stamp reset engine will be armed.
535 CAP_PROP_XI_TS_RST_SOURCE = 546, //!< Defines which source will be used for timestamp reset. Writing this parameter will trigger settings of engine (arming).
536 CAP_PROP_XI_IS_DEVICE_EXIST = 547, //!< Returns 1 if camera connected and works properly.
537 CAP_PROP_XI_ACQ_BUFFER_SIZE = 548, //!< Acquisition buffer size in buffer_size_unit. Default bytes.
538 CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT = 549, //!< Acquisition buffer size unit in bytes. Default 1. E.g. Value 1024 means that buffer_size is in KiBytes.
539 CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE = 550, //!< Acquisition transport buffer size in bytes.
540 CAP_PROP_XI_BUFFERS_QUEUE_SIZE = 551, //!< Queue of field/frame buffers.
541 CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT = 552, //!< Number of buffers to commit to low level.
542 CAP_PROP_XI_RECENT_FRAME = 553, //!< GetImage returns most recent frame.
543 CAP_PROP_XI_DEVICE_RESET = 554, //!< Resets the camera to default state.
544 CAP_PROP_XI_COLUMN_FPN_CORRECTION = 555, //!< Correction of column FPN.
545 CAP_PROP_XI_ROW_FPN_CORRECTION = 591, //!< Correction of row FPN.
546 CAP_PROP_XI_SENSOR_MODE = 558, //!< Current sensor mode. Allows to select sensor mode by one integer. Setting of this parameter affects: image dimensions and downsampling.
547 CAP_PROP_XI_HDR = 559, //!< Enable High Dynamic Range feature.
548 CAP_PROP_XI_HDR_KNEEPOINT_COUNT = 560, //!< The number of kneepoints in the PWLR.
549 CAP_PROP_XI_HDR_T1 = 561, //!< Position of first kneepoint(in % of XI_PRM_EXPOSURE).
550 CAP_PROP_XI_HDR_T2 = 562, //!< Position of second kneepoint (in % of XI_PRM_EXPOSURE).
551 CAP_PROP_XI_KNEEPOINT1 = 563, //!< Value of first kneepoint (% of sensor saturation).
552 CAP_PROP_XI_KNEEPOINT2 = 564, //!< Value of second kneepoint (% of sensor saturation).
553 CAP_PROP_XI_IMAGE_BLACK_LEVEL = 565, //!< Last image black level counts. Can be used for Offline processing to recall it.
554 CAP_PROP_XI_HW_REVISION = 571, //!< Returns hardware revision number.
555 CAP_PROP_XI_DEBUG_LEVEL = 572, //!< Set debug level.
556 CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION = 573, //!< Automatic bandwidth calculation.
557 CAP_PROP_XI_FFS_FILE_ID = 594, //!< File number.
558 CAP_PROP_XI_FFS_FILE_SIZE = 580, //!< Size of file.
559 CAP_PROP_XI_FREE_FFS_SIZE = 581, //!< Size of free camera FFS.
560 CAP_PROP_XI_USED_FFS_SIZE = 582, //!< Size of used camera FFS.
561 CAP_PROP_XI_FFS_ACCESS_KEY = 583, //!< Setting of key enables file operations on some cameras.
562 CAP_PROP_XI_SENSOR_FEATURE_SELECTOR = 585, //!< Selects the current feature which is accessible by XI_PRM_SENSOR_FEATURE_VALUE.
563 CAP_PROP_XI_SENSOR_FEATURE_VALUE = 586, //!< Allows access to sensor feature value currently selected by XI_PRM_SENSOR_FEATURE_SELECTOR.
564 };
565
566//! @} XIMEA
567
568
569/** @name ARAVIS Camera API
570 @{
571*/
572
573//! Properties of cameras available through ARAVIS backend
574enum { CAP_PROP_ARAVIS_AUTOTRIGGER = 600 //!< Automatically trigger frame capture if camera is configured with software trigger
575};
576
577//! @} ARAVIS
578
579/** @name AVFoundation framework for iOS
580 @{
581*/
582
583//! Properties of cameras available through AVFOUNDATION backend
584enum { CAP_PROP_IOS_DEVICE_FOCUS = 9001,
585 CAP_PROP_IOS_DEVICE_EXPOSURE = 9002,
586 CAP_PROP_IOS_DEVICE_FLASH = 9003,
587 CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004,
588 CAP_PROP_IOS_DEVICE_TORCH = 9005
589 };
590
591//! @} AVFoundation framework for iOS
592
593
594/** @name Smartek Giganetix GigEVisionSDK
595 @{
596*/
597
598//! Properties of cameras available through Smartek Giganetix Ethernet Vision backend
599/* --- Vladimir Litvinenko (litvinenko.vladimir@gmail.com) --- */
600enum { CAP_PROP_GIGA_FRAME_OFFSET_X = 10001,
601 CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002,
602 CAP_PROP_GIGA_FRAME_WIDTH_MAX = 10003,
603 CAP_PROP_GIGA_FRAME_HEIGH_MAX = 10004,
604 CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005,
605 CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006
606 };
607
608//! @} Smartek
609
610/** @name Intel Perceptual Computing SDK
611 @{
612*/
613enum { CAP_PROP_INTELPERC_PROFILE_COUNT = 11001,
614 CAP_PROP_INTELPERC_PROFILE_IDX = 11002,
615 CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE = 11003,
616 CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE = 11004,
617 CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD = 11005,
618 CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ = 11006,
619 CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT = 11007
620 };
621
622//! Intel Perceptual Streams
623enum { CAP_INTELPERC_DEPTH_GENERATOR = 1 << 29,
624 CAP_INTELPERC_IMAGE_GENERATOR = 1 << 28,
625 CAP_INTELPERC_IR_GENERATOR = 1 << 27,
626 CAP_INTELPERC_GENERATORS_MASK = CAP_INTELPERC_DEPTH_GENERATOR + CAP_INTELPERC_IMAGE_GENERATOR + CAP_INTELPERC_IR_GENERATOR
627 };
628
629enum { CAP_INTELPERC_DEPTH_MAP = 0, //!< Each pixel is a 16-bit integer. The value indicates the distance from an object to the camera's XY plane or the Cartesian depth.
630 CAP_INTELPERC_UVDEPTH_MAP = 1, //!< Each pixel contains two 32-bit floating point values in the range of 0-1, representing the mapping of depth coordinates to the color coordinates.
631 CAP_INTELPERC_IR_MAP = 2, //!< Each pixel is a 16-bit integer. The value indicates the intensity of the reflected laser beam.
632 CAP_INTELPERC_IMAGE = 3
633 };
634
635//! @} Intel Perceptual
636
637/** @name gPhoto2 connection
638 @{
639*/
640
641/** @brief gPhoto2 properties
642
643If `propertyId` is less than 0 then work on widget with that __additive inversed__ camera setting ID
644Get IDs by using CAP_PROP_GPHOTO2_WIDGET_ENUMERATE.
645@see CvCaptureCAM_GPHOTO2 for more info
646*/
647enum { CAP_PROP_GPHOTO2_PREVIEW = 17001, //!< Capture only preview from liveview mode.
648 CAP_PROP_GPHOTO2_WIDGET_ENUMERATE = 17002, //!< Readonly, returns (const char *).
649 CAP_PROP_GPHOTO2_RELOAD_CONFIG = 17003, //!< Trigger, only by set. Reload camera settings.
650 CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE = 17004, //!< Reload all settings on set.
651 CAP_PROP_GPHOTO2_COLLECT_MSGS = 17005, //!< Collect messages with details.
652 CAP_PROP_GPHOTO2_FLUSH_MSGS = 17006, //!< Readonly, returns (const char *).
653 CAP_PROP_SPEED = 17007, //!< Exposure speed. Can be readonly, depends on camera program.
654 CAP_PROP_APERTURE = 17008, //!< Aperture. Can be readonly, depends on camera program.
655 CAP_PROP_EXPOSUREPROGRAM = 17009, //!< Camera exposure program.
656 CAP_PROP_VIEWFINDER = 17010 //!< Enter liveview mode.
657 };
658
659//! @} gPhoto2
660
661
662/** @name Images backend
663 @{
664*/
665
666/** @brief Images backend properties
667
668*/
669enum { CAP_PROP_IMAGES_BASE = 18000,
670 CAP_PROP_IMAGES_LAST = 19000 // excluding
671 };
672
673//! @} Images
674
675/** @name OBSENSOR (for Orbbec 3D-Sensor device/module )
676 @{
677*/
678//! OBSENSOR data given from image generator
679enum VideoCaptureOBSensorDataType{
680 CAP_OBSENSOR_DEPTH_MAP = 0, //!< Depth values in mm (CV_16UC1)
681 CAP_OBSENSOR_BGR_IMAGE = 1, //!< Data given from BGR stream generator
682 CAP_OBSENSOR_IR_IMAGE = 2 //!< Data given from IR stream generator(CV_16UC1)
683};
684
685//! OBSENSOR stream generator
686enum VideoCaptureOBSensorGenerators{
687 CAP_OBSENSOR_DEPTH_GENERATOR = 1 << 29,
688 CAP_OBSENSOR_IMAGE_GENERATOR = 1 << 28,
689 CAP_OBSENSOR_IR_GENERATOR = 1 << 27,
690 CAP_OBSENSOR_GENERATORS_MASK = CAP_OBSENSOR_DEPTH_GENERATOR + CAP_OBSENSOR_IMAGE_GENERATOR + CAP_OBSENSOR_IR_GENERATOR
691};
692
693//!OBSENSOR properties
694enum VideoCaptureOBSensorProperties{
695 // INTRINSIC
696 CAP_PROP_OBSENSOR_INTRINSIC_FX=26001,
697 CAP_PROP_OBSENSOR_INTRINSIC_FY=26002,
698 CAP_PROP_OBSENSOR_INTRINSIC_CX=26003,
699 CAP_PROP_OBSENSOR_INTRINSIC_CY=26004,
700};
701
702//! @} OBSENSOR
703
704//! @} videoio_flags_others
705
706
707class IVideoCapture;
708//! @cond IGNORED
709namespace internal { class VideoCapturePrivateAccessor; }
710//! @endcond IGNORED
711
712/** @brief Class for video capturing from video files, image sequences or cameras.
713
714The class provides C++ API for capturing video from cameras or for reading video files and image sequences.
715
716Here is how the class can be used:
717@include samples/cpp/videocapture_basic.cpp
718
719@note In @ref videoio_c "C API" the black-box structure `CvCapture` is used instead of %VideoCapture.
720@note
721- (C++) A basic sample on using the %VideoCapture interface can be found at
722 `OPENCV_SOURCE_CODE/samples/cpp/videocapture_starter.cpp`
723- (Python) A basic sample on using the %VideoCapture interface can be found at
724 `OPENCV_SOURCE_CODE/samples/python/video.py`
725- (Python) A multi threaded video processing sample can be found at
726 `OPENCV_SOURCE_CODE/samples/python/video_threaded.py`
727- (Python) %VideoCapture sample showcasing some features of the Video4Linux2 backend
728 `OPENCV_SOURCE_CODE/samples/python/video_v4l2.py`
729 */
730class CV_EXPORTS_W VideoCapture
731{
732public:
733 /** @brief Default constructor
734 @note In @ref videoio_c "C API", when you finished working with video, release CvCapture structure with
735 cvReleaseCapture(), or use Ptr\<CvCapture\> that calls cvReleaseCapture() automatically in the
736 destructor.
737 */
738 CV_WRAP VideoCapture();
739
740 /** @overload
741 @brief Opens a video file or a capturing device or an IP video stream for video capturing with API Preference
742
743 @param filename it can be:
744 - name of video file (eg. `video.avi`)
745 - or image sequence (eg. `img_%02d.jpg`, which will read samples like `img_00.jpg, img_01.jpg, img_02.jpg, ...`)
746 - or URL of video stream (eg. `protocol://host:port/script_name?script_params|auth`)
747 - or GStreamer pipeline string in gst-launch tool format in case if GStreamer is used as backend
748 Note that each video stream or IP camera feed has its own URL scheme. Please refer to the
749 documentation of source stream to know the right URL.
750 @param apiPreference preferred Capture API backends to use. Can be used to enforce a specific reader
751 implementation if multiple are available: e.g. cv::CAP_FFMPEG or cv::CAP_IMAGES or cv::CAP_DSHOW.
752
753 @sa cv::VideoCaptureAPIs
754 */
755 CV_WRAP explicit VideoCapture(const String& filename, int apiPreference = CAP_ANY);
756
757 /** @overload
758 @brief Opens a video file or a capturing device or an IP video stream for video capturing with API Preference and parameters
759
760 The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
761 See cv::VideoCaptureProperties
762 */
763 CV_WRAP explicit VideoCapture(const String& filename, int apiPreference, const std::vector<int>& params);
764
765 /** @overload
766 @brief Opens a camera for video capturing
767
768 @param index id of the video capturing device to open. To open default camera using default backend just pass 0.
769 (to backward compatibility usage of camera_id + domain_offset (CAP_*) is valid when apiPreference is CAP_ANY)
770 @param apiPreference preferred Capture API backends to use. Can be used to enforce a specific reader
771 implementation if multiple are available: e.g. cv::CAP_DSHOW or cv::CAP_MSMF or cv::CAP_V4L.
772
773 @sa cv::VideoCaptureAPIs
774 */
775 CV_WRAP explicit VideoCapture(int index, int apiPreference = CAP_ANY);
776
777 /** @overload
778 @brief Opens a camera for video capturing with API Preference and parameters
779
780 The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
781 See cv::VideoCaptureProperties
782 */
783 CV_WRAP explicit VideoCapture(int index, int apiPreference, const std::vector<int>& params);
784
785 /** @brief Default destructor
786
787 The method first calls VideoCapture::release to close the already opened file or camera.
788 */
789 virtual ~VideoCapture();
790
791 /** @brief Opens a video file or a capturing device or an IP video stream for video capturing.
792
793 @overload
794
795 Parameters are same as the constructor VideoCapture(const String& filename, int apiPreference = CAP_ANY)
796 @return `true` if the file has been successfully opened
797
798 The method first calls VideoCapture::release to close the already opened file or camera.
799 */
800 CV_WRAP virtual bool open(const String& filename, int apiPreference = CAP_ANY);
801
802 /** @brief Opens a video file or a capturing device or an IP video stream for video capturing with API Preference and parameters
803
804 @overload
805
806 The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
807 See cv::VideoCaptureProperties
808
809 @return `true` if the file has been successfully opened
810
811 The method first calls VideoCapture::release to close the already opened file or camera.
812 */
813 CV_WRAP virtual bool open(const String& filename, int apiPreference, const std::vector<int>& params);
814
815 /** @brief Opens a camera for video capturing
816
817 @overload
818
819 Parameters are same as the constructor VideoCapture(int index, int apiPreference = CAP_ANY)
820 @return `true` if the camera has been successfully opened.
821
822 The method first calls VideoCapture::release to close the already opened file or camera.
823 */
824 CV_WRAP virtual bool open(int index, int apiPreference = CAP_ANY);
825
826 /** @brief Opens a camera for video capturing with API Preference and parameters
827
828 @overload
829
830 The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
831 See cv::VideoCaptureProperties
832
833 @return `true` if the camera has been successfully opened.
834
835 The method first calls VideoCapture::release to close the already opened file or camera.
836 */
837 CV_WRAP virtual bool open(int index, int apiPreference, const std::vector<int>& params);
838
839 /** @brief Returns true if video capturing has been initialized already.
840
841 If the previous call to VideoCapture constructor or VideoCapture::open() succeeded, the method returns
842 true.
843 */
844 CV_WRAP virtual bool isOpened() const;
845
846 /** @brief Closes video file or capturing device.
847
848 The method is automatically called by subsequent VideoCapture::open and by VideoCapture
849 destructor.
850
851 The C function also deallocates memory and clears \*capture pointer.
852 */
853 CV_WRAP virtual void release();
854
855 /** @brief Grabs the next frame from video file or capturing device.
856
857 @return `true` (non-zero) in the case of success.
858
859 The method/function grabs the next frame from video file or camera and returns true (non-zero) in
860 the case of success.
861
862 The primary use of the function is in multi-camera environments, especially when the cameras do not
863 have hardware synchronization. That is, you call VideoCapture::grab() for each camera and after that
864 call the slower method VideoCapture::retrieve() to decode and get frame from each camera. This way
865 the overhead on demosaicing or motion jpeg decompression etc. is eliminated and the retrieved frames
866 from different cameras will be closer in time.
867
868 Also, when a connected camera is multi-head (for example, a stereo camera or a Kinect device), the
869 correct way of retrieving data from it is to call VideoCapture::grab() first and then call
870 VideoCapture::retrieve() one or more times with different values of the channel parameter.
871
872 @ref tutorial_kinect_openni
873 */
874 CV_WRAP virtual bool grab();
875
876 /** @brief Decodes and returns the grabbed video frame.
877
878 @param [out] image the video frame is returned here. If no frames has been grabbed the image will be empty.
879 @param flag it could be a frame index or a driver specific flag
880 @return `false` if no frames has been grabbed
881
882 The method decodes and returns the just grabbed frame. If no frames has been grabbed
883 (camera has been disconnected, or there are no more frames in video file), the method returns false
884 and the function returns an empty image (with %cv::Mat, test it with Mat::empty()).
885
886 @sa read()
887
888 @note In @ref videoio_c "C API", functions cvRetrieveFrame() and cv.RetrieveFrame() return image stored inside the video
889 capturing structure. It is not allowed to modify or release the image! You can copy the frame using
890 cvCloneImage and then do whatever you want with the copy.
891 */
892 CV_WRAP virtual bool retrieve(OutputArray image, int flag = 0);
893
894 /** @brief Stream operator to read the next video frame.
895 @sa read()
896 */
897 virtual VideoCapture& operator >> (CV_OUT Mat& image);
898
899 /** @overload
900 @sa read()
901 */
902 virtual VideoCapture& operator >> (CV_OUT UMat& image);
903
904 /** @brief Grabs, decodes and returns the next video frame.
905
906 @param [out] image the video frame is returned here. If no frames has been grabbed the image will be empty.
907 @return `false` if no frames has been grabbed
908
909 The method/function combines VideoCapture::grab() and VideoCapture::retrieve() in one call. This is the
910 most convenient method for reading video files or capturing data from decode and returns the just
911 grabbed frame. If no frames has been grabbed (camera has been disconnected, or there are no more
912 frames in video file), the method returns false and the function returns empty image (with %cv::Mat, test it with Mat::empty()).
913
914 @note In @ref videoio_c "C API", functions cvRetrieveFrame() and cv.RetrieveFrame() return image stored inside the video
915 capturing structure. It is not allowed to modify or release the image! You can copy the frame using
916 cvCloneImage and then do whatever you want with the copy.
917 */
918 CV_WRAP virtual bool read(OutputArray image);
919
920 /** @brief Sets a property in the VideoCapture.
921
922 @param propId Property identifier from cv::VideoCaptureProperties (eg. cv::CAP_PROP_POS_MSEC, cv::CAP_PROP_POS_FRAMES, ...)
923 or one from @ref videoio_flags_others
924 @param value Value of the property.
925 @return `true` if the property is supported by backend used by the VideoCapture instance.
926 @note Even if it returns `true` this doesn't ensure that the property
927 value has been accepted by the capture device. See note in VideoCapture::get()
928 */
929 CV_WRAP virtual bool set(int propId, double value);
930
931 /** @brief Returns the specified VideoCapture property
932
933 @param propId Property identifier from cv::VideoCaptureProperties (eg. cv::CAP_PROP_POS_MSEC, cv::CAP_PROP_POS_FRAMES, ...)
934 or one from @ref videoio_flags_others
935 @return Value for the specified property. Value 0 is returned when querying a property that is
936 not supported by the backend used by the VideoCapture instance.
937
938 @note Reading / writing properties involves many layers. Some unexpected result might happens
939 along this chain.
940 @code{.txt}
941 VideoCapture -> API Backend -> Operating System -> Device Driver -> Device Hardware
942 @endcode
943 The returned value might be different from what really used by the device or it could be encoded
944 using device dependent rules (eg. steps or percentage). Effective behaviour depends from device
945 driver and API Backend
946
947 */
948 CV_WRAP virtual double get(int propId) const;
949
950 /** @brief Returns used backend API name
951
952 @note Stream should be opened.
953 */
954 CV_WRAP String getBackendName() const;
955
956 /** Switches exceptions mode
957 *
958 * methods raise exceptions if not successful instead of returning an error code
959 */
960 CV_WRAP void setExceptionMode(bool enable) { throwOnFail = enable; }
961
962 /// query if exception mode is active
963 CV_WRAP bool getExceptionMode() { return throwOnFail; }
964
965
966 /** @brief Wait for ready frames from VideoCapture.
967
968 @param streams input video streams
969 @param readyIndex stream indexes with grabbed frames (ready to use .retrieve() to fetch actual frame)
970 @param timeoutNs number of nanoseconds (0 - infinite)
971 @return `true` if streamReady is not empty
972
973 @throws Exception %Exception on stream errors (check .isOpened() to filter out malformed streams) or VideoCapture type is not supported
974
975 The primary use of the function is in multi-camera environments.
976 The method fills the ready state vector, grabs video frame, if camera is ready.
977
978 After this call use VideoCapture::retrieve() to decode and fetch frame data.
979 */
980 CV_WRAP static
981 bool waitAny(
982 const std::vector<VideoCapture>& streams,
983 CV_OUT std::vector<int>& readyIndex,
984 int64 timeoutNs = 0);
985
986protected:
987 Ptr<CvCapture> cap;
988 Ptr<IVideoCapture> icap;
989 bool throwOnFail;
990
991 friend class internal::VideoCapturePrivateAccessor;
992};
993
994class IVideoWriter;
995
996/** @example samples/cpp/tutorial_code/videoio/video-write/video-write.cpp
997Check @ref tutorial_video_write "the corresponding tutorial" for more details
998*/
999
1000/** @example samples/cpp/videowriter_basic.cpp
1001An example using VideoCapture and VideoWriter class
1002*/
1003
1004/** @brief Video writer class.
1005
1006The class provides C++ API for writing video files or image sequences.
1007*/
1008class CV_EXPORTS_W VideoWriter
1009{
1010public:
1011 /** @brief Default constructors
1012
1013 The constructors/functions initialize video writers.
1014 - On Linux FFMPEG is used to write videos;
1015 - On Windows FFMPEG or MSWF or DSHOW is used;
1016 - On MacOSX AVFoundation is used.
1017 */
1018 CV_WRAP VideoWriter();
1019
1020 /** @overload
1021 @param filename Name of the output video file.
1022 @param fourcc 4-character code of codec used to compress the frames. For example,
1023 VideoWriter::fourcc('P','I','M','1') is a MPEG-1 codec, VideoWriter::fourcc('M','J','P','G')
1024 is a motion-jpeg codec etc. List of codes can be obtained at
1025 [MSDN](https://docs.microsoft.com/en-us/windows/win32/medfound/video-fourccs) page
1026 or with this [page](https://fourcc.org/codecs.php)
1027 of the fourcc site for a more complete list). FFMPEG backend with MP4 container natively uses
1028 other values as fourcc code: see [ObjectType](http://mp4ra.org/#/codecs),
1029 so you may receive a warning message from OpenCV about fourcc code conversion.
1030 @param fps Framerate of the created video stream.
1031 @param frameSize Size of the video frames.
1032 @param isColor If it is not zero, the encoder will expect and encode color frames, otherwise it
1033 will work with grayscale frames.
1034
1035 @b Tips:
1036 - With some backends `fourcc=-1` pops up the codec selection dialog from the system.
1037 - To save image sequence use a proper filename (eg. `img_%02d.jpg`) and `fourcc=0`
1038 OR `fps=0`. Use uncompressed image format (eg. `img_%02d.BMP`) to save raw frames.
1039 - Most codecs are lossy. If you want lossless video file you need to use a lossless codecs
1040 (eg. FFMPEG FFV1, Huffman HFYU, Lagarith LAGS, etc...)
1041 - If FFMPEG is enabled, using `codec=0; fps=0;` you can create an uncompressed (raw) video file.
1042 - If FFMPEG is used, we allow frames of odd width or height, but in this case we truncate
1043 the rightmost column/the bottom row. Probably, this should be handled more elegantly,
1044 but some internal functions inside FFMPEG swscale require even width/height.
1045 */
1046 CV_WRAP VideoWriter(const String& filename, int fourcc, double fps,
1047 Size frameSize, bool isColor = true);
1048
1049 /** @overload
1050 The `apiPreference` parameter allows to specify API backends to use. Can be used to enforce a specific reader implementation
1051 if multiple are available: e.g. cv::CAP_FFMPEG or cv::CAP_GSTREAMER.
1052 */
1053 CV_WRAP VideoWriter(const String& filename, int apiPreference, int fourcc, double fps,
1054 Size frameSize, bool isColor = true);
1055
1056 /** @overload
1057 * The `params` parameter allows to specify extra encoder parameters encoded as pairs (paramId_1, paramValue_1, paramId_2, paramValue_2, ... .)
1058 * see cv::VideoWriterProperties
1059 */
1060 CV_WRAP VideoWriter(const String& filename, int fourcc, double fps, const Size& frameSize,
1061 const std::vector<int>& params);
1062
1063 /** @overload
1064 */
1065 CV_WRAP VideoWriter(const String& filename, int apiPreference, int fourcc, double fps,
1066 const Size& frameSize, const std::vector<int>& params);
1067
1068 /** @brief Default destructor
1069
1070 The method first calls VideoWriter::release to close the already opened file.
1071 */
1072 virtual ~VideoWriter();
1073
1074 /** @brief Initializes or reinitializes video writer.
1075
1076 The method opens video writer. Parameters are the same as in the constructor
1077 VideoWriter::VideoWriter.
1078 @return `true` if video writer has been successfully initialized
1079
1080 The method first calls VideoWriter::release to close the already opened file.
1081 */
1082 CV_WRAP virtual bool open(const String& filename, int fourcc, double fps,
1083 Size frameSize, bool isColor = true);
1084
1085 /** @overload
1086 */
1087 CV_WRAP bool open(const String& filename, int apiPreference, int fourcc, double fps,
1088 Size frameSize, bool isColor = true);
1089
1090 /** @overload
1091 */
1092 CV_WRAP bool open(const String& filename, int fourcc, double fps, const Size& frameSize,
1093 const std::vector<int>& params);
1094
1095 /** @overload
1096 */
1097 CV_WRAP bool open(const String& filename, int apiPreference, int fourcc, double fps,
1098 const Size& frameSize, const std::vector<int>& params);
1099
1100 /** @brief Returns true if video writer has been successfully initialized.
1101 */
1102 CV_WRAP virtual bool isOpened() const;
1103
1104 /** @brief Closes the video writer.
1105
1106 The method is automatically called by subsequent VideoWriter::open and by the VideoWriter
1107 destructor.
1108 */
1109 CV_WRAP virtual void release();
1110
1111 /** @brief Stream operator to write the next video frame.
1112 @sa write
1113 */
1114 virtual VideoWriter& operator << (const Mat& image);
1115
1116 /** @overload
1117 @sa write
1118 */
1119 virtual VideoWriter& operator << (const UMat& image);
1120
1121 /** @brief Writes the next video frame
1122
1123 @param image The written frame. In general, color images are expected in BGR format.
1124
1125 The function/method writes the specified image to video file. It must have the same size as has
1126 been specified when opening the video writer.
1127 */
1128 CV_WRAP virtual void write(InputArray image);
1129
1130 /** @brief Sets a property in the VideoWriter.
1131
1132 @param propId Property identifier from cv::VideoWriterProperties (eg. cv::VIDEOWRITER_PROP_QUALITY)
1133 or one of @ref videoio_flags_others
1134
1135 @param value Value of the property.
1136 @return `true` if the property is supported by the backend used by the VideoWriter instance.
1137 */
1138 CV_WRAP virtual bool set(int propId, double value);
1139
1140 /** @brief Returns the specified VideoWriter property
1141
1142 @param propId Property identifier from cv::VideoWriterProperties (eg. cv::VIDEOWRITER_PROP_QUALITY)
1143 or one of @ref videoio_flags_others
1144
1145 @return Value for the specified property. Value 0 is returned when querying a property that is
1146 not supported by the backend used by the VideoWriter instance.
1147 */
1148 CV_WRAP virtual double get(int propId) const;
1149
1150 /** @brief Concatenates 4 chars to a fourcc code
1151
1152 @return a fourcc code
1153
1154 This static method constructs the fourcc code of the codec to be used in the constructor
1155 VideoWriter::VideoWriter or VideoWriter::open.
1156 */
1157 CV_WRAP static int fourcc(char c1, char c2, char c3, char c4);
1158
1159 /** @brief Returns used backend API name
1160
1161 @note Stream should be opened.
1162 */
1163 CV_WRAP String getBackendName() const;
1164
1165protected:
1166 Ptr<CvVideoWriter> writer;
1167 Ptr<IVideoWriter> iwriter;
1168
1169 static Ptr<IVideoWriter> create(const String& filename, int fourcc, double fps,
1170 Size frameSize, bool isColor = true);
1171};
1172
1173//! @cond IGNORED
1174template<> struct DefaultDeleter<CvCapture>{ CV_EXPORTS void operator ()(CvCapture* obj) const; };
1175template<> struct DefaultDeleter<CvVideoWriter>{ CV_EXPORTS void operator ()(CvVideoWriter* obj) const; };
1176//! @endcond IGNORED
1177
1178//! @} videoio
1179
1180} // cv
1181
1182#endif //OPENCV_VIDEOIO_HPP
1183

Provided by KDAB

Privacy Policy
Improve your Profiling and Debugging skills
Find out more

source code of opencv/modules/videoio/include/opencv2/videoio.hpp