}

    else if (strcmp(property, CVCAM_RNDWIDTH) == 0)
    {
        int val = *(int*)value;
        OAFilterState state = State_Stopped;
        
        if(_cvcamMediaControl.is_valid())
            _cvcamMediaControl->GetState(0, &state);
        if(state != State_Stopped)
            cvcamStop();

        cvcam_properties[camera].rndwidth = val;
        
        if(state == State_Running)
            cvcamStart();
        return 0;
    }

    else if (strcmp(property, CVCAM_RNDHEIGHT) == 0)
    {
        int val = *(int*)value;
        OAFilterState state = State_Stopped;
        
        if(_cvcamMediaControl.is_valid())
            _cvcamMediaControl->GetState(0, &state);
        if(state != State_Stopped)
            cvcamStop();
        
        cvcam_properties[camera].rndheight = val;
        if(state == State_Running)
            cvcamStart();
        return 0;
    }



    return -2;
}
/////////////////////////////////////////////////////////////////////////////////////////
/* gets all property names. the actual number of properties is returned. */
CVCAM_API int cvcamGetPropertiesList(int camera, const char** properties, int count)
{
    CHECK_CAMERA((uint)camera);
    if(count-- > 0)
    {
        properties[0] = CVCAM_PROP_ENABLE;
    }
    if(count-- > 0)
    {
        properties[1] = CVCAM_PROP_RENDER;
    }
    if(count-- > 0)
    {
        properties[2] = CVCAM_PROP_WINDOW;
    }

    return 3;
}
/////////////////////////////////////////////////////////////////////////////////////////
/* Prepares the currently enabled cameras for work */
CVCAM_API int cvcamInit()
{
    
//    IBaseFilter* filter;
    vector<SafeUnknown> _objects;

    //*** video source filter have already been created when user call 
    //cvcamSetProperty to enable camera. So we don't need to do it again.
    //
    /* Create a video source filter */
//  _cvcamInitVideoSource(&filter);

    if(_cvcamNumberOfEnabled() == 2)
        return _cvcamInit2Cams();
    
    
    /* Create a proxy transform filter */
    if(FAILED(CoCreateInstance(CLSID_ProxyTransform, NULL, CLSCTX_INPROC_SERVER, 
                    IID_IProxyTransform, (void**)&_cvcamProxyTrans)))
    {
        MessageBox(0,"ProxyTrans.ax is not registered.\nPlease run \"opencv\\bin\\registerall.bat\" to register it.\n"
                   "Also, do not forget to add \"opencv\\bin\" to the system path.", "Error", MB_OK|MB_ICONERROR);
        return 0;
    }

    _cvcamProxyTrans->set_transform(
        (void(__cdecl*)(void*))cvcam_properties[camera_index].callback, 0);


    //*** Again, we already have got one. 
    //
    /* Create a filter graph object */
/*    if(FAILED(CoCreateInstance( CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, 
                      IID_IGraphBuilder, (void **)&_cvcamGraphBuilder )))
    {
        return 0;
    }
*/
    ASSERT(!_cvcamMediaControl.is_valid());
    _cvcamGraphBuilder->QueryInterface(IID_IMediaControl,(void**)&_cvcamMediaControl);
    _cvcamGraphBuilder->QueryInterface(IID_IMediaEventEx,(void**)&_cvcamMediaEventEx);
    _cvcamGraphBuilder->QueryInterface(IID_IVideoWindow, (void**)&_cvcamVideoWindow);

    IBaseFilter* pProxyTrans = 0;
    _cvcamProxyTrans->QueryInterface(IID_IBaseFilter, (void**)&pProxyTrans);
    _objects.push_back(SafeUnknown(pProxyTrans));

    /* link all filters together*/
    if( _cvcamGraphBuilder.is_valid() )
    {
        HRESULT hr;

        //*** It's been added.
//      hr = _cvcamGraphBuilder->AddFilter( (_cvcamSource[camera_index]).value(), L"Video Source" );

        hr = _cvcamGraphBuilder->AddFilter( pProxyTrans, L"Script processing");

        
        IPin* pSourceOut    = get_source_pin( _cvcamSource[camera_index].value(),
                                              PINDIR_OUTPUT );
        IPin* pProxyTransIn     = get_pin( pProxyTrans, PINDIR_INPUT );
        IPin* pProxyTransOut    = get_pin( pProxyTrans, PINDIR_OUTPUT );
        _objects.push_back(SafeUnknown(pSourceOut));
        _objects.push_back(SafeUnknown(pProxyTransIn));
        _objects.push_back(SafeUnknown(pProxyTransOut));
    
        if( pSourceOut && pProxyTransIn && pProxyTransOut )
        {
            
            hr = _cvcamGraphBuilder->Connect(pSourceOut, pProxyTransIn);

            int render;
            cvcamGetProperty(camera_index, CVCAM_PROP_RENDER, &render);
            if(render)
                hr = _cvcamGraphBuilder->Render( pProxyTransOut );

        }
    }

    return 1;
}

//*** I HAVE NOT YET TESTED WORKING WITH 2 CAMERAS.
//
/////////////////////////////////////////////////////////////////////////////////////////
//Makes the graph from 2 cameras and cvSync filter
static int _cvcamInit2Cams()
{
    /* Create a cvSync filter */
    if(FAILED(CoCreateInstance(CLSID_SyncFilter, NULL, CLSCTX_INPROC_SERVER, 
                    IID_ISyncFilter, (void**)&_cvcamCvSync)))
    {
        return 0;
    }

    if(stereo_callback)
        _cvcamCvSync->SetCallBack( (void(__cdecl*)(void*, void*))stereo_callback );
    
    //*** _cvcamGraphBuilder has already been created in _cvcamInitCapFilters.
    //
    /* Create a filter graph object */
/*    if(FAILED(CoCreateInstance( CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, 
                      IID_IGraphBuilder, (void **)&_cvcamGraphBuilder )))
    {
        _cvcamCvSync=NULL;
        return 0;
    }
*/
    ASSERT(!_cvcamMediaControl.is_valid());
    _cvcamGraphBuilder->QueryInterface(IID_IMediaControl,(void**)&_cvcamMediaControl);
    //_cvcamGraphBuilder->QueryInterface(IID_IMediaEventEx,(void**)&_cvcamMediaEventEx);
    //_cvcamGraphBuilder->QueryInterface(IID_IVideoWindow, (void**)&_cvcamVideoWindow);
//    _cvcamGraphBuilder->QueryInterface(IID_IFilterGraph, (void**)&_cvcamFilterGraph);

    IBaseFilter* pSyncFilter = 0;
    _cvcamCvSync->QueryInterface(IID_IBaseFilter, (void**)&pSyncFilter);
    

    vector<SafeUnknown> _objects;
    _objects.push_back(SafeUnknown(pSyncFilter));

/* link all filters together*/
    if( _cvcamGraphBuilder.is_valid() )
    {
        HRESULT hr;

        

        vector<int> indexes;
        
        for(uint i = 0; i < cvcam_properties.size(); i++)
        {
            if(cvcam_properties[i]._enabled)
            {
                //*** All source filters should have been added in .
/*                hr = _cvcamGraphBuilder->AddFilter( (_cvcamSource[i]).value(),
                                                    L"Video Source" );
                if(FAILED(hr)) 
                {
                    //_cvcamGraphBuilder=NULL;
                    //_cvcamCvSync=NULL;
                    return 0;
                }
*/
                indexes.push_back(i);
            }
        }
        
        hr = _cvcamGraphBuilder->AddFilter( pSyncFilter, L"Script processing");
        if(FAILED(hr))
        {
            //_cvcamGraphBuilder=NULL;
            //_cvcamCvSync=NULL;
            return 0;
        }

        
        IPin* pSourceOut1 = get_source_pin( _cvcamSource[indexes[0] ].value(),
                                            PINDIR_OUTPUT );
        if(!pSourceOut1)
        {
            //_cvcamGraphBuilder=NULL;
            //_cvcamCvSync=NULL;
            return 0;
        
        }
        IPin* pSourceOut2 = get_source_pin( _cvcamSource[indexes[1] ].value(),
                                            PINDIR_OUTPUT );
        if(!pSourceOut2)
        {
            //_cvcamGraphBuilder=NULL;
            //_cvcamCvSync=NULL;
            return 0;
        
        }
        

        IPin* pSyncInput1;
        IPin* pSyncInput2;
        IPin* pSyncOutput1;
        IPin* pSyncOutput2;
        pSyncFilter->FindPin(L"Input1", &pSyncInput1);
        pSyncFilter->FindPin(L"Input2", &pSyncInput2);
        pSyncFilter->FindPin(L"Output1", &pSyncOutput1);
        pSyncFilter->FindPin(L"Output2", &pSyncOutput2);

        
        
        _objects.push_back(SafeUnknown(pSourceOut1));
        _objects.push_back(SafeUnknown(pSourceOut2));
        _objects.push_back(SafeUnknown(pSyncInput1));
        _objects.push_back(SafeUnknown(pSyncInput2));
        _objects.push_back(SafeUnknown(pSyncOutput1));
        _objects.push_back(SafeUnknown(pSyncOutput2));
        
        
       
    
        if( pSourceOut1 && pSyncInput1 && pSyncOutput1 )
        {
            
            hr = _cvcamGraphBuilder->Connect(pSourceOut1, pSyncInput1);
            if(FAILED(hr)) 
            {
                //_cvcamGraphBuilder=NULL;
                //_cvcamCvSync=NULL;
                return 0;
            }
            int render;
            cvcamGetProperty(indexes[0], CVCAM_PROP_RENDER, &render);
            if(render)
                hr = _cvcamGraphBuilder->Render( pSyncOutput1 );
                if(FAILED(hr)) 
                {
                   // _cvcamGraphBuilder=NULL;
                    //_cvcamCvSync=NULL;
                    return 0;
                }
        }

        if( pSourceOut2 && pSyncInput2 && pSyncOutput2 )
        {
            
            hr = _cvcamGraphBuilder->Connect(pSourceOut2, pSyncInput2);
            if(FAILED(hr)) 
            {
                //_cvcamGraphBuilder=NULL;
                //_cvcamCvSync=NULL;
                return 0;
            }
            int render;
            cvcamGetProperty(indexes[1], CVCAM_PROP_RENDER, &render);
            
            if(render)
                hr = _cvcamGraphBuilder->Render( pSyncOutput2 );
                if(FAILED(hr)) 
                {
                    //_cvcamGraphBuilder=NULL;
                    //_cvcamCvSync=NULL;
                    return 0;
                }
        }
    
    }


    return 1;
};
/////////////////////////////////////////////////////////////////////////////////////////
int _cvcamStart2()
{
    
    vector<SafeUnknown> _objects;
    IBaseFilter* pcvSync = 0;

    vector<int> indexes;
        
        for(uint i = 0; i < cvcam_properties.size(); i++)
        {
            if(cvcam_properties[i]._enabled)
            {
                indexes.push_back(i);
            }
        }

    if(!(_cvcamCvSync.is_valid()))
        return -1;

    //We'll adjust video windows parameters. As we've possibly got 2 
    //renderers and so 2 windows, we can't get the IVideoWindow interface
    //from IGraphBuilder, so let's go directly to renderers;
    
    if(cvcam_properties[indexes[0]].render||cvcam_properties[indexes[1]].render)
    {
    
        _cvcamCvSync->QueryInterface(IID_IBaseFilter, (void**)&pcvSync);
        _objects.push_back(SafeUnknown(pcvSync));

        IPin* output1;
        IPin* output2;

        ASSERT(pcvSync);

        pcvSync->FindPin(L"Output1", &output1);
        pcvSync->FindPin(L"Output2", &output2);

        _objects.push_back(SafeUnknown(output1));
        _objects.push_back(SafeUnknown(output2));

        ASSERT(output1&&output2);

        if( !_cvcamMediaControl.is_valid() )
        {
            return -1;
        }//if( !_cvcamMediaControl.is_valid() )

        PIN_INFO PinInfo;
        IBaseFilter* renderer;
        IPin* pPin;

        if(cvcam_properties[indexes[0]].render)
        {

            output1->ConnectedTo(&pPin);
            if(!pPin)
                return VFW_E_NOT_CONNECTED;
            _objects.push_back(SafeUnknown(pPin));

            pPin->QueryPinInfo(&PinInfo);
            
            renderer = PinInfo.pFilter;

            _objects.push_back(SafeUnknown(renderer));


            //IVideoWindow* pVideoWindow;
            renderer->QueryInterface(IID_IVideoWindow, (void**)&_cvcamVideoWindow);

            

            HWND hWnd;
        
            cvcamGetProperty(indexes[0], CVCAM_PROP_WINDOW, &hWnd);
            if(!hWnd)
            {
                hWnd = _cvcamCreateWindow();
                cvcamSetProperty(indexes[0], CVCAM_PROP_WINDOW, &hWnd);
            }
            
            _cvcamVideoWindow->put_Owner((OAHWND)hWnd);

            long flags;
            _cvcamVideoWindow->get_WindowStyle(&flags);
            _cvcamVideoWindow->put_WindowStyle(flags & (~WS_CAPTION) | WS_CHILD);
            _cvcamVideoWindow->put_MessageDrain((OAHWND)hWnd);

            // Get the rectangle dimensions and resize the client window
            AM_MEDIA_TYPE amt;
            pPin->ConnectionMediaType(&amt);
            VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)amt.pbFormat;
            if(!vih)