opencv学习系列：采用videoInput类对视频处理

最新推荐文章于 2024-03-08 17:25:14 发布
最新推荐文章于 2024-03-08 17:25:14 发布
阅读量5.1k 收藏 5
点赞数
分类专栏： OpenCV opencv学习系列 文章标签： opencv videoInput 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuluohongshang/article/details/78870133
版权

videoInput.h

#ifndef _VIDEOINPUT
#define _VIDEOINPUT

//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 - theo.watson@gmail.com    //
//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 ;)

*/
/////////////////////////////////////////////////////////

#pragma comment(lib,"Strmiids.lib") 

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <wchar.h>
#include <string>
#include <vector>

//this is for TryEnterCriticalSection
#ifndef _WIN32_WINNT
    #   define _WIN32_WINNT 0x501
#endif
#include <windows.h>


//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 DON'T CHANGE

//videoInput defines
#define VI_VERSION   0.200
#define VI_MAX_CAMERAS  20
#define VI_NUM_TYPES    19 //DON'T TOUCH
#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

// added by gameover
#define VI_MEDIASUBTYPE_RGB24   0
#define VI_MEDIASUBTYPE_RGB32   1
#define VI_MEDIASUBTYPE_RGB555  2
#define VI_MEDIASUBTYPE_RGB565  3
#define VI_MEDIASUBTYPE_YUY2    4
#define VI_MEDIASUBTYPE_YVYU    5
#define VI_MEDIASUBTYPE_YUYV    6
#define VI_MEDIASUBTYPE_IYUV    7
#define VI_MEDIASUBTYPE_UYVY    8
#define VI_MEDIASUBTYPE_YV12    9
#define VI_MEDIASUBTYPE_YVU9    10
#define VI_MEDIASUBTYPE_Y411    11
#define VI_MEDIASUBTYPE_Y41P    12
#define VI_MEDIASUBTYPE_Y211    13
#define VI_MEDIASUBTYPE_AYUV    14
#define VI_MEDIASUBTYPE_Y800    15
#define VI_MEDIASUBTYPE_Y8      16
#define VI_MEDIASUBTYPE_GREY    17
#define VI_MEDIASUBTYPE_MJPG    18

//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;

        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);

        //this allows for multithreaded use of VI ( default is single threaded ).
        //call this before any videoInput calls. 
        //note if your app has other COM calls then you should set VIs COM usage to match the other COM mode 
        static void setComMultiThreaded(bool bMulti);

        //Functions in rough order they should be used.
        static int listDevices(bool silent = false);
        static std::vector <std::string> getDeviceList(); 

        //needs to be called after listDevices - otherwise returns NULL
        static const char * getDeviceName(int deviceID);
        static int getDeviceIDFromName(const char * name);

        //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 four to setup your device
        bool setupDevice(int deviceID);
        bool setupDevice(int deviceID, int w, int h);

        //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);

        //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);
        void setRequestedMediaSubType(int mediatype); // added by gameover

        //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);

        //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;

        long propBrightness;
        long propContrast;
        long propHue;
        long propSaturation;
        long propSharpness;
        long propGamma;
        long propColorEnable;
        long propWhiteBalance;
        long propBacklightCompensation;
        long propGain;

        long propPan;
        long propTilt;
        long propRoll;
        long propZoom;
        long propExposure;
        long propIris;
        long propFocus;

    private:

        void setPhyCon(int deviceID, int conn);
        void setAttemptCaptureSize(int deviceID, int w, int h);
        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);

        HRESULT getDevice(IBaseFilter **pSrcFilter, int deviceID, WCHAR * wDeviceName, char * nDeviceName);
        static HRESULT ShowFilterPropertyPages(IBaseFilter *pFilter);
        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;
        GUID requestedMediaSubType;

        //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];

};

 #endif

videoInput.cpp

//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.
#include  <iostream>

#include "videoInput.h"
#include <tchar.h>

//Include Directshow stuff here so we don't worry about needing all the h files.
#include <dshow.h>
//#include "streams.h"
#pragma include_alias( "dxtrans.h", "qedit.h" )
#define __IDxtCompositor_INTERFACE_DEFINED__
#define __IDxtAlphaSetter_INTERFACE_DEFINED__
#define __IDxtJpeg_INTERFACE_DEFINED__
#define __IDxtKey_INTERFACE_DEFINED__
#include <uuids.h>
#include <aviriff.h>
#include <windows.h>

//for threading
#include <process.h>

#ifndef HEADER
#define HEADER(pVideoInfo) (&(((VIDEOINFOHEADER *) (pVideoInfo))->bmiHeader))
#endif

// Due to a missing qedit.h in recent Platform SDKs, we've replicated the relevant contents here
// #include <qedit.h>
MIDL_INTERFACE("0579154A-2B53-4994-B0D0-E773148EFF85")
ISampleGrabberCB : public IUnknown
{
  public:
    virtual HRESULT STDMETHODCALLTYPE SampleCB( 
        double SampleTime,
        IMediaSample *pSample) = 0;

    virtual HRESULT STDMETHODCALLTYPE BufferCB( 
        double SampleTime,
        BYTE *pBuffer,
        long BufferLen) = 0;

};

MIDL_INTERFACE("6B652FFF-11FE-4fce-92AD-0266B5D7C78F")
ISampleGrabber : public IUnknown
{
  public:
    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( 
        /* [out][in] */ long *pBufferSize,
        /* [out] */ long *pBuffer) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurrentSample( 
        /* [retval][out] */ IMediaSample **ppSample) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetCallback( 
        ISampleGrabberCB *pCallback,
        long WhichMethodToCallback) = 0;

};
EXTERN_C const CLSID CLSID_SampleGrabber;
EXTERN_C const IID IID_ISampleGrabber;
EXTERN_C const CLSID CLSID_NullRenderer;

//use videoInput::setVerbose to change 
static bool verbose = true;

//use videoInput::setComMultiThreaded to change 
static bool VI_COM_MULTI_THREADED = false; 

///  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 riid, void **ppvObject){
        *ppvObject = static_cast<ISampleGrabberCB*>(this);
        return S_OK;
    }


    //This method is meant to have less overhead
    //------------------------------------------------
    STDMETHODIMP SampleCB(double Time, 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 Time, BYTE *pBuffer, long BufferLen){
        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;
         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};
            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] = static_cast<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 hr = 1;
        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 = NULL;

    //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;
    }

    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.
// ----------------------------------------------------------------------

void makeGUID( GUID *guid, unsigned long Data1, unsigned short Data2, unsigned short Data3,
    unsigned char b0, unsigned char b1, unsigned char b2, unsigned char b3,
    unsigned char b4, unsigned char b5, unsigned char b6, unsigned char b7 ){
    guid->Data1 = Data1;
    guid->Data2 = Data2;
    guid->Data3 = Data3;
    guid->Data4[0] = b0; guid->Data4[1] = b1; guid->Data4[2] = b2; guid->Data4[3] = b3;
    guid->Data4[4] = b4; guid->Data4[5] = b5; guid->Data4[6] = b6; guid->Data4[7] = b7;
}

videoInput::videoInput(){
    //start com
    comInit();

    devicesFound        = 0;
    callbackSetCount    = 0;
    bCallback           = true;
    requestedMediaSubType = MEDIASUBTYPE_RGB24;

    //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 - TFW2013 *****\n\n",VI_VERSION);

    //added for the pixelink firewire camera
//  MEDIASUBTYPE_Y800 = (GUID)FOURCCMap(FCC('Y800'));
    makeGUID( &MEDIASUBTYPE_Y800, 0x30303859, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71 );
    makeGUID( &MEDIASUBTYPE_Y8, 0x20203859, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71 );
    makeGUID( &MEDIASUBTYPE_GREY, 0x59455247, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71 );

    //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;

    //non standard
    mediaSubtypes[15]   = MEDIASUBTYPE_Y800;
    mediaSubtypes[16]   = MEDIASUBTYPE_Y8;
    mediaSubtypes[17]   = MEDIASUBTYPE_GREY;
    mediaSubtypes[18]   = MEDIASUBTYPE_MJPG; // added by gameover

    //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;


    propBrightness              = VideoProcAmp_Brightness;
    propContrast                = VideoProcAmp_Contrast;
    propHue                     = VideoProcAmp_Hue;
    propSaturation              = VideoProcAmp_Saturation;
    propSharpness               = VideoProcAmp_Sharpness;
    propGamma                   = VideoProcAmp_Gamma;
    propColorEnable             = VideoProcAmp_ColorEnable;
    propWhiteBalance            = VideoProcAmp_WhiteBalance;
    propBacklightCompensation   = VideoProcAmp_BacklightCompensation;
    propGain                    = VideoProcAmp_Gain;

    propPan                     = CameraControl_Pan;
    propTilt                    = CameraControl_Tilt;
    propRoll                    = CameraControl_Roll;
    propZoom                    = CameraControl_Zoom;
    propExposure                = CameraControl_Exposure;
    propIris                    = CameraControl_Iris;
    propFocus                   = CameraControl_Focus;

}


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

void videoInput::setVerbose(bool _verbose){
    verbose = _verbose;
}

// ----------------------------------------------------------------------
// static - new in 2013, allow for multithreaded use of VI without recompile. 
//
// ----------------------------------------------------------------------
void videoInput::setComMultiThreaded(bool bMulti){
    if( bMulti != VI_COM_MULTI_THREADED ){
        VI_COM_MULTI_THREADED = bMulti; 

        //we should only need one call to comUnInit - but as its reference counting its better to be safe. 
        int limit = 100; 
        while(!comUnInit() && limit > 0){
            limit--; 
        }
        comInit(); 
    }
}

// ----------------------------------------------------------------------
// 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 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)){
                printf("SETUP: couldn't set requested format\n");
            }else{
                long lValue = 0;
                hr = pVideoDec->get_AvailableTVFormats(&lValue);
                if( SUCCEEDED(hr) && (lValue & VDList[deviceNumber]->formatType) )
                {
                    hr = pVideoDec->put_TVFormat(VDList[deviceNumber]->formatType);
                    if( FAILED(hr) ){
                        printf("SETUP: couldn't set requested format\n");
                    }else{
                        returnVal = true;
                    }
                }

                pVideoDec->Release();
                pVideoDec = NULL;
            }
        }
    }

    return returnVal;
}

// ----------------------------------------------------------------------
// Our static function for returning device names - thanks Peter!
// Must call listDevices first.
//
// ----------------------------------------------------------------------
char videoInput::deviceNames[VI_MAX_CAMERAS][255]={{0}};

const char * videoInput::getDeviceName(int deviceID){
    if( deviceID >= VI_MAX_CAMERAS ){
        return NULL;
    }
    return deviceNames[deviceID];
}


// ----------------------------------------------------------------------
// Our static function for finding num devices available etc
//
// ----------------------------------------------------------------------

int videoInput::getDeviceIDFromName(const char * name) {

    if (listDevices(true) == 0) return -1;

    int deviceID = -1;

    for (int i = 0; i < VI_MAX_CAMERAS; i++) {
        if (deviceNames[i] == name) {
            deviceID = i;
            break;
        }
    }

    return deviceID;
}

std::vector <std::string> videoInput::getDeviceList(){
    int numDev = videoInput::listDevices(true);
    std::vector <std::string> deviceList; 
    for(int i = 0; i < numDev; i++){
        char * name = (char *) videoInput::getDeviceName(i);
        if( name == NULL )break; 
        deviceList.push_back(name); 
    }
    return deviceList;
}

int videoInput::listDevices(bool silent){

    //COM Library Intialization
    comInit();

    if(!silent)printf("\nVIDEOINPUT SPY MODE!\n\n");


    ICreateDevEnum *pDevEnum = NULL;
    IEnumMoniker *pEnum = NULL;
    int deviceCounter = 0;

    HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL,
        CLSCTX_INPROC_SERVER, IID_ICreateDevEnum,
        reinterpret_cast<void**>(&pDevEnum));


    if (SUCCEEDED(hr))
    {
        // Create an enumerator for the video capture category.
        hr = pDevEnum->CreateClassEnumerator(
            CLSID_VideoInputDeviceCategory,
            &pEnum, 0);

       if(hr == S_OK){

             if(!silent)printf("SETUP: Looking For Capture Devices\n");
            IMoniker *pMoniker = NULL;

            while (pEnum->Next(1, &pMoniker, NULL) == S_OK){

                IPropertyBag *pPropBag;
                hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag,
                    (void**)(&pPropBag));

                if (FAILED(hr)){
                    pMoniker->Release();
                    continue;  // Skip this one, maybe the next one will work.
                }


                // Find the description or friendly name.
                VARIANT varName;
                VariantInit(&varName);
                hr = pPropBag->Read(L"Description", &varName, 0);

                if (FAILED(hr)) hr = pPropBag->Read(L"FriendlyName", &varName, 0);

                if (SUCCEEDED(hr)){

                    hr = pPropBag->Read(L"FriendlyName", &varName, 0);

                    int count = 0;
                    int maxLen = sizeof(deviceNames[0])/sizeof(deviceNames[0][0]) - 2;
                    while( varName.bstrVal[count] != 0x00 && count < maxLen) {
                        deviceNames[deviceCounter][count] = static_cast<char>(varName.bstrVal[count]);
                        count++;
                    }
                    deviceNames[deviceCounter][count] = 0;

                    if(!silent)printf("SETUP: %i) %s \n",deviceCounter, deviceNames[deviceCounter]);
                }

                pPropBag->Release();
                pPropBag = NULL;

                pMoniker->Release();
                pMoniker = NULL;

                deviceCounter++;
            }

            pDevEnum->Release();
            pDevEnum = NULL;

            pEnum->Release();
            pEnum = NULL;
        }

         if(!silent)printf("SETUP: %i Device(s) found\n\n", deviceCounter);
    }

    comUnInit();

    return deviceCounter;
}


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

int videoInput::getWidth(int id){

    if(isDeviceSetup(id))
    {
        return VDList[id] ->width;
    }

    return 0;

}


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

int videoInput::getHeight(int id){

    if(isDeviceSetup(id))
    {
        return VDList[id] ->height;
    }

    return 0;

}


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

int videoInput::getSize(int id){

    if(isDeviceSetup(id))
    {
        return VDList[id] ->videoSize;
    }

    return 0;

}


// ----------------------------------------------------------------------
// Uses a supplied buffer
// ----------------------------------------------------------------------

bool videoInput::getPixels(int id, unsigned char * dstBuffer, bool flipRedAndBlue, bool flipImage){

    bool success = false;

    if(isDeviceSetup(id)){
        if(bCallback){
            //callback capture

            DWORD result = WaitForSingleObject(VDList[id]->sgCallback->hEvent, 1000);
            if( result != WAIT_OBJECT_0) return false;

            //double paranoia - mutexing with both event and critical section
            EnterCriticalSection(&VDList[id]->sgCallback->critSection);

                unsigned char * src = VDList[id]->sgCallback->pixels;
                unsigned char * dst = dstBuffer;
                int height          = VDList[id]->height;
                int width           = VDList[id]->width;

                processPixels(src, dst, width, height, flipRedAndBlue, flipImage);
                VDList[id]->sgCallback->newFrame = false;

            LeaveCriticalSection(&VDList[id]->sgCallback->critSection);

            ResetEvent(VDList[id]->sgCallback->hEvent);

            success = true;

        }
        else{
            //regular capture method
            long bufferSize = VDList[id]->videoSize;
            HRESULT hr = VDList[id]->pGrabber->GetCurrentBuffer(&bufferSize, (long *)VDList[id]->pBuffer);
            if(hr==S_OK){
                int numBytes = VDList[id]->videoSize;
                if (numBytes == bufferSize){

                    unsigned char * src = (unsigned char * )VDList[id]->pBuffer;
                    unsigned char * dst = dstBuffer;
                    int height          = VDList[id]->height;
                    int width           = VDList[id]->width;

                    processPixels(src, dst, width, height, flipRedAndBlue, flipImage);
                    success = true;
                }else{
                    if(verbose)printf("ERROR: GetPixels() - bufferSizes do not match!\n");
                }
            }else{
                if(verbose)printf("ERROR: GetPixels() - Unable to grab frame for device %i\n", id);
            }
        }
    }

    return success;
}


// ----------------------------------------------------------------------
// Returns a buffer
// ----------------------------------------------------------------------
unsigned char * videoInput::getPixels(int id, bool flipRedAndBlue, bool flipImage){

    if(isDeviceSetup(id)){
        getPixels(id, VDList[id]->pixels, flipRedAndBlue, flipImage);
    }

    return VDList[id]->pixels;
}



// ----------------------------------------------------------------------
//
//
// ----------------------------------------------------------------------
bool videoInput::isFrameNew(int id){
    if(!isDeviceSetup(id)) return false;
    if(!bCallback)return true;

    bool result = false;
    bool freeze = false;

    //again super paranoia!
    EnterCriticalSection(&VDList[id]->sgCallback->critSection);
        result = VDList[id]->sgCallback->newFrame;

        //we need to give it some time at the begining to start up so lets check after 400 frames
        if(VDList[id]->nFramesRunning > 400 && VDList[id]->sgCallback->freezeCheck > VDList[id]->nFramesForReconnect ){
            freeze = true;
        }

        //we increment the freezeCheck var here - the callback resets it to 1
        //so as long as the callback is running this var should never get too high.
        //if the callback is not running then this number will get high and trigger the freeze action below
        VDList[id]->sgCallback->freezeCheck++;
    LeaveCriticalSection(&VDList[id]->sgCallback->critSection);

    VDList[id]->nFramesRunning++;

    if(freeze && VDList[id]->autoReconnect){
        if(verbose)printf("ERROR: Device seems frozen - attempting to reconnect\n");
        if( !restartDevice(VDList[id]->myID) ){
            if(verbose)printf("ERROR: Unable to reconnect to device\n");
        }else{
            if(verbose)printf("SUCCESS: Able to reconnect to device\n");
        }
    }

    return result;
}


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

bool videoInput::isDeviceSetup(int id){

    if(id<devicesFound && VDList[id]->readyToCapture)return true;
    else return false;

}


// ----------------------------------------------------------------------
// Gives us a little pop up window to adjust settings
// We do this in a seperate thread now!
// ----------------------------------------------------------------------


void __cdecl videoInput::basicThread(void * objPtr){

    //get a reference to the video device
    //not a copy as we need to free the filter
    videoDevice * vd = *( (videoDevice **)(objPtr) );
    ShowFilterPropertyPages(vd->pVideoInputFilter);

    //now we free the filter and make sure it set to NULL
    if(vd->pVideoInputFilter)vd->pVideoInputFilter->Release();
    if(vd->pVideoInputFilter)vd->pVideoInputFilter = NULL;

    return;
}

void videoInput::showSettingsWindow(int id){

    if(isDeviceSetup(id)){

        HANDLE myTempThread;

        //we reconnect to the device as we have freed our reference to it
        //why have we freed our reference? because there seemed to be an issue
        //with some mpeg devices if we didn't
        HRESULT hr = getDevice(&VDList[id]->pVideoInputFilter, id, VDList[id]->wDeviceName, VDList[id]->nDeviceName);
        if(hr == S_OK){
            myTempThread = (HANDLE)_beginthread(basicThread, 0, (void *)&VDList[id]);
        }
    }
}


// Set a video signal setting using IAMVideoProcAmp
bool videoInput::getVideoSettingFilter(int deviceID, long Property, long &min, long &max, long &SteppingDelta, long &currentValue, long &flags, long &defaultValue){
    if( !isDeviceSetup(deviceID) )return false;

    HRESULT hr;
    bool isSuccessful = false;

    videoDevice * VD = VDList[deviceID];

    hr = getDevice(&VD->pVideoInputFilter, deviceID, VD->wDeviceName, VD->nDeviceName);
    if (FAILED(hr)){
        printf("setVideoSetting - getDevice Error\n");
        return false;
    }

    IAMVideoProcAmp *pAMVideoProcAmp = NULL;

    hr = VD->pVideoInputFilter->QueryInterface(IID_IAMVideoProcAmp, (void**)&pAMVideoProcAmp);
    if(FAILED(hr)){
        printf("setVideoSetting - QueryInterface Error\n");
        if(VD->pVideoInputFilter)VD->pVideoInputFilter->Release();
        if(VD->pVideoInputFilter)VD->pVideoInputFilter = NULL;
        return false;
    }

    if (verbose) printf("Setting video setting %ld.\n", Property);

    pAMVideoProcAmp->GetRange(Property, &min, &max, &SteppingDelta, &defaultValue, &flags);
    if (verbose) printf("Range for video setting %ld: Min:%ld Max:%ld SteppingDelta:%ld Default:%ld Flags:%ld\n", Property, min, max, SteppingDelta, defaultValue, flags);
    pAMVideoProcAmp->Get(Property, &currentValue, &flags);

    if(pAMVideoProcAmp)pAMVideoProcAmp->Release();
    if(VD->pVideoInputFilter)VD->pVideoInputFilter->Release();
    if(VD->pVideoInputFilter)VD->pVideoInputFilter = NULL;

    return true;

}


// Set a video signal setting using IAMVideoProcAmp
bool videoInput::setVideoSettingFilterPct(int deviceID, long Property, float pctValue, long Flags){
    if( !isDeviceSetup(deviceID) )return false;

    long min, max, currentValue, flags, defaultValue, stepAmnt;

    if( !getVideoSettingFilter(deviceID, Property, min, max, stepAmnt, currentValue, flags, defaultValue) )return false;

    if(pctValue > 1.0)pctValue = 1.0;
    else if(pctValue < 0)pctValue = 0.0;

    float range = (float)max - (float)min;
    if(range <= 0)return false;
    if(stepAmnt == 0) return false;

    long value  = (long)( (float)min + range * pctValue );
    long rasterValue = value;

    //if the range is the stepAmnt then it is just a switch
    //so we either set the value to low or high
    if( range == stepAmnt ){
        if( pctValue < 0.5)rasterValue = min;
        else rasterValue = max;
    }else{
        //we need to rasterize the value to the stepping amnt
        long mod        = value % stepAmnt;
        double halfStep     = stepAmnt * 0.5;
        if( mod < halfStep ) rasterValue -= mod;
        else rasterValue += stepAmnt - mod;
        printf("RASTER - pctValue is %f - value is %i - step is %i - mod is %i - rasterValue is %i\n", pctValue, value, stepAmnt, mod, rasterValue);
    }

    return setVideoSettingFilter(deviceID, Property, rasterValue, Flags, false);
}


// Set a video signal setting using IAMVideoProcAmp
bool videoInput::setVideoSettingFilter(int deviceID, long Property, long lValue, long Flags, bool useDefaultValue){
    if( !isDeviceSetup(deviceID) )return false;

    HRESULT hr;
    bool isSuccessful = false;

    videoDevice * VD = VDList[deviceID];

    hr = getDevice(&VD->pVideoInputFilter, deviceID, VD->wDeviceName, VD->nDeviceName);
    if (FAILED(hr)){
        printf("setVideoSetting - getDevice Error\n");
        return false;
    }

    IAMVideoProcAmp *pAMVideoProcAmp = NULL;

    hr = VD->pVideoInputFilter->QueryInterface(IID_IAMVideoProcAmp, (void**)&pAMVideoProcAmp);
    if(FAILED(hr)){
        printf("setVideoSetting - QueryInterface Error\n");
        if(VD->pVideoInputFilter)VD->pVideoInputFilter->Release();
        if(VD->pVideoInputFilter)VD->pVideoInputFilter = NULL;
        return false;
    }

    if (verbose) printf("Setting video setting %ld.\n", Property);
    long CurrVal, Min, Max, SteppingDelta, Default, CapsFlags, AvailableCapsFlags = 0;


    pAMVideoProcAmp->GetRange(Property, &Min, &Max, &SteppingDelta, &Default, &AvailableCapsFlags);
    if (verbose) printf("Range for video setting %ld: Min:%ld Max:%ld SteppingDelta:%ld Default:%ld Flags:%ld\n", Property, Min, Max, SteppingDelta, Default, AvailableCapsFlags);
    pAMVideoProcAmp->Get(Property, &CurrVal, &CapsFlags);

    if (verbose) printf("Current value: %ld Flags %ld (%s)\n", CurrVal, CapsFlags, (CapsFlags == 1 ? "Auto" : (CapsFlags == 2 ? "Manual" : "Unknown")));

    if (useDefaultValue) {
        pAMVideoProcAmp->Set(Property, Default, VideoProcAmp_Flags_Auto);
    }
    else{
        // Perhaps add a check that lValue and Flags are within the range aquired from GetRange above
        pAMVideoProcAmp->Set(Property, lValue, Flags);
    }

    if(pAMVideoProcAmp)pAMVideoProcAmp->Release();
    if(VD->pVideoInputFilter)VD->pVideoInputFilter->Release();
    if(VD->pVideoInputFilter)VD->pVideoInputFilter = NULL;

    return true;

}


bool videoInput::setVideoSettingCameraPct(int deviceID, long Property, float pctValue, long Flags){
    if( !isDeviceSetup(deviceID) )return false;

    long min, max, currentValue, flags, defaultValue, stepAmnt;

    if( !getVideoSettingCamera(deviceID, Property, min, max, stepAmnt, currentValue, flags, defaultValue) )return false;

    if(pctValue > 1.0)pctValue = 1.0;
    else if(pctValue < 0)pctValue = 0.0;

    float range = (float)max - (float)min;
    if(range <= 0)return false;
    if(stepAmnt == 0) return false;

    long value  = (long)( (float)min + range * pctValue );
    long rasterValue = value;

    //if the range is the stepAmnt then it is just a switch
    //so we either set the value to low or high
    if( range == stepAmnt ){
        if( pctValue < 0.5)rasterValue = min;
        else rasterValue = max;
    }else{
        //we need to rasterize the value to the stepping amnt
        long mod        = value % stepAmnt;
        double halfStep     = stepAmnt * 0.5;
        if( mod < halfStep ) rasterValue -= mod;
        else rasterValue += stepAmnt - mod;
        printf("RASTER - pctValue is %f - value is %i - step is %i - mod is %i - rasterValue is %i\n", pctValue, value, stepAmnt, mod, rasterValue);
    }

    return setVideoSettingCamera(deviceID, Property, rasterValue, Flags, false);
}


bool videoInput::setVideoSettingCamera(int deviceID, long Property, long lValue, long Flags, bool useDefaultValue){
    IAMCameraControl *pIAMCameraControl;
    if(isDeviceSetup(deviceID))
    {
        HRESULT hr;
        hr = getDevice(&VDList[deviceID]->pVideoInputFilter, deviceID, VDList[deviceID]->wDeviceName, VDList[deviceID]->nDeviceName);

        if (verbose) printf("Setting video setting %ld.\n", Property);
        hr = VDList[deviceID]->pVideoInputFilter->QueryInterface(IID_IAMCameraControl, (void**)&pIAMCameraControl);
        if (FAILED(hr)) {
            printf("Error\n");
            return false;
        }
        else
        {
            long CurrVal, Min, Max, SteppingDelta, Default, CapsFlags, AvailableCapsFlags;
            pIAMCameraControl->GetRange(Property, &Min, &Max, &SteppingDelta, &Default, &AvailableCapsFlags);
            if (verbose) printf("Range for video setting %ld: Min:%ld Max:%ld SteppingDelta:%ld Default:%ld Flags:%ld\n", Property, Min, Max, SteppingDelta, Default, AvailableCapsFlags);
            pIAMCameraControl->Get(Property, &CurrVal, &CapsFlags);
            if (verbose) printf("Current value: %ld Flags %ld (%s)\n", CurrVal, CapsFlags, (CapsFlags == 1 ? "Auto" : (CapsFlags == 2 ? "Manual" : "Unknown")));
            if (useDefaultValue) {
                pIAMCameraControl->Set(Property, Default, CameraControl_Flags_Auto);
            }
            else
            {
                // Perhaps add a check that lValue and Flags are within the range aquired from GetRange above
                pIAMCameraControl->Set(Property, lValue, Flags);
            }
            pIAMCameraControl->Release();
            return true;
        }
    }
    return false;
}



bool videoInput::getVideoSettingCamera(int deviceID, long Property, long &min, long &max, long &SteppingDelta, long &currentValue, long &flags, long &defaultValue){
    if( !isDeviceSetup(deviceID) )return false;

    HRESULT hr;
    bool isSuccessful = false;

    videoDevice * VD = VDList[deviceID];

    hr = getDevice(&VD->pVideoInputFilter, deviceID, VD->wDeviceName, VD->nDeviceName);
    if (FAILED(hr)){
        printf("setVideoSetting - getDevice Error\n");
        return false;
    }

    IAMCameraControl *pIAMCameraControl = NULL;

    hr = VD->pVideoInputFilter->QueryInterface(IID_IAMCameraControl, (void**)&pIAMCameraControl);
    if(FAILED(hr)){
        printf("setVideoSetting - QueryInterface Error\n");
        if(VD->pVideoInputFilter)VD->pVideoInputFilter->Release();
        if(VD->pVideoInputFilter)VD->pVideoInputFilter = NULL;
        return false;
    }

    if (verbose) printf("Setting video setting %ld.\n", Property);

    pIAMCameraControl->GetRange(Property, &min, &max, &SteppingDelta, &defaultValue, &flags);
    if (verbose) printf("Range for video setting %ld: Min:%ld Max:%ld SteppingDelta:%ld Default:%ld Flags:%ld\n", Property, min, max, SteppingDelta, defaultValue, flags);
    pIAMCameraControl->Get(Property, &currentValue, &flags);

    if(pIAMCameraControl)pIAMCameraControl->Release();
    if(VD->pVideoInputFilter)VD->pVideoInputFilter->Release();
    if(VD->pVideoInputFilter)VD->pVideoInputFilter = NULL;

    return true;

}


// ----------------------------------------------------------------------
// Shutsdown the device, deletes the object and creates a new object
// so it is ready to be setup again
// ----------------------------------------------------------------------

void videoInput::stopDevice(int id){
    if(id < VI_MAX_CAMERAS)
    {
        delete VDList[id];
        VDList[id] = new videoDevice();
    }

}

// ----------------------------------------------------------------------
// Restarts the device with the same settings it was using
//
// ----------------------------------------------------------------------

bool videoInput::restartDevice(int id){
    if(isDeviceSetup(id))
    {
        int conn        = VDList[id]->storeConn;
        int tmpW        = VDList[id]->width;
        int tmpH        = VDList[id]->height;

        bool bFormat    = VDList[id]->specificFormat;
        long format     = VDList[id]->formatType;

        int nReconnect  = VDList[id]->nFramesForReconnect;
        bool bReconnect = VDList[id]->autoReconnect;

        unsigned long avgFrameTime = VDList[id]->requestedFrameTime;

        stopDevice(id);

        //set our fps if needed
        if( avgFrameTime != -1){
            VDList[id]->requestedFrameTime = avgFrameTime;
        }

        if( setupDevice(id, tmpW, tmpH, conn) ){
            //reapply the format - ntsc / pal etc
            if( bFormat ){
                setFormat(id, format);
            }
            if( bReconnect ){
                setAutoReconnectOnFreeze(id, true, nReconnect);
            }
            return true;
        }
    }
    return false;
}

// ----------------------------------------------------------------------
// Shuts down all devices, deletes objects and unitializes com if needed
//
// ----------------------------------------------------------------------
videoInput::~videoInput(){

    for(int i = 0; i < VI_MAX_CAMERAS; i++)
    {
        delete VDList[i];
    }
    //Unitialize com
    comUnInit();
}


//  VIDEO INPUT  
  PRIVATE METHODS  //

// ----------------------------------------------------------------------
// We only should init com if it hasn't been done so by our apps thread
// Use a static counter to keep track of other times it has been inited
// (do we need to worry about multithreaded apps?)
// ----------------------------------------------------------------------

bool videoInput::comInit(){
    HRESULT hr = NULL;

    //no need for us to start com more than once
    if(comInitCount == 0 ){

        // Initialize the COM library.
        //CoInitializeEx so videoInput can run in another thread
    if( VI_COM_MULTI_THREADED ){
        hr = CoInitializeEx(NULL,COINIT_MULTITHREADED);
    }else{
        hr = CoInitialize(NULL);
    }
        //this is the only case where there might be a problem
        //if another library has started com as single threaded
        //and we need it multi-threaded - send warning but don't fail
        if( hr == RPC_E_CHANGED_MODE){
             if(verbose)printf("SETUP - COM already setup - threaded VI might not be possible\n");
        }
    }

    comInitCount++;
    return true;
}


// ----------------------------------------------------------------------
// Same as above but to unitialize com, decreases counter and frees com
// if no one else is using it
// ----------------------------------------------------------------------

bool videoInput::comUnInit(){
    if(comInitCount > 0)comInitCount--;     //decrease the count of instances using com

    if(comInitCount == 0){
        CoUninitialize();   //if there are no instances left - uninitialize com
        return true;
    }

    return false;
}


// ----------------------------------------------------------------------
// This is the size we ask for - we might not get it though :)
//
// ----------------------------------------------------------------------

void videoInput::setAttemptCaptureSize(int id, int w, int h){

    VDList[id]->tryWidth    = w;
    VDList[id]->tryHeight   = h;
    VDList[id]->tryDiffSize = true;

}


// ----------------------------------------------------------------------
// Set the connection type
// (maybe move to private?)
// ----------------------------------------------------------------------

void videoInput::setPhyCon(int id, int conn){

        switch(conn){

            case 0:
                VDList[id]->connection = PhysConn_Video_Composite;
                break;
            case 1:
                VDList[id]->connection = PhysConn_Video_SVideo;
                break;
            case 2:
                VDList[id]->connection = PhysConn_Video_Tuner;
                break;
            case 3:
                VDList[id]->connection = PhysConn_Video_USB;
                break;
            case 4:
                VDList[id]->connection = PhysConn_Video_1394;
                break;
            default:
                return; //if it is not these types don't set crossbar
            break;
        }

        VDList[id]->storeConn   = conn;
        VDList[id]->useCrossbar = true;
}


// ----------------------------------------------------------------------
// Check that we are not trying to setup a non-existant device
// Then start the graph building!
// ----------------------------------------------------------------------

bool videoInput::setup(int deviceNumber){
    devicesFound = getDeviceCount();

    if(deviceNumber>devicesFound-1)
    {
        if(verbose)printf("SETUP: device[%i] not found - you have %i devices available\n", deviceNumber, devicesFound);
        if(devicesFound>=0) if(verbose)printf("SETUP: this means that the last device you can use is device[%i] \n",  devicesFound-1);
        return false;
    }

    if(VDList[deviceNumber]->readyToCapture)
    {
        if(verbose)printf("SETUP: can't setup, device %i is currently being used\n",VDList[deviceNumber]->myID);
        return false;
    }

    HRESULT hr = start(deviceNumber, VDList[deviceNumber]);
    if(hr == S_OK)return true;
    else return false;
}


// ----------------------------------------------------------------------
// Does both vertical buffer flipping and bgr to rgb swapping
// You have any combination of those.
// ----------------------------------------------------------------------

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

    int widthInBytes = width * 3;
    int numBytes = widthInBytes * height;

    if(!bRGB){

        int x = 0;
        int y = 0;

        if(bFlip){
            for(int y = 0; y < height; y++){
                memcpy(dst + (y * widthInBytes), src + ( (height -y -1) * widthInBytes), widthInBytes);
            }

        }else{
            memcpy(dst, src, numBytes);
        }
    }else{
        if(bFlip){

            int x = 0;
            int y = (height - 1) * widthInBytes;
            src += y;

            for(int i = 0; i < numBytes; i+=3){
                if(x >= width){
                    x = 0;
                    src -= widthInBytes*2;
                }

                *dst = *(src+2);
                dst++;

                *dst = *(src+1);
                dst++;

                *dst = *src;
                dst++;

                src+=3;
                x++;
            }
        }
        else{
            for(int i = 0; i < numBytes; i+=3){
                *dst = *(src+2);
                dst++;

                *dst = *(src+1);
                dst++;

                *dst = *src;
                dst++;

                src+=3;
            }
        }
    }
}


//------------------------------------------------------------------------------------------
void videoInput::getMediaSubtypeAsString(GUID type, char * typeAsString){

    static const int maxStr = 8;
    char tmpStr[maxStr];
    if( type == MEDIASUBTYPE_RGB24) strncpy(tmpStr, "RGB24", maxStr);
    else if(type == MEDIASUBTYPE_RGB32) strncpy(tmpStr, "RGB32", maxStr);
    else if(type == MEDIASUBTYPE_RGB555)strncpy(tmpStr, "RGB555", maxStr);
    else if(type == MEDIASUBTYPE_RGB565)strncpy(tmpStr, "RGB565", maxStr);  
    else if(type == MEDIASUBTYPE_YUY2) strncpy(tmpStr, "YUY2", maxStr);
    else if(type == MEDIASUBTYPE_YVYU) strncpy(tmpStr, "YVYU", maxStr);
    else if(type == MEDIASUBTYPE_YUYV) strncpy(tmpStr, "YUYV", maxStr);
    else if(type == MEDIASUBTYPE_IYUV) strncpy(tmpStr, "IYUV", maxStr);
    else if(type == MEDIASUBTYPE_UYVY) strncpy(tmpStr, "UYVY", maxStr);
    else if(type == MEDIASUBTYPE_YV12) strncpy(tmpStr, "YV12", maxStr);
    else if(type == MEDIASUBTYPE_YVU9) strncpy(tmpStr, "YVU9", maxStr);
    else if(type == MEDIASUBTYPE_Y411) strncpy(tmpStr, "Y411", maxStr);
    else if(type == MEDIASUBTYPE_Y41P) strncpy(tmpStr, "Y41P", maxStr);
    else if(type == MEDIASUBTYPE_Y211) strncpy(tmpStr, "Y211", maxStr);
    else if(type == MEDIASUBTYPE_AYUV) strncpy(tmpStr, "AYUV", maxStr);
    else if(type == MEDIASUBTYPE_Y800) strncpy(tmpStr, "Y800", maxStr);
    else if(type == MEDIASUBTYPE_Y8) strncpy(tmpStr, "Y8", maxStr);
    else if(type == MEDIASUBTYPE_GREY) strncpy(tmpStr, "GREY", maxStr);
    else strncpy(tmpStr, "OTHER", maxStr);

    memcpy(typeAsString, tmpStr, sizeof(char)*8);
}

void videoInput::setRequestedMediaSubType(int mediatype) {
    requestedMediaSubType = mediaSubtypes[mediatype];
}


//-------------------------------------------------------------------------------------------
static void findClosestSizeAndSubtype(videoDevice * VD, int widthIn, int heightIn, int &widthOut, int &heightOut, GUID & mediatypeOut){
    HRESULT hr;

    //find perfect match or closest size
    int nearW               = 9999999;
    int nearH               = 9999999;
    bool foundClosestMatch  = true;

    int iCount = 0;
    int iSize = 0;
    hr = VD->streamConf->GetNumberOfCapabilities(&iCount, &iSize);

    if (iSize == sizeof(VIDEO_STREAM_CONFIG_CAPS))
    {
        //For each format type RGB24 YUV2 etc
        for (int iFormat = 0; iFormat < iCount; iFormat++)
        {
            VIDEO_STREAM_CONFIG_CAPS scc;
            AM_MEDIA_TYPE *pmtConfig;
            hr =  VD->streamConf->GetStreamCaps(iFormat, &pmtConfig, (BYTE*)&scc);

            if (SUCCEEDED(hr)){

                //his is how many diff sizes are available for the format
                int stepX = scc.OutputGranularityX;
                int stepY = scc.OutputGranularityY;

                int tempW = 999999;
                int tempH = 999999;

                //Don't want to get stuck in a loop
                if(stepX < 1 || stepY < 1) continue;

                //if(verbose)printf("min is %i %i max is %i %i - res is %i %i \n", scc.MinOutputSize.cx, scc.MinOutputSize.cy,  scc.MaxOutputSize.cx,  scc.MaxOutputSize.cy, stepX, stepY);
                //if(verbose)printf("min frame duration is %i  max duration is %i\n", scc.MinFrameInterval, scc.MaxFrameInterval);

                bool exactMatch     = false;
                bool exactMatchX    = false;
                bool exactMatchY    = false;

                for(int x = scc.MinOutputSize.cx; x <= scc.MaxOutputSize.cx; x+= stepX){
                    //If we find an exact match
                    if( widthIn == x ){
                        exactMatchX = true;
                        tempW = x;
                    }
                    //Otherwise lets find the closest match based on width
                    else if( abs(widthIn-x) < abs(widthIn-tempW) ){
                        tempW = x;
                    }
                }

                for(int y = scc.MinOutputSize.cy; y <= scc.MaxOutputSize.cy; y+= stepY){
                    //If we find an exact match
                    if( heightIn == y){
                        exactMatchY = true;
                        tempH = y;
                    }
                    //Otherwise lets find the closest match based on height
                    else if( abs(heightIn-y) < abs(heightIn-tempH) ){
                        tempH = y;
                    }
                }

                //see if we have an exact match!
                if(exactMatchX && exactMatchY){
                    foundClosestMatch = false;
                    exactMatch = true;

                    widthOut        = widthIn;
                    heightOut       = heightIn;
                    mediatypeOut    = pmtConfig->subtype;
                }

                //otherwise lets see if this filters closest size is the closest
                //available. the closest size is determined by the sum difference
                //of the widths and heights
                else if( abs(widthIn - tempW) + abs(heightIn - tempH)  < abs(widthIn - nearW) + abs(heightIn - nearH) )
                {
                    nearW = tempW;
                    nearH = tempH;

                    widthOut        = nearW;
                    heightOut       = nearH;
                    mediatypeOut    = pmtConfig->subtype;
                }

                MyDeleteMediaType(pmtConfig);

                //If we have found an exact match no need to search anymore
                if(exactMatch)break;
            }
         }
    }

}


//---------------------------------------------------------------------------------------------------
static bool setSizeAndSubtype(videoDevice * VD, int attemptWidth, int attemptHeight, GUID mediatype){
    VIDEOINFOHEADER *pVih =  reinterpret_cast<VIDEOINFOHEADER*>(VD->pAmMediaType->pbFormat);

    //store current size
    int tmpWidth  = HEADER(pVih)->biWidth;
    int tmpHeight = HEADER(pVih)->biHeight;
    AM_MEDIA_TYPE * tmpType = NULL;

    HRESULT hr = VD->streamConf->GetFormat(&tmpType);
    if(hr != S_OK)return false;

    //set new size:
    //width and height
    HEADER(pVih)->biWidth  = attemptWidth;
    HEADER(pVih)->biHeight = attemptHeight;

    VD->pAmMediaType->formattype = FORMAT_VideoInfo;
    VD->pAmMediaType->majortype  = MEDIATYPE_Video;
    VD->pAmMediaType->subtype    = mediatype;

    //buffer size
    VD->pAmMediaType->lSampleSize = attemptWidth*attemptHeight*3;

    //set fps if requested
    if( VD->requestedFrameTime != -1){
        pVih->AvgTimePerFrame = VD->requestedFrameTime;
    }

    //okay lets try new size
    hr = VD->streamConf->SetFormat(VD->pAmMediaType);
    if(hr == S_OK){
        if( tmpType != NULL )MyDeleteMediaType(tmpType);
        return true;
    }else{
        VD->streamConf->SetFormat(tmpType);
        if( tmpType != NULL )MyDeleteMediaType(tmpType);
    }

    return false;
}

// ----------------------------------------------------------------------
// Where all the work happens!
// Attempts to build a graph for the specified device
// ----------------------------------------------------------------------

int videoInput::start(int deviceID, videoDevice *VD){

    HRESULT hr          = NULL;
    VD->myID            = deviceID;
    VD->setupStarted    = true;
    CAPTURE_MODE        = PIN_CATEGORY_CAPTURE; //Don't worry - it ends up being preview (which is faster)
    callbackSetCount    = 1;  //make sure callback method is not changed after setup called

    if(verbose)printf("SETUP: Setting up device %i\n",deviceID);

    // CREATE THE GRAPH BUILDER //
    // Create the filter graph manager and query for interfaces.
    hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER, IID_ICaptureGraphBuilder2, (void **)&VD->pCaptureGraph);
    if (FAILED(hr)) // FAILED is a macro that tests the return value
    {
        if(verbose)printf("ERROR - Could not create the Filter Graph Manager\n");
        return hr;
    }

    //FITLER GRAPH MANAGER//
    // Create the Filter Graph Manager.
    hr = CoCreateInstance(CLSID_FilterGraph, 0, CLSCTX_INPROC_SERVER,IID_IGraphBuilder, (void**)&VD->pGraph);
    if (FAILED(hr))
    {
        if(verbose)printf("ERROR - Could not add the graph builder!\n");
        stopDevice(deviceID);
        return hr;
    }

    //SET THE FILTERGRAPH//
    hr = VD->pCaptureGraph->SetFiltergraph(VD->pGraph);
    if (FAILED(hr))
    {
        if(verbose)printf("ERROR - Could not set filtergraph\n");
        stopDevice(deviceID);
        return hr;
    }

    //MEDIA CONTROL (START/STOPS STREAM)//
    // Using QueryInterface on the graph builder,
    // Get the Media Control object.
    hr = VD->pGraph->QueryInterface(IID_IMediaControl, (void **)&VD->pControl);
    if (FAILED(hr))
    {
        if(verbose)printf("ERROR - Could not create the Media Control object\n");
        stopDevice(deviceID);
        return hr;
    }


    //FIND VIDEO DEVICE AND ADD TO GRAPH//
    //gets the device specified by the second argument.
    hr = getDevice(&VD->pVideoInputFilter, deviceID, VD->wDeviceName, VD->nDeviceName);

    if (SUCCEEDED(hr)){
        if(verbose)printf("SETUP: %s\n", VD->nDeviceName);
        hr = VD->pGraph->AddFilter(VD->pVideoInputFilter, VD->wDeviceName);
    }else{
        if(verbose)printf("ERROR - Could not find specified video device\n");
        stopDevice(deviceID);
        return hr;
    }

    //LOOK FOR PREVIEW PIN IF THERE IS NONE THEN WE USE CAPTURE PIN AND THEN SMART TEE TO PREVIEW
    IAMStreamConfig *streamConfTest = NULL;
    hr = VD->pCaptureGraph->FindInterface(&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, VD->pVideoInputFilter, IID_IAMStreamConfig, (void **)&streamConfTest);
    if(FAILED(hr)){
        if(verbose)printf("SETUP: Couldn't find preview pin using SmartTee\n");
    }else{
         CAPTURE_MODE = PIN_CATEGORY_PREVIEW;
         streamConfTest->Release();
         streamConfTest = NULL;
    }

    //CROSSBAR (SELECT PHYSICAL INPUT TYPE)//
    //my own function that checks to see if the device can support a crossbar and if so it routes it.
    //webcams tend not to have a crossbar so this function will also detect a webcams and not apply the crossbar
    if(VD->useCrossbar)
    {
        if(verbose)printf("SETUP: Checking crossbar\n");
        routeCrossbar(&VD->pCaptureGraph, &VD->pVideoInputFilter, VD->connection, CAPTURE_MODE);
    }


    //we do this because webcams don't have a preview mode
    hr = VD->pCaptureGraph->FindInterface(&CAPTURE_MODE, &MEDIATYPE_Video, VD->pVideoInputFilter, IID_IAMStreamConfig, (void **)&VD->streamConf);
    if(FAILED(hr)){
        if(verbose)printf("ERROR: Couldn't config the stream!\n");
        stopDevice(deviceID);
        return hr;
    }

    //NOW LETS DEAL WITH GETTING THE RIGHT SIZE
    hr = VD->streamConf->GetFormat(&VD->pAmMediaType);
    if(FAILED(hr)){
        if(verbose)printf("ERROR: Couldn't getFormat for pAmMediaType!\n");
        stopDevice(deviceID);
        return hr;
    }

    VIDEOINFOHEADER *pVih =  reinterpret_cast<VIDEOINFOHEADER*>(VD->pAmMediaType->pbFormat);
    int currentWidth    =  HEADER(pVih)->biWidth;
    int currentHeight   =  HEADER(pVih)->biHeight;

    bool customSize = VD->tryDiffSize;
    bool foundSize  = false;

    if(customSize){
        if(verbose) printf("SETUP: Default Format is set to %i by %i \n", currentWidth, currentHeight);

        char guidStr[8];
        getMediaSubtypeAsString(requestedMediaSubType, guidStr); 

        if(verbose)printf("SETUP: trying requested format %s @ %i by %i\n", guidStr, VD->tryWidth, VD->tryHeight);
        if( setSizeAndSubtype(VD, VD->tryWidth, VD->tryHeight, requestedMediaSubType) ) {
                VD->setSize(VD->tryWidth, VD->tryHeight);
                foundSize = true;
        }


        if (!foundSize) {

            for(int i = 0; i < VI_NUM_TYPES; i++){

                getMediaSubtypeAsString(mediaSubtypes[i], guidStr);

                if(verbose)printf("SETUP: trying format %s @ %i by %i\n", guidStr, VD->tryWidth, VD->tryHeight);
                if( setSizeAndSubtype(VD, VD->tryWidth, VD->tryHeight, mediaSubtypes[i]) ){
                    VD->setSize(VD->tryWidth, VD->tryHeight);
                    foundSize = true;
                    break;
                }
            }

        }





        //if we didn't find the requested size - lets try and find the closest matching size
        if( foundSize == false ){
            if( verbose )printf("SETUP: couldn't find requested size - searching for closest matching size\n");

            int closestWidth        = -1;
            int closestHeight       = -1;
            GUID newMediaSubtype;

            findClosestSizeAndSubtype(VD, VD->tryWidth, VD->tryHeight, closestWidth, closestHeight, newMediaSubtype);

            if( closestWidth != -1 && closestHeight != -1){
                getMediaSubtypeAsString(newMediaSubtype, guidStr);

                if(verbose)printf("SETUP: closest supported size is %s @ %i %i\n", guidStr, closestWidth, closestHeight);
                if( setSizeAndSubtype(VD, closestWidth, closestHeight, newMediaSubtype) ){
                    VD->setSize(closestWidth, closestHeight);
                    foundSize = true;
                }
            }
        }
    }

    //if we didn't specify a custom size or if we did but couldn't find it lets setup with the default settings
    if(customSize == false || foundSize == false){
        if( VD->requestedFrameTime != -1 ){
            pVih->AvgTimePerFrame  = VD->requestedFrameTime;
            hr = VD->streamConf->SetFormat(VD->pAmMediaType);
        }
        VD->setSize(currentWidth, currentHeight);
    }

    //SAMPLE GRABBER (ALLOWS US TO GRAB THE BUFFER)//
    // Create the Sample Grabber.
    hr = CoCreateInstance(CLSID_SampleGrabber, NULL, CLSCTX_INPROC_SERVER,IID_IBaseFilter, (void**)&VD->pGrabberF);
    if (FAILED(hr)){
        if(verbose)printf("Could not Create Sample Grabber - CoCreateInstance()\n");
        stopDevice(deviceID);
        return hr;
    }

    hr = VD->pGraph->AddFilter(VD->pGrabberF, L"Sample Grabber");
    if (FAILED(hr)){
        if(verbose)printf("Could not add Sample Grabber - AddFilter()\n");
        stopDevice(deviceID);
        return hr;
    }

    hr = VD->pGrabberF->QueryInterface(IID_ISampleGrabber, (void**)&VD->pGrabber);
    if (FAILED(hr)){
        if(verbose)printf("ERROR: Could not query SampleGrabber\n");
        stopDevice(deviceID);
        return hr;
    }


    //Set Params - One Shot should be false unless you want to capture just one buffer
    hr = VD->pGrabber->SetOneShot(FALSE);
    if(bCallback){
        hr = VD->pGrabber->SetBufferSamples(FALSE);
    }else{
        hr = VD->pGrabber->SetBufferSamples(TRUE);
    }

    if(bCallback){
        //Tell the grabber to use our callback function - 0 is for SampleCB and 1 for BufferCB
        //We use SampleCB
        hr = VD->pGrabber->SetCallback(VD->sgCallback, 0);
        if (FAILED(hr)){
            if(verbose)printf("ERROR: problem setting callback\n");
            stopDevice(deviceID);
            return hr;
        }else{
            if(verbose)printf("SETUP: Capture callback set\n");
        }
    }

    //MEDIA CONVERSION
    //Get video properties from the stream's mediatype and apply to the grabber (otherwise we don't get an RGB image)
    //zero the media type - lets try this :) - maybe this works?
    AM_MEDIA_TYPE mt;
    ZeroMemory(&mt,sizeof(AM_MEDIA_TYPE));

    mt.majortype    = MEDIATYPE_Video;
    mt.subtype      = MEDIASUBTYPE_RGB24;
    mt.formattype   = FORMAT_VideoInfo;

    //VD->pAmMediaType->subtype = VD->videoType;
    hr = VD->pGrabber->SetMediaType(&mt);

    //lets try freeing our stream conf here too
    //this will fail if the device is already running
    if(VD->streamConf){
        VD->streamConf->Release();
        VD->streamConf = NULL;
    }else{
        if(verbose)printf("ERROR: connecting device - prehaps it is already being used?\n");
        stopDevice(deviceID);
        return S_FALSE;
    }


    //NULL RENDERER//
    //used to give the video stream somewhere to go to.
    hr = CoCreateInstance(CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void**)(&VD->pDestFilter));
    if (FAILED(hr)){
        if(verbose)printf("ERROR: Could not create filter - NullRenderer\n");
        stopDevice(deviceID);
        return hr;
    }

    hr = VD->pGraph->AddFilter(VD->pDestFilter, L"NullRenderer");
    if (FAILED(hr)){
        if(verbose)printf("ERROR: Could not add filter - NullRenderer\n");
        stopDevice(deviceID);
        return hr;
    }

    //RENDER STREAM//
    //This is where the stream gets put together.
    hr = VD->pCaptureGraph->RenderStream(&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, VD->pVideoInputFilter, VD->pGrabberF, VD->pDestFilter);

    if (FAILED(hr)){
        if(verbose)printf("ERROR: Could not connect pins - RenderStream()\n");
        stopDevice(deviceID);
        return hr;
    }


    //EXP - lets try setting the sync source to null - and make it run as fast as possible
    {
        IMediaFilter *pMediaFilter = 0;
        hr = VD->pGraph->QueryInterface(IID_IMediaFilter, (void**)&pMediaFilter);
        if (FAILED(hr)){
            if(verbose)printf("ERROR: Could not get IID_IMediaFilter interface\n");
        }else{
            pMediaFilter->SetSyncSource(NULL);
            pMediaFilter->Release();
        }
    }


    //LETS RUN THE STREAM!
    hr = VD->pControl->Run();

    if (FAILED(hr)){
         if(verbose)printf("ERROR: Could not start graph\n");
         stopDevice(deviceID);
         return hr;
    }


    //MAKE SURE THE DEVICE IS SENDING VIDEO BEFORE WE FINISH
    if(!bCallback){

        long bufferSize = VD->videoSize;

        while( hr != S_OK){
            hr = VD->pGrabber->GetCurrentBuffer(&bufferSize, (long *)VD->pBuffer);
            Sleep(10);
        }

    }

    if(verbose)printf("SETUP: Device is setup and ready to capture.\n\n");
    VD->readyToCapture = true;

    //Release filters - seen someone else do this
    //looks like it solved the freezes

    //if we release this then we don't have access to the settings
    //we release our video input filter but then reconnect with it
    //each time we need to use it
    VD->pVideoInputFilter->Release();
    VD->pVideoInputFilter = NULL;

    VD->pGrabberF->Release();
    VD->pGrabberF = NULL;

    VD->pDestFilter->Release();
    VD->pDestFilter = NULL;

    return S_OK;
}


// ----------------------------------------------------------------------
// Returns number of good devices
//
// ----------------------------------------------------------------------

int videoInput::getDeviceCount(){


    ICreateDevEnum *pDevEnum = NULL;
    IEnumMoniker *pEnum = NULL;
    int deviceCounter = 0;

    HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL,
        CLSCTX_INPROC_SERVER, IID_ICreateDevEnum,
        reinterpret_cast<void**>(&pDevEnum));


    if (SUCCEEDED(hr))
    {
        // Create an enumerator for the video capture category.
        hr = pDevEnum->CreateClassEnumerator(
            CLSID_VideoInputDeviceCategory,
            &pEnum, 0);

       if(hr == S_OK){
            IMoniker *pMoniker = NULL;
            while (pEnum->Next(1, &pMoniker, NULL) == S_OK){

                IPropertyBag *pPropBag;
                hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag,
                    (void**)(&pPropBag));

                if (FAILED(hr)){
                    pMoniker->Release();
                    continue;  // Skip this one, maybe the next one will work.
                }

                pPropBag->Release();
                pPropBag = NULL;

                pMoniker->Release();
                pMoniker = NULL;

                deviceCounter++;
            }

            pEnum->Release();
            pEnum = NULL;
        }

        pDevEnum->Release();
        pDevEnum = NULL;
    }
    return deviceCounter;
}


// ----------------------------------------------------------------------
// Do we need this?
//
// Enumerate all of the video input devices
// Return the filter with a matching friendly name
// ----------------------------------------------------------------------

HRESULT videoInput::getDevice(IBaseFilter** gottaFilter, int deviceId, WCHAR * wDeviceName, char * nDeviceName){
    BOOL done = false;
    int deviceCounter = 0;

    // Create the System Device Enumerator.
    ICreateDevEnum *pSysDevEnum = NULL;
    HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void **)&pSysDevEnum);
    if (FAILED(hr))
    {
        return hr;
    }

    // Obtain a class enumerator for the video input category.
    IEnumMoniker *pEnumCat = NULL;
    hr = pSysDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEnumCat, 0);

    if (hr == S_OK)
    {
        // Enumerate the monikers.
        IMoniker *pMoniker = NULL;
        ULONG cFetched;
        while ((pEnumCat->Next(1, &pMoniker, &cFetched) == S_OK) && (!done))
        {
            if(deviceCounter == deviceId)
            {
                // Bind the first moniker to an object
                IPropertyBag *pPropBag;
                hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag, (void **)&pPropBag);
                if (SUCCEEDED(hr))
                {
                    // To retrieve the filter's friendly name, do the following:
                    VARIANT varName;
                    VariantInit(&varName);
                    hr = pPropBag->Read(L"FriendlyName", &varName, 0);
                    if (SUCCEEDED(hr))
                    {

                        //copy the name to nDeviceName & wDeviceName
                        int count = 0;
                        while( varName.bstrVal[count] != 0x00 ) {
                             wDeviceName[count] = varName.bstrVal[count];
                             nDeviceName[count] = (char)varName.bstrVal[count];
                             count++;
                        }

                        // We found it, so send it back to the caller
                        hr = pMoniker->BindToObject(NULL, NULL, IID_IBaseFilter, (void**)gottaFilter);
                        done = true;
                    }
                    VariantClear(&varName);
                    pPropBag->Release();
                    pPropBag = NULL;
                    pMoniker->Release();
                    pMoniker = NULL;
                }
            }
            deviceCounter++;
        }
        pEnumCat->Release();
        pEnumCat = NULL;
    }
    pSysDevEnum->Release();
    pSysDevEnum = NULL;

    if (done) {
        return hr;  // found it, return native error
    } else {
        return VFW_E_NOT_FOUND; // didn't find it error
    }
}


// ----------------------------------------------------------------------
// Show the property pages for a filter
// This is stolen from the DX9 SDK
// ----------------------------------------------------------------------

HRESULT videoInput::ShowFilterPropertyPages(IBaseFilter *pFilter){

    ISpecifyPropertyPages *pProp;
    HRESULT hr = pFilter->QueryInterface(IID_ISpecifyPropertyPages, (void **)&pProp);
    if (SUCCEEDED(hr))
    {
        // Get the filter's name and IUnknown pointer.
        FILTER_INFO FilterInfo;
        hr = pFilter->QueryFilterInfo(&FilterInfo);
        IUnknown *pFilterUnk;
        pFilter->QueryInterface(IID_IUnknown, (void **)&pFilterUnk);

        // Show the page.
        CAUUID caGUID;
        pProp->GetPages(&caGUID);
        pProp->Release();
        OleCreatePropertyFrame(
            NULL,                   // Parent window
            0, 0,                   // Reserved
            FilterInfo.achName,     // Caption for the dialog box
            1,                      // Number of objects (just the filter)
            &pFilterUnk,            // Array of object pointers.
            caGUID.cElems,          // Number of property pages
            caGUID.pElems,          // Array of property page CLSIDs
            0,                      // Locale identifier
            0, NULL                 // Reserved
        );

        // Clean up.
        if(pFilterUnk)pFilterUnk->Release();
        if(FilterInfo.pGraph)FilterInfo.pGraph->Release();
        CoTaskMemFree(caGUID.pElems);
    }
    return hr;
}


// ----------------------------------------------------------------------
// This code was also brazenly stolen from the DX9 SDK
// Pass it a file name in wszPath, and it will save the filter graph to that file.
// ----------------------------------------------------------------------

HRESULT videoInput::SaveGraphFile(IGraphBuilder *pGraph, WCHAR *wszPath) {
    const WCHAR wszStreamName[] = L"ActiveMovieGraph";
    HRESULT hr;
    IStorage *pStorage = NULL;

    // First, create a document file which will hold the GRF file
    hr = StgCreateDocfile(
        wszPath,
        STGM_CREATE | STGM_TRANSACTED | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
        0, &pStorage);
    if(FAILED(hr))
    {
        return hr;
    }

    // Next, create a stream to store.
    IStream *pStream;
    hr = pStorage->CreateStream(
        wszStreamName,
        STGM_WRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
        0, 0, &pStream);
    if (FAILED(hr))
    {
        pStorage->Release();
        return hr;
    }

    // The IPersistStream converts a stream into a persistent object.
    IPersistStream *pPersist = NULL;
    pGraph->QueryInterface(IID_IPersistStream, reinterpret_cast<void**>(&pPersist));
    hr = pPersist->Save(pStream, TRUE);
    pStream->Release();
    pPersist->Release();
    if (SUCCEEDED(hr))
    {
        hr = pStorage->Commit(STGC_DEFAULT);
    }
    pStorage->Release();
    return hr;
}


// ----------------------------------------------------------------------
// For changing the input types
//
// ----------------------------------------------------------------------

HRESULT videoInput::routeCrossbar(ICaptureGraphBuilder2 **ppBuild, IBaseFilter **pVidInFilter, int conType, GUID captureMode){

    //create local ICaptureGraphBuilder2
    ICaptureGraphBuilder2 *pBuild = NULL;
    pBuild = *ppBuild;

    //create local IBaseFilter
    IBaseFilter *pVidFilter = NULL;
    pVidFilter = * pVidInFilter;

    // Search upstream for a crossbar.
    IAMCrossbar *pXBar1 = NULL;
    HRESULT hr = pBuild->FindInterface(&LOOK_UPSTREAM_ONLY, NULL, pVidFilter,
            IID_IAMCrossbar, (void**)&pXBar1);
    if (SUCCEEDED(hr))
    {

        bool foundDevice = false;

        if(verbose)printf("SETUP: You are not a webcam! Setting Crossbar\n");
        pXBar1->Release();

        IAMCrossbar *Crossbar;
        hr = pBuild->FindInterface(&captureMode, &MEDIATYPE_Interleaved, pVidFilter, IID_IAMCrossbar, (void **)&Crossbar);

        if(hr != NOERROR){
            hr = pBuild->FindInterface(&captureMode, &MEDIATYPE_Video, pVidFilter, IID_IAMCrossbar, (void **)&Crossbar);
        }

        LONG lInpin, lOutpin;
        hr = Crossbar->get_PinCounts(&lOutpin , &lInpin);

        BOOL IPin=TRUE; LONG pIndex=0 , pRIndex=0 , pType=0;

        while( pIndex < lInpin)
        {
            hr = Crossbar->get_CrossbarPinInfo( IPin , pIndex , &pRIndex , &pType);

            if( pType == conType){
                    if(verbose)printf("SETUP: Found Physical Interface");

                    switch(conType){

                        case PhysConn_Video_Composite:
                            if(verbose)printf(" - Composite\n");
                            break;
                        case PhysConn_Video_SVideo:
                            if(verbose)printf(" - S-Video\n");
                            break;
                        case PhysConn_Video_Tuner:
                            if(verbose)printf(" - Tuner\n");
                            break;
                        case PhysConn_Video_USB:
                             if(verbose)printf(" - USB\n");
                            break;
                        case PhysConn_Video_1394:
                            if(verbose)printf(" - Firewire\n");
                            break;
                    }

                foundDevice = true;
                break;
            }
            pIndex++;

        }

        if(foundDevice){
            BOOL OPin=FALSE; LONG pOIndex=0 , pORIndex=0 , pOType=0;
            while( pOIndex < lOutpin)
            {
                hr = Crossbar->get_CrossbarPinInfo( OPin , pOIndex , &pORIndex , &pOType);
                if( pOType == PhysConn_Video_VideoDecoder)
                    break;
            }
            Crossbar->Route(pOIndex,pIndex);
        }else{
            if(verbose)printf("SETUP: Didn't find specified Physical Connection type. Using Defualt. \n");
        }

        //we only free the crossbar when we close or restart the device
        //we were getting a crash otherwise
        //if(Crossbar)Crossbar->Release();
        //if(Crossbar)Crossbar = NULL;

        if(pXBar1)pXBar1->Release();
        if(pXBar1)pXBar1 = NULL;

    }else{
        if(verbose)printf("SETUP: You are a webcam or snazzy firewire cam! No Crossbar needed\n");
        return hr;
    }

    return hr;
}

frameProcessor.h

#ifndef FRAMEPROCESSOR_H
#define FRAMEPROCESSOR_H
#include <opencv2/opencv.hpp>

class FrameProcessor
{
public:
    virtual void process(cv::Mat &input, cv::Mat &output) = 0;
};

#endif // FRAMEPROCESSOR_H

videoProcessor.h

//处理视频帧,为了对视频的每一帧进行处理，这里创建自己的类VideoProcessor，其中封装了OpenCV的视频获取框架，该类允许我们指定每帧调用的处理函数,可对设备或者视频或者自定义的图像序列进行处理。
//改自：http://blog.csdn.net/liyuefeilong/article/details/44066097
/*
说明：
在此之前，需要先另外创建一个类，即VideoProcessor内部使用的帧处理类。
这是因为在面向对象的上下文中，更适合使用帧处理类而不是一个帧处理函数，
而使用类可以给程序员在涉及算法方面有更多的灵活度（书上介绍的）。
将这个内部帧处理类命名为FrameProcessor，需要新建！其定义如下：
#ifndef FRAMEPROCESSOR_H
#define FRAMEPROCESSOR_H
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>

class FrameProcessor
{
public:
virtual void process(cv:: Mat &input, cv:: Mat &output)= 0;
};

#endif // FRAMEPROCESSOR_H
*/

/应用实例//
// 定义一个视频处理类处理视频帧
// 首先创建实例
//VideoProcessor processor;
// 打开视频文件
//processor.setInput("e:/BrokeGirls.mkv");//此为以打开视频文件为例
// 声明显示窗口
// 分别为输入和输出视频
//processor.displayInput("Input Video");
//processor.displayOutput("Output Video");
// 以原始帧率播放视频
//processor.setDelay(1000. / processor.getFrameRate());此处这个表达式含getFrameRate()，所以只能用于视频文件，当处理的是设备或者序列图像的帧时最好不能用getFrameRate()
// 设置处理回调函数
//processor.setFrameProcessor(canny);表示采用在main文件中按一定格式自编的封装canny算法的函数！也可用声明frameProcessor的方法且该类中需定义好帧处理算法
// 开始帧处理过程
//processor.run();//该类的run（）结果只是显示，并没有保存处理的结果，要实现此功能可加入相应代码即可！！
//cv::waitKey();

//定义VideoProcessor类:
#ifndef VIDEOPROCESSOR_H
#define VIDEOPROCESSOR_H
#include <opencv2/opencv.hpp>
#include <iostream>
#include "frameProcessor.h"
using namespace std;
using namespace cv;
class VideoProcessor
{
private:
    // 创建视频捕获对象
    cv::VideoCapture capture;
    // 每帧调用的回调函数
    void(*process)(cv::Mat&, cv::Mat&);
    // FrameProcessor接口
    FrameProcessor *frameProcessor;
    // 确定是否调用回调函数的bool信号
    bool callIt;
    // 输入窗口的名称
    std::string windowNameInput;
    // 输出窗口的名称
    std::string windowNameOutput;
    // 延迟
    int delay;
    // 已处理的帧数
    long fnumber;
    // 在该帧停止
    long frameToStop;
    // 是否停止处理
    bool stop;

    // 当输入图像序列存储在不同文件中时，可使用以下设置
    // 把图像文件名的数组作为输入
    std::vector<std::string> images;
    // 图像向量的迭加器
    std::vector<std::string>::const_iterator itImg;

    // !!!!!!循环获取每一帧，得到下一帧图像！！！！！！
    // 可能来自：视频文件或摄像头，该函数自动判定！
    bool readNextFrame(cv::Mat &frame)
    {
        if (images.size() == 0)
            return capture.read(frame);//意思等同于frame=capture.read()，成功return一个标志！！
        else {

            if (itImg != images.end())
            {
                frame = cv::imread(*itImg);
                itImg++;
                return frame.data != 0;
            }
        }
    }

public:

    // 构造函数：默认设置 digits(0), frameToStop(-1),
    VideoProcessor() : callIt(false), delay(-1),
        fnumber(0), stop(false),
        process(0), frameProcessor(0) {}

    // 创建输入窗口
    void displayInput(std::string wt);
    // 创建输出窗口
    void displayOutput(std::string wn);
    // 不再显示处理后的帧
    void dontDisplay();

    // 以下三个函数设置输入的图像向量
    bool setInput(std::string filename);
    // 若输入为摄像头，设置ID
    bool setInput(int id);
    // 若输入为一组图像序列时，应用该函数
    bool setInput(const std::vector<std::string>& imgs);

    // 设置帧之间的延迟
    // 0意味着在每一帧都等待按键响应
    // 负数意味着没有延迟
    void setDelay(int d);

    // 返回图像的帧率
    double getFrameRate();

    // 需要调用回调函数
    void callProcess();

    // 不需要调用回调函数
    void dontCallProcess();

    // 设置FrameProcessor实例
    void setFrameProcessor(FrameProcessor* frameProcessorPtr);

    // 设置回调函数
    void setFrameProcessor(void(*frameProcessingCallback)(cv::Mat&, cv::Mat&));

    // 停止运行
    void stopIt();

    // 判断是否已经停止
    bool isStopped();

    // 是否开始了捕获设备？
    bool isOpened();

    // 返回捕获视频或文件的总帧数，捕获设备时不能用该函数
    long getFrameNumber();

    // 该函数获取并处理视频帧
    void run();

};

#endif // VIDEOPROCESSOR_H

videoProcessor.cpp

#include "videoProcessor.h"

// 创建输入窗口
void VideoProcessor::displayInput(std::string wt)
{
    windowNameInput = wt;
    cv::namedWindow(windowNameInput);
}

// 创建输出窗口
void VideoProcessor::displayOutput(std::string wn)
{
    windowNameOutput = wn;
    cv::namedWindow(windowNameOutput);
}

// 不再显示处理后的帧
void VideoProcessor::dontDisplay()
{
    cv::destroyWindow(windowNameInput);
    cv::destroyWindow(windowNameOutput);
    windowNameInput.clear();
    windowNameOutput.clear();
}

// 设置输入的图像向量
bool VideoProcessor::setInput(std::string filename)
{
    fnumber = 0;
    // 释放之前打开过的视频文件资源
    capture.release();
    images.clear();

    // 打开视频
    return capture.open(filename);
}

// 若输入为摄像头，设置ID
bool VideoProcessor::setInput(int id)
{
    fnumber = 0;
    // 释放之前打开过的视频资源
    capture.release();
    images.clear();

    // 打开视频文件
    return capture.open(id);
}

// 若输入为一组图像序列时，应用该函数
bool VideoProcessor::setInput(const std::vector<std::string>& imgs)
{
    fnumber = 0;
    // 释放之前打开过的视频资源
    capture.release();

    // 输入将是该图像的向量
    images = imgs;
    itImg = images.begin();

    return true;
}

// 设置帧之间的延迟
// 0意味着在每一帧都等待按键响应
// 负数意味着没有延迟
void VideoProcessor::setDelay(int d)
{
    delay = d;
}

// 返回图像的帧率
double VideoProcessor::getFrameRate()
{
    if (images.size() != 0) return 25.0;//即自定义图像序列采用默认的25fps处理每帧
    double r = capture.get(CV_CAP_PROP_FPS);
    return r;
}

// 需要调用回调函数
void VideoProcessor::callProcess()
{
    callIt = true;
}

// 不需要调用回调函数
void VideoProcessor::dontCallProcess()
{
    callIt = false;
}

//重载代表是使用外置的即main中自己按一定格式写的函数还是用frameProcessor类中已定义的内含的帧处理函数！！！
// 设置FrameProcessor实例
void VideoProcessor::setFrameProcessor(FrameProcessor* frameProcessorPtr)
{
    // 使回调函数无效化
    process = 0;
    // 重新设置FrameProcessor实例
    frameProcessor = frameProcessorPtr;
    callProcess();
}
// 设置回调函数
void VideoProcessor::setFrameProcessor(void(*frameProcessingCallback)(cv::Mat&, cv::Mat&))
{
    // 使FrameProcessor实例无效化
    frameProcessor = 0;
    // 重新设置回调函数
    process = frameProcessingCallback;
    callProcess();
}

// 以下函数表示视频的读取状态
// 停止运行
void VideoProcessor::stopIt()
{
    stop = true;
}

// 判断是否已经停止
bool VideoProcessor::isStopped()
{
    return stop;
}

// 是否开始了捕获设备？
bool VideoProcessor::isOpened()
{
    return capture.isOpened() || !images.empty();
}

// 有问题：返回处理设备或视频或序列图像的总帧数，问题在于当捕获的是设备视频时无法得到总的帧数的信息，即不能调用次函数。
long VideoProcessor::getFrameNumber()
{
    if (images.size() == 0)
    {
        // 得到捕获设备的信息
        long f = static_cast<long>(capture.get(CV_CAP_PROP_POS_FRAMES));
        return f;

    }
    else // 当输入来自一组图像序列时的情况
    {
        return static_cast<long>(images.end() - images.begin());
    }
}

// 该函数获取并处理视频帧
void VideoProcessor::run()
{
    // 当前帧
    cv::Mat frame;
    // 输出帧
    cv::Mat output;


    // 打开失败时
    if (!isOpened())//该成员函数是用于判定从设备或视频   和   从序列图像是否成功打开，如果isOpened()为真则成功捕获到源！表示可进行下一步读入图像操作
    {
        cout << "Error!"<<"打开预处理的视频或序列文件或设备失败！"<<endl;
        return;
    }

    stop = false;
    while (!isStopped())
    {
        // 读取下一帧
        if (!readNextFrame(frame))
            break;
        // 显示输出帧
        if (windowNameInput.length() != 0)
            cv::imshow(windowNameInput, frame);
        // 调用处理函数
        if (callIt)
        {
            // 处理当前帧
            if (process)
                process(frame, output);
            else if (frameProcessor)
                frameProcessor->process(frame, output);//表示调用类frameProcessor的指针类型对象*frameProcessor，它也是类videoProcessor的成员变量，可以通过videoProcessor的成员函数给该指针成员变量赋予实例的地址。

            // 已处理的帧数计数
            fnumber++;
        }
        else
        {
            output = frame;//即在不调用帧处理算法的时候，输出窗口显示为原图像
        }
        // 显示输出帧
        if (windowNameOutput.length() != 0)
            cv::imshow(windowNameOutput, output);
        // 引入延迟
        if (delay >= 0 && cv::waitKey(delay) >= 0)
            stopIt();
        // 检查是否需要停止运行,该函数不能用于捕获设备的情况
        //if (getFrameNumber() == fnumber)
        //  stopIt();
    }
}
leeboosunny
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaCV进阶opencv图像处理：批量人脸图像分类训练
eguid音视频技术分享（JavaCV教程、FFmpeg教程、openCV图像处理教程、音视频教程）
03-22 2704
javacv进阶opencv图像检测/识别 JavaCV进阶opencv图像处理：摄像头图像人脸检测 JavaCV进阶opencv图像处理：ffmpeg视频图像画面人脸检测 JavaCV进阶opencv图像处理：批量人脸图像分类训练 JavaCV进阶opencv图像处理：摄像头图像人脸识别 前言 阅读顺序以检测、训练、识别为顺序阅读，识别需要用到本章训练好的数据fisherFaceRecognizer.xml。 让我们立刻开始吧 功能实现 1、批量读取图片 2、批量人脸训练 .
VideoInput
03-17
VideoInput库源码 以及demo VS2010工程 欢迎下载
OpenCV学习笔记（三十）——解开VideoInput面纱highgui
yangshen998
11-25 426
最近做一个东西，摄像头使用的高清摄像头，采集出来的视频是D1格式（720*480）。使用VideoCapture发现速度很忙，网上的朋友说VideoCapture提供的读写功能采用VFW，效率低下且有些格式支持不好。而 OpenCV 2.0 内置了videoInput Library，可以自动在VFW和DirectShow间切换。videoInput是老外写的功能强大的开源视频处理库。是一个第三方...
videoInput视频采集
急支糖浆的博客
08-21 1173
videoInput视频采集 videoInputgithub地址 从中获取到videoInput.cpp和videoInput.h两个文件。 创建vs工程加入上面两个文件并创建main.cpp。main.cpp示例代码： #include <iostream> #include <thread> #include "videoInput.h" using namespace std; int main() { //获取摄像头的数量和名字 video.
OpenCV实例：基于videoInput的视频录像机
gonxi的专栏
04-02 3671
1. 新建项目    启动Code::Blocks，选择File->New->Project, 项目类型选择:Console Application,项目名为：MyRecorder，其他按默认选择。2. 代码    打开main.cpp文件，输入以下代码：#include #include #include using namespace std;int main(int argc, char** argv){    int width = 640;    int height = 400;    char
VideoInput: 实时视频输入处理库
最新发布
gitblog_00009的博客
03-08 559
VideoInput: 实时视频输入处理库 VideoInput 是一个开源的 C++ 库，用于捕获、预览和处理实时视频流。它为开发人员提供了简单易用的 API 来实现各种实时视频应用。 项目简介 VideoInput 库的目标是简化实时视频处理的流程，并且提供跨平台的支持。它可以用于开发需要实时视频输入的应用，例如： 视频会议软件 监控系统 虚拟现实应用 视频特效处理工具 增强现实应用 游戏引...
opencv学习中——对视频的处理
gaotong0527的博客
09-21 1162
1.将视频保存为连续的图片：#include "stdafx.h" #include <stdio.h> #include "opencv2/opencv.hpp" #include <iostream>int main(int argc, char *argv[]) { CvCapture* capture = cvCaptureFromAVI("G:\\21.flv");//captur
用OpenCV处理视频
星声如沸
12-30 1866
开发软件说明 使用OpenCV，对输入的一段彩色视频，用OpenCV实现以下功能或要求: 1.  对输入视频的每一帧图像都用同一个阈值进行二值化； 2.  在每帧二值化图像上叠加上含自己学号与姓名等信息的版权字幕； 3.  在处理的过程中，实时显示每帧图片处理之后的效果； 4.  将所有这些二值化图像按视频原来顺序合成输出一个视频文件，按原输入视频播放速度的两倍合成； 5. 
基于QT5+Opencv完成简单的图像处理及视频处理软件
02-25
QT图形界面编程 大作业，主要功能分为图像处理以及视频处理两大块。 图像处理包括：灰度化、...软件使用的是QT 5.12.2+QT Creator 4.8.2+win10，QT5版本应该都可行，视频处理涉及到OpenCV，我使用的是OpenCV4.0.1版本。
OpenCV实现SfM:双目三维重建
09-02
使用OpenCV3.0进行双目三维重建。 代码是用VS2013写的，OpenCV版本为3.0且包含扩展部分，如果不使用SIFT特征，可以修改源代码，然后使用官方未包含扩展部分的库。软件运行后会将三维重建的结果写入Viewer目录下的...
基于VideoInput的摄像头操作类-附件资源
03-05
基于VideoInput的摄像头操作类-附件资源
videoinput源码
10-04
包括videoInput0.1995和videoInput-2014-Stable，可以稳定支持vs2012之前的软件。
videoinput-0.200-1.5.7-API文档-中文版.zip
07-06
赠送jar包：videoinput-0.200-1.5.7.jar； 赠送原API文档：videoinput-0.200-1.5.7-javadoc.jar； 赠送源代码：videoinput-0.200-1.5.7-sources.jar； 赠送Maven依赖信息文件：videoinput-0.200-1.5.7.pom； 包含翻译后的API文档：videoinput-0.200-1.5.7-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.bytedeco:videoinput:0.200-1.5.7； 标签：bytedeco、videoinput、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
OpenCV实战（26）——视频序列处理
盼小辉丶的博客
06-07 7947
视频信号包含丰富的视觉信息，视频由一系列图像组成，每一图像称为一帧 (frame)，这些图像以固定的时间间隔(通过指定帧率，单位为秒/帧)拍摄并显示运动场景。随着计算机算力的提升，现在已经可以对视频序列执行复杂的视觉分析，处理速度已经接近甚至快于实际视频帧率 (frame rate)。本节将学习如何读取、处理和存储视频序列。
OpenCV实战（1）——OpenCV与图像处理基础
热门推荐
盼小辉丶的博客
10-24 6万+
OpenCV 是一个跨平台计算机视觉和机器学习库，实现了图像处理和计算机视觉方面的很多通用算法。本节将介绍 OpenCV 的基础知识，以及如何编译运行 OpenCV 程序，并介绍如何完成最基本的图像处理任务——读取、显示和保存图像。除此之外，鼠标事件和图形绘制也是 OpenCV 计算机视觉项目中常用的基本功能，本节介绍了如何使用这两个重要的 OpenCV 功能。
videoInput样例
genganpeng的专栏
08-23 1630
这是来源于videoInput.h中的一个例子： //create a videoInput object videoInput VI; //Prints out a list of available devices and returns num o
matlab的videoinput函数
l2014010671的博客
03-26 8132
matlab的videoinput函数有三个重要的输入参数，分别是adaptorname、deviceID、format，如下图所示，其他参数可以有选择性的设置。deviceID如果不设置的话，系统会自动寻找第一个可用的图像采集设备并使用。如果计算机上安装了多个摄像头，那么就要设置它们的ID号。format是视频格式。除了deviceID，其他两个参数需要用‘’括起来。 在不知道计算机里安装...
videoInput库+opencv+usb采集卡+监控相机
马仔老虞
08-12 2180
一.设备 1.监控相机：登利路30倍变焦 2.usb采集卡：MINE Vcap2860 二：软件 1.VS2010 2.opencv2.3.1 3.videoInput库    网盘下载地址链接: http://pan.baidu.com/s/1c2gFV7E 密码: s936 三：编程测试 1.代码： #include "stdafx.h" #include
opencv与videoInput
genganpeng的专栏
08-23 4139
从opencv2.0开始带有第三方库videoInput支持directshow 在lib中加上inputVideo.lib文件： // Opencv2.2-videoInput.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #in
OpenCV学习笔记：CUDA加速与图像处理
"这篇学习心得主要分享了作者在学习OpenCV过程中积累的知识点，包括类的概念、CUDA在GPU计算中的作用、GitHub的分布式版本控制特性，以及OpenCV的基础使用，如图片读取、灰度处理、滤波和视频读取等。" 在OpenCV的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值