| /*M/////////////////////////////////////////////////////////////////////////////////////// |
| /*M/////////////////////////////////////////////////////////////////////////////////////// |
| // |
| // |
| // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. |
| // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. |
| // |
| // |
| // By downloading, copying, installing or using the software you agree to this license. |
| // 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, |
| // If you do not agree to this license, do not download, install, |
| // copy or use the software. |
| // copy or use the software. |
| // |
| // |
| // |
| // |
| // Intel License Agreement |
| // Intel License Agreement |
| // For Open Source Computer Vision Library |
| // For Open Source Computer Vision Library |
| // |
| // |
| // Copyright (C) 2000, Intel Corporation, all rights reserved. |
| // Copyright (C) 2000, Intel Corporation, all rights reserved. |
| // Third party copyrights are property of their respective owners. |
| // Third party copyrights are property of their respective owners. |
| // |
| // |
| // Redistribution and use in source and binary forms, with or without modification, |
| // Redistribution and use in source and binary forms, with or without modification, |
| // are permitted provided that the following conditions are met: |
| // are permitted provided that the following conditions are met: |
| // |
| // |
| // * Redistribution's of source code must retain the above copyright notice, |
| // * Redistribution's of source code must retain the above copyright notice, |
| // this list of conditions and the following disclaimer. |
| // this list of conditions and the following disclaimer. |
| // |
| // |
| // * Redistribution's in binary form must reproduce the above copyright notice, |
| // * Redistribution's in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // and/or other materials provided with the distribution. |
| // |
| // |
| // * The name of Intel Corporation may not be used to endorse or promote products |
| // * The name of Intel Corporation may not be used to endorse or promote products |
| // derived from this software without specific prior written permission. |
| // derived from this software without specific prior written permission. |
| // |
| // |
| // This software is provided by the copyright holders and contributors "as is" and |
| // 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 |
| // any express or implied warranties, including, but not limited to, the implied |
| // warranties of merchantability and fitness for a particular purpose are disclaimed. |
| // 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, |
| // In no event shall the Intel Corporation or contributors be liable for any direct, |
| // indirect, incidental, special, exemplary, or consequential damages |
| // indirect, incidental, special, exemplary, or consequential damages |
| // (including, but not limited to, procurement of substitute goods or services; |
| // (including, but not limited to, procurement of substitute goods or services; |
| // loss of use, data, or profits; or business interruption) however caused |
| // loss of use, data, or profits; or business interruption) however caused |
| // and on any theory of liability, whether in contract, strict liability, |
| // and on any theory of liability, whether in contract, strict liability, |
| // or tort (including negligence or otherwise) arising in any way out of |
| // 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. |
| // the use of this software, even if advised of the possibility of such damage. |
| // |
| // |
| //M*/ |
| //M*/ |
| |
| |
| #include "_highgui.h" |
| #include "_highgui.h" |
| |
| #include "interfaces\ffopencv\ffopencv.h" |
| |
| |
| extern "C" |
| //extern "C" |
| { |
| //{ |
| typedef void* (*CvCreateFileCapture_Plugin)( const char* filename ); |
| //typedef void* (*CvCreateFileCapture_Plugin)( const char* filename ); |
| typedef void* (*CvCreateCameraCapture_Plugin)( int index ); |
| //typedef void* (*CvCreateCameraCapture_Plugin)( int index ); |
| typedef int (*CvGrabFrame_Plugin)( void* capture_handle ); |
| //typedef int (*CvGrabFrame_Plugin)( void* capture_handle ); |
| typedef IplImage* (*CvRetrieveFrame_Plugin)( void* capture_handle, int ); |
| //typedef IplImage* (*CvRetrieveFrame_Plugin)( void* capture_handle, int ); |
| typedef int (*CvSetCaptureProperty_Plugin)( void* capture_handle, int prop_id, double value ); |
| //typedef int (*CvSetCaptureProperty_Plugin)( void* capture_handle, int prop_id, double value ); |
| typedef double (*CvGetCaptureProperty_Plugin)( void* capture_handle, int prop_id ); |
| //typedef double (*CvGetCaptureProperty_Plugin)( void* capture_handle, int prop_id ); |
| typedef void (*CvReleaseCapture_Plugin)( void** capture_handle ); |
| //typedef void (*CvReleaseCapture_Plugin)( void** capture_handle ); |
| typedef void* (*CvCreateVideoWriter_Plugin)( const char* filename, int fourcc, |
| //typedef void* (*CvCreateVideoWriter_Plugin)( const char* filename, int fourcc, |
| double fps, CvSize frameSize, int isColor ); |
| // double fps, CvSize frameSize, int isColor ); |
| typedef int (*CvWriteFrame_Plugin)( void* writer_handle, const IplImage* frame ); |
| //typedef int (*CvWriteFrame_Plugin)( void* writer_handle, const IplImage* frame ); |
| typedef void (*CvReleaseVideoWriter_Plugin)( void** writer ); |
| //typedef void (*CvReleaseVideoWriter_Plugin)( void** writer ); |
| } |
| //} |
| |
| // |
| static HMODULE icvFFOpenCV = 0; |
| //static HMODULE icvFFOpenCV = 0; |
| static CvCreateFileCapture_Plugin icvCreateFileCapture_FFMPEG_p = 0; |
| //static CvCreateFileCapture_Plugin icvCreateFileCapture_FFMPEG_p = 0; |
| static CvReleaseCapture_Plugin icvReleaseCapture_FFMPEG_p = 0; |
| //static CvReleaseCapture_Plugin icvReleaseCapture_FFMPEG_p = 0; |
| static CvGrabFrame_Plugin icvGrabFrame_FFMPEG_p = 0; |
| //static CvGrabFrame_Plugin icvGrabFrame_FFMPEG_p = 0; |
| static CvRetrieveFrame_Plugin icvRetrieveFrame_FFMPEG_p = 0; |
| //static CvRetrieveFrame_Plugin icvRetrieveFrame_FFMPEG_p = 0; |
| static CvSetCaptureProperty_Plugin icvSetCaptureProperty_FFMPEG_p = 0; |
| //static CvSetCaptureProperty_Plugin icvSetCaptureProperty_FFMPEG_p = 0; |
| static CvGetCaptureProperty_Plugin icvGetCaptureProperty_FFMPEG_p = 0; |
| //static CvGetCaptureProperty_Plugin icvGetCaptureProperty_FFMPEG_p = 0; |
| static CvCreateVideoWriter_Plugin icvCreateVideoWriter_FFMPEG_p = 0; |
| //static CvCreateVideoWriter_Plugin icvCreateVideoWriter_FFMPEG_p = 0; |
| static CvReleaseVideoWriter_Plugin icvReleaseVideoWriter_FFMPEG_p = 0; |
| //static CvReleaseVideoWriter_Plugin icvReleaseVideoWriter_FFMPEG_p = 0; |
| static CvWriteFrame_Plugin icvWriteFrame_FFMPEG_p = 0; |
| //static CvWriteFrame_Plugin icvWriteFrame_FFMPEG_p = 0; |
| |
| |
| static void |
| //static void |
| icvInitFFMPEG(void) |
| //icvInitFFMPEG(void) |
| { |
| //{ |
| static int ffmpegInitialized = 0; |
| // static int ffmpegInitialized = 0; |
| if( !ffmpegInitialized ) |
| // if( !ffmpegInitialized ) |
| { |
| // { |
| #ifdef __MINGW32__ |
| //#ifdef __MINGW32__ |
| #define ffopencv_prefix "lib" |
| //#define ffopencv_prefix "lib" |
| #else |
| //#else |
| #define ffopencv_prefix "" |
| //#define ffopencv_prefix "" |
| #endif |
| //#endif |
| #if defined(_DEBUG) |
| //#if defined(_DEBUG) |
| #define ffopencv_suffix_dbg "d" |
| //#define ffopencv_suffix_dbg "d" |
| #else |
| //#else |
| #define ffopencv_suffix_dbg "" |
| //#define ffopencv_suffix_dbg "" |
| #endif |
| //#endif |
| #if defined EM64T |
| //#if defined EM64T |
| #define ffopencv_suffix "_64" |
| //#define ffopencv_suffix "_64" |
| #else |
| //#else |
| #define ffopencv_suffix "" |
| //#define ffopencv_suffix "" |
| #endif |
| //#endif |
| |
| // |
| #define ffopencv_name_m2(a,b,c) ffopencv_prefix "opencv_ffmpeg" #a #b #c ffopencv_suffix ffopencv_suffix_dbg ".dll" |
| //#define ffopencv_name_m2(a,b,c) ffopencv_prefix "opencv_ffmpeg" #a #b #c ffopencv_suffix ffopencv_suffix_dbg ".dll" |
| #define ffopencv_name_m(a,b,c) ffopencv_name_m2(a,b,c) |
| //#define ffopencv_name_m(a,b,c) ffopencv_name_m2(a,b,c) |
| const char* ffopencv_name = |
| // const char* ffopencv_name = |
| ffopencv_name_m(CV_MAJOR_VERSION,CV_MINOR_VERSION,CV_SUBMINOR_VERSION); |
| // ffopencv_name_m(CV_MAJOR_VERSION,CV_MINOR_VERSION,CV_SUBMINOR_VERSION); |
| |
| // |
| icvFFOpenCV = LoadLibrary( ffopencv_name ); |
| // icvFFOpenCV = LoadLibrary( ffopencv_name ); |
| if( icvFFOpenCV ) |
| // if( icvFFOpenCV ) |
| { |
| // { |
| icvCreateFileCapture_FFMPEG_p = |
| // icvCreateFileCapture_FFMPEG_p = |
| (CvCreateFileCapture_Plugin)GetProcAddress(icvFFOpenCV, "cvCreateFileCapture_FFMPEG"); |
| // (CvCreateFileCapture_Plugin)GetProcAddress(icvFFOpenCV, "cvCreateFileCapture_FFMPEG"); |
| icvReleaseCapture_FFMPEG_p = |
| // icvReleaseCapture_FFMPEG_p = |
| (CvReleaseCapture_Plugin)GetProcAddress(icvFFOpenCV, "cvReleaseCapture_FFMPEG"); |
| // (CvReleaseCapture_Plugin)GetProcAddress(icvFFOpenCV, "cvReleaseCapture_FFMPEG"); |
| icvGrabFrame_FFMPEG_p = |
| // icvGrabFrame_FFMPEG_p = |
| (CvGrabFrame_Plugin)GetProcAddress(icvFFOpenCV, "cvGrabFrame_FFMPEG"); |
| // (CvGrabFrame_Plugin)GetProcAddress(icvFFOpenCV, "cvGrabFrame_FFMPEG"); |
| icvRetrieveFrame_FFMPEG_p = |
| // icvRetrieveFrame_FFMPEG_p = |
| (CvRetrieveFrame_Plugin)GetProcAddress(icvFFOpenCV, "cvRetrieveFrame_FFMPEG"); |
| // (CvRetrieveFrame_Plugin)GetProcAddress(icvFFOpenCV, "cvRetrieveFrame_FFMPEG"); |
| icvSetCaptureProperty_FFMPEG_p = |
| // icvSetCaptureProperty_FFMPEG_p = |
| (CvSetCaptureProperty_Plugin)GetProcAddress(icvFFOpenCV, "cvSetCaptureProperty_FFMPEG"); |
| // (CvSetCaptureProperty_Plugin)GetProcAddress(icvFFOpenCV, "cvSetCaptureProperty_FFMPEG"); |
| icvGetCaptureProperty_FFMPEG_p = |
| // icvGetCaptureProperty_FFMPEG_p = |
| (CvGetCaptureProperty_Plugin)GetProcAddress(icvFFOpenCV, "cvGetCaptureProperty_FFMPEG"); |
| // (CvGetCaptureProperty_Plugin)GetProcAddress(icvFFOpenCV, "cvGetCaptureProperty_FFMPEG"); |
| icvCreateVideoWriter_FFMPEG_p = |
| // icvCreateVideoWriter_FFMPEG_p = |
| (CvCreateVideoWriter_Plugin)GetProcAddress(icvFFOpenCV, "cvCreateVideoWriter_FFMPEG"); |
| // (CvCreateVideoWriter_Plugin)GetProcAddress(icvFFOpenCV, "cvCreateVideoWriter_FFMPEG"); |
| icvReleaseVideoWriter_FFMPEG_p = |
| // icvReleaseVideoWriter_FFMPEG_p = |
| (CvReleaseVideoWriter_Plugin)GetProcAddress(icvFFOpenCV, "cvReleaseVideoWriter_FFMPEG"); |
| // (CvReleaseVideoWriter_Plugin)GetProcAddress(icvFFOpenCV, "cvReleaseVideoWriter_FFMPEG"); |
| icvWriteFrame_FFMPEG_p = |
| // icvWriteFrame_FFMPEG_p = |
| (CvWriteFrame_Plugin)GetProcAddress(icvFFOpenCV, "cvWriteFrame_FFMPEG"); |
| // (CvWriteFrame_Plugin)GetProcAddress(icvFFOpenCV, "cvWriteFrame_FFMPEG"); |
| } |
| // } |
| ffmpegInitialized = 1; |
| // ffmpegInitialized = 1; |
| } |
| // } |
| } |
| //} |
| |
| |
| |
| |
| class CvCapture_FFMPEG_proxy : public CvCapture |
| class CvCapture_FFMPEG_proxy : public CvCapture |
| { |
| { |
| public: |
| public: |
| CvCapture_FFMPEG_proxy() { ffmpegCapture = 0; } |
| CvCapture_FFMPEG_proxy() { ffmpegCapture = 0; } |
| virtual ~CvCapture_FFMPEG_proxy() { close(); } |
| virtual ~CvCapture_FFMPEG_proxy() { close(); } |
| |
| |
| virtual double getProperty(int propId) |
| virtual double getProperty(int propId) |
| { |
| { |
| return ffmpegCapture ? icvGetCaptureProperty_FFMPEG_p(ffmpegCapture, propId) : 0; |
| return ffmpegCapture ? cvGetCaptureProperty_FFMPEG(ffmpegCapture, propId) : 0; |
| } |
| } |
| virtual bool setProperty(int propId, double value) |
| virtual bool setProperty(int propId, double value) |
| { |
| { |
| return ffmpegCapture ? icvSetCaptureProperty_FFMPEG_p(ffmpegCapture, propId, value)!=0 : false; |
| return ffmpegCapture ? cvSetCaptureProperty_FFMPEG(ffmpegCapture, propId, value)!=0 : false; |
| } |
| } |
| virtual bool grabFrame() |
| virtual bool grabFrame() |
| { |
| { |
| return ffmpegCapture ? icvGrabFrame_FFMPEG_p(ffmpegCapture)!=0 : false; |
| return ffmpegCapture ? cvGrabFrame_FFMPEG(ffmpegCapture)!=0 : false; |
| } |
| } |
| virtual IplImage* retrieveFrame(int) |
| virtual IplImage* retrieveFrame(int) |
| { |
| { |
| return ffmpegCapture ? icvRetrieveFrame_FFMPEG_p(ffmpegCapture,0) : 0; |
| return ffmpegCapture ? cvRetrieveFrame_FFMPEG(ffmpegCapture,0) : 0; |
| } |
| } |
| virtual bool open( const char* filename ) |
| virtual bool open( const char* filename ) |
| { |
| { |
| close(); |
| close(); |
| |
| |
| icvInitFFMPEG(); |
| //icvInitFFMPEG(); |
| if( !icvCreateFileCapture_FFMPEG_p ) |
| //if( !icvCreateFileCapture_FFMPEG_p ) |
| return false; |
| // return false; |
| ffmpegCapture = icvCreateFileCapture_FFMPEG_p( filename ); |
| ffmpegCapture = cvCreateFileCapture_FFMPEG( filename ); |
| return ffmpegCapture != 0; |
| return ffmpegCapture != 0; |
| } |
| } |
| virtual void close() |
| virtual void close() |
| { |
| { |
| if( ffmpegCapture && icvReleaseCapture_FFMPEG_p ) |
| if( ffmpegCapture ) |
| icvReleaseCapture_FFMPEG_p( &ffmpegCapture ); |
| cvReleaseCapture_FFMPEG( &ffmpegCapture ); |
| assert( ffmpegCapture == 0 ); |
| assert( ffmpegCapture == 0 ); |
| ffmpegCapture = 0; |
| ffmpegCapture = 0; |
| } |
| } |
| |
| |
| protected: |
| protected: |
| void* ffmpegCapture; |
| CvCapture* ffmpegCapture; |
| }; |
| }; |
| |
| |
| |
| |
| CvCapture* cvCreateFileCapture_Win32(const char * filename) |
| CvCapture* cvCreateFileCapture_Win32(const char * filename) |
| { |
| { |
| CvCapture_FFMPEG_proxy* result = new CvCapture_FFMPEG_proxy; |
| CvCapture_FFMPEG_proxy* result = new CvCapture_FFMPEG_proxy; |
| if( result->open( filename )) |
| if( result->open( filename )) |
| return result; |
| return result; |
| delete result; |
| delete result; |
| return cvCreateFileCapture_VFW(filename); |
| return cvCreateFileCapture_VFW(filename); |
| } |
| } |
| |
| |
| |
| |
| class CvVideoWriter_FFMPEG_proxy : public CvVideoWriter |
| class CvVideoWriter_FFMPEG_proxy : public CvVideoWriter |
| { |
| { |
| public: |
| public: |
| CvVideoWriter_FFMPEG_proxy() { ffmpegWriter = 0; } |
| CvVideoWriter_FFMPEG_proxy() { ffmpegWriter = 0; } |
| virtual ~CvVideoWriter_FFMPEG_proxy() { close(); } |
| virtual ~CvVideoWriter_FFMPEG_proxy() { close(); } |
| |
| |
| virtual bool writeFrame( const IplImage* image ) |
| virtual bool writeFrame( const IplImage* image ) |
| { |
| { |
| return ffmpegWriter ? icvWriteFrame_FFMPEG_p(ffmpegWriter, image)!=0 : false; |
| return ffmpegWriter ? cvWriteFrame_FFMPEG(ffmpegWriter, image)!=0 : false; |
| } |
| } |
| virtual bool open( const char* filename, int fourcc, double fps, CvSize frameSize, bool isColor ) |
| virtual bool open( const char* filename, int fourcc, double fps, CvSize frameSize, bool isColor ) |
| { |
| { |
| close(); |
| close(); |
| icvInitFFMPEG(); |
| //icvInitFFMPEG(); |
| if( !icvCreateVideoWriter_FFMPEG_p ) |
| //if( !icvCreateVideoWriter_FFMPEG_p ) |
| return false; |
| // return false; |
| ffmpegWriter = icvCreateVideoWriter_FFMPEG_p( filename, fourcc, fps, frameSize, isColor ); |
| ffmpegWriter = cvCreateVideoWriter_FFMPEG( filename, fourcc, fps, frameSize, isColor ); |
| return ffmpegWriter != 0; |
| return ffmpegWriter != 0; |
| } |
| } |
| |
| |
| virtual void close() |
| virtual void close() |
| { |
| { |
| if( ffmpegWriter && icvReleaseVideoWriter_FFMPEG_p ) |
| if( ffmpegWriter ) |
| icvReleaseVideoWriter_FFMPEG_p( &ffmpegWriter ); |
| cvReleaseVideoWriter_FFMPEG( &ffmpegWriter ); |
| assert( ffmpegWriter == 0 ); |
| assert( ffmpegWriter == 0 ); |
| ffmpegWriter = 0; |
| ffmpegWriter = 0; |
| } |
| } |
| |
| |
| protected: |
| protected: |
| void* ffmpegWriter; |
| CvVideoWriter* ffmpegWriter; |
| }; |
| }; |
| |
| |
| |
| |
| CvVideoWriter* cvCreateVideoWriter_Win32( const char* filename, int fourcc, |
| CvVideoWriter* cvCreateVideoWriter_Win32( const char* filename, int fourcc, |
| double fps, CvSize frameSize, int isColor ) |
| double fps, CvSize frameSize, int isColor ) |
| { |
| { |
| CvVideoWriter_FFMPEG_proxy* result = new CvVideoWriter_FFMPEG_proxy; |
| CvVideoWriter_FFMPEG_proxy* result = new CvVideoWriter_FFMPEG_proxy; |
| |
| |
| if( result->open( filename, fourcc, fps, frameSize, isColor != 0 )) |
| if( result->open( filename, fourcc, fps, frameSize, isColor != 0 )) |
| return result; |
| return result; |
| delete result; |
| delete result; |
| |
| |
| return cvCreateVideoWriter_VFW(filename, fourcc, fps, frameSize, isColor); |
| return cvCreateVideoWriter_VFW(filename, fourcc, fps, frameSize, isColor); |
| } |
| } |
| |
| |