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 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 CAP_PROP_PTS = 71, //!< (read-only) FFmpeg back-end only - presentation timestamp of the most recently read frame using the FPS time base. e.g. fps = 25, VideoCapture::get(\ref CAP_PROP_PTS) = 3, presentation time = 3/25 seconds.
215 CAP_PROP_DTS_DELAY = 72, //!< (read-only) FFmpeg back-end only - maximum difference between presentation (pts) and decompression timestamps (dts) using FPS time base. e.g. delay is maximum when frame_num = 0, if true, VideoCapture::get(\ref CAP_PROP_PTS) = 0 and VideoCapture::get(\ref CAP_PROP_DTS_DELAY) = 2, dts = -2. Non zero values usually imply the stream is encoded using B-frames which are not decoded in presentation order.
216#ifndef CV_DOXYGEN
217 CV__CAP_PROP_LATEST
218#endif
219 };
220
221/** @brief cv::VideoWriter generic properties identifier.
222 @sa VideoWriter::get(), VideoWriter::set()
223*/
224enum VideoWriterProperties {
225 VIDEOWRITER_PROP_QUALITY = 1, //!< Current quality (0..100%) of the encoded videostream. Can be adjusted dynamically in some codecs.
226 VIDEOWRITER_PROP_FRAMEBYTES = 2, //!< (Read-only): Size of just encoded video frame. Note that the encoding order may be different from representation order.
227 VIDEOWRITER_PROP_NSTRIPES = 3, //!< Number of stripes for parallel encoding. -1 for auto detection.
228 VIDEOWRITER_PROP_IS_COLOR = 4, //!< If it is not zero, the encoder will expect and encode color frames, otherwise it
229 //!< will work with grayscale frames.
230 VIDEOWRITER_PROP_DEPTH = 5, //!< Defaults to \ref CV_8U.
231 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.
232 VIDEOWRITER_PROP_HW_DEVICE = 7, //!< (**open-only**) Hardware device index (select GPU if multiple available). Device enumeration is acceleration type specific.
233 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.
234 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.
235 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 back-end only.
236 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 back-end only.
237 VIDEOWRITER_PROP_PTS = 12, //!< Specifies the frame presentation timestamp for each frame using the FPS time base. This property is **only** necessary when encapsulating **externally** encoded video where the decoding order differs from the presentation order, such as in GOP patterns with bi-directional B-frames. The value should be provided by your external encoder and for video sources with fixed frame rates it is equivalent to dividing the current frame's presentation time (\ref CAP_PROP_POS_MSEC) by the frame duration (1000.0 / VideoCapture::get(\ref CAP_PROP_FPS)). It can be queried from the resulting encapsulated video file using VideoCapture::get(\ref CAP_PROP_PTS). FFmpeg back-end only.
238 VIDEOWRITER_PROP_DTS_DELAY = 13, //!< Specifies the maximum difference between presentation (pts) and decompression timestamps (dts) using the FPS time base. This property is necessary **only** when encapsulating **externally** encoded video where the decoding order differs from the presentation order, such as in GOP patterns with bi-directional B-frames. The value should be calculated based on the specific GOP pattern used during encoding. For example, in a GOP with presentation order IBP and decoding order IPB, this value would be 1, as the B-frame is the second frame presented but the third to be decoded. It can be queried from the resulting encapsulated video file using VideoCapture::get(\ref CAP_PROP_DTS_DELAY). Non-zero values usually imply the stream is encoded using B-frames. FFmpeg back-end only.
239#ifndef CV_DOXYGEN
240 CV__VIDEOWRITER_PROP_LATEST
241#endif
242};
243
244//! @} videoio_flags_base
245
246//! @addtogroup videoio_flags_others
247//! @{
248
249/** @name Hardware acceleration support
250 @{
251*/
252
253/** @brief Video Acceleration type
254 *
255 * Used as value in #CAP_PROP_HW_ACCELERATION and #VIDEOWRITER_PROP_HW_ACCELERATION
256 *
257 * @note In case of FFmpeg backend, it translated to enum AVHWDeviceType (https://github.com/FFmpeg/FFmpeg/blob/master/libavutil/hwcontext.h)
258 */
259enum VideoAccelerationType
260{
261 VIDEO_ACCELERATION_NONE = 0, //!< Do not require any specific H/W acceleration, prefer software processing.
262 //!< Reading of this value means that special H/W accelerated handling is not added or not detected by OpenCV.
263
264 VIDEO_ACCELERATION_ANY = 1, //!< Prefer to use H/W acceleration. If no one supported, then fallback to software processing.
265 //!< @note H/W acceleration may require special configuration of used environment.
266 //!< @note Results in encoding scenario may differ between software and hardware accelerated encoders.
267
268 VIDEO_ACCELERATION_D3D11 = 2, //!< DirectX 11
269 VIDEO_ACCELERATION_VAAPI = 3, //!< VAAPI
270 VIDEO_ACCELERATION_MFX = 4, //!< libmfx (Intel MediaSDK/oneVPL)
271};
272
273//! @} Hardware acceleration support
274
275/** @name IEEE 1394 drivers
276 @{
277*/
278
279/** @brief Modes of the IEEE 1394 controlling registers
280(can be: auto, manual, auto single push, absolute Latter allowed with any other mode)
281every feature can have only one mode turned on at a time
282*/
283enum { CAP_PROP_DC1394_OFF = -4, //!< turn the feature off (not controlled manually nor automatically).
284 CAP_PROP_DC1394_MODE_MANUAL = -3, //!< set automatically when a value of the feature is set by the user.
285 CAP_PROP_DC1394_MODE_AUTO = -2,
286 CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1,
287 CAP_PROP_DC1394_MAX = 31
288 };
289
290//! @} IEEE 1394 drivers
291
292/** @name OpenNI (for Kinect)
293 @{
294*/
295
296//! OpenNI map generators
297enum { CAP_OPENNI_DEPTH_GENERATOR = 1 << 31,
298 CAP_OPENNI_IMAGE_GENERATOR = 1 << 30,
299 CAP_OPENNI_IR_GENERATOR = 1 << 29,
300 CAP_OPENNI_GENERATORS_MASK = CAP_OPENNI_DEPTH_GENERATOR + CAP_OPENNI_IMAGE_GENERATOR + CAP_OPENNI_IR_GENERATOR
301 };
302
303//! Properties of cameras available through OpenNI backend
304enum { CAP_PROP_OPENNI_OUTPUT_MODE = 100,
305 CAP_PROP_OPENNI_FRAME_MAX_DEPTH = 101, //!< In mm
306 CAP_PROP_OPENNI_BASELINE = 102, //!< In mm
307 CAP_PROP_OPENNI_FOCAL_LENGTH = 103, //!< In pixels
308 CAP_PROP_OPENNI_REGISTRATION = 104, //!< Flag that synchronizes the remapping depth map to image map
309 //!< by changing depth generator's view point (if the flag is "on") or
310 //!< sets this view point to its normal one (if the flag is "off").
311 CAP_PROP_OPENNI_REGISTRATION_ON = CAP_PROP_OPENNI_REGISTRATION,
312 CAP_PROP_OPENNI_APPROX_FRAME_SYNC = 105,
313 CAP_PROP_OPENNI_MAX_BUFFER_SIZE = 106,
314 CAP_PROP_OPENNI_CIRCLE_BUFFER = 107,
315 CAP_PROP_OPENNI_MAX_TIME_DURATION = 108,
316 CAP_PROP_OPENNI_GENERATOR_PRESENT = 109,
317 CAP_PROP_OPENNI2_SYNC = 110,
318 CAP_PROP_OPENNI2_MIRROR = 111
319 };
320
321#ifdef _MSC_VER
322#pragma warning( push )
323#pragma warning( disable: 5054 )
324#endif
325//! OpenNI shortcuts
326enum { CAP_OPENNI_IMAGE_GENERATOR_PRESENT = +CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
327 CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE = +CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_OUTPUT_MODE,
328 CAP_OPENNI_DEPTH_GENERATOR_PRESENT = +CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
329 CAP_OPENNI_DEPTH_GENERATOR_BASELINE = +CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_BASELINE,
330 CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH = +CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_FOCAL_LENGTH,
331 CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION = +CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_REGISTRATION,
332 CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION,
333 CAP_OPENNI_IR_GENERATOR_PRESENT = +CAP_OPENNI_IR_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT
334 };
335#ifdef _MSC_VER
336#pragma warning( pop )
337#endif
338
339//! OpenNI data given from depth generator
340enum { CAP_OPENNI_DEPTH_MAP = 0, //!< Depth values in mm (CV_16UC1)
341 CAP_OPENNI_POINT_CLOUD_MAP = 1, //!< XYZ in meters (CV_32FC3)
342 CAP_OPENNI_DISPARITY_MAP = 2, //!< Disparity in pixels (CV_8UC1)
343 CAP_OPENNI_DISPARITY_MAP_32F = 3, //!< Disparity in pixels (CV_32FC1)
344 CAP_OPENNI_VALID_DEPTH_MASK = 4, //!< CV_8UC1
345
346 CAP_OPENNI_BGR_IMAGE = 5, //!< Data given from RGB image generator
347 CAP_OPENNI_GRAY_IMAGE = 6, //!< Data given from RGB image generator
348
349 CAP_OPENNI_IR_IMAGE = 7 //!< Data given from IR image generator
350 };
351
352//! Supported output modes of OpenNI image generator
353enum { CAP_OPENNI_VGA_30HZ = 0,
354 CAP_OPENNI_SXGA_15HZ = 1,
355 CAP_OPENNI_SXGA_30HZ = 2,
356 CAP_OPENNI_QVGA_30HZ = 3,
357 CAP_OPENNI_QVGA_60HZ = 4
358 };
359
360//! @} OpenNI
361
362/** @name GStreamer
363 @{
364*/
365
366enum { CAP_PROP_GSTREAMER_QUEUE_LENGTH = 200 //!< Default is 1
367 };
368
369//! @} GStreamer
370
371/** @name PvAPI, Prosilica GigE SDK
372 @{
373*/
374
375//! PVAPI
376enum { CAP_PROP_PVAPI_MULTICASTIP = 300, //!< IP for enable multicast master mode. 0 for disable multicast.
377 CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE = 301, //!< FrameStartTriggerMode: Determines how a frame is initiated.
378 CAP_PROP_PVAPI_DECIMATIONHORIZONTAL = 302, //!< Horizontal sub-sampling of the image.
379 CAP_PROP_PVAPI_DECIMATIONVERTICAL = 303, //!< Vertical sub-sampling of the image.
380 CAP_PROP_PVAPI_BINNINGX = 304, //!< Horizontal binning factor.
381 CAP_PROP_PVAPI_BINNINGY = 305, //!< Vertical binning factor.
382 CAP_PROP_PVAPI_PIXELFORMAT = 306 //!< Pixel format.
383 };
384
385//! PVAPI: FrameStartTriggerMode
386enum { CAP_PVAPI_FSTRIGMODE_FREERUN = 0, //!< Freerun
387 CAP_PVAPI_FSTRIGMODE_SYNCIN1 = 1, //!< SyncIn1
388 CAP_PVAPI_FSTRIGMODE_SYNCIN2 = 2, //!< SyncIn2
389 CAP_PVAPI_FSTRIGMODE_FIXEDRATE = 3, //!< FixedRate
390 CAP_PVAPI_FSTRIGMODE_SOFTWARE = 4 //!< Software
391 };
392
393//! PVAPI: DecimationHorizontal, DecimationVertical
394enum { CAP_PVAPI_DECIMATION_OFF = 1, //!< Off
395 CAP_PVAPI_DECIMATION_2OUTOF4 = 2, //!< 2 out of 4 decimation
396 CAP_PVAPI_DECIMATION_2OUTOF8 = 4, //!< 2 out of 8 decimation
397 CAP_PVAPI_DECIMATION_2OUTOF16 = 8 //!< 2 out of 16 decimation
398 };
399
400//! PVAPI: PixelFormat
401enum { CAP_PVAPI_PIXELFORMAT_MONO8 = 1, //!< Mono8
402 CAP_PVAPI_PIXELFORMAT_MONO16 = 2, //!< Mono16
403 CAP_PVAPI_PIXELFORMAT_BAYER8 = 3, //!< Bayer8
404 CAP_PVAPI_PIXELFORMAT_BAYER16 = 4, //!< Bayer16
405 CAP_PVAPI_PIXELFORMAT_RGB24 = 5, //!< Rgb24
406 CAP_PVAPI_PIXELFORMAT_BGR24 = 6, //!< Bgr24
407 CAP_PVAPI_PIXELFORMAT_RGBA32 = 7, //!< Rgba32
408 CAP_PVAPI_PIXELFORMAT_BGRA32 = 8, //!< Bgra32
409 };
410
411//! @} PvAPI
412
413/** @name XIMEA Camera API
414 @{
415*/
416
417//! Properties of cameras available through XIMEA SDK backend
418enum { CAP_PROP_XI_DOWNSAMPLING = 400, //!< Change image resolution by binning or skipping.
419 CAP_PROP_XI_DATA_FORMAT = 401, //!< Output data format.
420 CAP_PROP_XI_OFFSET_X = 402, //!< Horizontal offset from the origin to the area of interest (in pixels).
421 CAP_PROP_XI_OFFSET_Y = 403, //!< Vertical offset from the origin to the area of interest (in pixels).
422 CAP_PROP_XI_TRG_SOURCE = 404, //!< Defines source of trigger.
423 CAP_PROP_XI_TRG_SOFTWARE = 405, //!< Generates an internal trigger. PRM_TRG_SOURCE must be set to TRG_SOFTWARE.
424 CAP_PROP_XI_GPI_SELECTOR = 406, //!< Selects general purpose input.
425 CAP_PROP_XI_GPI_MODE = 407, //!< Set general purpose input mode.
426 CAP_PROP_XI_GPI_LEVEL = 408, //!< Get general purpose level.
427 CAP_PROP_XI_GPO_SELECTOR = 409, //!< Selects general purpose output.
428 CAP_PROP_XI_GPO_MODE = 410, //!< Set general purpose output mode.
429 CAP_PROP_XI_LED_SELECTOR = 411, //!< Selects camera signalling LED.
430 CAP_PROP_XI_LED_MODE = 412, //!< Define camera signalling LED functionality.
431 CAP_PROP_XI_MANUAL_WB = 413, //!< Calculates White Balance(must be called during acquisition).
432 CAP_PROP_XI_AUTO_WB = 414, //!< Automatic white balance.
433 CAP_PROP_XI_AEAG = 415, //!< Automatic exposure/gain.
434 CAP_PROP_XI_EXP_PRIORITY = 416, //!< Exposure priority (0.5 - exposure 50%, gain 50%).
435 CAP_PROP_XI_AE_MAX_LIMIT = 417, //!< Maximum limit of exposure in AEAG procedure.
436 CAP_PROP_XI_AG_MAX_LIMIT = 418, //!< Maximum limit of gain in AEAG procedure.
437 CAP_PROP_XI_AEAG_LEVEL = 419, //!< Average intensity of output signal AEAG should achieve(in %).
438 CAP_PROP_XI_TIMEOUT = 420, //!< Image capture timeout in milliseconds.
439 CAP_PROP_XI_EXPOSURE = 421, //!< Exposure time in microseconds.
440 CAP_PROP_XI_EXPOSURE_BURST_COUNT = 422, //!< Sets the number of times of exposure in one frame.
441 CAP_PROP_XI_GAIN_SELECTOR = 423, //!< Gain selector for parameter Gain allows to select different type of gains.
442 CAP_PROP_XI_GAIN = 424, //!< Gain in dB.
443 CAP_PROP_XI_DOWNSAMPLING_TYPE = 426, //!< Change image downsampling type.
444 CAP_PROP_XI_BINNING_SELECTOR = 427, //!< Binning engine selector.
445 CAP_PROP_XI_BINNING_VERTICAL = 428, //!< Vertical Binning - number of vertical photo-sensitive cells to combine together.
446 CAP_PROP_XI_BINNING_HORIZONTAL = 429, //!< Horizontal Binning - number of horizontal photo-sensitive cells to combine together.
447 CAP_PROP_XI_BINNING_PATTERN = 430, //!< Binning pattern type.
448 CAP_PROP_XI_DECIMATION_SELECTOR = 431, //!< Decimation engine selector.
449 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.
450 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.
451 CAP_PROP_XI_DECIMATION_PATTERN = 434, //!< Decimation pattern type.
452 CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR = 587, //!< Selects which test pattern generator is controlled by the TestPattern feature.
453 CAP_PROP_XI_TEST_PATTERN = 588, //!< Selects which test pattern type is generated by the selected generator.
454 CAP_PROP_XI_IMAGE_DATA_FORMAT = 435, //!< Output data format.
455 CAP_PROP_XI_SHUTTER_TYPE = 436, //!< Change sensor shutter type(CMOS sensor).
456 CAP_PROP_XI_SENSOR_TAPS = 437, //!< Number of taps.
457 CAP_PROP_XI_AEAG_ROI_OFFSET_X = 439, //!< Automatic exposure/gain ROI offset X.
458 CAP_PROP_XI_AEAG_ROI_OFFSET_Y = 440, //!< Automatic exposure/gain ROI offset Y.
459 CAP_PROP_XI_AEAG_ROI_WIDTH = 441, //!< Automatic exposure/gain ROI Width.
460 CAP_PROP_XI_AEAG_ROI_HEIGHT = 442, //!< Automatic exposure/gain ROI Height.
461 CAP_PROP_XI_BPC = 445, //!< Correction of bad pixels.
462 CAP_PROP_XI_WB_KR = 448, //!< White balance red coefficient.
463 CAP_PROP_XI_WB_KG = 449, //!< White balance green coefficient.
464 CAP_PROP_XI_WB_KB = 450, //!< White balance blue coefficient.
465 CAP_PROP_XI_WIDTH = 451, //!< Width of the Image provided by the device (in pixels).
466 CAP_PROP_XI_HEIGHT = 452, //!< Height of the Image provided by the device (in pixels).
467 CAP_PROP_XI_REGION_SELECTOR = 589, //!< Selects Region in Multiple ROI which parameters are set by width, height, ... ,region mode.
468 CAP_PROP_XI_REGION_MODE = 595, //!< Activates/deactivates Region selected by Region Selector.
469 CAP_PROP_XI_LIMIT_BANDWIDTH = 459, //!< Set/get bandwidth(datarate)(in Megabits).
470 CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH = 460, //!< Sensor output data bit depth.
471 CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH = 461, //!< Device output data bit depth.
472 CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH = 462, //!< bitdepth of data returned by function xiGetImage.
473 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.
474 CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE = 464, //!< Data packing type. Some cameras supports only specific packing type.
475 CAP_PROP_XI_IS_COOLED = 465, //!< Returns 1 for cameras that support cooling.
476 CAP_PROP_XI_COOLING = 466, //!< Start camera cooling.
477 CAP_PROP_XI_TARGET_TEMP = 467, //!< Set sensor target temperature for cooling.
478 CAP_PROP_XI_CHIP_TEMP = 468, //!< Camera sensor temperature.
479 CAP_PROP_XI_HOUS_TEMP = 469, //!< Camera housing temperature.
480 CAP_PROP_XI_HOUS_BACK_SIDE_TEMP = 590, //!< Camera housing back side temperature.
481 CAP_PROP_XI_SENSOR_BOARD_TEMP = 596, //!< Camera sensor board temperature.
482 CAP_PROP_XI_CMS = 470, //!< Mode of color management system.
483 CAP_PROP_XI_APPLY_CMS = 471, //!< Enable applying of CMS profiles to xiGetImage (see XI_PRM_INPUT_CMS_PROFILE, XI_PRM_OUTPUT_CMS_PROFILE).
484 CAP_PROP_XI_IMAGE_IS_COLOR = 474, //!< Returns 1 for color cameras.
485 CAP_PROP_XI_COLOR_FILTER_ARRAY = 475, //!< Returns color filter array type of RAW data.
486 CAP_PROP_XI_GAMMAY = 476, //!< Luminosity gamma.
487 CAP_PROP_XI_GAMMAC = 477, //!< Chromaticity gamma.
488 CAP_PROP_XI_SHARPNESS = 478, //!< Sharpness Strength.
489 CAP_PROP_XI_CC_MATRIX_00 = 479, //!< Color Correction Matrix element [0][0].
490 CAP_PROP_XI_CC_MATRIX_01 = 480, //!< Color Correction Matrix element [0][1].
491 CAP_PROP_XI_CC_MATRIX_02 = 481, //!< Color Correction Matrix element [0][2].
492 CAP_PROP_XI_CC_MATRIX_03 = 482, //!< Color Correction Matrix element [0][3].
493 CAP_PROP_XI_CC_MATRIX_10 = 483, //!< Color Correction Matrix element [1][0].
494 CAP_PROP_XI_CC_MATRIX_11 = 484, //!< Color Correction Matrix element [1][1].
495 CAP_PROP_XI_CC_MATRIX_12 = 485, //!< Color Correction Matrix element [1][2].
496 CAP_PROP_XI_CC_MATRIX_13 = 486, //!< Color Correction Matrix element [1][3].
497 CAP_PROP_XI_CC_MATRIX_20 = 487, //!< Color Correction Matrix element [2][0].
498 CAP_PROP_XI_CC_MATRIX_21 = 488, //!< Color Correction Matrix element [2][1].
499 CAP_PROP_XI_CC_MATRIX_22 = 489, //!< Color Correction Matrix element [2][2].
500 CAP_PROP_XI_CC_MATRIX_23 = 490, //!< Color Correction Matrix element [2][3].
501 CAP_PROP_XI_CC_MATRIX_30 = 491, //!< Color Correction Matrix element [3][0].
502 CAP_PROP_XI_CC_MATRIX_31 = 492, //!< Color Correction Matrix element [3][1].
503 CAP_PROP_XI_CC_MATRIX_32 = 493, //!< Color Correction Matrix element [3][2].
504 CAP_PROP_XI_CC_MATRIX_33 = 494, //!< Color Correction Matrix element [3][3].
505 CAP_PROP_XI_DEFAULT_CC_MATRIX = 495, //!< Set default Color Correction Matrix.
506 CAP_PROP_XI_TRG_SELECTOR = 498, //!< Selects the type of trigger.
507 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.
508 CAP_PROP_XI_DEBOUNCE_EN = 507, //!< Enable/Disable debounce to selected GPI.
509 CAP_PROP_XI_DEBOUNCE_T0 = 508, //!< Debounce time (x * 10us).
510 CAP_PROP_XI_DEBOUNCE_T1 = 509, //!< Debounce time (x * 10us).
511 CAP_PROP_XI_DEBOUNCE_POL = 510, //!< Debounce polarity (pol = 1 t0 - falling edge, t1 - rising edge).
512 CAP_PROP_XI_LENS_MODE = 511, //!< Status of lens control interface. This shall be set to XI_ON before any Lens operations.
513 CAP_PROP_XI_LENS_APERTURE_VALUE = 512, //!< Current lens aperture value in stops. Examples: 2.8, 4, 5.6, 8, 11.
514 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.
515 CAP_PROP_XI_LENS_FOCUS_MOVE = 514, //!< Moves lens focus motor by steps set in XI_PRM_LENS_FOCUS_MOVEMENT_VALUE.
516 CAP_PROP_XI_LENS_FOCUS_DISTANCE = 515, //!< Lens focus distance in cm.
517 CAP_PROP_XI_LENS_FOCAL_LENGTH = 516, //!< Lens focal distance in mm.
518 CAP_PROP_XI_LENS_FEATURE_SELECTOR = 517, //!< Selects the current feature which is accessible by XI_PRM_LENS_FEATURE.
519 CAP_PROP_XI_LENS_FEATURE = 518, //!< Allows access to lens feature value currently selected by XI_PRM_LENS_FEATURE_SELECTOR.
520 CAP_PROP_XI_DEVICE_MODEL_ID = 521, //!< Returns device model id.
521 CAP_PROP_XI_DEVICE_SN = 522, //!< Returns device serial number.
522 CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA = 529, //!< The alpha channel of RGB32 output image format.
523 CAP_PROP_XI_IMAGE_PAYLOAD_SIZE = 530, //!< Buffer size in bytes sufficient for output image returned by xiGetImage.
524 CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT = 531, //!< Current format of pixels on transport layer.
525 CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ = 532, //!< Sensor clock frequency in Hz.
526 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.
527 CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT = 534, //!< Number of output channels from sensor used for data transfer.
528 CAP_PROP_XI_FRAMERATE = 535, //!< Define framerate in Hz.
529 CAP_PROP_XI_COUNTER_SELECTOR = 536, //!< Select counter.
530 CAP_PROP_XI_COUNTER_VALUE = 537, //!< Counter status.
531 CAP_PROP_XI_ACQ_TIMING_MODE = 538, //!< Type of sensor frames timing.
532 CAP_PROP_XI_AVAILABLE_BANDWIDTH = 539, //!< Calculate and returns available interface bandwidth(int Megabits).
533 CAP_PROP_XI_BUFFER_POLICY = 540, //!< Data move policy.
534 CAP_PROP_XI_LUT_EN = 541, //!< Activates LUT.
535 CAP_PROP_XI_LUT_INDEX = 542, //!< Control the index (offset) of the coefficient to access in the LUT.
536 CAP_PROP_XI_LUT_VALUE = 543, //!< Value at entry LUTIndex of the LUT.
537 CAP_PROP_XI_TRG_DELAY = 544, //!< Specifies the delay in microseconds (us) to apply after the trigger reception before activating it.
538 CAP_PROP_XI_TS_RST_MODE = 545, //!< Defines how time stamp reset engine will be armed.
539 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).
540 CAP_PROP_XI_IS_DEVICE_EXIST = 547, //!< Returns 1 if camera connected and works properly.
541 CAP_PROP_XI_ACQ_BUFFER_SIZE = 548, //!< Acquisition buffer size in buffer_size_unit. Default bytes.
542 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.
543 CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE = 550, //!< Acquisition transport buffer size in bytes.
544 CAP_PROP_XI_BUFFERS_QUEUE_SIZE = 551, //!< Queue of field/frame buffers.
545 CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT = 552, //!< Number of buffers to commit to low level.
546 CAP_PROP_XI_RECENT_FRAME = 553, //!< GetImage returns most recent frame.
547 CAP_PROP_XI_DEVICE_RESET = 554, //!< Resets the camera to default state.
548 CAP_PROP_XI_COLUMN_FPN_CORRECTION = 555, //!< Correction of column FPN.
549 CAP_PROP_XI_ROW_FPN_CORRECTION = 591, //!< Correction of row FPN.
550 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.
551 CAP_PROP_XI_HDR = 559, //!< Enable High Dynamic Range feature.
552 CAP_PROP_XI_HDR_KNEEPOINT_COUNT = 560, //!< The number of kneepoints in the PWLR.
553 CAP_PROP_XI_HDR_T1 = 561, //!< Position of first kneepoint(in % of XI_PRM_EXPOSURE).
554 CAP_PROP_XI_HDR_T2 = 562, //!< Position of second kneepoint (in % of XI_PRM_EXPOSURE).
555 CAP_PROP_XI_KNEEPOINT1 = 563, //!< Value of first kneepoint (% of sensor saturation).
556 CAP_PROP_XI_KNEEPOINT2 = 564, //!< Value of second kneepoint (% of sensor saturation).
557 CAP_PROP_XI_IMAGE_BLACK_LEVEL = 565, //!< Last image black level counts. Can be used for Offline processing to recall it.
558 CAP_PROP_XI_HW_REVISION = 571, //!< Returns hardware revision number.
559 CAP_PROP_XI_DEBUG_LEVEL = 572, //!< Set debug level.
560 CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION = 573, //!< Automatic bandwidth calculation.
561 CAP_PROP_XI_FFS_FILE_ID = 594, //!< File number.
562 CAP_PROP_XI_FFS_FILE_SIZE = 580, //!< Size of file.
563 CAP_PROP_XI_FREE_FFS_SIZE = 581, //!< Size of free camera FFS.
564 CAP_PROP_XI_USED_FFS_SIZE = 582, //!< Size of used camera FFS.
565 CAP_PROP_XI_FFS_ACCESS_KEY = 583, //!< Setting of key enables file operations on some cameras.
566 CAP_PROP_XI_SENSOR_FEATURE_SELECTOR = 585, //!< Selects the current feature which is accessible by XI_PRM_SENSOR_FEATURE_VALUE.
567 CAP_PROP_XI_SENSOR_FEATURE_VALUE = 586, //!< Allows access to sensor feature value currently selected by XI_PRM_SENSOR_FEATURE_SELECTOR.
568 };
569
570//! @} XIMEA
571
572
573/** @name ARAVIS Camera API
574 @{
575*/
576
577//! Properties of cameras available through ARAVIS backend
578enum { CAP_PROP_ARAVIS_AUTOTRIGGER = 600 //!< Automatically trigger frame capture if camera is configured with software trigger
579};
580
581//! @} ARAVIS
582
583
584/** @name Android
585 @{
586*/
587
588//! Properties of cameras available through NDK Camera API backend
589enum { CAP_PROP_ANDROID_DEVICE_TORCH = 8001,
590 };
591
592//! @} Android
593
594
595/** @name AVFoundation framework for iOS
596 @{
597*/
598
599//! Properties of cameras available through AVFOUNDATION backend
600enum { CAP_PROP_IOS_DEVICE_FOCUS = 9001,
601 CAP_PROP_IOS_DEVICE_EXPOSURE = 9002,
602 CAP_PROP_IOS_DEVICE_FLASH = 9003,
603 CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004,
604 CAP_PROP_IOS_DEVICE_TORCH = 9005
605 };
606
607//! @} AVFoundation framework for iOS
608
609
610/** @name Smartek Giganetix GigEVisionSDK
611 @{
612*/
613
614//! Properties of cameras available through Smartek Giganetix Ethernet Vision backend
615/* --- Vladimir Litvinenko (litvinenko.vladimir@gmail.com) --- */
616enum { CAP_PROP_GIGA_FRAME_OFFSET_X = 10001,
617 CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002,
618 CAP_PROP_GIGA_FRAME_WIDTH_MAX = 10003,
619 CAP_PROP_GIGA_FRAME_HEIGH_MAX = 10004,
620 CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005,
621 CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006
622 };
623
624//! @} Smartek
625
626/** @name Intel Perceptual Computing SDK
627 @{
628*/
629enum { CAP_PROP_INTELPERC_PROFILE_COUNT = 11001,
630 CAP_PROP_INTELPERC_PROFILE_IDX = 11002,
631 CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE = 11003,
632 CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE = 11004,
633 CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD = 11005,
634 CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ = 11006,
635 CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT = 11007
636 };
637
638//! Intel Perceptual Streams
639enum { CAP_INTELPERC_DEPTH_GENERATOR = 1 << 29,
640 CAP_INTELPERC_IMAGE_GENERATOR = 1 << 28,
641 CAP_INTELPERC_IR_GENERATOR = 1 << 27,
642 CAP_INTELPERC_GENERATORS_MASK = CAP_INTELPERC_DEPTH_GENERATOR + CAP_INTELPERC_IMAGE_GENERATOR + CAP_INTELPERC_IR_GENERATOR
643 };
644
645enum { 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.
646 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.
647 CAP_INTELPERC_IR_MAP = 2, //!< Each pixel is a 16-bit integer. The value indicates the intensity of the reflected laser beam.
648 CAP_INTELPERC_IMAGE = 3
649 };
650
651//! @} Intel Perceptual
652
653/** @name gPhoto2 connection
654 @{
655*/
656
657/** @brief gPhoto2 properties
658
659If `propertyId` is less than 0 then work on widget with that __additive inversed__ camera setting ID
660Get IDs by using CAP_PROP_GPHOTO2_WIDGET_ENUMERATE.
661@see CvCaptureCAM_GPHOTO2 for more info
662*/
663enum { CAP_PROP_GPHOTO2_PREVIEW = 17001, //!< Capture only preview from liveview mode.
664 CAP_PROP_GPHOTO2_WIDGET_ENUMERATE = 17002, //!< Readonly, returns (const char *).
665 CAP_PROP_GPHOTO2_RELOAD_CONFIG = 17003, //!< Trigger, only by set. Reload camera settings.
666 CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE = 17004, //!< Reload all settings on set.
667 CAP_PROP_GPHOTO2_COLLECT_MSGS = 17005, //!< Collect messages with details.
668 CAP_PROP_GPHOTO2_FLUSH_MSGS = 17006, //!< Readonly, returns (const char *).
669 CAP_PROP_SPEED = 17007, //!< Exposure speed. Can be readonly, depends on camera program.
670 CAP_PROP_APERTURE = 17008, //!< Aperture. Can be readonly, depends on camera program.
671 CAP_PROP_EXPOSUREPROGRAM = 17009, //!< Camera exposure program.
672 CAP_PROP_VIEWFINDER = 17010 //!< Enter liveview mode.
673 };
674
675//! @} gPhoto2
676
677
678/** @name Images backend
679 @{
680*/
681
682/** @brief Images backend properties
683
684*/
685enum { CAP_PROP_IMAGES_BASE = 18000,
686 CAP_PROP_IMAGES_LAST = 19000 // excluding
687 };
688
689//! @} Images
690
691/** @name OBSENSOR (for Orbbec 3D-Sensor device/module )
692 @{
693*/
694//! OBSENSOR data given from image generator
695enum VideoCaptureOBSensorDataType{
696 CAP_OBSENSOR_DEPTH_MAP = 0, //!< Depth values in mm (CV_16UC1)
697 CAP_OBSENSOR_BGR_IMAGE = 1, //!< Data given from BGR stream generator
698 CAP_OBSENSOR_IR_IMAGE = 2 //!< Data given from IR stream generator(CV_16UC1)
699};
700
701//! OBSENSOR stream generator
702enum VideoCaptureOBSensorGenerators{
703 CAP_OBSENSOR_DEPTH_GENERATOR = 1 << 29,
704 CAP_OBSENSOR_IMAGE_GENERATOR = 1 << 28,
705 CAP_OBSENSOR_IR_GENERATOR = 1 << 27,
706 CAP_OBSENSOR_GENERATORS_MASK = CAP_OBSENSOR_DEPTH_GENERATOR + CAP_OBSENSOR_IMAGE_GENERATOR + CAP_OBSENSOR_IR_GENERATOR
707};
708
709//!OBSENSOR properties
710enum VideoCaptureOBSensorProperties{
711 // INTRINSIC
712 CAP_PROP_OBSENSOR_INTRINSIC_FX=26001,
713 CAP_PROP_OBSENSOR_INTRINSIC_FY=26002,
714 CAP_PROP_OBSENSOR_INTRINSIC_CX=26003,
715 CAP_PROP_OBSENSOR_INTRINSIC_CY=26004,
716};
717
718//! @} OBSENSOR
719
720//! @} videoio_flags_others
721
722/** @brief Read data stream interface
723 */
724class CV_EXPORTS_W IStreamReader
725{
726public:
727 virtual ~IStreamReader();
728
729 /** @brief Read bytes from stream */
730 virtual long long read(char* buffer, long long size) = 0;
731
732 /** @brief Sets the stream position
733 *
734 * @param offset Seek offset
735 * @param origin SEEK_SET / SEEK_END / SEEK_CUR
736 *
737 * @see fseek
738 */
739 virtual long long seek(long long offset, int origin) = 0;
740};
741
742class IVideoCapture;
743//! @cond IGNORED
744namespace internal { class VideoCapturePrivateAccessor; }
745//! @endcond IGNORED
746
747/** @brief Class for video capturing from video files, image sequences or cameras.
748
749The class provides C++ API for capturing video from cameras or for reading video files and image sequences.
750
751Here is how the class can be used:
752@include samples/cpp/videocapture_basic.cpp
753
754@note In @ref videoio_c "C API" the black-box structure `CvCapture` is used instead of %VideoCapture.
755@note
756- (C++) A basic sample on using the %VideoCapture interface can be found at
757 `OPENCV_SOURCE_CODE/samples/cpp/videocapture_starter.cpp`
758- (Python) A basic sample on using the %VideoCapture interface can be found at
759 `OPENCV_SOURCE_CODE/samples/python/video.py`
760- (Python) A multi threaded video processing sample can be found at
761 `OPENCV_SOURCE_CODE/samples/python/video_threaded.py`
762- (Python) %VideoCapture sample showcasing some features of the Video4Linux2 backend
763 `OPENCV_SOURCE_CODE/samples/python/video_v4l2.py`
764 */
765class CV_EXPORTS_W VideoCapture
766{
767public:
768 /** @brief Default constructor
769 @note In @ref videoio_c "C API", when you finished working with video, release CvCapture structure with
770 cvReleaseCapture(), or use Ptr\<CvCapture\> that calls cvReleaseCapture() automatically in the
771 destructor.
772 */
773 CV_WRAP VideoCapture();
774
775 /** @overload
776 @brief Opens a video file or a capturing device or an IP video stream for video capturing with API Preference
777
778 @param filename it can be:
779 - name of video file (eg. `video.avi`)
780 - or image sequence (eg. `img_%02d.jpg`, which will read samples like `img_00.jpg, img_01.jpg, img_02.jpg, ...`)
781 - or URL of video stream (eg. `protocol://host:port/script_name?script_params|auth`)
782 - or GStreamer pipeline string in gst-launch tool format in case if GStreamer is used as backend
783 Note that each video stream or IP camera feed has its own URL scheme. Please refer to the
784 documentation of source stream to know the right URL.
785 @param apiPreference preferred Capture API backends to use. Can be used to enforce a specific reader
786 implementation if multiple are available: e.g. cv::CAP_FFMPEG or cv::CAP_IMAGES or cv::CAP_DSHOW.
787
788 @sa cv::VideoCaptureAPIs
789 */
790 CV_WRAP explicit VideoCapture(const String& filename, int apiPreference = CAP_ANY);
791
792 /** @overload
793 @brief Opens a video file or a capturing device or an IP video stream for video capturing with API Preference and parameters
794
795 The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
796 See cv::VideoCaptureProperties
797 */
798 CV_WRAP explicit VideoCapture(const String& filename, int apiPreference, const std::vector<int>& params);
799
800 /** @overload
801 @brief Opens a camera for video capturing
802
803 @param index id of the video capturing device to open. To open default camera using default backend just pass 0.
804 (to backward compatibility usage of camera_id + domain_offset (CAP_*) is valid when apiPreference is CAP_ANY)
805 @param apiPreference preferred Capture API backends to use. Can be used to enforce a specific reader
806 implementation if multiple are available: e.g. cv::CAP_DSHOW or cv::CAP_MSMF or cv::CAP_V4L.
807
808 @sa cv::VideoCaptureAPIs
809 */
810 CV_WRAP explicit VideoCapture(int index, int apiPreference = CAP_ANY);
811
812 /** @overload
813 @brief Opens a camera for video capturing with API Preference and parameters
814
815 The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
816 See cv::VideoCaptureProperties
817 */
818 CV_WRAP explicit VideoCapture(int index, int apiPreference, const std::vector<int>& params);
819
820 /** @overload
821 @brief Opens a video using data stream.
822
823 The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
824 See cv::VideoCaptureProperties
825 */
826 CV_WRAP VideoCapture(const Ptr<IStreamReader>& source, int apiPreference, const std::vector<int>& params);
827
828 /** @brief Default destructor
829
830 The method first calls VideoCapture::release to close the already opened file or camera.
831 */
832 virtual ~VideoCapture();
833
834 /** @brief Opens a video file or a capturing device or an IP video stream for video capturing.
835
836 @overload
837
838 Parameters are same as the constructor VideoCapture(const String& filename, int apiPreference = CAP_ANY)
839 @return `true` if the file has been successfully opened
840
841 The method first calls VideoCapture::release to close the already opened file or camera.
842 */
843 CV_WRAP virtual bool open(const String& filename, int apiPreference = CAP_ANY);
844
845 /** @brief Opens a video file or a capturing device or an IP video stream for video capturing with API Preference and parameters
846
847 @overload
848
849 The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
850 See cv::VideoCaptureProperties
851
852 @return `true` if the file has been successfully opened
853
854 The method first calls VideoCapture::release to close the already opened file or camera.
855 */
856 CV_WRAP virtual bool open(const String& filename, int apiPreference, const std::vector<int>& params);
857
858 /** @brief Opens a camera for video capturing
859
860 @overload
861
862 Parameters are same as the constructor VideoCapture(int index, int apiPreference = CAP_ANY)
863 @return `true` if the camera has been successfully opened.
864
865 The method first calls VideoCapture::release to close the already opened file or camera.
866 */
867 CV_WRAP virtual bool open(int index, int apiPreference = CAP_ANY);
868
869 /** @brief Opens a camera for video capturing with API Preference and parameters
870
871 @overload
872
873 The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
874 See cv::VideoCaptureProperties
875
876 @return `true` if the camera has been successfully opened.
877
878 The method first calls VideoCapture::release to close the already opened file or camera.
879 */
880 CV_WRAP virtual bool open(int index, int apiPreference, const std::vector<int>& params);
881
882 /** @brief Opens a video using data stream.
883
884 @overload
885
886 The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.
887 See cv::VideoCaptureProperties
888
889 @return `true` if the file has been successfully opened
890
891 The method first calls VideoCapture::release to close the already opened file or camera.
892 */
893 CV_WRAP virtual bool open(const Ptr<IStreamReader>& source, int apiPreference, const std::vector<int>& params);
894
895 /** @brief Returns true if video capturing has been initialized already.
896
897 If the previous call to VideoCapture constructor or VideoCapture::open() succeeded, the method returns
898 true.
899 */
900 CV_WRAP virtual bool isOpened() const;
901
902 /** @brief Closes video file or capturing device.
903
904 The method is automatically called by subsequent VideoCapture::open and by VideoCapture
905 destructor.
906
907 The C function also deallocates memory and clears \*capture pointer.
908 */
909 CV_WRAP virtual void release();
910
911 /** @brief Grabs the next frame from video file or capturing device.
912
913 @return `true` (non-zero) in the case of success.
914
915 The method/function grabs the next frame from video file or camera and returns true (non-zero) in
916 the case of success.
917
918 The primary use of the function is in multi-camera environments, especially when the cameras do not
919 have hardware synchronization. That is, you call VideoCapture::grab() for each camera and after that
920 call the slower method VideoCapture::retrieve() to decode and get frame from each camera. This way
921 the overhead on demosaicing or motion jpeg decompression etc. is eliminated and the retrieved frames
922 from different cameras will be closer in time.
923
924 Also, when a connected camera is multi-head (for example, a stereo camera or a Kinect device), the
925 correct way of retrieving data from it is to call VideoCapture::grab() first and then call
926 VideoCapture::retrieve() one or more times with different values of the channel parameter.
927
928 @ref tutorial_kinect_openni
929 */
930 CV_WRAP virtual bool grab();
931
932 /** @brief Decodes and returns the grabbed video frame.
933
934 @param [out] image the video frame is returned here. If no frames has been grabbed the image will be empty.
935 @param flag it could be a frame index or a driver specific flag
936 @return `false` if no frames has been grabbed
937
938 The method decodes and returns the just grabbed frame. If no frames has been grabbed
939 (camera has been disconnected, or there are no more frames in video file), the method returns false
940 and the function returns an empty image (with %cv::Mat, test it with Mat::empty()).
941
942 @sa read()
943
944 @note In @ref videoio_c "C API", functions cvRetrieveFrame() and cv.RetrieveFrame() return image stored inside the video
945 capturing structure. It is not allowed to modify or release the image! You can copy the frame using
946 cvCloneImage and then do whatever you want with the copy.
947 */
948 CV_WRAP virtual bool retrieve(OutputArray image, int flag = 0);
949
950 /** @brief Stream operator to read the next video frame.
951 @sa read()
952 */
953 virtual VideoCapture& operator >> (CV_OUT Mat& image);
954
955 /** @overload
956 @sa read()
957 */
958 virtual VideoCapture& operator >> (CV_OUT UMat& image);
959
960 /** @brief Grabs, decodes and returns the next video frame.
961
962 @param [out] image the video frame is returned here. If no frames has been grabbed the image will be empty.
963 @return `false` if no frames has been grabbed
964
965 The method/function combines VideoCapture::grab() and VideoCapture::retrieve() in one call. This is the
966 most convenient method for reading video files or capturing data from decode and returns the just
967 grabbed frame. If no frames has been grabbed (camera has been disconnected, or there are no more
968 frames in video file), the method returns false and the function returns empty image (with %cv::Mat, test it with Mat::empty()).
969
970 @note In @ref videoio_c "C API", functions cvRetrieveFrame() and cv.RetrieveFrame() return image stored inside the video
971 capturing structure. It is not allowed to modify or release the image! You can copy the frame using
972 cvCloneImage and then do whatever you want with the copy.
973 */
974 CV_WRAP virtual bool read(OutputArray image);
975
976 /** @brief Sets a property in the VideoCapture.
977
978 @param propId Property identifier from cv::VideoCaptureProperties (eg. cv::CAP_PROP_POS_MSEC, cv::CAP_PROP_POS_FRAMES, ...)
979 or one from @ref videoio_flags_others
980 @param value Value of the property.
981 @return `true` if the property is supported by backend used by the VideoCapture instance.
982 @note Even if it returns `true` this doesn't ensure that the property
983 value has been accepted by the capture device. See note in VideoCapture::get()
984 */
985 CV_WRAP virtual bool set(int propId, double value);
986
987 /** @brief Returns the specified VideoCapture property
988
989 @param propId Property identifier from cv::VideoCaptureProperties (eg. cv::CAP_PROP_POS_MSEC, cv::CAP_PROP_POS_FRAMES, ...)
990 or one from @ref videoio_flags_others
991 @return Value for the specified property. Value 0 is returned when querying a property that is
992 not supported by the backend used by the VideoCapture instance.
993
994 @note Reading / writing properties involves many layers. Some unexpected result might happens
995 along this chain.
996 @code{.txt}
997 VideoCapture -> API Backend -> Operating System -> Device Driver -> Device Hardware
998 @endcode
999 The returned value might be different from what really used by the device or it could be encoded
1000 using device dependent rules (eg. steps or percentage). Effective behaviour depends from device
1001 driver and API Backend
1002
1003 */
1004 CV_WRAP virtual double get(int propId) const;
1005
1006 /** @brief Returns used backend API name
1007
1008 @note Stream should be opened.
1009 */
1010 CV_WRAP String getBackendName() const;
1011
1012 /** Switches exceptions mode
1013 *
1014 * methods raise exceptions if not successful instead of returning an error code
1015 */
1016 CV_WRAP void setExceptionMode(bool enable) { throwOnFail = enable; }
1017
1018 /// query if exception mode is active
1019 CV_WRAP bool getExceptionMode() const { return throwOnFail; }
1020
1021
1022 /** @brief Wait for ready frames from VideoCapture.
1023
1024 @param streams input video streams
1025 @param readyIndex stream indexes with grabbed frames (ready to use .retrieve() to fetch actual frame)
1026 @param timeoutNs number of nanoseconds (0 - infinite)
1027 @return `true` if streamReady is not empty
1028
1029 @throws Exception %Exception on stream errors (check .isOpened() to filter out malformed streams) or VideoCapture type is not supported
1030
1031 The primary use of the function is in multi-camera environments.
1032 The method fills the ready state vector, grabs video frame, if camera is ready.
1033
1034 After this call use VideoCapture::retrieve() to decode and fetch frame data.
1035 */
1036 CV_WRAP static
1037 bool waitAny(
1038 const std::vector<VideoCapture>& streams,
1039 CV_OUT std::vector<int>& readyIndex,
1040 int64 timeoutNs = 0);
1041
1042protected:
1043 Ptr<CvCapture> cap;
1044 Ptr<IVideoCapture> icap;
1045 bool throwOnFail;
1046
1047 friend class internal::VideoCapturePrivateAccessor;
1048};
1049
1050class IVideoWriter;
1051
1052/** @example samples/cpp/tutorial_code/videoio/video-write/video-write.cpp
1053Check @ref tutorial_video_write "the corresponding tutorial" for more details
1054*/
1055
1056/** @example samples/cpp/videowriter_basic.cpp
1057An example using VideoCapture and VideoWriter class
1058*/
1059
1060/** @brief Video writer class.
1061
1062The class provides C++ API for writing video files or image sequences.
1063*/
1064class CV_EXPORTS_W VideoWriter
1065{
1066public:
1067 /** @brief Default constructors
1068
1069 The constructors/functions initialize video writers.
1070 - On Linux FFMPEG is used to write videos;
1071 - On Windows FFMPEG or MSWF or DSHOW is used;
1072 - On MacOSX AVFoundation is used.
1073 */
1074 CV_WRAP VideoWriter();
1075
1076 /** @overload
1077 @param filename Name of the output video file.
1078 @param fourcc 4-character code of codec used to compress the frames. For example,
1079 VideoWriter::fourcc('P','I','M','1') is a MPEG-1 codec, VideoWriter::fourcc('M','J','P','G')
1080 is a motion-jpeg codec etc. List of codes can be obtained at
1081 [MSDN](https://docs.microsoft.com/en-us/windows/win32/medfound/video-fourccs) page
1082 or with this [page](https://fourcc.org/codecs.php)
1083 of the fourcc site for a more complete list). FFMPEG backend with MP4 container natively uses
1084 other values as fourcc code: see [ObjectType](http://mp4ra.org/#/codecs),
1085 so you may receive a warning message from OpenCV about fourcc code conversion.
1086 @param fps Framerate of the created video stream.
1087 @param frameSize Size of the video frames.
1088 @param isColor If it is not zero, the encoder will expect and encode color frames, otherwise it
1089 will work with grayscale frames.
1090
1091 @b Tips:
1092 - With some backends `fourcc=-1` pops up the codec selection dialog from the system.
1093 - To save image sequence use a proper filename (eg. `img_%02d.jpg`) and `fourcc=0`
1094 OR `fps=0`. Use uncompressed image format (eg. `img_%02d.BMP`) to save raw frames.
1095 - Most codecs are lossy. If you want lossless video file you need to use a lossless codecs
1096 (eg. FFMPEG FFV1, Huffman HFYU, Lagarith LAGS, etc...)
1097 - If FFMPEG is enabled, using `codec=0; fps=0;` you can create an uncompressed (raw) video file.
1098 - If FFMPEG is used, we allow frames of odd width or height, but in this case we truncate
1099 the rightmost column/the bottom row. Probably, this should be handled more elegantly,
1100 but some internal functions inside FFMPEG swscale require even width/height.
1101 */
1102 CV_WRAP VideoWriter(const String& filename, int fourcc, double fps,
1103 Size frameSize, bool isColor = true);
1104
1105 /** @overload
1106 The `apiPreference` parameter allows to specify API backends to use. Can be used to enforce a specific reader implementation
1107 if multiple are available: e.g. cv::CAP_FFMPEG or cv::CAP_GSTREAMER.
1108 */
1109 CV_WRAP VideoWriter(const String& filename, int apiPreference, int fourcc, double fps,
1110 Size frameSize, bool isColor = true);
1111
1112 /** @overload
1113 * The `params` parameter allows to specify extra encoder parameters encoded as pairs (paramId_1, paramValue_1, paramId_2, paramValue_2, ... .)
1114 * see cv::VideoWriterProperties
1115 */
1116 CV_WRAP VideoWriter(const String& filename, int fourcc, double fps, const Size& frameSize,
1117 const std::vector<int>& params);
1118
1119 /** @overload
1120 */
1121 CV_WRAP VideoWriter(const String& filename, int apiPreference, int fourcc, double fps,
1122 const Size& frameSize, const std::vector<int>& params);
1123
1124 /** @brief Default destructor
1125
1126 The method first calls VideoWriter::release to close the already opened file.
1127 */
1128 virtual ~VideoWriter();
1129
1130 /** @brief Initializes or reinitializes video writer.
1131
1132 The method opens video writer. Parameters are the same as in the constructor
1133 VideoWriter::VideoWriter.
1134 @return `true` if video writer has been successfully initialized
1135
1136 The method first calls VideoWriter::release to close the already opened file.
1137 */
1138 CV_WRAP virtual bool open(const String& filename, int fourcc, double fps,
1139 Size frameSize, bool isColor = true);
1140
1141 /** @overload
1142 */
1143 CV_WRAP bool open(const String& filename, int apiPreference, int fourcc, double fps,
1144 Size frameSize, bool isColor = true);
1145
1146 /** @overload
1147 */
1148 CV_WRAP bool open(const String& filename, int fourcc, double fps, const Size& frameSize,
1149 const std::vector<int>& params);
1150
1151 /** @overload
1152 */
1153 CV_WRAP bool open(const String& filename, int apiPreference, int fourcc, double fps,
1154 const Size& frameSize, const std::vector<int>& params);
1155
1156 /** @brief Returns true if video writer has been successfully initialized.
1157 */
1158 CV_WRAP virtual bool isOpened() const;
1159
1160 /** @brief Closes the video writer.
1161
1162 The method is automatically called by subsequent VideoWriter::open and by the VideoWriter
1163 destructor.
1164 */
1165 CV_WRAP virtual void release();
1166
1167 /** @brief Stream operator to write the next video frame.
1168 @sa write
1169 */
1170 virtual VideoWriter& operator << (const Mat& image);
1171
1172 /** @overload
1173 @sa write
1174 */
1175 virtual VideoWriter& operator << (const UMat& image);
1176
1177 /** @brief Writes the next video frame
1178
1179 @param image The written frame. In general, color images are expected in BGR format.
1180
1181 The function/method writes the specified image to video file. It must have the same size as has
1182 been specified when opening the video writer.
1183 */
1184 CV_WRAP virtual void write(InputArray image);
1185
1186 /** @brief Sets a property in the VideoWriter.
1187
1188 @param propId Property identifier from cv::VideoWriterProperties (eg. cv::VIDEOWRITER_PROP_QUALITY)
1189 or one of @ref videoio_flags_others
1190
1191 @param value Value of the property.
1192 @return `true` if the property is supported by the backend used by the VideoWriter instance.
1193 */
1194 CV_WRAP virtual bool set(int propId, double value);
1195
1196 /** @brief Returns the specified VideoWriter property
1197
1198 @param propId Property identifier from cv::VideoWriterProperties (eg. cv::VIDEOWRITER_PROP_QUALITY)
1199 or one of @ref videoio_flags_others
1200
1201 @return Value for the specified property. Value 0 is returned when querying a property that is
1202 not supported by the backend used by the VideoWriter instance.
1203 */
1204 CV_WRAP virtual double get(int propId) const;
1205
1206 /** @brief Concatenates 4 chars to a fourcc code
1207
1208 @return a fourcc code
1209
1210 This static method constructs the fourcc code of the codec to be used in the constructor
1211 VideoWriter::VideoWriter or VideoWriter::open.
1212 */
1213 CV_WRAP static int fourcc(char c1, char c2, char c3, char c4);
1214
1215 /** @brief Returns used backend API name
1216
1217 @note Stream should be opened.
1218 */
1219 CV_WRAP String getBackendName() const;
1220
1221protected:
1222 Ptr<CvVideoWriter> writer;
1223 Ptr<IVideoWriter> iwriter;
1224
1225 static Ptr<IVideoWriter> create(const String& filename, int fourcc, double fps,
1226 Size frameSize, bool isColor = true);
1227};
1228
1229//! @cond IGNORED
1230template<> struct DefaultDeleter<CvCapture>{ CV_EXPORTS void operator ()(CvCapture* obj) const; };
1231template<> struct DefaultDeleter<CvVideoWriter>{ CV_EXPORTS void operator ()(CvVideoWriter* obj) const; };
1232//! @endcond IGNORED
1233
1234//! @} videoio
1235
1236} // cv
1237
1238#endif //OPENCV_VIDEOIO_HPP
1239

Provided by KDAB

Privacy Policy
Improve your Profiling and Debugging skills
Find out more

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