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