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