mirror of
https://github.com/opencv/opencv.git
synced 2025-06-06 00:43:52 +08:00
videoio: drop obsolete backends
- VFW - QuickTime/QtKit - Unicap - GPL, no active support: https://github.com/unicap/unicap - DC1394 (1st version) / CMU1394
This commit is contained in:
Alexander Alekhin
parent
b17e1531d2
commit
5869415a57
@ -229,7 +229,6 @@ OCV_OPTION(WITH_CUFFT "Include NVidia Cuda Fast Fourier Transform (FFT)
|
||||
OCV_OPTION(WITH_CUBLAS "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" ON IF (NOT IOS AND NOT WINRT) )
|
||||
OCV_OPTION(WITH_NVCUVID "Include NVidia Video Decoding library support" ON IF (NOT IOS AND NOT APPLE) )
|
||||
OCV_OPTION(WITH_EIGEN "Include Eigen2/Eigen3 support" (NOT CV_DISABLE_OPTIMIZATION) IF (NOT WINRT AND NOT CMAKE_CROSSCOMPILING) )
|
||||
OCV_OPTION(WITH_VFW "Include Video for Windows support" ON IF WIN32 )
|
||||
OCV_OPTION(WITH_FFMPEG "Include FFMPEG support" ON IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
|
||||
OCV_OPTION(WITH_GSTREAMER "Include Gstreamer support" ON IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
|
||||
OCV_OPTION(WITH_GSTREAMER_0_10 "Enable Gstreamer 0.10 support (instead of 1.x)" OFF )
|
||||
@ -254,14 +253,11 @@ OCV_OPTION(WITH_GIGEAPI "Include Smartek GigE support" OFF
|
||||
OCV_OPTION(WITH_ARAVIS "Include Aravis GigE support" OFF IF (NOT ANDROID AND NOT IOS AND NOT WINRT AND NOT WIN32) )
|
||||
OCV_OPTION(WITH_QT "Build with Qt Backend support" OFF IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
|
||||
OCV_OPTION(WITH_WIN32UI "Build with Win32 UI Backend support" ON IF WIN32 AND NOT WINRT)
|
||||
OCV_OPTION(WITH_QUICKTIME "Use QuickTime for Video I/O (OBSOLETE)" OFF IF APPLE )
|
||||
OCV_OPTION(WITH_QTKIT "Use QTKit Video I/O backend" OFF IF APPLE )
|
||||
OCV_OPTION(WITH_TBB "Include Intel TBB support" OFF IF (NOT IOS AND NOT WINRT) )
|
||||
OCV_OPTION(WITH_HPX "Include Ste||ar Group HPX support" OFF)
|
||||
OCV_OPTION(WITH_OPENMP "Include OpenMP support" OFF)
|
||||
OCV_OPTION(WITH_PTHREADS_PF "Use pthreads-based parallel_for" ON IF (NOT WIN32 OR MINGW) )
|
||||
OCV_OPTION(WITH_TIFF "Include TIFF support" ON IF (NOT IOS) )
|
||||
OCV_OPTION(WITH_UNICAP "Include Unicap support (GPL)" OFF IF (UNIX AND NOT APPLE AND NOT ANDROID) )
|
||||
OCV_OPTION(WITH_V4L "Include Video 4 Linux support" ON IF (UNIX AND NOT ANDROID AND NOT APPLE) )
|
||||
OCV_OPTION(WITH_LIBV4L "Use libv4l for Video 4 Linux support" OFF IF (UNIX AND NOT ANDROID AND NOT APPLE) )
|
||||
OCV_OPTION(WITH_DSHOW "Build VideoIO with DirectShow support" ON IF (WIN32 AND NOT ARM AND NOT WINRT) )
|
||||
@ -1250,15 +1246,9 @@ endif()
|
||||
status("")
|
||||
status(" Video I/O:")
|
||||
|
||||
if(WITH_VFW OR HAVE_VFW)
|
||||
status(" Video for Windows:" HAVE_VFW THEN YES ELSE NO)
|
||||
endif()
|
||||
|
||||
if(WITH_1394 OR HAVE_DC1394)
|
||||
if(WITH_1394 OR HAVE_DC1394_2)
|
||||
if (HAVE_DC1394_2)
|
||||
status(" DC1394:" "YES (ver ${ALIASOF_libdc1394-2_VERSION})")
|
||||
elseif (HAVE_DC1394)
|
||||
status(" DC1394:" "YES (ver ${ALIASOF_libdc1394_VERSION})")
|
||||
else()
|
||||
status(" DC1394:" "NO")
|
||||
endif()
|
||||
@ -1316,14 +1306,6 @@ if(APPLE)
|
||||
if(WITH_QUICKTIME OR HAVE_QUICKTIME)
|
||||
status(" QuickTime:" HAVE_QUICKTIME THEN YES ELSE NO)
|
||||
endif()
|
||||
if(WITH_QTKIT OR HAVE_QTKIT)
|
||||
status(" QTKit:" HAVE_QTKIT THEN "YES (deprecated)" ELSE NO)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(WITH_UNICAP OR HAVE_UNICAP)
|
||||
status(" UniCap:" HAVE_UNICAP THEN "YES (ver ${ALIASOF_libunicap_VERSION})" ELSE NO)
|
||||
status(" UniCap ucil:" HAVE_UNICAP_UCIL THEN "YES (ver ${ALIASOF_libucil_VERSION})" ELSE NO)
|
||||
endif()
|
||||
|
||||
if(WITH_V4L OR WITH_LIBV4L OR HAVE_LIBV4L OR HAVE_CAMV4L OR HAVE_CAMV4L2 OR HAVE_VIDEOIO)
|
||||
|
||||
@ -2,14 +2,6 @@
|
||||
# Detect 3rd-party video IO libraries
|
||||
# ----------------------------------------------------------------------------
|
||||
|
||||
ocv_clear_vars(HAVE_VFW)
|
||||
if(WITH_VFW)
|
||||
try_compile(HAVE_VFW
|
||||
"${OpenCV_BINARY_DIR}"
|
||||
"${OpenCV_SOURCE_DIR}/cmake/checks/vfwtest.cpp"
|
||||
CMAKE_FLAGS "-DLINK_LIBRARIES:STRING=vfw32")
|
||||
endif(WITH_VFW)
|
||||
|
||||
# --- GStreamer ---
|
||||
ocv_clear_vars(HAVE_GSTREAMER)
|
||||
# try to find gstreamer 1.x first if 0.10 was not requested
|
||||
@ -62,16 +54,6 @@ if(WITH_GSTREAMER AND NOT HAVE_GSTREAMER OR WITH_GSTREAMER_0_10)
|
||||
endif()
|
||||
endif(WITH_GSTREAMER AND NOT HAVE_GSTREAMER OR WITH_GSTREAMER_0_10)
|
||||
|
||||
# --- unicap ---
|
||||
ocv_clear_vars(HAVE_UNICAP)
|
||||
if(WITH_UNICAP)
|
||||
CHECK_MODULE(libunicap HAVE_UNICAP_ VIDEOIO)
|
||||
CHECK_MODULE(libucil HAVE_UNICAP_UCIL VIDEOIO)
|
||||
if(HAVE_UNICAP_ AND HAVE_UNICAP_UCIL)
|
||||
set(HAVE_UNICAP TRUE)
|
||||
endif()
|
||||
endif(WITH_UNICAP)
|
||||
|
||||
# --- PvApi ---
|
||||
ocv_clear_vars(HAVE_PVAPI)
|
||||
if(WITH_PVAPI)
|
||||
@ -286,12 +268,8 @@ endif(WITH_MSMF)
|
||||
# --- Extra HighGUI and VideoIO libs on Windows ---
|
||||
if(WIN32)
|
||||
list(APPEND HIGHGUI_LIBRARIES comctl32 gdi32 ole32 setupapi ws2_32)
|
||||
if(HAVE_VFW)
|
||||
list(APPEND VIDEOIO_LIBRARIES vfw32)
|
||||
endif()
|
||||
if(MINGW64)
|
||||
list(APPEND VIDEOIO_LIBRARIES avifil32 avicap32 winmm msvfw32)
|
||||
list(REMOVE_ITEM VIDEOIO_LIBRARIES vfw32)
|
||||
elseif(MINGW)
|
||||
list(APPEND VIDEOIO_LIBRARIES winmm)
|
||||
endif()
|
||||
@ -301,13 +279,6 @@ if(APPLE)
|
||||
if(WITH_AVFOUNDATION)
|
||||
set(HAVE_AVFOUNDATION YES)
|
||||
endif()
|
||||
if(NOT IOS)
|
||||
if(WITH_QUICKTIME)
|
||||
set(HAVE_QUICKTIME YES)
|
||||
elseif(WITH_QTKIT)
|
||||
set(HAVE_QTKIT YES)
|
||||
endif()
|
||||
endif()
|
||||
endif(APPLE)
|
||||
|
||||
# --- Intel librealsense ---
|
||||
|
||||
@ -1,10 +0,0 @@
|
||||
|
||||
#include <windows.h>
|
||||
#include <vfw.h>
|
||||
|
||||
int main()
|
||||
{
|
||||
AVIFileInit();
|
||||
AVIFileExit();
|
||||
return 0;
|
||||
}
|
||||
@ -166,12 +166,6 @@
|
||||
/* Qt OpenGL support */
|
||||
#cmakedefine HAVE_QT_OPENGL
|
||||
|
||||
/* QuickTime video libraries */
|
||||
#cmakedefine HAVE_QUICKTIME
|
||||
|
||||
/* QTKit video libraries */
|
||||
#cmakedefine HAVE_QTKIT
|
||||
|
||||
/* Intel Threading Building Blocks */
|
||||
#cmakedefine HAVE_TBB
|
||||
|
||||
@ -181,12 +175,6 @@
|
||||
/* TIFF codec */
|
||||
#cmakedefine HAVE_TIFF
|
||||
|
||||
/* Unicap video capture library */
|
||||
#cmakedefine HAVE_UNICAP
|
||||
|
||||
/* Video for Windows support */
|
||||
#cmakedefine HAVE_VFW
|
||||
|
||||
/* V4L2 capturing support in videoio.h */
|
||||
#cmakedefine HAVE_VIDEOIO
|
||||
|
||||
@ -226,8 +214,6 @@
|
||||
|
||||
#if defined(HAVE_XINE) || \
|
||||
defined(HAVE_GSTREAMER) || \
|
||||
defined(HAVE_QUICKTIME) || \
|
||||
defined(HAVE_QTKIT) || \
|
||||
defined(HAVE_AVFOUNDATION) || \
|
||||
/*defined(HAVE_OPENNI) || too specialized */ \
|
||||
defined(HAVE_FFMPEG) || \
|
||||
@ -237,8 +223,6 @@
|
||||
|
||||
#if /*defined(HAVE_XINE) || */\
|
||||
defined(HAVE_GSTREAMER) || \
|
||||
defined(HAVE_QUICKTIME) || \
|
||||
defined(HAVE_QTKIT) || \
|
||||
defined(HAVE_AVFOUNDATION) || \
|
||||
defined(HAVE_FFMPEG) || \
|
||||
defined(HAVE_MSMF)
|
||||
|
||||
@ -73,10 +73,6 @@ if(HAVE_MFX)
|
||||
list(APPEND VIDEOIO_LIBRARIES mfx)
|
||||
endif()
|
||||
|
||||
if(WIN32 AND NOT ARM)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_cmu.cpp)
|
||||
endif()
|
||||
|
||||
if (WIN32 AND HAVE_DSHOW)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_dshow.cpp)
|
||||
list(APPEND videoio_hdrs ${CMAKE_CURRENT_LIST_DIR}/src/cap_dshow.hpp)
|
||||
@ -93,10 +89,6 @@ if (WIN32 AND HAVE_MSMF)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if (WIN32 AND HAVE_VFW)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_vfw.cpp)
|
||||
endif()
|
||||
|
||||
if(HAVE_XINE)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_xine.cpp)
|
||||
endif(HAVE_XINE)
|
||||
@ -105,10 +97,6 @@ if(HAVE_DC1394_2)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_dc1394_v2.cpp)
|
||||
endif(HAVE_DC1394_2)
|
||||
|
||||
if(HAVE_DC1394)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_dc1394.cpp)
|
||||
endif(HAVE_DC1394)
|
||||
|
||||
if(HAVE_GSTREAMER)
|
||||
IF(WIN32)
|
||||
INCLUDE_DIRECTORIES(${GSTREAMER_INCLUDE_DIR})
|
||||
@ -117,10 +105,6 @@ if(HAVE_GSTREAMER)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_gstreamer.cpp)
|
||||
endif(HAVE_GSTREAMER)
|
||||
|
||||
if(HAVE_UNICAP)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_unicap.cpp)
|
||||
endif(HAVE_UNICAP)
|
||||
|
||||
if(HAVE_LIBV4L)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_libv4l.cpp)
|
||||
elseif(HAVE_CAMV4L2 OR HAVE_VIDEOIO)
|
||||
@ -206,14 +190,6 @@ if(HAVE_AVFOUNDATION)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(HAVE_QUICKTIME)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_qt.cpp)
|
||||
list(APPEND VIDEOIO_LIBRARIES "-framework Carbon" "-framework QuickTime" "-framework CoreFoundation" "-framework QuartzCore")
|
||||
elseif(HAVE_QTKIT)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_qtkit.mm)
|
||||
list(APPEND VIDEOIO_LIBRARIES "-framework QTKit" "-framework QuartzCore" "-framework AppKit")
|
||||
endif()
|
||||
|
||||
if(HAVE_INTELPERC)
|
||||
list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_intelperc.cpp)
|
||||
ocv_include_directories(${INTELPERC_INCLUDE_DIR})
|
||||
|
||||
@ -15,7 +15,7 @@ I/O APIs used as backend.
|
||||
|
||||
|
||||
|
||||
Some backends such as (DSHOW) Direct Show, Video For Windows (VFW), Microsoft Media Foundation (MSMF),
|
||||
Some backends such as (DSHOW) Direct Show, Microsoft Media Foundation (MSMF),
|
||||
Video 4 Linux (V4L), etc... are interfaces to the video I/O library provided by the operating system.
|
||||
|
||||
Some others backends like OpenNI2 for Kinect, Intel Perceptual Computing SDK, GStreamer,
|
||||
@ -62,11 +62,11 @@ cap.open(filename, cv::CAP_DSHOW);
|
||||
Backends are available only if they have been built with your OpenCV binaries.
|
||||
|
||||
Check in `opencv2/cvconfig.h` to know which APIs are currently available
|
||||
(e.g. `HAVE_MSMF, HAVE_VFW, HAVE_LIBV4L`, etc...).
|
||||
(e.g. `HAVE_MSMF, HAVE_V4L2`, etc...).
|
||||
|
||||
To enable/disable APIs, you have to:
|
||||
1. re-configure OpenCV using appropriates CMake switches
|
||||
(e.g. `-DWITH_MSMF=ON -DWITH_VFW=ON ... `) or checking related switch in cmake-gui
|
||||
(e.g. `-DWITH_MSMF=ON -DWITH_DSHOW=ON ... `) or checking related switch in cmake-gui
|
||||
2. rebuild OpenCV itself
|
||||
|
||||
#### Use 3rd party drivers or cameras
|
||||
|
||||
@ -88,16 +88,16 @@ See @ref videoio_overview for more information.
|
||||
*/
|
||||
enum VideoCaptureAPIs {
|
||||
CAP_ANY = 0, //!< Auto detect == 0
|
||||
CAP_VFW = 200, //!< Video For Windows (platform native)
|
||||
CAP_VFW = 200, //!< Video For Windows (obsolete, removed)
|
||||
CAP_V4L = 200, //!< V4L/V4L2 capturing support via libv4l
|
||||
CAP_V4L2 = CAP_V4L, //!< Same as CAP_V4L
|
||||
CAP_FIREWIRE = 300, //!< IEEE 1394 drivers
|
||||
CAP_FIREWARE = CAP_FIREWIRE, //!< Same as CAP_FIREWIRE
|
||||
CAP_IEEE1394 = CAP_FIREWIRE, //!< Same as CAP_FIREWIRE
|
||||
CAP_DC1394 = CAP_FIREWIRE, //!< Same as CAP_FIREWIRE
|
||||
CAP_CMU1394 = CAP_FIREWIRE, //!< Same as CAP_FIREWIRE
|
||||
CAP_QT = 500, //!< QuickTime
|
||||
CAP_UNICAP = 600, //!< Unicap drivers
|
||||
CAP_FIREWARE = CAP_FIREWIRE, //!< Same value as CAP_FIREWIRE
|
||||
CAP_IEEE1394 = CAP_FIREWIRE, //!< Same value as CAP_FIREWIRE
|
||||
CAP_DC1394 = CAP_FIREWIRE, //!< Same value as CAP_FIREWIRE
|
||||
CAP_CMU1394 = CAP_FIREWIRE, //!< Same value as CAP_FIREWIRE
|
||||
CAP_QT = 500, //!< QuickTime (obsolete, removed)
|
||||
CAP_UNICAP = 600, //!< Unicap drivers (obsolete, removed)
|
||||
CAP_DSHOW = 700, //!< DirectShow (via videoInput)
|
||||
CAP_PVAPI = 800, //!< PvAPI, Prosilica GigE SDK
|
||||
CAP_OPENNI = 900, //!< OpenNI (for Kinect)
|
||||
@ -815,8 +815,8 @@ public:
|
||||
|
||||
The constructors/functions initialize video writers.
|
||||
- On Linux FFMPEG is used to write videos;
|
||||
- On Windows FFMPEG or VFW is used;
|
||||
- On MacOSX QTKit is used.
|
||||
- On Windows FFMPEG or MSWF or DSHOW is used;
|
||||
- On MacOSX AVFoundation is used.
|
||||
*/
|
||||
CV_WRAP VideoWriter();
|
||||
|
||||
|
||||
@ -29,7 +29,7 @@ PERF_TEST_P(VideoWriter_Writing, WriteFrame,
|
||||
const string filename = getDataPath(get<0>(GetParam()));
|
||||
const bool isColor = get<1>(GetParam());
|
||||
Mat image = imread(filename, isColor ? IMREAD_COLOR : IMREAD_GRAYSCALE );
|
||||
#if defined(HAVE_MSMF) && !defined(HAVE_VFW) && !defined(HAVE_FFMPEG) // VFW has greater priority
|
||||
#if defined(HAVE_MSMF) && !defined(HAVE_FFMPEG)
|
||||
const string outfile = cv::tempfile(".wmv");
|
||||
const int fourcc = VideoWriter::fourcc('W', 'M', 'V', '3');
|
||||
#else
|
||||
|
||||
@ -1,551 +0,0 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// Intel License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000, Intel Corporation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of Intel Corporation may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
|
||||
#ifdef _WIN32
|
||||
|
||||
/****************** Capturing video from camera via CMU lib *******************/
|
||||
|
||||
#ifdef HAVE_CMU1394
|
||||
|
||||
// This firewire capability added by Philip Gruebele (pgruebele@cox.net).
|
||||
// For this to work you need to install the CMU firewire DCAM drivers,
|
||||
// located at http://www-2.cs.cmu.edu/~iwan/1394/.
|
||||
#include "1394camera.h"
|
||||
|
||||
class CvCaptureCAM_CMU : public CvCapture
|
||||
{
|
||||
public:
|
||||
CvCaptureCAM_CMU()
|
||||
{
|
||||
index = -1;
|
||||
image = 0;
|
||||
}
|
||||
|
||||
virtual ~CvCaptureCAM_CMU()
|
||||
{
|
||||
close();
|
||||
}
|
||||
|
||||
virtual bool open(int cameraId);
|
||||
virtual void close();
|
||||
virtual double getProperty(int) const CV_OVERRIDE;
|
||||
virtual bool setProperty(int, double) CV_OVERRIDE;
|
||||
virtual bool grabFrame() CV_OVERRIDE;
|
||||
virtual IplImage* retrieveFrame(int) CV_OVERRIDE;
|
||||
|
||||
protected:
|
||||
C1394Camera* camera();
|
||||
CvSize getSize();
|
||||
int getDepth();
|
||||
int getNChannels();
|
||||
|
||||
bool setVideoSize(int, int);
|
||||
bool setMode(int mode);
|
||||
bool setFrameRate(int rate);
|
||||
bool setFormat(int format);
|
||||
|
||||
int fps; // 0-5
|
||||
int mode; // 0-7
|
||||
int format; // 0-2, 7 ?
|
||||
int index;
|
||||
IplImage* image;
|
||||
};
|
||||
|
||||
// CMU 1394 camera stuff.
|
||||
// This firewire capability added by Philip Gruebele (pgruebele@cox.net)
|
||||
// and modified by Roman Stanchak (rstanchak@yahoo.com).
|
||||
// For this to work you need to install the CMU firewire DCAM drivers,
|
||||
// located at http://www-2.cs.cmu.edu/~iwan/1394/.
|
||||
#define CMU_MAX_CAMERAS 20
|
||||
int CMU_numCameras = 0;
|
||||
int CMU_numActiveCameras = 0;
|
||||
bool CMU_useCameraFlags[CMU_MAX_CAMERAS];
|
||||
C1394Camera *CMU_theCamera = 0;
|
||||
|
||||
// stupid defines for mode, format, FPS
|
||||
#define CV_CAP_IEEE1394_FPS_1_875 0
|
||||
#define CV_CAP_IEEE1394_FPS_3_75 1
|
||||
#define CV_CAP_IEEE1394_FPS_7_5 2
|
||||
#define CV_CAP_IEEE1394_FPS_15 3
|
||||
#define CV_CAP_IEEE1394_FPS_30 4
|
||||
#define CV_CAP_IEEE1394_FPS_60 5
|
||||
|
||||
// index by size, color
|
||||
#define CV_CAP_IEEE1394_COLOR_MONO 0
|
||||
#define CV_CAP_IEEE1394_COLOR_MONO16 1
|
||||
#define CV_CAP_IEEE1394_COLOR_YUV444 2
|
||||
#define CV_CAP_IEEE1394_COLOR_YUV422 3
|
||||
#define CV_CAP_IEEE1394_COLOR_YUV411 4
|
||||
#define CV_CAP_IEEE1394_COLOR_RGB 5
|
||||
|
||||
#define CV_CAP_IEEE1394_SIZE_160X120 0
|
||||
#define CV_CAP_IEEE1394_SIZE_320X240 1
|
||||
#define CV_CAP_IEEE1394_SIZE_640X480 2
|
||||
#define CV_CAP_IEEE1394_SIZE_800X600 3
|
||||
#define CV_CAP_IEEE1394_SIZE_1024X768 4
|
||||
#define CV_CAP_IEEE1394_SIZE_1280X960 5
|
||||
#define CV_CAP_IEEE1394_SIZE_1600X1200 6
|
||||
|
||||
// given color, size, output format
|
||||
// 1 16 444 422 411 RGB
|
||||
static char CV_CAP_IEEE1394_FORMAT[7][6] =
|
||||
{
|
||||
{-1, -1, 0, -1, -1, -1}, // 160x120
|
||||
{-1, -1, -1, 0, -1, -1}, // 320x240
|
||||
{ 0, 0, -1, 0, 0, 0}, // 640x480
|
||||
{ 1, 1, -1, 1, -1, 1}, // 800x600
|
||||
{ 1, 1, -1, 1, -1, 1}, // 1024x768
|
||||
{ 2, 2, -1, 2, -1, 2}, // 1280x960
|
||||
{ 2, 2, -1, 2, -1, 2} // 1600x1200
|
||||
};
|
||||
|
||||
// given color, size, output corresponding mode
|
||||
static char CV_CAP_IEEE1394_MODE[7][6] =
|
||||
{
|
||||
{-1, -1, 0, -1, -1, -1}, // 160x120
|
||||
{-1, -1, -1, 1, -1, -1}, // 320x240
|
||||
{ 5, 6, -1, 3, 2, 4}, // 640x480
|
||||
{ 2, 6, -1, 0, -1, 1}, // 800x600
|
||||
{ 5, 7, -1, 3, -1, 4}, // 1024x768
|
||||
{ 2, 6, -1, 0, -1, 1}, // 1280x960
|
||||
{ 5, 7, -1, 3, -1, 4} // 1600x1200
|
||||
};
|
||||
|
||||
// given format, mode, return COLOR
|
||||
static char CV_CAP_IEEE1394_COLOR[2][8] =
|
||||
{
|
||||
{
|
||||
CV_CAP_IEEE1394_COLOR_YUV444,
|
||||
CV_CAP_IEEE1394_COLOR_YUV422,
|
||||
CV_CAP_IEEE1394_COLOR_YUV411,
|
||||
CV_CAP_IEEE1394_COLOR_YUV422,
|
||||
CV_CAP_IEEE1394_COLOR_RGB,
|
||||
CV_CAP_IEEE1394_COLOR_MONO,
|
||||
CV_CAP_IEEE1394_COLOR_MONO16
|
||||
},
|
||||
{
|
||||
CV_CAP_IEEE1394_COLOR_YUV422,
|
||||
CV_CAP_IEEE1394_COLOR_RGB,
|
||||
CV_CAP_IEEE1394_COLOR_MONO,
|
||||
CV_CAP_IEEE1394_COLOR_YUV422,
|
||||
CV_CAP_IEEE1394_COLOR_RGB,
|
||||
CV_CAP_IEEE1394_COLOR_MONO,
|
||||
CV_CAP_IEEE1394_COLOR_MONO16,
|
||||
CV_CAP_IEEE1394_COLOR_MONO16
|
||||
}
|
||||
};
|
||||
|
||||
// convert frame rate to suitable enum
|
||||
/*static int icvFrameRateToIndex_CMU(double framerate){
|
||||
if(framerate > 30) return CV_CAP_IEEE1394_FPS_60;
|
||||
else if(framerate > 15) return CV_CAP_IEEE1394_FPS_30;
|
||||
else if(framerate > 7.5) return CV_CAP_IEEE1394_FPS_15;
|
||||
else if(framerate > 3.75) return CV_CAP_IEEE1394_FPS_7_5;
|
||||
else if(framerate > 1.875) return CV_CAP_IEEE1394_FPS_3_75;
|
||||
return CV_CAP_IEEE1394_FPS_1_875;
|
||||
}*/
|
||||
|
||||
#if _MSC_VER >= 1200
|
||||
#pragma comment(lib,"1394camera.lib")
|
||||
#endif
|
||||
|
||||
C1394Camera* CvCaptureCAM_CMU::camera()
|
||||
{
|
||||
return CMU_theCamera && index >= 0 ? &CMU_theCamera[index] : 0;
|
||||
}
|
||||
|
||||
// return the size of the image
|
||||
CvSize CvCaptureCAM_CMU::getSize()
|
||||
{
|
||||
C1394Camera* cmucam = camera();
|
||||
unsigned long width = 0, height = 0;
|
||||
cmucam->GetVideoFrameDimensions( &width, &height );
|
||||
return cvSize((int)width, (int)height);
|
||||
}
|
||||
|
||||
// return the opencv depth flag corresponding to the camera format
|
||||
int CvCaptureCAM_CMU::getDepth()
|
||||
{
|
||||
C1394Camera* cmucam = camera();
|
||||
int format = cmucam->GetVideoFormat();
|
||||
int mode = cmucam->GetVideoMode();
|
||||
|
||||
// TODO
|
||||
if( format==7 ) {
|
||||
assert(0);
|
||||
return 1;
|
||||
}
|
||||
// irrelvant to depth
|
||||
if( format > 1 )
|
||||
format = 1;
|
||||
|
||||
if( CV_CAP_IEEE1394_COLOR[format][mode]==CV_CAP_IEEE1394_COLOR_MONO16 )
|
||||
return IPL_DEPTH_16S;
|
||||
|
||||
return IPL_DEPTH_8U;
|
||||
}
|
||||
|
||||
// return the number of channels for camera
|
||||
int CvCaptureCAM_CMU::getNChannels()
|
||||
{
|
||||
C1394Camera* cmucam = camera();
|
||||
int format = cmucam->GetVideoFormat();
|
||||
int mode = cmucam->GetVideoMode();
|
||||
|
||||
if( format==7 ){
|
||||
assert(0);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// irrelvant to nchannels
|
||||
if( format > 1 )
|
||||
format = 1;
|
||||
|
||||
switch(CV_CAP_IEEE1394_COLOR[format][mode]){
|
||||
case CV_CAP_IEEE1394_COLOR_RGB:
|
||||
return 3;
|
||||
case CV_CAP_IEEE1394_COLOR_MONO:
|
||||
case CV_CAP_IEEE1394_COLOR_MONO16:
|
||||
return 1;
|
||||
case CV_CAP_IEEE1394_COLOR_YUV422:
|
||||
case CV_CAP_IEEE1394_COLOR_YUV444:
|
||||
case CV_CAP_IEEE1394_COLOR_YUV411:
|
||||
return 3;
|
||||
default:
|
||||
;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
bool CvCaptureCAM_CMU::open( int _index )
|
||||
{
|
||||
close();
|
||||
|
||||
// if first time, then allocate all available cameras
|
||||
if( CMU_numCameras == 0 )
|
||||
{
|
||||
CMU_numActiveCameras = 0;
|
||||
CMU_theCamera = new C1394Camera[CMU_MAX_CAMERAS];
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// create all cameras
|
||||
try
|
||||
{
|
||||
// create camera0
|
||||
if( CMU_theCamera[0].CheckLink() != CAM_SUCCESS )
|
||||
throw 1;
|
||||
|
||||
// we have one pin per camera
|
||||
CMU_numCameras = CMU_theCamera[0].GetNumberCameras();
|
||||
|
||||
// allocate remaining cameras
|
||||
for(int i = 1; i < CMU_numCameras && i<CMU_MAX_CAMERAS; i++ )
|
||||
{
|
||||
CMU_useCameraFlags[i] = false;
|
||||
if (CMU_theCamera[i].CheckLink() != CAM_SUCCESS)
|
||||
throw 1;
|
||||
}
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
// free any allocated cameras
|
||||
// ...
|
||||
CMU_numCameras = 0;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
CvSize size;
|
||||
|
||||
// pick first unused camera
|
||||
if(_index==-1){
|
||||
for(int i = 0; i < CMU_numCameras; i++ )
|
||||
{
|
||||
if( !CMU_useCameraFlags[i] ){
|
||||
_index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// no empty camera found
|
||||
if (_index==-1)
|
||||
throw 1;
|
||||
|
||||
if (CMU_theCamera[_index].SelectCamera(_index) != CAM_SUCCESS)
|
||||
throw 2;
|
||||
|
||||
if (CMU_theCamera[_index].InitCamera() != CAM_SUCCESS)
|
||||
throw 3;
|
||||
|
||||
// set initial format -- try to pick best frame rate first, then color, then size
|
||||
bool found_format = false;
|
||||
for (int rate=5; rate>=0 && !found_format; rate--)
|
||||
{
|
||||
for (int color=CV_CAP_IEEE1394_COLOR_RGB; color>=0 && !found_format; color--)
|
||||
{
|
||||
for (int size=CV_CAP_IEEE1394_SIZE_1600X1200; size>=0 && !found_format; size--)
|
||||
{
|
||||
int format = CV_CAP_IEEE1394_FORMAT[size][color];
|
||||
int mode = CV_CAP_IEEE1394_MODE[size][color];
|
||||
if (format!=-1 && mode!=-1 &&
|
||||
CMU_theCamera[_index].HasVideoFrameRate(format,mode,rate))
|
||||
{
|
||||
CMU_theCamera[_index].SetVideoFormat(format);
|
||||
CMU_theCamera[_index].SetVideoMode(mode);
|
||||
CMU_theCamera[_index].SetVideoFrameRate(rate);
|
||||
found_format = (CMU_theCamera[_index].StartImageAcquisition() == CAM_SUCCESS);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// try format 7
|
||||
if(!found_format){
|
||||
CMU_theCamera[_index].SetVideoFormat(7);
|
||||
CMU_theCamera[_index].SetVideoMode(0);
|
||||
if(CMU_theCamera[_index].StartImageAcquisition() != CAM_SUCCESS){
|
||||
// no format found
|
||||
throw 9;
|
||||
}
|
||||
}
|
||||
|
||||
index = _index;
|
||||
size = getSize();
|
||||
// allocate image frame
|
||||
image = cvCreateImage( size, 8, 3 );
|
||||
cvZero(image);
|
||||
|
||||
// successfully activated camera
|
||||
CMU_numActiveCameras++;
|
||||
CMU_useCameraFlags[_index] = true;
|
||||
}
|
||||
catch ( int )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CvCaptureCAM_CMU::close()
|
||||
{
|
||||
C1394Camera* cmucam = camera();
|
||||
if( cmucam )
|
||||
{
|
||||
cvReleaseImage( &image );
|
||||
cmucam->StopImageAcquisition();
|
||||
CMU_useCameraFlags[index] = false;
|
||||
index = -1;
|
||||
|
||||
if( --CMU_numActiveCameras == 0 )
|
||||
{
|
||||
delete[] CMU_theCamera;
|
||||
CMU_theCamera = 0;
|
||||
CMU_numCameras = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool CvCaptureCAM_CMU::grabFrame()
|
||||
{
|
||||
C1394Camera* cmucam = camera();
|
||||
return cmucam ? cmucam->AcquireImage() == CAM_SUCCESS : false;
|
||||
}
|
||||
|
||||
/*static void swapRedBlue(IplImage * im)
|
||||
{
|
||||
uchar * ptr = (uchar *) im->imageData;
|
||||
uchar t;
|
||||
for(int i=0; i<im->height; i++){
|
||||
ptr = (uchar *) im->imageData+im->widthStep*i;
|
||||
for(int j=0; j<im->width; j++){
|
||||
t = ptr[0];
|
||||
ptr[0] = ptr[2];
|
||||
ptr[2] = t;
|
||||
ptr+=3;
|
||||
}
|
||||
}
|
||||
}*/
|
||||
|
||||
IplImage* CvCaptureCAM_CMU::retrieveFrame(int)
|
||||
{
|
||||
C1394Camera* cmucam = camera();
|
||||
if( !cmucam )
|
||||
return 0;
|
||||
cmucam->getRGB((uchar*)image->imageData, image->imageSize);
|
||||
cvConvertImage( image, image, CV_CVTIMG_SWAP_RB );
|
||||
return image;
|
||||
}
|
||||
|
||||
|
||||
double CvCaptureCAM_CMU::getProperty( int property_id ) const
|
||||
{
|
||||
C1394Camera* cmucam = camera();
|
||||
if( !cmucam )
|
||||
return 0;
|
||||
switch( property_id )
|
||||
{
|
||||
case CV_CAP_PROP_FRAME_WIDTH:
|
||||
return image->width;
|
||||
case CV_CAP_PROP_FRAME_HEIGHT:
|
||||
return image->height;
|
||||
case CV_CAP_PROP_FPS:
|
||||
return cmucam->GetVideoFrameRate();
|
||||
case CV_CAP_PROP_MODE:
|
||||
return cmucam->GetVideoMode();
|
||||
case CV_CAP_PROP_FORMAT:
|
||||
return cmucam->GetVideoFormat();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool CvCaptureCAM_CMU::setVideoSize(int, int)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CvCaptureCAM_CMU::setMode(int mode)
|
||||
{
|
||||
int format;
|
||||
C1394Camera* cmucam = camera();
|
||||
if( !cmucam )
|
||||
return false;
|
||||
format = cmucam->GetVideoFormat();
|
||||
if( mode < 0 || mode > 7 || !cmucam->HasVideoMode(format, mode))
|
||||
return false;
|
||||
cmucam->StopImageAcquisition();
|
||||
cmucam->SetVideoMode(mode);
|
||||
cmucam->StartImageAcquisition();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CvCaptureCAM_CMU::setFrameRate(int rate)
|
||||
{
|
||||
int format, mode;
|
||||
C1394Camera* cmucam = camera();
|
||||
if( !cmucam )
|
||||
return false;
|
||||
mode = cmucam->GetVideoMode();
|
||||
format = cmucam->GetVideoFormat();
|
||||
if( rate < 0 || rate > 5 || !cmucam->HasVideoFrameRate(format, mode, rate) )
|
||||
return false;
|
||||
cmucam->StopImageAcquisition();
|
||||
cmucam->SetVideoFrameRate(rate);
|
||||
cmucam->StartImageAcquisition();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CvCaptureCAM_CMU::setFormat(int format)
|
||||
{
|
||||
C1394Camera* cmucam = camera();
|
||||
if( !cmucam )
|
||||
return false;
|
||||
if( format < 0 || format > 2 || !cmucam->HasVideoFormat(format) )
|
||||
return false;
|
||||
cmucam->StopImageAcquisition();
|
||||
cmucam->SetVideoFormat(format);
|
||||
cmucam->StartImageAcquisition();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CvCaptureCAM_CMU::setProperty( int property_id, double value )
|
||||
{
|
||||
bool retval = false;
|
||||
int ival = cvRound(value);
|
||||
C1394Camera* cmucam = camera();
|
||||
if( !cmucam )
|
||||
return false;
|
||||
|
||||
switch (property_id) {
|
||||
case CV_CAP_PROP_FRAME_WIDTH:
|
||||
case CV_CAP_PROP_FRAME_HEIGHT:
|
||||
{
|
||||
int width, height;
|
||||
if (property_id == CV_CAP_PROP_FRAME_WIDTH)
|
||||
{
|
||||
width = ival;
|
||||
height = width*3/4;
|
||||
}
|
||||
else {
|
||||
height = ival;
|
||||
width = height*4/3;
|
||||
}
|
||||
retval = setVideoSize(width, height);
|
||||
}
|
||||
break;
|
||||
case CV_CAP_PROP_FPS:
|
||||
retval = setFrameRate(ival);
|
||||
break;
|
||||
case CV_CAP_PROP_MODE:
|
||||
retval = setMode(ival);
|
||||
break;
|
||||
case CV_CAP_PROP_FORMAT:
|
||||
retval = setFormat(ival);
|
||||
break;
|
||||
}
|
||||
|
||||
// resize image if its not the right size anymore
|
||||
CvSize size = getSize();
|
||||
if( !image || image->width != size.width || image->height != size.height )
|
||||
{
|
||||
cvReleaseImage( &image );
|
||||
image = cvCreateImage( size, 8, 3 );
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
CvCapture * cvCreateCameraCapture_CMU (int index)
|
||||
{
|
||||
CvCaptureCAM_CMU* capture = new CvCaptureCAM_CMU;
|
||||
if( capture->open(index) )
|
||||
return capture;
|
||||
delete capture;
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif // CMU
|
||||
#endif // _WIN32
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,332 +0,0 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// Intel License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2008, Xavier Delacour, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of Intel Corporation may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
// 2008-04-27 Xavier Delacour <xavier.delacour@gmail.com>
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include <unistd.h>
|
||||
#include <unicap.h>
|
||||
extern "C" {
|
||||
#include <ucil.h>
|
||||
}
|
||||
|
||||
#ifdef NDEBUG
|
||||
#define CV_WARN(message)
|
||||
#else
|
||||
#define CV_WARN(message) fprintf(stderr, "warning: %s (%s:%d)\n", message, __FILE__, __LINE__)
|
||||
#endif
|
||||
|
||||
struct CvCapture_Unicap : public CvCapture
|
||||
{
|
||||
CvCapture_Unicap() { init(); }
|
||||
virtual ~CvCapture_Unicap() { close(); }
|
||||
|
||||
virtual bool open( int index );
|
||||
virtual void close();
|
||||
|
||||
virtual double getProperty(int) const CV_OVERRIDE;
|
||||
virtual bool setProperty(int, double) CV_OVERRIDE;
|
||||
virtual bool grabFrame() CV_OVERRIDE;
|
||||
virtual IplImage* retrieveFrame(int) CV_OVERRIDE;
|
||||
virtual int getCaptureDomain() CV_OVERRIDE { return CV_CAP_UNICAP; }
|
||||
|
||||
bool shutdownDevice();
|
||||
bool initDevice();
|
||||
|
||||
void init()
|
||||
{
|
||||
device_initialized = false;
|
||||
desired_format = 0;
|
||||
desired_size = cvSize(0,0);
|
||||
convert_rgb = false;
|
||||
|
||||
handle = 0;
|
||||
memset( &device, 0, sizeof(device) );
|
||||
memset( &format_spec, 0, sizeof(format_spec) );
|
||||
memset( &format, 0, sizeof(format) );
|
||||
memset( &raw_buffer, 0, sizeof(raw_buffer) );
|
||||
memset( &buffer, 0, sizeof(buffer) );
|
||||
|
||||
raw_frame = frame = 0;
|
||||
}
|
||||
|
||||
bool device_initialized;
|
||||
|
||||
int desired_device;
|
||||
int desired_format;
|
||||
CvSize desired_size;
|
||||
bool convert_rgb;
|
||||
|
||||
unicap_handle_t handle;
|
||||
unicap_device_t device;
|
||||
unicap_format_t format_spec;
|
||||
unicap_format_t format;
|
||||
unicap_data_buffer_t raw_buffer;
|
||||
unicap_data_buffer_t buffer;
|
||||
|
||||
IplImage *raw_frame;
|
||||
IplImage *frame;
|
||||
};
|
||||
|
||||
bool CvCapture_Unicap::shutdownDevice() {
|
||||
bool result = false;
|
||||
CV_FUNCNAME("CvCapture_Unicap::shutdownDevice");
|
||||
__BEGIN__;
|
||||
|
||||
if (!SUCCESS(unicap_stop_capture(handle)))
|
||||
CV_ERROR(CV_StsError, "unicap: failed to stop capture on device\n");
|
||||
|
||||
if (!SUCCESS(unicap_close(handle)))
|
||||
CV_ERROR(CV_StsError, "unicap: failed to close the device\n");
|
||||
|
||||
cvReleaseImage(&raw_frame);
|
||||
cvReleaseImage(&frame);
|
||||
|
||||
device_initialized = false;
|
||||
|
||||
result = true;
|
||||
__END__;
|
||||
return result;
|
||||
}
|
||||
|
||||
bool CvCapture_Unicap::initDevice() {
|
||||
bool result = false;
|
||||
CV_FUNCNAME("CvCapture_Unicap::initDevice");
|
||||
__BEGIN__;
|
||||
|
||||
if (device_initialized && !shutdownDevice())
|
||||
return false;
|
||||
|
||||
if(!SUCCESS(unicap_enumerate_devices(NULL, &device, desired_device)))
|
||||
CV_ERROR(CV_StsError, "unicap: failed to get info for device\n");
|
||||
|
||||
if(!SUCCESS(unicap_open( &handle, &device)))
|
||||
CV_ERROR(CV_StsError, "unicap: failed to open device\n");
|
||||
|
||||
unicap_void_format(&format_spec);
|
||||
|
||||
if (!SUCCESS(unicap_enumerate_formats(handle, &format_spec, &format, desired_format))) {
|
||||
shutdownDevice();
|
||||
CV_ERROR(CV_StsError, "unicap: failed to get video format\n");
|
||||
}
|
||||
|
||||
int i;
|
||||
if (format.sizes)
|
||||
{
|
||||
for (i = format.size_count - 1; i > 0; i--)
|
||||
if (format.sizes[i].width == desired_size.width &&
|
||||
format.sizes[i].height == desired_size.height)
|
||||
break;
|
||||
format.size.width = format.sizes[i].width;
|
||||
format.size.height = format.sizes[i].height;
|
||||
}
|
||||
|
||||
if (!SUCCESS(unicap_set_format(handle, &format))) {
|
||||
shutdownDevice();
|
||||
CV_ERROR(CV_StsError, "unicap: failed to set video format\n");
|
||||
}
|
||||
|
||||
memset(&raw_buffer, 0x0, sizeof(unicap_data_buffer_t));
|
||||
raw_frame = cvCreateImage(cvSize(format.size.width,
|
||||
format.size.height),
|
||||
8, format.bpp / 8);
|
||||
memcpy(&raw_buffer.format, &format, sizeof(raw_buffer.format));
|
||||
raw_buffer.data = (unsigned char*)raw_frame->imageData;
|
||||
raw_buffer.buffer_size = format.size.width *
|
||||
format.size.height * format.bpp / 8;
|
||||
|
||||
memset(&buffer, 0x0, sizeof(unicap_data_buffer_t));
|
||||
memcpy(&buffer.format, &format, sizeof(buffer.format));
|
||||
|
||||
buffer.format.fourcc = UCIL_FOURCC('B','G','R','3');
|
||||
buffer.format.bpp = 24;
|
||||
// * todo support greyscale output
|
||||
// buffer.format.fourcc = UCIL_FOURCC('G','R','E','Y');
|
||||
// buffer.format.bpp = 8;
|
||||
|
||||
frame = cvCreateImage(cvSize(buffer.format.size.width,
|
||||
buffer.format.size.height),
|
||||
8, buffer.format.bpp / 8);
|
||||
buffer.data = (unsigned char*)frame->imageData;
|
||||
buffer.buffer_size = buffer.format.size.width *
|
||||
buffer.format.size.height * buffer.format.bpp / 8;
|
||||
|
||||
if(!SUCCESS(unicap_start_capture(handle))) {
|
||||
shutdownDevice();
|
||||
CV_ERROR(CV_StsError, "unicap: failed to start capture on device\n");
|
||||
}
|
||||
|
||||
device_initialized = true;
|
||||
result = true;
|
||||
__END__;
|
||||
return result;
|
||||
}
|
||||
|
||||
void CvCapture_Unicap::close() {
|
||||
if(device_initialized)
|
||||
shutdownDevice();
|
||||
}
|
||||
|
||||
bool CvCapture_Unicap::grabFrame() {
|
||||
bool result = false;
|
||||
|
||||
CV_FUNCNAME("CvCapture_Unicap::grabFrame");
|
||||
__BEGIN__;
|
||||
|
||||
unicap_data_buffer_t *returned_buffer;
|
||||
|
||||
int retry_count = 100;
|
||||
|
||||
while (retry_count--) {
|
||||
if(!SUCCESS(unicap_queue_buffer(handle, &raw_buffer)))
|
||||
CV_ERROR(CV_StsError, "unicap: failed to queue a buffer on device\n");
|
||||
|
||||
if(SUCCESS(unicap_wait_buffer(handle, &returned_buffer)))
|
||||
{
|
||||
result = true;
|
||||
EXIT;
|
||||
}
|
||||
|
||||
CV_WARN("unicap: failed to wait for buffer on device\n");
|
||||
usleep(100 * 1000);
|
||||
}
|
||||
|
||||
__END__;
|
||||
return result;
|
||||
}
|
||||
|
||||
IplImage * CvCapture_Unicap::retrieveFrame(int) {
|
||||
if (convert_rgb) {
|
||||
ucil_convert_buffer(&buffer, &raw_buffer);
|
||||
return frame;
|
||||
}
|
||||
return raw_frame;
|
||||
}
|
||||
|
||||
double CvCapture_Unicap::getProperty(int id) const
|
||||
{
|
||||
switch (id) {
|
||||
case CV_CAP_PROP_POS_MSEC: break;
|
||||
case CV_CAP_PROP_POS_FRAMES: break;
|
||||
case CV_CAP_PROP_POS_AVI_RATIO: break;
|
||||
case CV_CAP_PROP_FRAME_WIDTH:
|
||||
return desired_size.width;
|
||||
case CV_CAP_PROP_FRAME_HEIGHT:
|
||||
return desired_size.height;
|
||||
case CV_CAP_PROP_FPS: break;
|
||||
case CV_CAP_PROP_FOURCC: break;
|
||||
case CV_CAP_PROP_FRAME_COUNT: break;
|
||||
case CV_CAP_PROP_FORMAT:
|
||||
return desired_format;
|
||||
case CV_CAP_PROP_MODE: break;
|
||||
case CV_CAP_PROP_BRIGHTNESS: break;
|
||||
case CV_CAP_PROP_CONTRAST: break;
|
||||
case CV_CAP_PROP_SATURATION: break;
|
||||
case CV_CAP_PROP_HUE: break;
|
||||
case CV_CAP_PROP_GAIN: break;
|
||||
case CV_CAP_PROP_CONVERT_RGB:
|
||||
return convert_rgb;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool CvCapture_Unicap::setProperty(int id, double value) {
|
||||
bool reinit = false;
|
||||
|
||||
switch (id) {
|
||||
case CV_CAP_PROP_POS_MSEC: break;
|
||||
case CV_CAP_PROP_POS_FRAMES: break;
|
||||
case CV_CAP_PROP_POS_AVI_RATIO: break;
|
||||
case CV_CAP_PROP_FRAME_WIDTH:
|
||||
desired_size.width = (int)value;
|
||||
reinit = true;
|
||||
break;
|
||||
case CV_CAP_PROP_FRAME_HEIGHT:
|
||||
desired_size.height = (int)value;
|
||||
reinit = true;
|
||||
break;
|
||||
case CV_CAP_PROP_FPS: break;
|
||||
case CV_CAP_PROP_FOURCC: break;
|
||||
case CV_CAP_PROP_FRAME_COUNT: break;
|
||||
case CV_CAP_PROP_FORMAT:
|
||||
desired_format = id;
|
||||
reinit = true;
|
||||
break;
|
||||
case CV_CAP_PROP_MODE: break;
|
||||
case CV_CAP_PROP_BRIGHTNESS: break;
|
||||
case CV_CAP_PROP_CONTRAST: break;
|
||||
case CV_CAP_PROP_SATURATION: break;
|
||||
case CV_CAP_PROP_HUE: break;
|
||||
case CV_CAP_PROP_GAIN: break;
|
||||
case CV_CAP_PROP_CONVERT_RGB:
|
||||
convert_rgb = value != 0;
|
||||
break;
|
||||
}
|
||||
|
||||
if (reinit && !initDevice())
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CvCapture_Unicap::open(int index)
|
||||
{
|
||||
close();
|
||||
device_initialized = false;
|
||||
|
||||
desired_device = index < 0 ? 0 : index;
|
||||
desired_format = 0;
|
||||
desired_size = cvSize(320, 240);
|
||||
convert_rgb = true;
|
||||
|
||||
return initDevice();
|
||||
}
|
||||
|
||||
|
||||
CvCapture * cvCreateCameraCapture_Unicap(const int index)
|
||||
{
|
||||
CvCapture_Unicap *cap = new CvCapture_Unicap;
|
||||
if( cap->open(index) )
|
||||
return cap;
|
||||
delete cap;
|
||||
return 0;
|
||||
}
|
||||
@ -1,868 +0,0 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// Intel License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000, Intel Corporation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of Intel Corporation may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
|
||||
#include <vfw.h>
|
||||
|
||||
#ifdef __GNUC__
|
||||
#define WM_CAP_FIRSTA (WM_USER)
|
||||
#define capSendMessage(hwnd,m,w,l) (IsWindow(hwnd)?SendMessage(hwnd,m,w,l):0)
|
||||
#endif
|
||||
|
||||
#if defined _M_X64 && defined _MSC_VER
|
||||
#pragma optimize("",off)
|
||||
#pragma warning(disable: 4748)
|
||||
#endif
|
||||
|
||||
/********************* Capturing video from AVI via VFW ************************/
|
||||
|
||||
static BITMAPINFOHEADER icvBitmapHeader( int width, int height, int bpp, int compression = BI_RGB )
|
||||
{
|
||||
BITMAPINFOHEADER bmih;
|
||||
memset( &bmih, 0, sizeof(bmih));
|
||||
bmih.biSize = sizeof(bmih);
|
||||
bmih.biWidth = width;
|
||||
bmih.biHeight = height;
|
||||
bmih.biBitCount = (WORD)bpp;
|
||||
bmih.biCompression = compression;
|
||||
bmih.biPlanes = 1;
|
||||
|
||||
return bmih;
|
||||
}
|
||||
|
||||
|
||||
static void icvInitCapture_VFW()
|
||||
{
|
||||
static int isInitialized = 0;
|
||||
if( !isInitialized )
|
||||
{
|
||||
AVIFileInit();
|
||||
isInitialized = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class CvCaptureAVI_VFW : public CvCapture
|
||||
{
|
||||
public:
|
||||
CvCaptureAVI_VFW()
|
||||
{
|
||||
CoInitialize(NULL);
|
||||
init();
|
||||
}
|
||||
|
||||
virtual ~CvCaptureAVI_VFW()
|
||||
{
|
||||
close();
|
||||
CoUninitialize();
|
||||
}
|
||||
|
||||
virtual bool open( const char* filename );
|
||||
virtual void close();
|
||||
|
||||
virtual double getProperty(int) const CV_OVERRIDE;
|
||||
virtual bool setProperty(int, double) CV_OVERRIDE;
|
||||
virtual bool grabFrame() CV_OVERRIDE;
|
||||
virtual IplImage* retrieveFrame(int) CV_OVERRIDE;
|
||||
virtual int getCaptureDomain() CV_OVERRIDE { return CV_CAP_VFW; }
|
||||
|
||||
protected:
|
||||
void init();
|
||||
|
||||
PAVIFILE avifile;
|
||||
PAVISTREAM avistream;
|
||||
PGETFRAME getframe;
|
||||
AVISTREAMINFO aviinfo;
|
||||
BITMAPINFOHEADER * bmih;
|
||||
CvSlice film_range;
|
||||
double fps;
|
||||
int pos;
|
||||
IplImage* frame;
|
||||
CvSize size;
|
||||
};
|
||||
|
||||
|
||||
void CvCaptureAVI_VFW::init()
|
||||
{
|
||||
avifile = 0;
|
||||
avistream = 0;
|
||||
getframe = 0;
|
||||
memset( &aviinfo, 0, sizeof(aviinfo) );
|
||||
bmih = 0;
|
||||
film_range = cvSlice(0,0);
|
||||
fps = 0;
|
||||
pos = 0;
|
||||
frame = 0;
|
||||
size = cvSize(0,0);
|
||||
}
|
||||
|
||||
|
||||
void CvCaptureAVI_VFW::close()
|
||||
{
|
||||
if( getframe )
|
||||
AVIStreamGetFrameClose( getframe );
|
||||
|
||||
if( avistream )
|
||||
AVIStreamRelease( avistream );
|
||||
|
||||
if( avifile )
|
||||
AVIFileRelease( avifile );
|
||||
|
||||
if (frame)
|
||||
cvReleaseImage( &frame );
|
||||
|
||||
init();
|
||||
}
|
||||
|
||||
|
||||
bool CvCaptureAVI_VFW::open( const char* filename )
|
||||
{
|
||||
close();
|
||||
icvInitCapture_VFW();
|
||||
|
||||
if( !filename )
|
||||
return false;
|
||||
|
||||
HRESULT hr = AVIFileOpen( &avifile, filename, OF_READ, NULL );
|
||||
if( SUCCEEDED(hr))
|
||||
{
|
||||
hr = AVIFileGetStream( avifile, &avistream, streamtypeVIDEO, 0 );
|
||||
if( SUCCEEDED(hr))
|
||||
{
|
||||
hr = AVIStreamInfo( avistream, &aviinfo, sizeof(aviinfo));
|
||||
if( SUCCEEDED(hr))
|
||||
{
|
||||
size.width = aviinfo.rcFrame.right - aviinfo.rcFrame.left;
|
||||
size.height = aviinfo.rcFrame.bottom - aviinfo.rcFrame.top;
|
||||
BITMAPINFOHEADER bmihdr = icvBitmapHeader( size.width, size.height, 24 );
|
||||
|
||||
film_range.start_index = (int)aviinfo.dwStart;
|
||||
film_range.end_index = film_range.start_index + (int)aviinfo.dwLength;
|
||||
fps = (double)aviinfo.dwRate/aviinfo.dwScale;
|
||||
pos = film_range.start_index;
|
||||
getframe = AVIStreamGetFrameOpen( avistream, &bmihdr );
|
||||
if( getframe != 0 )
|
||||
return true;
|
||||
|
||||
// Attempt to open as 8-bit AVI.
|
||||
bmihdr = icvBitmapHeader( size.width, size.height, 8);
|
||||
getframe = AVIStreamGetFrameOpen( avistream, &bmihdr );
|
||||
if( getframe != 0 )
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
close();
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CvCaptureAVI_VFW::grabFrame()
|
||||
{
|
||||
if( avistream )
|
||||
bmih = (BITMAPINFOHEADER*)AVIStreamGetFrame( getframe, pos++ );
|
||||
return bmih != 0;
|
||||
}
|
||||
|
||||
IplImage* CvCaptureAVI_VFW::retrieveFrame(int)
|
||||
{
|
||||
if( avistream && bmih )
|
||||
{
|
||||
bool isColor = bmih->biBitCount == 24;
|
||||
int nChannels = (isColor) ? 3 : 1;
|
||||
IplImage src;
|
||||
cvInitImageHeader( &src, cvSize( bmih->biWidth, bmih->biHeight ),
|
||||
IPL_DEPTH_8U, nChannels, IPL_ORIGIN_BL, 4 );
|
||||
|
||||
char* dataPtr = (char*)(bmih + 1);
|
||||
|
||||
// Only account for the color map size if we are an 8-bit image and the color map is used
|
||||
if (!isColor)
|
||||
{
|
||||
static int RGBQUAD_SIZE_PER_BYTE = sizeof(RGBQUAD)/sizeof(BYTE);
|
||||
int offsetFromColormapToData = (int)bmih->biClrUsed*RGBQUAD_SIZE_PER_BYTE;
|
||||
dataPtr += offsetFromColormapToData;
|
||||
}
|
||||
|
||||
cvSetData( &src, dataPtr, src.widthStep );
|
||||
|
||||
if( !frame || frame->width != src.width || frame->height != src.height )
|
||||
{
|
||||
cvReleaseImage( &frame );
|
||||
frame = cvCreateImage( cvGetSize(&src), 8, nChannels );
|
||||
}
|
||||
|
||||
cvFlip( &src, frame, 0 );
|
||||
return frame;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
double CvCaptureAVI_VFW::getProperty( int property_id ) const
|
||||
{
|
||||
switch( property_id )
|
||||
{
|
||||
case CV_CAP_PROP_POS_MSEC:
|
||||
return cvRound(pos*1000./fps);
|
||||
case CV_CAP_PROP_POS_FRAMES:
|
||||
return pos;
|
||||
case CV_CAP_PROP_POS_AVI_RATIO:
|
||||
return (pos - film_range.start_index)/
|
||||
(film_range.end_index - film_range.start_index + 1e-10);
|
||||
case CV_CAP_PROP_FRAME_WIDTH:
|
||||
return size.width;
|
||||
case CV_CAP_PROP_FRAME_HEIGHT:
|
||||
return size.height;
|
||||
case CV_CAP_PROP_FPS:
|
||||
return fps;
|
||||
case CV_CAP_PROP_FOURCC:
|
||||
return aviinfo.fccHandler;
|
||||
case CV_CAP_PROP_FRAME_COUNT:
|
||||
return film_range.end_index - film_range.start_index;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool CvCaptureAVI_VFW::setProperty( int property_id, double value )
|
||||
{
|
||||
switch( property_id )
|
||||
{
|
||||
case CV_CAP_PROP_POS_MSEC:
|
||||
case CV_CAP_PROP_POS_FRAMES:
|
||||
case CV_CAP_PROP_POS_AVI_RATIO:
|
||||
{
|
||||
switch( property_id )
|
||||
{
|
||||
case CV_CAP_PROP_POS_MSEC:
|
||||
pos = cvRound(value*fps*0.001);
|
||||
break;
|
||||
case CV_CAP_PROP_POS_AVI_RATIO:
|
||||
pos = cvRound(value*(film_range.end_index -
|
||||
film_range.start_index) +
|
||||
film_range.start_index);
|
||||
break;
|
||||
default:
|
||||
pos = cvRound(value);
|
||||
}
|
||||
if( pos < film_range.start_index )
|
||||
pos = film_range.start_index;
|
||||
if( pos > film_range.end_index )
|
||||
pos = film_range.end_index;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
CvCapture* cvCreateFileCapture_VFW (const char* filename)
|
||||
{
|
||||
CvCaptureAVI_VFW* capture = new CvCaptureAVI_VFW;
|
||||
if( capture->open(filename) )
|
||||
return capture;
|
||||
delete capture;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/********************* Capturing video from camera via VFW *********************/
|
||||
|
||||
class CvCaptureCAM_VFW : public CvCapture
|
||||
{
|
||||
public:
|
||||
CvCaptureCAM_VFW()
|
||||
{
|
||||
CoInitialize(NULL);
|
||||
init();
|
||||
}
|
||||
virtual ~CvCaptureCAM_VFW()
|
||||
{
|
||||
close();
|
||||
CoUninitialize();
|
||||
}
|
||||
|
||||
virtual bool open( int index );
|
||||
virtual void close();
|
||||
virtual double getProperty(int) const;
|
||||
virtual bool setProperty(int, double);
|
||||
virtual bool grabFrame();
|
||||
virtual IplImage* retrieveFrame(int);
|
||||
virtual int getCaptureDomain() { return CV_CAP_VFW; } // Return the type of the capture object: CV_CAP_VFW, etc...
|
||||
|
||||
protected:
|
||||
void init();
|
||||
void closeHIC();
|
||||
static LRESULT PASCAL frameCallback( HWND hWnd, VIDEOHDR* hdr );
|
||||
|
||||
CAPDRIVERCAPS caps;
|
||||
HWND capWnd;
|
||||
VIDEOHDR* hdr;
|
||||
DWORD fourcc;
|
||||
int width, height;
|
||||
int widthSet, heightSet;
|
||||
HIC hic;
|
||||
IplImage* frame;
|
||||
};
|
||||
|
||||
|
||||
void CvCaptureCAM_VFW::init()
|
||||
{
|
||||
memset( &caps, 0, sizeof(caps) );
|
||||
capWnd = 0;
|
||||
hdr = 0;
|
||||
fourcc = 0;
|
||||
hic = 0;
|
||||
frame = 0;
|
||||
width = height = -1;
|
||||
widthSet = heightSet = 0;
|
||||
}
|
||||
|
||||
void CvCaptureCAM_VFW::closeHIC()
|
||||
{
|
||||
if( hic )
|
||||
{
|
||||
ICDecompressEnd( hic );
|
||||
ICClose( hic );
|
||||
hic = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
LRESULT PASCAL CvCaptureCAM_VFW::frameCallback( HWND hWnd, VIDEOHDR* hdr )
|
||||
{
|
||||
CvCaptureCAM_VFW* capture = 0;
|
||||
|
||||
if (!hWnd) return FALSE;
|
||||
|
||||
capture = (CvCaptureCAM_VFW*)capGetUserData(hWnd);
|
||||
if (!capture) return (LRESULT)FALSE;
|
||||
capture->hdr = hdr;
|
||||
return (LRESULT)TRUE;
|
||||
}
|
||||
|
||||
|
||||
// Initialize camera input
|
||||
bool CvCaptureCAM_VFW::open( int wIndex )
|
||||
{
|
||||
char szDeviceName[80];
|
||||
char szDeviceVersion[80];
|
||||
HWND hWndC = 0;
|
||||
|
||||
close();
|
||||
|
||||
if( (unsigned)wIndex >= 10 )
|
||||
wIndex = 0;
|
||||
|
||||
for( ; wIndex < 10; wIndex++ )
|
||||
{
|
||||
if( capGetDriverDescription( wIndex, szDeviceName,
|
||||
sizeof (szDeviceName), szDeviceVersion,
|
||||
sizeof (szDeviceVersion)))
|
||||
{
|
||||
hWndC = capCreateCaptureWindow ( "My Own Capture Window",
|
||||
WS_POPUP | WS_CHILD, 0, 0, 320, 240, 0, 0);
|
||||
if( capDriverConnect (hWndC, wIndex))
|
||||
break;
|
||||
DestroyWindow( hWndC );
|
||||
hWndC = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if( hWndC )
|
||||
{
|
||||
capWnd = hWndC;
|
||||
hdr = 0;
|
||||
hic = 0;
|
||||
fourcc = (DWORD)-1;
|
||||
|
||||
memset( &caps, 0, sizeof(caps));
|
||||
capDriverGetCaps( hWndC, &caps, sizeof(caps));
|
||||
CAPSTATUS status = {};
|
||||
capGetStatus(hWndC, &status, sizeof(status));
|
||||
::SetWindowPos(hWndC, NULL, 0, 0, status.uiImageWidth, status.uiImageHeight, SWP_NOZORDER|SWP_NOMOVE);
|
||||
capSetUserData( hWndC, (size_t)this );
|
||||
capSetCallbackOnFrame( hWndC, frameCallback );
|
||||
CAPTUREPARMS p;
|
||||
capCaptureGetSetup(hWndC,&p,sizeof(CAPTUREPARMS));
|
||||
p.dwRequestMicroSecPerFrame = 66667/2; // 30 FPS
|
||||
capCaptureSetSetup(hWndC,&p,sizeof(CAPTUREPARMS));
|
||||
//capPreview( hWndC, 1 );
|
||||
capPreviewScale(hWndC,FALSE);
|
||||
capPreviewRate(hWndC,1);
|
||||
|
||||
// Get frame initial parameters.
|
||||
const DWORD size = capGetVideoFormatSize(capWnd);
|
||||
if( size > 0 )
|
||||
{
|
||||
unsigned char *pbi = new unsigned char[size];
|
||||
if( pbi )
|
||||
{
|
||||
if( capGetVideoFormat(capWnd, pbi, size) == size )
|
||||
{
|
||||
BITMAPINFOHEADER& vfmt = ((BITMAPINFO*)pbi)->bmiHeader;
|
||||
widthSet = vfmt.biWidth;
|
||||
heightSet = vfmt.biHeight;
|
||||
fourcc = vfmt.biCompression;
|
||||
}
|
||||
delete []pbi;
|
||||
}
|
||||
}
|
||||
// And alternative way in case of failure.
|
||||
if( widthSet == 0 || heightSet == 0 )
|
||||
{
|
||||
widthSet = status.uiImageWidth;
|
||||
heightSet = status.uiImageHeight;
|
||||
}
|
||||
|
||||
}
|
||||
return capWnd != 0;
|
||||
}
|
||||
|
||||
|
||||
void CvCaptureCAM_VFW::close()
|
||||
{
|
||||
if( capWnd )
|
||||
{
|
||||
capSetCallbackOnFrame( capWnd, NULL );
|
||||
capDriverDisconnect( capWnd );
|
||||
DestroyWindow( capWnd );
|
||||
closeHIC();
|
||||
}
|
||||
cvReleaseImage( &frame );
|
||||
init();
|
||||
}
|
||||
|
||||
|
||||
bool CvCaptureCAM_VFW::grabFrame()
|
||||
{
|
||||
if( capWnd )
|
||||
return capGrabFrameNoStop(capWnd) == TRUE;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
IplImage* CvCaptureCAM_VFW::retrieveFrame(int)
|
||||
{
|
||||
BITMAPINFO vfmt;
|
||||
memset( &vfmt, 0, sizeof(vfmt));
|
||||
BITMAPINFOHEADER& vfmt0 = vfmt.bmiHeader;
|
||||
|
||||
if( !capWnd )
|
||||
return 0;
|
||||
|
||||
const DWORD sz = capGetVideoFormat( capWnd, &vfmt, sizeof(vfmt));
|
||||
const int prevWidth = frame ? frame->width : 0;
|
||||
const int prevHeight = frame ? frame->height : 0;
|
||||
|
||||
if( !hdr || hdr->lpData == 0 || sz == 0 )
|
||||
return 0;
|
||||
|
||||
if( !frame || frame->width != vfmt0.biWidth || frame->height != vfmt0.biHeight )
|
||||
{
|
||||
cvReleaseImage( &frame );
|
||||
frame = cvCreateImage( cvSize( vfmt0.biWidth, vfmt0.biHeight ), 8, 3 );
|
||||
}
|
||||
|
||||
if ( vfmt0.biCompression == MAKEFOURCC('N','V','1','2') )
|
||||
{
|
||||
// Frame is in YUV 4:2:0 NV12 format, convert to BGR color space
|
||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx#nv12)
|
||||
IplImage src;
|
||||
cvInitImageHeader( &src, cvSize( vfmt0.biWidth, vfmt0.biHeight * 3 / 2 ), IPL_DEPTH_8U, 1, IPL_ORIGIN_BL, 4 );
|
||||
cvSetData( &src, hdr->lpData, src.widthStep );
|
||||
cvCvtColor( &src, frame, CV_YUV2BGR_NV12 );
|
||||
}
|
||||
else if( vfmt0.biCompression != BI_RGB ||
|
||||
vfmt0.biBitCount != 24 )
|
||||
{
|
||||
BITMAPINFOHEADER vfmt1 = icvBitmapHeader( vfmt0.biWidth, vfmt0.biHeight, 24 );
|
||||
|
||||
if( hic == 0 || fourcc != vfmt0.biCompression ||
|
||||
prevWidth != vfmt0.biWidth || prevHeight != vfmt0.biHeight )
|
||||
{
|
||||
closeHIC();
|
||||
hic = ICOpen( MAKEFOURCC('V','I','D','C'),
|
||||
vfmt0.biCompression, ICMODE_DECOMPRESS );
|
||||
if( hic )
|
||||
{
|
||||
if( ICDecompressBegin( hic, &vfmt0, &vfmt1 ) != ICERR_OK )
|
||||
{
|
||||
closeHIC();
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if( !hic || ICDecompress( hic, 0, &vfmt0, hdr->lpData,
|
||||
&vfmt1, frame->imageData ) != ICERR_OK )
|
||||
{
|
||||
closeHIC();
|
||||
return 0;
|
||||
}
|
||||
|
||||
cvFlip( frame, frame, 0 );
|
||||
}
|
||||
else
|
||||
{
|
||||
IplImage src;
|
||||
cvInitImageHeader( &src, cvSize(vfmt0.biWidth, vfmt0.biHeight),
|
||||
IPL_DEPTH_8U, 3, IPL_ORIGIN_BL, 4 );
|
||||
cvSetData( &src, hdr->lpData, src.widthStep );
|
||||
cvFlip( &src, frame, 0 );
|
||||
}
|
||||
|
||||
return frame;
|
||||
}
|
||||
|
||||
|
||||
double CvCaptureCAM_VFW::getProperty( int property_id ) const
|
||||
{
|
||||
switch( property_id )
|
||||
{
|
||||
case CV_CAP_PROP_FRAME_WIDTH:
|
||||
return widthSet;
|
||||
case CV_CAP_PROP_FRAME_HEIGHT:
|
||||
return heightSet;
|
||||
case CV_CAP_PROP_FOURCC:
|
||||
return fourcc;
|
||||
case CV_CAP_PROP_FPS:
|
||||
{
|
||||
CAPTUREPARMS params = {};
|
||||
if( capCaptureGetSetup(capWnd, ¶ms, sizeof(params)) )
|
||||
return 1e6 / params.dwRequestMicroSecPerFrame;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool CvCaptureCAM_VFW::setProperty(int property_id, double value)
|
||||
{
|
||||
bool handledSize = false;
|
||||
|
||||
switch( property_id )
|
||||
{
|
||||
case CV_CAP_PROP_FRAME_WIDTH:
|
||||
width = cvRound(value);
|
||||
handledSize = true;
|
||||
break;
|
||||
case CV_CAP_PROP_FRAME_HEIGHT:
|
||||
height = cvRound(value);
|
||||
handledSize = true;
|
||||
break;
|
||||
case CV_CAP_PROP_FOURCC:
|
||||
break;
|
||||
case CV_CAP_PROP_FPS:
|
||||
if( value > 0 )
|
||||
{
|
||||
CAPTUREPARMS params;
|
||||
if( capCaptureGetSetup(capWnd, ¶ms, sizeof(params)) )
|
||||
{
|
||||
params.dwRequestMicroSecPerFrame = cvRound(1e6/value);
|
||||
return capCaptureSetSetup(capWnd, ¶ms, sizeof(params)) == TRUE;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if ( handledSize )
|
||||
{
|
||||
// If both width and height are set then change frame size.
|
||||
if( width > 0 && height > 0 )
|
||||
{
|
||||
const DWORD size = capGetVideoFormatSize(capWnd);
|
||||
if( size == 0 )
|
||||
return false;
|
||||
|
||||
unsigned char *pbi = new unsigned char[size];
|
||||
if( !pbi )
|
||||
return false;
|
||||
|
||||
if( capGetVideoFormat(capWnd, pbi, size) != size )
|
||||
{
|
||||
delete []pbi;
|
||||
return false;
|
||||
}
|
||||
|
||||
BITMAPINFOHEADER& vfmt = ((BITMAPINFO*)pbi)->bmiHeader;
|
||||
bool success = true;
|
||||
if( width != vfmt.biWidth || height != vfmt.biHeight )
|
||||
{
|
||||
// Change frame size.
|
||||
vfmt.biWidth = width;
|
||||
vfmt.biHeight = height;
|
||||
vfmt.biSizeImage = height * ((width * vfmt.biBitCount + 31) / 32) * 4;
|
||||
vfmt.biCompression = BI_RGB;
|
||||
success = capSetVideoFormat(capWnd, pbi, size) == TRUE;
|
||||
}
|
||||
if( success )
|
||||
{
|
||||
// Adjust capture window size.
|
||||
CAPSTATUS status = {};
|
||||
capGetStatus(capWnd, &status, sizeof(status));
|
||||
::SetWindowPos(capWnd, NULL, 0, 0, status.uiImageWidth, status.uiImageHeight, SWP_NOZORDER|SWP_NOMOVE);
|
||||
// Store frame size.
|
||||
widthSet = width;
|
||||
heightSet = height;
|
||||
}
|
||||
delete []pbi;
|
||||
width = height = -1;
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
CvCapture* cvCreateCameraCapture_VFW( int index )
|
||||
{
|
||||
CvCaptureCAM_VFW* capture = new CvCaptureCAM_VFW;
|
||||
|
||||
if( capture->open( index ))
|
||||
return capture;
|
||||
|
||||
delete capture;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*************************** writing AVIs ******************************/
|
||||
|
||||
class CvVideoWriter_VFW : public CvVideoWriter
|
||||
{
|
||||
public:
|
||||
CvVideoWriter_VFW()
|
||||
{
|
||||
CoInitialize(NULL);
|
||||
init();
|
||||
}
|
||||
virtual ~CvVideoWriter_VFW()
|
||||
{
|
||||
close();
|
||||
CoUninitialize();
|
||||
}
|
||||
|
||||
virtual bool open( const char* filename, int fourcc,
|
||||
double fps, CvSize frameSize, bool isColor );
|
||||
virtual void close();
|
||||
virtual bool writeFrame( const IplImage* );
|
||||
|
||||
int getCaptureDomain() const CV_OVERRIDE { return cv::CAP_VFW; }
|
||||
protected:
|
||||
void init();
|
||||
bool createStreams( CvSize frameSize, bool isColor );
|
||||
|
||||
PAVIFILE avifile;
|
||||
PAVISTREAM compressed;
|
||||
PAVISTREAM uncompressed;
|
||||
double fps;
|
||||
IplImage* tempFrame;
|
||||
long pos;
|
||||
int fourcc;
|
||||
};
|
||||
|
||||
|
||||
void CvVideoWriter_VFW::init()
|
||||
{
|
||||
avifile = 0;
|
||||
compressed = uncompressed = 0;
|
||||
fps = 0;
|
||||
tempFrame = 0;
|
||||
pos = 0;
|
||||
fourcc = 0;
|
||||
}
|
||||
|
||||
void CvVideoWriter_VFW::close()
|
||||
{
|
||||
if( uncompressed )
|
||||
AVIStreamRelease( uncompressed );
|
||||
if( compressed )
|
||||
AVIStreamRelease( compressed );
|
||||
if( avifile )
|
||||
AVIFileRelease( avifile );
|
||||
cvReleaseImage( &tempFrame );
|
||||
init();
|
||||
}
|
||||
|
||||
|
||||
// philipg. Made this code capable of writing 8bpp gray scale bitmaps
|
||||
struct BITMAPINFO_8Bit
|
||||
{
|
||||
BITMAPINFOHEADER bmiHeader;
|
||||
RGBQUAD bmiColors[256];
|
||||
};
|
||||
|
||||
|
||||
bool CvVideoWriter_VFW::open( const char* filename, int _fourcc, double _fps, CvSize frameSize, bool isColor )
|
||||
{
|
||||
close();
|
||||
|
||||
icvInitCapture_VFW();
|
||||
if( AVIFileOpen( &avifile, filename, OF_CREATE | OF_WRITE, 0 ) == AVIERR_OK )
|
||||
{
|
||||
fourcc = _fourcc;
|
||||
fps = _fps;
|
||||
if( frameSize.width > 0 && frameSize.height > 0 &&
|
||||
!createStreams( frameSize, isColor ) )
|
||||
{
|
||||
close();
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool CvVideoWriter_VFW::createStreams( CvSize frameSize, bool isColor )
|
||||
{
|
||||
if( !avifile )
|
||||
return false;
|
||||
AVISTREAMINFO aviinfo;
|
||||
|
||||
BITMAPINFO_8Bit bmih;
|
||||
bmih.bmiHeader = icvBitmapHeader( frameSize.width, frameSize.height, isColor ? 24 : 8 );
|
||||
for( int i = 0; i < 256; i++ )
|
||||
{
|
||||
bmih.bmiColors[i].rgbBlue = (BYTE)i;
|
||||
bmih.bmiColors[i].rgbGreen = (BYTE)i;
|
||||
bmih.bmiColors[i].rgbRed = (BYTE)i;
|
||||
bmih.bmiColors[i].rgbReserved = 0;
|
||||
}
|
||||
|
||||
memset( &aviinfo, 0, sizeof(aviinfo));
|
||||
aviinfo.fccType = streamtypeVIDEO;
|
||||
aviinfo.fccHandler = 0;
|
||||
// use highest possible accuracy for dwRate/dwScale
|
||||
aviinfo.dwScale = (DWORD)((double)0x7FFFFFFF / fps);
|
||||
aviinfo.dwRate = cvRound(fps * aviinfo.dwScale);
|
||||
aviinfo.rcFrame.top = aviinfo.rcFrame.left = 0;
|
||||
aviinfo.rcFrame.right = frameSize.width;
|
||||
aviinfo.rcFrame.bottom = frameSize.height;
|
||||
|
||||
if( AVIFileCreateStream( avifile, &uncompressed, &aviinfo ) == AVIERR_OK )
|
||||
{
|
||||
AVICOMPRESSOPTIONS copts, *pcopts = &copts;
|
||||
copts.fccType = streamtypeVIDEO;
|
||||
copts.fccHandler = fourcc != -1 ? fourcc : 0;
|
||||
copts.dwKeyFrameEvery = 1;
|
||||
copts.dwQuality = 10000;
|
||||
copts.dwBytesPerSecond = 0;
|
||||
copts.dwFlags = AVICOMPRESSF_VALID;
|
||||
copts.lpFormat = &bmih;
|
||||
copts.cbFormat = (isColor ? sizeof(BITMAPINFOHEADER) : sizeof(bmih));
|
||||
copts.lpParms = 0;
|
||||
copts.cbParms = 0;
|
||||
copts.dwInterleaveEvery = 0;
|
||||
|
||||
if( fourcc != -1 || AVISaveOptions( 0, 0, 1, &uncompressed, &pcopts ) == TRUE )
|
||||
{
|
||||
if( AVIMakeCompressedStream( &compressed, uncompressed, pcopts, 0 ) == AVIERR_OK &&
|
||||
AVIStreamSetFormat( compressed, 0, &bmih, sizeof(bmih)) == AVIERR_OK )
|
||||
{
|
||||
fps = fps;
|
||||
fourcc = (int)copts.fccHandler;
|
||||
frameSize = frameSize;
|
||||
tempFrame = cvCreateImage( frameSize, 8, (isColor ? 3 : 1) );
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool CvVideoWriter_VFW::writeFrame( const IplImage* image )
|
||||
{
|
||||
bool result = false;
|
||||
CV_FUNCNAME( "CvVideoWriter_VFW::writeFrame" );
|
||||
|
||||
__BEGIN__;
|
||||
|
||||
if( !image )
|
||||
EXIT;
|
||||
|
||||
if( !compressed && !createStreams( cvGetSize(image), image->nChannels > 1 ))
|
||||
EXIT;
|
||||
|
||||
if( image->width != tempFrame->width || image->height != tempFrame->height )
|
||||
CV_ERROR( CV_StsUnmatchedSizes,
|
||||
"image size is different from the currently set frame size" );
|
||||
|
||||
if( image->nChannels != tempFrame->nChannels ||
|
||||
image->depth != tempFrame->depth ||
|
||||
image->origin == 0 ||
|
||||
image->widthStep != cvAlign(image->width*image->nChannels*((image->depth & 255)/8), 4))
|
||||
{
|
||||
cvConvertImage( image, tempFrame, image->origin == 0 ? CV_CVTIMG_FLIP : 0 );
|
||||
image = (const IplImage*)tempFrame;
|
||||
}
|
||||
|
||||
result = AVIStreamWrite( compressed, pos++, 1, image->imageData,
|
||||
image->imageSize, AVIIF_KEYFRAME, 0, 0 ) == AVIERR_OK;
|
||||
|
||||
__END__;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
CvVideoWriter* cvCreateVideoWriter_VFW( const char* filename, int fourcc,
|
||||
double fps, CvSize frameSize, int isColor )
|
||||
{
|
||||
CvVideoWriter_VFW* writer = new CvVideoWriter_VFW;
|
||||
if( writer->open( filename, fourcc, fps, frameSize, isColor != 0 ))
|
||||
return writer;
|
||||
delete writer;
|
||||
return 0;
|
||||
}
|
||||
@ -93,7 +93,7 @@ struct CvCapture
|
||||
virtual bool setProperty(int, double) { return 0; }
|
||||
virtual bool grabFrame() { return true; }
|
||||
virtual IplImage* retrieveFrame(int) { return 0; }
|
||||
virtual int getCaptureDomain() { return cv::CAP_ANY; } // Return the type of the capture object: CAP_VFW, etc...
|
||||
virtual int getCaptureDomain() { return cv::CAP_ANY; } // Return the type of the capture object: CAP_DSHOW, etc...
|
||||
};
|
||||
|
||||
/*************************** CvVideoWriter structure ****************************/
|
||||
@ -107,18 +107,12 @@ struct CvVideoWriter
|
||||
|
||||
CvCapture * cvCreateCameraCapture_V4L( int index );
|
||||
CvCapture * cvCreateCameraCapture_V4L( const char* deviceName );
|
||||
CvCapture * cvCreateCameraCapture_DC1394( int index );
|
||||
CvCapture * cvCreateCameraCapture_DC1394_2( int index );
|
||||
CvCapture* cvCreateCameraCapture_MIL( int index );
|
||||
CvCapture* cvCreateCameraCapture_Giganetix( int index );
|
||||
CvCapture * cvCreateCameraCapture_CMU( int index );
|
||||
CvCapture* cvCreateFileCapture_Win32( const char* filename );
|
||||
CvCapture* cvCreateCameraCapture_VFW( int index );
|
||||
CvCapture* cvCreateFileCapture_VFW( const char* filename );
|
||||
CvVideoWriter* cvCreateVideoWriter_Win32( const char* filename, int fourcc,
|
||||
double fps, CvSize frameSize, int is_color );
|
||||
CvVideoWriter* cvCreateVideoWriter_VFW( const char* filename, int fourcc,
|
||||
double fps, CvSize frameSize, int is_color );
|
||||
CvCapture* cvCreateCameraCapture_DShow( int index );
|
||||
CvCapture* cvCreateCameraCapture_OpenNI( int index );
|
||||
CvCapture* cvCreateCameraCapture_OpenNI2( int index );
|
||||
@ -150,7 +144,6 @@ CvVideoWriter* cvCreateVideoWriter_AVFoundation( const char* filename, int fourc
|
||||
double fps, CvSize frameSize, int is_color );
|
||||
|
||||
|
||||
CvCapture * cvCreateCameraCapture_Unicap (const int index);
|
||||
CvCapture * cvCreateCameraCapture_PvAPI (const int index);
|
||||
CvVideoWriter* cvCreateVideoWriter_GStreamer( const char* filename, int fourcc,
|
||||
double fps, CvSize frameSize, int is_color );
|
||||
@ -167,7 +160,7 @@ namespace cv
|
||||
virtual bool grabFrame() = 0;
|
||||
virtual bool retrieveFrame(int, OutputArray) = 0;
|
||||
virtual bool isOpened() const = 0;
|
||||
virtual int getCaptureDomain() { return CAP_ANY; } // Return the type of the capture object: CAP_VFW, etc...
|
||||
virtual int getCaptureDomain() { return CAP_ANY; } // Return the type of the capture object: CAP_DSHOW, etc...
|
||||
};
|
||||
|
||||
class IVideoWriter
|
||||
|
||||
@ -44,10 +44,10 @@ namespace {
|
||||
|
||||
/** Ordering guidelines:
|
||||
- modern optimized, multi-platform libraries: ffmpeg, gstreamer, Media SDK
|
||||
- platform specific universal SDK: WINRT, QTKIT/AVFOUNDATION, MSMF/VFW/DSHOW, V4L/V4L2
|
||||
- platform specific universal SDK: WINRT, AVFOUNDATION, MSMF/DSHOW, V4L/V4L2
|
||||
- RGB-D: OpenNI/OpenNI2, INTELPERC/REALSENSE
|
||||
- special OpenCV (file-based): "images", "mjpeg"
|
||||
- special camera SDKs, including stereo: other special SDKs: FIREWIRE/1394, XIMEA/ARAVIS/GIGANETIX/PVAPI(GigE), UNICAP
|
||||
- special camera SDKs, including stereo: other special SDKs: FIREWIRE/1394, XIMEA/ARAVIS/GIGANETIX/PVAPI(GigE)
|
||||
- other: XINE, gphoto2, etc
|
||||
*/
|
||||
static const struct VideoBackendInfo builtin_backends[] =
|
||||
@ -64,9 +64,6 @@ static const struct VideoBackendInfo builtin_backends[] =
|
||||
|
||||
|
||||
// Apple platform
|
||||
#if defined(HAVE_QUICKTIME) || defined(HAVE_QTKIT)
|
||||
DECLARE_BACKEND(CAP_QT, "QUICKTIME", MODE_CAPTURE_ALL | MODE_WRITER),
|
||||
#endif
|
||||
#ifdef HAVE_AVFOUNDATION
|
||||
DECLARE_BACKEND(CAP_AVFOUNDATION, "AVFOUNDATION", MODE_CAPTURE_ALL | MODE_WRITER),
|
||||
#endif
|
||||
@ -81,9 +78,6 @@ static const struct VideoBackendInfo builtin_backends[] =
|
||||
#ifdef HAVE_DSHOW
|
||||
DECLARE_BACKEND(CAP_DSHOW, "DSHOW", MODE_CAPTURE_BY_INDEX),
|
||||
#endif
|
||||
#ifdef HAVE_VFW
|
||||
DECLARE_BACKEND(CAP_VFW, "VFW", MODE_CAPTURE_ALL | MODE_WRITER),
|
||||
#endif
|
||||
|
||||
// Linux, some Unix
|
||||
#if defined HAVE_CAMV4L2
|
||||
@ -111,7 +105,7 @@ static const struct VideoBackendInfo builtin_backends[] =
|
||||
DECLARE_BACKEND(CAP_OPENCV_MJPEG, "CV_MJPEG", MODE_CAPTURE_BY_FILENAME | MODE_WRITER),
|
||||
|
||||
// special interfaces / stereo cameras / other SDKs
|
||||
#if defined(HAVE_DC1394_2) || defined(HAVE_DC1394) || defined(HAVE_CMU1394)
|
||||
#if defined(HAVE_DC1394_2)
|
||||
DECLARE_BACKEND(CAP_FIREWIRE, "FIREWIRE", MODE_CAPTURE_BY_INDEX),
|
||||
#endif
|
||||
// GigE
|
||||
@ -127,9 +121,6 @@ static const struct VideoBackendInfo builtin_backends[] =
|
||||
#ifdef HAVE_ARAVIS_API
|
||||
DECLARE_BACKEND(CAP_ARAVIS, "ARAVIS", MODE_CAPTURE_BY_INDEX),
|
||||
#endif
|
||||
#ifdef HAVE_UNICAP
|
||||
DECLARE_BACKEND(CAP_UNICAP, "UNICAP", MODE_CAPTURE_BY_INDEX),
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_GPHOTO2
|
||||
DECLARE_BACKEND(CAP_GPHOTO2, "GPHOTO2", MODE_CAPTURE_ALL),
|
||||
@ -443,23 +434,9 @@ void VideoCapture_create(CvCapture*& capture, Ptr<IVideoCapture>& icap, VideoCap
|
||||
TRY_OPEN(createGPhoto2Capture(index));
|
||||
break;
|
||||
#endif
|
||||
case CAP_VFW: // or CAP_V4L or CAP_V4L2
|
||||
#ifdef HAVE_VFW
|
||||
TRY_OPEN_LEGACY(cvCreateCameraCapture_VFW(index))
|
||||
#endif
|
||||
#if defined HAVE_LIBV4L || defined HAVE_CAMV4L || defined HAVE_CAMV4L2 || defined HAVE_VIDEOIO
|
||||
TRY_OPEN_LEGACY(cvCreateCameraCapture_V4L(index))
|
||||
#endif
|
||||
break;
|
||||
case CAP_FIREWIRE:
|
||||
#ifdef HAVE_DC1394_2
|
||||
TRY_OPEN_LEGACY(cvCreateCameraCapture_DC1394_2(index))
|
||||
#endif
|
||||
#ifdef HAVE_DC1394
|
||||
TRY_OPEN_LEGACY(cvCreateCameraCapture_DC1394(index))
|
||||
#endif
|
||||
#ifdef HAVE_CMU1394
|
||||
TRY_OPEN_LEGACY(cvCreateCameraCapture_CMU(index))
|
||||
#endif
|
||||
break; // CAP_FIREWIRE
|
||||
#ifdef HAVE_MIL
|
||||
@ -467,16 +444,6 @@ void VideoCapture_create(CvCapture*& capture, Ptr<IVideoCapture>& icap, VideoCap
|
||||
TRY_OPEN_LEGACY(cvCreateCameraCapture_MIL(index))
|
||||
break;
|
||||
#endif
|
||||
#if defined(HAVE_QUICKTIME) || defined(HAVE_QTKIT)
|
||||
case CAP_QT:
|
||||
TRY_OPEN_LEGACY(cvCreateCameraCapture_QT(index))
|
||||
break;
|
||||
#endif
|
||||
#ifdef HAVE_UNICAP
|
||||
case CAP_UNICAP:
|
||||
TRY_OPEN_LEGACY(cvCreateCameraCapture_Unicap(index))
|
||||
break;
|
||||
#endif
|
||||
#ifdef HAVE_PVAPI
|
||||
case CAP_PVAPI:
|
||||
TRY_OPEN_LEGACY(cvCreateCameraCapture_PvAPI(index))
|
||||
@ -531,18 +498,6 @@ void VideoCapture_create(CvCapture*& capture, Ptr<IVideoCapture>& icap, VideoCap
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_VFW
|
||||
case CAP_VFW:
|
||||
TRY_OPEN_LEGACY(cvCreateFileCapture_VFW(filename.c_str()))
|
||||
break;
|
||||
#endif
|
||||
|
||||
#if defined(HAVE_QUICKTIME) || defined(HAVE_QTKIT)
|
||||
case CAP_QT:
|
||||
TRY_OPEN_LEGACY(cvCreateFileCapture_QT(filename.c_str()))
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_AVFOUNDATION
|
||||
case CAP_AVFOUNDATION:
|
||||
TRY_OPEN_LEGACY(cvCreateFileCapture_AVFoundation(filename.c_str()))
|
||||
@ -664,21 +619,11 @@ void VideoWriter_create(CvVideoWriter*& writer, Ptr<IVideoWriter>& iwriter, Vide
|
||||
CREATE_WRITER(VideoWriter_IntelMFX::create(filename, fourcc, fps, frameSize, isColor));
|
||||
break;
|
||||
#endif
|
||||
#ifdef HAVE_VFW
|
||||
case CAP_VFW:
|
||||
CREATE_WRITER_LEGACY(cvCreateVideoWriter_VFW(filename.c_str(), fourcc, fps, cvSize(frameSize), isColor))
|
||||
break;
|
||||
#endif
|
||||
#ifdef HAVE_AVFOUNDATION
|
||||
case CAP_AVFOUNDATION:
|
||||
CREATE_WRITER_LEGACY(cvCreateVideoWriter_AVFoundation(filename.c_str(), fourcc, fps, cvSize(frameSize), isColor))
|
||||
break;
|
||||
#endif
|
||||
#if defined(HAVE_QUICKTIME) || defined(HAVE_QTKIT)
|
||||
case(CAP_QT):
|
||||
CREATE_WRITER_LEGACY(cvCreateVideoWriter_QT(filename.c_str(), fourcc, fps, cvSize(frameSize), isColor))
|
||||
break;
|
||||
#endif
|
||||
#ifdef HAVE_GSTREAMER
|
||||
case CAP_GSTREAMER:
|
||||
CREATE_WRITER_LEGACY(cvCreateVideoWriter_GStreamer (filename.c_str(), fourcc, fps, cvSize(frameSize), isColor))
|
||||
|
||||
@ -316,11 +316,6 @@ static const VideoCaptureAPIs backend_params[] = {
|
||||
CAP_MSMF,
|
||||
#endif
|
||||
|
||||
// TODO: Broken?
|
||||
//#ifdef HAVE_VFW
|
||||
// CAP_VFW,
|
||||
//#endif
|
||||
|
||||
#ifdef HAVE_GSTREAMER
|
||||
CAP_GSTREAMER,
|
||||
#endif
|
||||
@ -389,18 +384,6 @@ static Ext_Fourcc_PSNR synthetic_params[] = {
|
||||
makeParam("mov", "H264", 30.f, CAP_MSMF),
|
||||
#endif
|
||||
|
||||
// TODO: Broken?
|
||||
//#ifdef HAVE_VFW
|
||||
//#if !defined(_M_ARM)
|
||||
// makeParam("wmv", "WMV1", 30.f, CAP_VFW),
|
||||
// makeParam("wmv", "WMV2", 30.f, CAP_VFW),
|
||||
//#endif
|
||||
// makeParam("wmv", "WMV3", 30.f, CAP_VFW),
|
||||
// makeParam("wmv", "WVC1", 30.f, CAP_VFW),
|
||||
// makeParam("avi", "H264", 30.f, CAP_VFW),
|
||||
// makeParam("avi", "MJPG", 30.f, CAP_VFW),
|
||||
//#endif
|
||||
|
||||
#ifdef HAVE_QUICKTIME
|
||||
makeParam("mov", "mp4v", 30.f, CAP_QT),
|
||||
makeParam("avi", "XVID", 30.f, CAP_QT),
|
||||
|
||||
Loading…
Reference in New Issue
Block a user