/*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"

#if (defined WIN32 || defined _WIN32) && defined HAVE_VIDEOINPUT

/*

   DirectShow-based Video Capturing module is based on

   videoInput library by Theodore Watson:

   http://muonics.net/school/spring05/videoInput/

   Below is the original copyright

*/    

//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

//THE SOFTWARE.

//////////////////////////////////////////////////////////

//Written by Theodore Watson - [email protected]    //

//Do whatever you want with this code but if you find   //

//a bug or make an improvement I would love to know!    //

//                                                                                                                //

//Warning This code is experimental                                         //

//use at your own risk :)                                                                //

//////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////

/*                     Shoutouts

Thanks to:

                   Dillip Kumar Kara for crossbar code.

                   Zachary Lieberman for getting me into this stuff

                   and for being so generous with time and code.

                   The guys at Potion Design for helping me with VC++

                   Josh Fisher for being a serious C++ nerd :)

                   Golan Levin for helping me debug the strangest

                   and slowest bug in the world!

                   And all the people using this library who send in

                   bugs, suggestions and improvements who keep me working on

                   the next version - yeah thanks a lot ;)

*/

/////////////////////////////////////////////////////////

#include "precomp.hpp"

#if _MSC_VER >= 100

#pragma warning(disable: 4995)

#endif

#include <tchar.h>

#include <stdlib.h>

#include <stdio.h>

#include <math.h>

#include <string.h>

#include <wchar.h>

#include <vector>

//Include Directshow stuff here so we don't worry about needing all the h files.

#if _MSC_VER >= 1500

#include "DShow.h"

#include "strmif.h"

#include "Aviriff.h"

#include "dvdmedia.h"

#include "bdaiface.h"

#else

#ifdef _MSC_VER

#define __extension__

typedef BOOL WINBOOL;

#endif

#include "dshow/dshow.h"

#include "dshow/dvdmedia.h"

#include "dshow/bdatypes.h"

interface IEnumPIDMap : public IUnknown

{

public:

    virtual HRESULT STDMETHODCALLTYPE Next( 

        /* [in] */ ULONG cRequest,

        /* [size_is][out][in] */ PID_MAP *pPIDMap,

        /* [out] */ ULONG *pcReceived) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip( 

        /* [in] */ ULONG cRecords) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clone( 

        /* [out] */ IEnumPIDMap **ppIEnumPIDMap) = 0;    

};

interface IMPEG2PIDMap : public IUnknown

{

    virtual HRESULT STDMETHODCALLTYPE MapPID( 

        /* [in] */ ULONG culPID,

        /* [in] */ ULONG *pulPID,

        /* [in] */ MEDIA_SAMPLE_CONTENT MediaSampleContent) = 0;

    virtual HRESULT STDMETHODCALLTYPE UnmapPID( 

        /* [in] */ ULONG culPID,

        /* [in] */ ULONG *pulPID) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumPIDMap( 

        /* [out] */ IEnumPIDMap **pIEnumPIDMap) = 0;    

};

#endif

//for threading

#include <process.h>

//this is for TryEnterCriticalSection

#ifndef _WIN32_WINNT

#define _WIN32_WINNT 0x400

#endif

/*

MEDIASUBTYPE_I420 : TGUID ='{30323449-0000-0010-8000-00AA00389B71}';

MEDIASUBTYPE_Y800 : TGUID ='{30303859-0000-0010-8000-00AA00389B71}';

MEDIASUBTYPE_Y8 : TGUID ='{20203859-0000-0010-8000-00AA00389B71}';

MEDIASUBTYPE_Y160 : TGUID ='{30363159-0000-0010-8000-00AA00389B71}';

MEDIASUBTYPE_YV16 : TGUID ='{32315659-0000-0010-8000-00AA00389B71}';

MEDIASUBTYPE_Y422 : TGUID ='{32323459-0000-0010-8000-00AA00389B71}';

MEDIASUBTYPE_GREY : TGUID ='{59455247-0000-0010-8000-00AA00389B71}';

*/

#include <initguid.h>

DEFINE_GUID(MEDIASUBTYPE_GREY, 0x59455247, 0x0000, 0x0010, 0x80, 0x00,

    0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);

DEFINE_GUID(MEDIASUBTYPE_Y8, 0x20203859, 0x0000, 0x0010, 0x80, 0x00,

    0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);

DEFINE_GUID(MEDIASUBTYPE_Y800, 0x30303859, 0x0000, 0x0010, 0x80, 0x00, 

    0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);

DEFINE_GUID(CLSID_CaptureGraphBuilder2,0xbf87b6e1,0x8c27,0x11d0,0xb3,0xf0,0x00,0xaa,0x00,0x37,0x61,0xc5);

DEFINE_GUID(CLSID_FilterGraph,0xe436ebb3,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70);

DEFINE_GUID(CLSID_NullRenderer,0xc1f400a4,0x3f08,0x11d3,0x9f,0x0b,0x00,0x60,0x08,0x03,0x9e,0x37);

DEFINE_GUID(CLSID_SampleGrabber,0xc1f400a0,0x3f08,0x11d3,0x9f,0x0b,0x00,0x60,0x08,0x03,0x9e,0x37);

DEFINE_GUID(CLSID_SystemDeviceEnum,0x62be5d10,0x60eb,0x11d0,0xbd,0x3b,0x00,0xa0,0xc9,0x11,0xce,0x86);

DEFINE_GUID(CLSID_VideoInputDeviceCategory,0x860bb310,0x5d01,0x11d0,0xbd,0x3b,0x00,0xa0,0xc9,0x11,0xce,0x86);

DEFINE_GUID(FORMAT_VideoInfo,0x05589f80,0xc356,0x11ce,0xbf,0x01,0x00,0xaa,0x00,0x55,0x59,0x5a);

DEFINE_GUID(IID_IAMAnalogVideoDecoder,0xc6e13350,0x30ac,0x11d0,0xa1,0x8c,0x00,0xa0,0xc9,0x11,0x89,0x56);

DEFINE_GUID(IID_IAMCameraControl,0xc6e13370,0x30ac,0x11d0,0xa1,0x8c,0x00,0xa0,0xc9,0x11,0x89,0x56);

DEFINE_GUID(IID_IAMCrossbar,0xc6e13380,0x30ac,0x11d0,0xa1,0x8c,0x00,0xa0,0xc9,0x11,0x89,0x56);

DEFINE_GUID(IID_IAMStreamConfig,0xc6e13340,0x30ac,0x11d0,0xa1,0x8c,0x00,0xa0,0xc9,0x11,0x89,0x56);

DEFINE_GUID(IID_IAMVideoProcAmp,0xc6e13360,0x30ac,0x11d0,0xa1,0x8c,0x00,0xa0,0xc9,0x11,0x89,0x56);

DEFINE_GUID(IID_IBaseFilter,0x56a86895,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70);

DEFINE_GUID(IID_ICaptureGraphBuilder2,0x93e5a4e0,0x2d50,0x11d2,0xab,0xfa,0x00,0xa0,0xc9,0xc6,0xe3,0x8d);

DEFINE_GUID(IID_ICreateDevEnum,0x29840822,0x5b84,0x11d0,0xbd,0x3b,0x00,0xa0,0xc9,0x11,0xce,0x86);

DEFINE_GUID(IID_IGraphBuilder,0x56a868a9,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70);

DEFINE_GUID(IID_IMPEG2PIDMap,0xafb6c2a1,0x2c41,0x11d3,0x8a,0x60,0x00,0x00,0xf8,0x1e,0x0e,0x4a);

DEFINE_GUID(IID_IMediaControl,0x56a868b1,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70);

DEFINE_GUID(IID_IMediaFilter,0x56a86899,0x0ad4,0x11ce,0xb0,0x3a,0x00,0x20,0xaf,0x0b,0xa7,0x70);

DEFINE_GUID(IID_ISampleGrabber,0x6b652fff,0x11fe,0x4fce,0x92,0xad,0x02,0x66,0xb5,0xd7,0xc7,0x8f);

DEFINE_GUID(LOOK_UPSTREAM_ONLY,0xac798be0,0x98e3,0x11d1,0xb3,0xf1,0x00,0xaa,0x00,0x37,0x61,0xc5);

DEFINE_GUID(MEDIASUBTYPE_AYUV,0x56555941,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIASUBTYPE_IYUV,0x56555949,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIASUBTYPE_RGB24,0xe436eb7d,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70);

DEFINE_GUID(MEDIASUBTYPE_RGB32,0xe436eb7e,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70);

DEFINE_GUID(MEDIASUBTYPE_RGB555,0xe436eb7c,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70);

DEFINE_GUID(MEDIASUBTYPE_RGB565,0xe436eb7b,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70);

DEFINE_GUID(MEDIASUBTYPE_UYVY,0x59565955,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIASUBTYPE_Y211,0x31313259,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIASUBTYPE_Y411,0x31313459,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIASUBTYPE_Y41P,0x50313459,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIASUBTYPE_YUY2,0x32595559,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIASUBTYPE_YUYV,0x56595559,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIASUBTYPE_YV12,0x32315659,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIASUBTYPE_YVU9,0x39555659,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIASUBTYPE_YVYU,0x55595659,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIASUBTYPE_MJPG,0x47504A4D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); // MGB 

DEFINE_GUID(MEDIATYPE_Interleaved,0x73766169,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(MEDIATYPE_Video,0x73646976,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

DEFINE_GUID(PIN_CATEGORY_CAPTURE,0xfb6c4281,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba);

DEFINE_GUID(PIN_CATEGORY_PREVIEW,0xfb6c4282,0x0353,0x11d1,0x90,0x5f,0x00,0x00,0xc0,0xcc,0x16,0xba);

interface ISampleGrabberCB : public IUnknown

{

    virtual HRESULT STDMETHODCALLTYPE SampleCB(

        double SampleTime,

        IMediaSample *pSample) = 0;

    virtual HRESULT STDMETHODCALLTYPE BufferCB(

        double SampleTime,

        BYTE *pBuffer,

        LONG BufferLen) = 0;

};

interface ISampleGrabber : public IUnknown

{

    virtual HRESULT STDMETHODCALLTYPE SetOneShot(

        BOOL OneShot) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetMediaType(

        const AM_MEDIA_TYPE *pType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetConnectedMediaType(

        AM_MEDIA_TYPE *pType) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetBufferSamples(

        BOOL BufferThem) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurrentBuffer(

        LONG *pBufferSize,

        LONG *pBuffer) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurrentSample(

        IMediaSample **ppSample) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetCallback(

        ISampleGrabberCB *pCallback,

        LONG WhichMethodToCallback) = 0;

};

#ifndef HEADER

#define HEADER(p) (&(((VIDEOINFOHEADER*)(p))->bmiHeader))

#endif

//Example Usage

/*

        //create a videoInput object

        videoInput VI;

        //Prints out a list of available devices and returns num of devices found

        int numDevices = VI.listDevices();        

        int device1 = 0;  //this could be any deviceID that shows up in listDevices

        int device2 = 1;  //this could be any deviceID that shows up in listDevices

        //if you want to capture at a different frame rate (default is 30) 

        //specify it here, you are not guaranteed to get this fps though.

        //VI.setIdealFramerate(dev, 60);        

        //setup the first device - there are a number of options:

        VI.setupDevice(device1);                                                   //setup the first device with the default settings

        //VI.setupDevice(device1, VI_COMPOSITE);                           //or setup device with specific connection type

        //VI.setupDevice(device1, 320, 240);                                  //or setup device with specified video size

        //VI.setupDevice(device1, 320, 240, VI_COMPOSITE);  //or setup device with video size and connection type

        //VI.setFormat(device1, VI_NTSC_M);                                        //if your card doesn't remember what format it should be

                                                                                                                //call this with the appropriate format listed above

                                                                                                                //NOTE: must be called after setupDevice!

        //optionally setup a second (or third, fourth ...) device - same options as above

        VI.setupDevice(device2);                                                   

        //As requested width and height can not always be accomodated

        //make sure to check the size once the device is setup

        int width         = VI.getWidth(device1);

        int height         = VI.getHeight(device1);

        int size        = VI.getSize(device1);

        unsigned char * yourBuffer1 = new unsigned char[size];

        unsigned char * yourBuffer2 = new unsigned char[size];

        //to get the data from the device first check if the data is new

        if(VI.isFrameNew(device1)){

                VI.getPixels(device1, yourBuffer1, false, false);        //fills pixels as a BGR (for openCV) unsigned char array - no flipping

                VI.getPixels(device1, yourBuffer2, true, true);         //fills pixels as a RGB (for openGL) unsigned char array - flipping!

        }

        //same applies to device2 etc

        //to get a settings dialog for the device

        VI.showSettingsWindow(device1);

        //Shut down devices properly

        VI.stopDevice(device1);

        VI.stopDevice(device2);

*/

//////////////////////////////////////   VARS AND DEFS   //////////////////////////////////

//STUFF YOU CAN CHANGE

//change for verbose debug info

static bool verbose = true;

//if you need VI to use multi threaded com

//#define VI_COM_MULTI_THREADED

//STUFF YOU DON'T CHANGE

//videoInput defines

#define VI_VERSION         0.1995

#define VI_MAX_CAMERAS  20

#define VI_NUM_TYPES    19 //MGB

#define VI_NUM_FORMATS  18 //DON'T TOUCH

//defines for setPhyCon - tuner is not as well supported as composite and s-video 

#define VI_COMPOSITE 0

#define VI_S_VIDEO   1

#define VI_TUNER     2

#define VI_USB       3

#define VI_1394                 4

//defines for formats

#define VI_NTSC_M        0

#define VI_PAL_B        1

#define VI_PAL_D        2

#define VI_PAL_G        3

#define VI_PAL_H        4

#define VI_PAL_I        5

#define VI_PAL_M        6

#define VI_PAL_N        7

#define VI_PAL_NC        8

#define VI_SECAM_B        9

#define VI_SECAM_D        10

#define VI_SECAM_G        11

#define VI_SECAM_H        12

#define VI_SECAM_K        13

#define VI_SECAM_K1        14

#define VI_SECAM_L        15

#define VI_NTSC_M_J        16

#define VI_NTSC_433        17

//allows us to directShow classes here with the includes in the cpp

struct ICaptureGraphBuilder2;

struct IGraphBuilder;

struct IBaseFilter;

struct IAMCrossbar;

struct IMediaControl;

struct ISampleGrabber;

struct IMediaEventEx;

struct IAMStreamConfig;

struct _AMMediaType;

class SampleGrabberCallback;

typedef _AMMediaType AM_MEDIA_TYPE;

//keeps track of how many instances of VI are being used

//don't touch

static int comInitCount = 0;

////////////////////////////////////////   VIDEO DEVICE   ///////////////////////////////////

class videoDevice{

        public:

                videoDevice();

                void setSize(int w, int h);

                void NukeDownstream(IBaseFilter *pBF);

                void destroyGraph();

                ~videoDevice();

                int videoSize;

                int width;

                int height;

                int tryWidth;

                int tryHeight;

                GUID tryVideoType;

                ICaptureGraphBuilder2 *pCaptureGraph;        // Capture graph builder object

                IGraphBuilder *pGraph;                                        // Graph builder object

            IMediaControl *pControl;                                // Media control object

                IBaseFilter *pVideoInputFilter;                  // Video Capture filter                

                IBaseFilter *pGrabberF;

                IBaseFilter * pDestFilter;

                IAMStreamConfig *streamConf;

                ISampleGrabber * pGrabber;                            // Grabs frame

                AM_MEDIA_TYPE * pAmMediaType;

                IMediaEventEx * pMediaEvent;

                GUID videoType;

                long formatType;

                SampleGrabberCallback * sgCallback;                                

                bool tryDiffSize;

                bool useCrossbar;

                bool readyToCapture;

                bool sizeSet;

                bool setupStarted;

                bool specificFormat;

                bool autoReconnect;

                int  nFramesForReconnect;

                unsigned long nFramesRunning;

                int  connection;

                int         storeConn;

                int  myID;

                long requestedFrameTime; //ie fps

                char         nDeviceName[255];

                WCHAR         wDeviceName[255];

                unsigned char * pixels;

                char * pBuffer;

};

//////////////////////////////////////   VIDEO INPUT   /////////////////////////////////////

class videoInput{

        public:

                videoInput();

                ~videoInput();

                //turns off console messages - default is to print messages

                static void setVerbose(bool _verbose);

                //Functions in rough order they should be used.

                static int listDevices(bool silent = false);

                //needs to be called after listDevices - otherwise returns NULL

                static char * getDeviceName(int deviceID);

                //choose to use callback based capture - or single threaded

                void setUseCallback(bool useCallback);        

                //call before setupDevice

                //directshow will try and get the closest possible framerate to what is requested

                void setIdealFramerate(int deviceID, int idealFramerate);

                //some devices will stop delivering frames after a while - this method gives you the option to try and reconnect

                //to a device if videoInput detects that a device has stopped delivering frames. 

                //you MUST CALL isFrameNew every app loop for this to have any effect

                void setAutoReconnectOnFreeze(int deviceNumber, bool doReconnect, int numMissedFramesBeforeReconnect);

                //Choose one of these five to setup your device

                bool setupDevice(int deviceID);

                bool setupDevice(int deviceID, int w, int h);

                bool setupDeviceFourcc(int deviceID, int w, int h,int fourcc);

                //These two are only for capture cards

                //USB and Firewire cameras souldn't specify connection 

                bool setupDevice(int deviceID, int connection);        

                bool setupDevice(int deviceID, int w, int h, int connection); 

                bool setFourcc(int deviceNumber, int fourcc);        

                //If you need to you can set your NTSC/PAL/SECAM

                //preference here. if it is available it will be used.

                //see #defines above for available formats - eg VI_NTSC_M or VI_PAL_B

                //should be called after setupDevice

                //can be called multiple times

                bool setFormat(int deviceNumber, int format);        

                //Tells you when a new frame has arrived - you should call this if you have specified setAutoReconnectOnFreeze to true

                bool isFrameNew(int deviceID); 

                bool isDeviceSetup(int deviceID);

                //Returns the pixels - flipRedAndBlue toggles RGB/BGR flipping - and you can flip the image too

                unsigned char * getPixels(int deviceID, bool flipRedAndBlue = true, bool flipImage = false);

                //Or pass in a buffer for getPixels to fill returns true if successful.

                bool getPixels(int id, unsigned char * pixels, bool flipRedAndBlue = true, bool flipImage = false);

                //Launches a pop up settings window

                //For some reason in GLUT you have to call it twice each time. 

                void showSettingsWindow(int deviceID);

                //Manual control over settings thanks..... 

                //These are experimental for now.

                bool setVideoSettingFilter(int deviceID, long Property, long lValue, long Flags = NULL, bool useDefaultValue = false);

                bool setVideoSettingFilterPct(int deviceID, long Property, float pctValue, long Flags = NULL);

                bool getVideoSettingFilter(int deviceID, long Property, long &min, long &max, long &SteppingDelta, long &currentValue, long &flags, long &defaultValue);

                bool setVideoSettingCamera(int deviceID, long Property, long lValue, long Flags = NULL, bool useDefaultValue = false);

                bool setVideoSettingCameraPct(int deviceID, long Property, float pctValue, long Flags = NULL);

                bool getVideoSettingCamera(int deviceID, long Property, long &min, long &max, long &SteppingDelta, long &currentValue, long &flags, long &defaultValue);

                //bool setVideoSettingCam(int deviceID, long Property, long lValue, long Flags = NULL, bool useDefaultValue = false);

                //get width, height and number of pixels

                int  getWidth(int deviceID);

                int  getHeight(int deviceID);

                int  getSize(int deviceID);

                int  getFourcc(int deviceID);

                double getFPS(int deviceID);

                //completely stops and frees a device

                void stopDevice(int deviceID);

                //as above but then sets it up with same settings

                bool restartDevice(int deviceID);

                //number of devices available

                int  devicesFound;

                // mapping from OpenCV CV_CAP_PROP to videoinput/dshow properties

                int getVideoPropertyFromCV(int cv_property);

                int getCameraPropertyFromCV(int cv_property);

        private:                

                void setPhyCon(int deviceID, int conn);                   

                void setAttemptCaptureSize(int deviceID, int w, int h,GUID mediaType=MEDIASUBTYPE_RGB24);   

                bool setup(int deviceID);

                void processPixels(unsigned char * src, unsigned char * dst, int width, int height, bool bRGB, bool bFlip);

                int  start(int deviceID, videoDevice * VD);                   

                int  getDeviceCount();

                void getMediaSubtypeAsString(GUID type, char * typeAsString);

                GUID *getMediaSubtypeFromFourcc(int fourcc);

                int        getFourccFromMediaSubtype(GUID type);

                void getVideoPropertyAsString(int prop, char * propertyAsString);

                void getCameraPropertyAsString(int prop, char * propertyAsString);

                HRESULT getDevice(IBaseFilter **pSrcFilter, int deviceID, WCHAR * wDeviceName, char * nDeviceName);

                static HRESULT ShowFilterPropertyPages(IBaseFilter *pFilter);

                static HRESULT ShowStreamPropertyPages(IAMStreamConfig  *pStream);

                HRESULT SaveGraphFile(IGraphBuilder *pGraph, WCHAR *wszPath);

                HRESULT routeCrossbar(ICaptureGraphBuilder2 **ppBuild, IBaseFilter **pVidInFilter, int conType, GUID captureMode);

                //don't touch

                static bool comInit();

                static bool comUnInit();

                int  connection;

                int  callbackSetCount;

                bool bCallback;

                GUID CAPTURE_MODE;

                //Extra video subtypes

                GUID MEDIASUBTYPE_Y800;

                GUID MEDIASUBTYPE_Y8;

                GUID MEDIASUBTYPE_GREY;

                videoDevice * VDList[VI_MAX_CAMERAS];

                GUID mediaSubtypes[VI_NUM_TYPES];

                long formatTypes[VI_NUM_FORMATS];

                static void __cdecl basicThread(void * objPtr);

                static char deviceNames[VI_MAX_CAMERAS][255];

}; 

///////////////////////////  HANDY FUNCTIONS  /////////////////////////////

void MyFreeMediaType(AM_MEDIA_TYPE& mt){

    if (mt.cbFormat != 0)

    {

        CoTaskMemFree((PVOID)mt.pbFormat);

        mt.cbFormat = 0;

        mt.pbFormat = NULL;

    }

    if (mt.pUnk != NULL)

    {

        // Unecessary because pUnk should not be used, but safest.

        mt.pUnk->Release();

        mt.pUnk = NULL;

    }

}

void MyDeleteMediaType(AM_MEDIA_TYPE *pmt)

{

    if (pmt != NULL)

    {

        MyFreeMediaType(*pmt); 

        CoTaskMemFree(pmt);

    }

}

//////////////////////////////  CALLBACK  ////////////////////////////////

//Callback class

class SampleGrabberCallback : public ISampleGrabberCB{

public:

        //------------------------------------------------

        SampleGrabberCallback(){

                InitializeCriticalSection(&critSection);

                freezeCheck = 0;

                bufferSetup                 = false;

                newFrame                        = false;

                latestBufferLength         = 0;

                hEvent = CreateEvent(NULL, true, false, NULL);

        }

        //------------------------------------------------

        ~SampleGrabberCallback(){

                ptrBuffer = NULL;

                DeleteCriticalSection(&critSection);

                CloseHandle(hEvent);

                if(bufferSetup){

                        delete pixels;

                }

        }        

        //------------------------------------------------

        bool setupBuffer(int numBytesIn){

                if(bufferSetup){

                        return false;

                }else{

                        numBytes                         = numBytesIn;

                        pixels                                 = new unsigned char[numBytes];

                        bufferSetup                 = true;

                        newFrame                        = false;

                        latestBufferLength         = 0;

                }

                return true;

        }

        //------------------------------------------------

    STDMETHODIMP_(ULONG) AddRef() { return 1; }

    STDMETHODIMP_(ULONG) Release() { return 2; }

        //------------------------------------------------

    STDMETHODIMP QueryInterface(REFIID, void **ppvObject){

        *ppvObject = static_cast<ISampleGrabberCB*>(this);

        return S_OK;

    }

    //This method is meant to have less overhead

        //------------------------------------------------

    STDMETHODIMP SampleCB(double , IMediaSample *pSample){

            if(WaitForSingleObject(hEvent, 0) == WAIT_OBJECT_0) return S_OK;

            HRESULT hr = pSample->GetPointer(&ptrBuffer);  

            if(hr == S_OK){

                    latestBufferLength = pSample->GetActualDataLength();                            

                      if(latestBufferLength == numBytes){

                                EnterCriticalSection(&critSection);

                                      memcpy(pixels, ptrBuffer, latestBufferLength);        

                                        newFrame        = true;

                                        freezeCheck = 1;

                                LeaveCriticalSection(&critSection);

                                SetEvent(hEvent);

                        }else{

                                printf("ERROR: SampleCB() - buffer sizes do not match\n");

                        }

                }

                return S_OK;

    }

    //This method is meant to have more overhead

    STDMETHODIMP BufferCB(double, BYTE *, long){

            return E_NOTIMPL;

    }

        int freezeCheck;

        int latestBufferLength;

        int numBytes;

        bool newFrame;

        bool bufferSetup;

        unsigned char * pixels;

        unsigned char * ptrBuffer;

        CRITICAL_SECTION critSection;

        HANDLE hEvent;        

};

//////////////////////////////  VIDEO DEVICE  ////////////////////////////////

// ---------------------------------------------------------------------- 

//        Should this class also be the callback?                                                                

//                                                                  

// ---------------------------------------------------------------------- 

videoDevice::videoDevice(){

                 pCaptureGraph      = NULL;        // Capture graph builder object

                 pGraph             = NULL;        // Graph builder object

             pControl           = NULL;        // Media control object

                 pVideoInputFilter  = NULL; // Video Capture filter

                 pGrabber           = NULL; // Grabs frame

                 pDestFilter                 = NULL; // Null Renderer Filter

                 pGrabberF                         = NULL; // Grabber Filter

                 pMediaEvent                = NULL; 

                 streamConf                        = NULL;

                 pAmMediaType                = NULL;

                 //This is our callback class that processes the frame.

                 sgCallback                        = new SampleGrabberCallback();

                 sgCallback->newFrame = false;

                 //Default values for capture type

                 videoType                         = MEDIASUBTYPE_RGB24;

             connection             = PhysConn_Video_Composite;

                 storeConn                        = 0;

                 videoSize                         = 0;

             width                             = 0;

             height                            = 0;

             tryWidth                        = 0;

             tryHeight                        = 0;

                 tryVideoType = MEDIASUBTYPE_RGB24;

                 nFramesForReconnect= 10000;

                 nFramesRunning     = 0;

             myID                                = -1;

             tryDiffSize             = false;

             useCrossbar             = false;

                 readyToCapture          = false;

                 sizeSet                        = false;

                 setupStarted                = false;

                 specificFormat                = false;

                 autoReconnect                = false;

                 requestedFrameTime = -1;

                 memset(wDeviceName, 0, sizeof(WCHAR) * 255);

                 memset(nDeviceName, 0, sizeof(char) * 255);

}

// ---------------------------------------------------------------------- 

//        The only place we are doing new                                                        

//                                                                      

// ---------------------------------------------------------------------- 

void videoDevice::setSize(int w, int h){

        if(sizeSet){

                if(verbose)printf("SETUP: Error device size should not be set more than once \n");

        }

        else

        {

                width                                 = w;

                height                                 = h;

                videoSize                         = w*h*3;

                sizeSet                         = true;

                pixels                                = new unsigned char[videoSize];

                pBuffer                                = new char[videoSize];

                memset(pixels, 0 , videoSize);

                sgCallback->setupBuffer(videoSize);

        }

}

// ---------------------------------------------------------------------- 

//        Borrowed from the SDK, use it to take apart the graph from                                                         

//  the capture device downstream to the null renderer                                                                   

// ---------------------------------------------------------------------- 

void videoDevice::NukeDownstream(IBaseFilter *pBF){

        IPin *pP, *pTo;

        ULONG u;

        IEnumPins *pins = NULL;

        PIN_INFO pininfo;

        HRESULT hr = pBF->EnumPins(&pins);

        pins->Reset();

        while (hr == NOERROR)

        {

                hr = pins->Next(1, &pP, &u);

                if (hr == S_OK && pP)

                {

                        pP->ConnectedTo(&pTo);

                        if (pTo)

                        {

                                hr = pTo->QueryPinInfo(&pininfo);

                                if (hr == NOERROR)

                                {

                                        if (pininfo.dir == PINDIR_INPUT)

                                        {

                                                NukeDownstream(pininfo.pFilter);

                                                pGraph->Disconnect(pTo);

                                                pGraph->Disconnect(pP);

                                                pGraph->RemoveFilter(pininfo.pFilter);

                                        }

                                        pininfo.pFilter->Release();

                                                                                pininfo.pFilter = NULL;

                                }

                                pTo->Release();

                        }

                        pP->Release();

                }

        }

        if (pins) pins->Release();

} 

// ---------------------------------------------------------------------- 

//        Also from SDK                                                         

// ---------------------------------------------------------------------- 

void videoDevice::destroyGraph(){

        HRESULT hr = NULL;

         //int FuncRetval=0;

         //int NumFilters=0;

        int i = 0;

        while (hr == NOERROR)        

        {

                IEnumFilters * pEnum = 0;

                ULONG cFetched;

                // We must get the enumerator again every time because removing a filter from the graph

                // invalidates the enumerator. We always get only the first filter from each enumerator.

                hr = pGraph->EnumFilters(&pEnum);

                if (FAILED(hr)) { if(verbose)printf("SETUP: pGraph->EnumFilters() failed. \n"); return; }

                IBaseFilter * pFilter = NULL;

                if (pEnum->Next(1, &pFilter, &cFetched) == S_OK)

                {

                        FILTER_INFO FilterInfo={0};

                        memset(&FilterInfo, 0, sizeof(FilterInfo));

                        hr = pFilter->QueryFilterInfo(&FilterInfo);

                        FilterInfo.pGraph->Release();

                        int count = 0;

                        char buffer[255];

                        memset(buffer, 0, 255 * sizeof(char));

                        while( FilterInfo.achName[count] != 0x00 ) 

                        {

                                buffer[count] = (char)FilterInfo.achName[count];

                                count++;

                        }

                        if(verbose)printf("SETUP: removing filter %s...\n", buffer);

                        hr = pGraph->RemoveFilter(pFilter);

                        if (FAILED(hr)) { if(verbose)printf("SETUP: pGraph->RemoveFilter() failed. \n"); return; }

                        if(verbose)printf("SETUP: filter removed %s  \n",buffer);

                        pFilter->Release();

                        pFilter = NULL;

                }

                else break;

                pEnum->Release();

                pEnum = NULL;

                i++;

        }

 return;

}

// ---------------------------------------------------------------------- 

// Our deconstructor, attempts to tear down graph and release filters etc

// Does checking to make sure it only is freeing if it needs to

// Probably could be a lot cleaner! :)                                                                

// ---------------------------------------------------------------------- 

videoDevice::~videoDevice(){

        if(setupStarted){ if(verbose)printf("\nSETUP: Disconnecting device %i\n", myID); }

        else{

                if(sgCallback){

                        sgCallback->Release();

                        delete sgCallback;

                }

                return;

        }

        HRESULT HR = NOERROR;

        //Stop the callback and free it

    if( (sgCallback) && (pGrabber) )

    {

            pGrabber->SetCallback(NULL, 1);

        if(verbose)printf("SETUP: freeing Grabber Callback\n");

        sgCallback->Release();         

                //delete our pixels 

                if(sizeSet){

                         delete[] pixels;

                         delete[] pBuffer;

                }

                delete sgCallback;

        }

        //Check to see if the graph is running, if so stop it. 

         if( (pControl) )

        {

                HR = pControl->Pause();

                if (FAILED(HR)) if(verbose)printf("ERROR - Could not pause pControl\n");

                HR = pControl->Stop();

                if (FAILED(HR)) if(verbose)printf("ERROR - Could not stop pControl\n");

    }

    //Disconnect filters from capture device

    if( (pVideoInputFilter) )NukeDownstream(pVideoInputFilter);

        //Release and zero pointers to our filters etc

        if( (pDestFilter) ){                 if(verbose)printf("SETUP: freeing Renderer \n");

                                                                (pDestFilter)->Release();

                                                                (pDestFilter) = 0;

        }        

        if( (pVideoInputFilter) ){         if(verbose)printf("SETUP: freeing Capture Source \n");

                                                                (pVideoInputFilter)->Release();                

                                                                (pVideoInputFilter) = 0;

        }

        if( (pGrabberF) ){                         if(verbose)printf("SETUP: freeing Grabber Filter  \n");

                                                                (pGrabberF)->Release();

                                                                (pGrabberF) = 0;                          

        }

        if( (pGrabber) ){                         if(verbose)printf("SETUP: freeing Grabber  \n"); 

                                                                (pGrabber)->Release();

                                                                (pGrabber) = 0;                          

        }

        if( (pControl) ){                         if(verbose)printf("SETUP: freeing Control   \n");

                                                                (pControl)->Release();

                                                                (pControl) = 0;                         

        }                

        if( (pMediaEvent) ){                 if(verbose)printf("SETUP: freeing Media Event  \n");

                                                                (pMediaEvent)->Release();                                

                                                                (pMediaEvent) = 0;                  

        }

        if( (streamConf) ){                 if(verbose)printf("SETUP: freeing Stream  \n");

                                                                (streamConf)->Release();                                        

                                                                (streamConf) = 0;                          

        }

        if( (pAmMediaType) ){                 if(verbose)printf("SETUP: freeing Media Type  \n");

                                                                MyDeleteMediaType(pAmMediaType);                          

        }

        if((pMediaEvent)){

                        if(verbose)printf("SETUP: freeing Media Event  \n");

                        (pMediaEvent)->Release();                                        

                        (pMediaEvent) = 0;  

        }

        //Destroy the graph

        if( (pGraph) )destroyGraph();

        //Release and zero our capture graph and our main graph

        if( (pCaptureGraph) ){                 if(verbose)printf("SETUP: freeing Capture Graph \n");

                                                                (pCaptureGraph)->Release();

                                                                (pCaptureGraph) = 0;                  

        }

        if( (pGraph) ){                         if(verbose)printf("SETUP: freeing Main Graph \n");

                                                                (pGraph)->Release();                                        

                                                                (pGraph) = 0;                                  

        }                

        //delete our pointers

        delete pDestFilter;

        delete pVideoInputFilter;

        delete pGrabberF;

        delete pGrabber;

        delete pControl;

        delete streamConf;

        delete pMediaEvent;

        delete pCaptureGraph;

        delete pGraph;

        if(verbose)printf("SETUP: Device %i disconnected and freed\n\n",myID);

}

//////////////////////////////  VIDEO INPUT  ////////////////////////////////

////////////////////////////  PUBLIC METHODS  ///////////////////////////////

// ---------------------------------------------------------------------- 

// Constructor - creates instances of videoDevice and adds the various

// media subtypes to check.                                               

// ---------------------------------------------------------------------- 

videoInput::videoInput(){    

        //start com

        comInit();

        devicesFound                 = 0;

        callbackSetCount         = 0;

        bCallback                         = true;

    //setup a max no of device objects

    for(int i=0; i<VI_MAX_CAMERAS; i++)  VDList[i] = new videoDevice();

    if(verbose)printf("\n***** VIDEOINPUT LIBRARY - %2.04f - TFW07 *****\n\n",VI_VERSION);

        //added for the pixelink firewire camera

         //MEDIASUBTYPE_Y800 = (GUID)FOURCCMap(FCC('Y800'));

         //MEDIASUBTYPE_Y8   = (GUID)FOURCCMap(FCC('Y8'));

         //MEDIASUBTYPE_GREY = (GUID)FOURCCMap(FCC('GREY'));

        //The video types we support

        //in order of preference

        mediaSubtypes[0]         = MEDIASUBTYPE_RGB24;

        mediaSubtypes[1]         = MEDIASUBTYPE_RGB32;

        mediaSubtypes[2]         = MEDIASUBTYPE_RGB555;

        mediaSubtypes[3]         = MEDIASUBTYPE_RGB565;

        mediaSubtypes[4]         = MEDIASUBTYPE_YUY2;

        mediaSubtypes[5]         = MEDIASUBTYPE_YVYU;

        mediaSubtypes[6]         = MEDIASUBTYPE_YUYV;

        mediaSubtypes[7]         = MEDIASUBTYPE_IYUV;

        mediaSubtypes[8]         = MEDIASUBTYPE_UYVY;

        mediaSubtypes[9]         = MEDIASUBTYPE_YV12;

        mediaSubtypes[10]        = MEDIASUBTYPE_YVU9;

        mediaSubtypes[11]         = MEDIASUBTYPE_Y411;

        mediaSubtypes[12]         = MEDIASUBTYPE_Y41P;

        mediaSubtypes[13]         = MEDIASUBTYPE_Y211;

        mediaSubtypes[14]        = MEDIASUBTYPE_AYUV;

        mediaSubtypes[15]        = MEDIASUBTYPE_MJPG; // MGB

        //non standard

        mediaSubtypes[16]        = MEDIASUBTYPE_Y800;

    mediaSubtypes[17]        = MEDIASUBTYPE_Y8;

        mediaSubtypes[18]        = MEDIASUBTYPE_GREY;        

        //The video formats we support

        formatTypes[VI_NTSC_M]                = AnalogVideo_NTSC_M;

        formatTypes[VI_NTSC_M_J]        = AnalogVideo_NTSC_M_J;

        formatTypes[VI_NTSC_433]        = AnalogVideo_NTSC_433;

        formatTypes[VI_PAL_B]                = AnalogVideo_PAL_B;

        formatTypes[VI_PAL_D]                = AnalogVideo_PAL_D;

        formatTypes[VI_PAL_G]                = AnalogVideo_PAL_G;

        formatTypes[VI_PAL_H]                = AnalogVideo_PAL_H;

        formatTypes[VI_PAL_I]                = AnalogVideo_PAL_I;

        formatTypes[VI_PAL_M]                = AnalogVideo_PAL_M;

        formatTypes[VI_PAL_N]                = AnalogVideo_PAL_N;

        formatTypes[VI_PAL_NC]                = AnalogVideo_PAL_N_COMBO;

        formatTypes[VI_SECAM_B]                = AnalogVideo_SECAM_B;

        formatTypes[VI_SECAM_D]                = AnalogVideo_SECAM_D;

        formatTypes[VI_SECAM_G]                = AnalogVideo_SECAM_G;

        formatTypes[VI_SECAM_H]                = AnalogVideo_SECAM_H;

        formatTypes[VI_SECAM_K]                = AnalogVideo_SECAM_K;

        formatTypes[VI_SECAM_K1]        = AnalogVideo_SECAM_K1;

        formatTypes[VI_SECAM_L]                = AnalogVideo_SECAM_L;

}

// ---------------------------------------------------------------------- 

// static - set whether messages get printed to console or not

//                                            

// ---------------------------------------------------------------------- 

void videoInput::setVerbose(bool _verbose){

        verbose = _verbose;

}

// ---------------------------------------------------------------------- 

// change to use callback or regular capture

// callback tells you when a new frame has arrived

// but non-callback won't - but is single threaded

// ---------------------------------------------------------------------- 

void videoInput::setUseCallback(bool useCallback){

        if(callbackSetCount == 0){

                bCallback = useCallback;

                callbackSetCount = 1;

        }else{

                printf("ERROR: setUseCallback can only be called before setup\n");

        }

}

// ---------------------------------------------------------------------- 

// Set the requested framerate - no guarantee you will get this

//                                            

// ---------------------------------------------------------------------- 

void videoInput::setIdealFramerate(int deviceNumber, int idealFramerate){

        if(deviceNumber >= VI_MAX_CAMERAS || VDList[deviceNumber]->readyToCapture) return;

        if( idealFramerate > 0 ){

                VDList[deviceNumber]->requestedFrameTime = (unsigned long)(10000000 / idealFramerate);

        }

}

// ---------------------------------------------------------------------- 

// Set the requested framerate - no guarantee you will get this

//                                            

// ---------------------------------------------------------------------- 

void videoInput::setAutoReconnectOnFreeze(int deviceNumber, bool doReconnect, int numMissedFramesBeforeReconnect){

        if(deviceNumber >= VI_MAX_CAMERAS) return;

        VDList[deviceNumber]->autoReconnect                        = doReconnect;

        VDList[deviceNumber]->nFramesForReconnect        = numMissedFramesBeforeReconnect;        

}

// ---------------------------------------------------------------------- 

// Setup a device with the default settings

//                                            

// ---------------------------------------------------------------------- 

bool videoInput::setupDevice(int deviceNumber){

        if(deviceNumber >= VI_MAX_CAMERAS || VDList[deviceNumber]->readyToCapture) return false;

        if(setup(deviceNumber))return true;

        return false;

}

// ---------------------------------------------------------------------- 

// Setup a device with the default size but specify input type

//                                            

// ---------------------------------------------------------------------- 

bool videoInput::setupDevice(int deviceNumber, int connection){

        if(deviceNumber >= VI_MAX_CAMERAS || VDList[deviceNumber]->readyToCapture) return false;

        setPhyCon(deviceNumber, connection);

        if(setup(deviceNumber))return true;

        return false;

}

// ---------------------------------------------------------------------- 

// Setup a device with the default connection but specify size 

//                                            

// ---------------------------------------------------------------------- 

bool videoInput::setupDevice(int deviceNumber, int w, int h){ 

        if(deviceNumber >= VI_MAX_CAMERAS || VDList[deviceNumber]->readyToCapture) return false;

        setAttemptCaptureSize(deviceNumber,w,h);

        if(setup(deviceNumber))return true;

        return false;

}

// ---------------------------------------------------------------------- 

// Setup a device with the default connection but specify size and image format

// 

// Note:

// Need a new name for this since signature clashes with ",int connection)"

// ---------------------------------------------------------------------- 

bool videoInput::setupDeviceFourcc(int deviceNumber, int w, int h,int fourcc){ 

        if(deviceNumber >= VI_MAX_CAMERAS || VDList[deviceNumber]->readyToCapture) return false;

        if ( fourcc > 0 ) {

                GUID *mediaType = getMediaSubtypeFromFourcc(fourcc);

                if ( mediaType ) {

                        setAttemptCaptureSize(deviceNumber,w,h,*mediaType);        

                }

        } else {

                setAttemptCaptureSize(deviceNumber,w,h);

        }

        if(setup(deviceNumber))return true;

        return false;

}

// ---------------------------------------------------------------------- 

// Setup a device with specific size and connection

//                                            

// ---------------------------------------------------------------------- 

bool videoInput::setupDevice(int deviceNumber, int w, int h, int connection){

        if(deviceNumber >= VI_MAX_CAMERAS || VDList[deviceNumber]->readyToCapture) return false;

        setAttemptCaptureSize(deviceNumber,w,h);

        setPhyCon(deviceNumber, connection);

        if(setup(deviceNumber))return true;

        return false;

}

// ---------------------------------------------------------------------- 

// Setup the default video format of the device

// Must be called after setup!

// See #define formats in header file (eg VI_NTSC_M )

//                                            

// ---------------------------------------------------------------------- 

bool videoInput::setFormat(int deviceNumber, int format){

        if(deviceNumber >= VI_MAX_CAMERAS || !VDList[deviceNumber]->readyToCapture) return false;

        bool returnVal = false;

        if(format >= 0 && format < VI_NUM_FORMATS){

                VDList[deviceNumber]->formatType = formatTypes[format];        

                VDList[deviceNumber]->specificFormat = true;

                if(VDList[deviceNumber]->specificFormat){

                        HRESULT hr = getDevice(&VDList[deviceNumber]->pVideoInputFilter, deviceNumber, VDList[deviceNumber]->wDeviceName, VDList[deviceNumber]->nDeviceName);

                        if(hr != S_OK){

                                return false;

                        }

                        IAMAnalogVideoDecoder *pVideoDec = NULL;            

                           hr = VDList[deviceNumber]->pCaptureGraph->FindInterface(NULL, &MEDIATYPE_Video, VDList[deviceNumber]->pVideoInputFilter, IID_IAMAnalogVideoDecoder, (void **)&pVideoDec);

                        //in case the settings window some how freed them first

                        if(VDList[deviceNumber]->pVideoInputFilter)VDList[deviceNumber]->pVideoInputFilter->Release();                  

                        if(VDList[deviceNumber]->pVideoInputFilter)VDList[deviceNumber]->pVideoInputFilter = NULL;  

                        if(FAILED(hr)){