cvcam.cpp

是一个人脸识别特征提取的Vc代码

    /* Create capture device enumerator*/
    if(!_cvcamEnumMon.is_valid())
    {
        HRESULT hr = _cvcamCreateDevEnum->CreateClassEnumerator( CLSID_VideoInputDeviceCategory,
                        &_cvcamEnumMon, 0);
        if( hr != NOERROR)
            return -1;
    }


    if(!_cvcamSource.size())//           [0]/*.is_valid()*/)
    {
        uint count = cvcam_properties.size();
        if(cvcam_properties.size() == 0)
        {
            /* Count the capture devices */
            unsigned long fetched = 1;
            for(count = 0; fetched != 0; count++)
            {
                _cvcamEnumMon->Next(1, &_cvcamMon, &fetched);
                if(fetched)
                {
                    _cvcamMonikers.push_back(_cvcamMon);


                    SafePointer<IBaseFilter> pIBF(NULL);

                    _cvcamSource.push_back(pIBF);
                }
            }
            count--;
            _cam_properties prop;
            cvcam_properties.assign(count, prop);
        }


        if(filter)
        {
            // find the user's camera selection
            for(uint i = 0; i < cvcam_properties.size(); i++)
            {
                if(cvcam_properties[i]._enabled)
                {
                    camera_index = i;
                }
            }

            if(camera_index < 0)
            {
                /* select a video source and return a pointer to it */
                for(uint i = 0; i < count; i++)
                {
                    _cvcamMonikers[i]->BindToObject(0, 0, IID_IBaseFilter, 
                                                    (void **)filter);
                    if(filter)
                    {
                        cvcam_properties[i]._enabled = 1;
                        _cvcamSource[i]=*filter;
                        camera_index = i;
                        return count;
                    }
                }
            }
            else
            {
                _cvcamMonikers[(uint)camera_index]->BindToObject(0, 0, IID_IBaseFilter,
                                                                (void **)filter);
                if(filter)
                {
                    _cvcamSource[(uint)camera_index]=*filter;
                }
            }

            *filter = 0;
            return 0;
        }

        return count;
    }
    else
    {
        if(!filter)
            return cvcam_properties.size();

        for(uint i = 0; i < cvcam_properties.size(); i++)
        {
            if(cvcam_properties[i]._enabled)
            {
                /* Initialize the camera */
                _cvcamMonikers[i]->BindToObject(0, 0, IID_IBaseFilter, (void **)filter);
                if(filter)
                {
                    _cvcamSource[i]=*filter;
                    camera_index = i;
                    return i;
                }
            }
        }

        /* No camera has been selected */
        *filter = 0;
        return -1;
    }
}

/* Creates a window for DS rendering */
HWND _cvcamCreateWindow()
{
    cvNamedWindow("cvcam window", 0);
    return (HWND)cvGetWindowHandle("cvcam window");
}

/* Returns the actual number of currently available cameras */
CVCAM_API int cvcamGetCamerasCount()
{
    int n = _cvcamInitVideoSource(0);
    return (n>0)?n:0;
}

/* Summons the video format property page */
static void _cvcamSummonPinPropPage(int camera)
{
    if(!cvcam_properties[camera]._enabled)
        return;
    //Find the output pit that is connected to the next filter...
    CAUUID uuID;
    ISpecifyPropertyPages* pspp = 0;
    
    //***    
    int fcvcamInit = 0;
    OAFilterState state = State_Stopped;
    //if _cvcamMediaControl is valid, it means Graph has already been builded 
    //then we have to disconnect all filters first
    if(_cvcamMediaControl.is_valid())
    {
        fcvcamInit = 1;
        //keep graph state before disconnect it, os we can restart from current state 
        _cvcamMediaControl->GetState(0, &state);
        //disconnect graph
        _cvcamTearDownGraph();
    }
    //***

    IBaseFilter* filter = _cvcamSource[camera].value();
    
    IPin* pPin = get_source_pin(_cvcamSource[camera].value(), PINDIR_OUTPUT);
    if(!pPin)
        pPin=get_pin(filter, PINDIR_OUTPUT);

    if(!pPin)
        return;

    pPin->QueryInterface(IID_ISpecifyPropertyPages, (void**)&pspp);
    if(!pspp)
        return;
        
    pspp->GetPages(&uuID);
    pspp->Release();


    OleCreatePropertyFrame(NULL, 0, 0, L"Video Source", 1, 
        (IUnknown**)&pPin, uuID.cElems, uuID.pElems,
        0, 0, NULL);

    CoTaskMemFree(uuID.pElems);
    pPin->Release();


    //*** take them back to where they were before they called this function
    if(fcvcamInit)
    {
        cvcamInit();
        if(state == State_Running)
            cvcamStart();
    }
    //***

    
}

/* Summons the video format property page */
static void _cvcamSummonFilterPropPage(int camera)
{
    if(!cvcam_properties[camera]._enabled)
        return;

    //Find the output pit that is connected to the next filter...
    CAUUID uuID;
    ISpecifyPropertyPages* pspp = 0;
    //IBaseFilter* filter =_cvcamSource[camera].value();
    //IMoniker* mon = _cvcamMonikers[camera].value();
    //_cvcamProxyTrans->QueryInterface(IID_IBaseFilter, (void**)&filter);
    //IPin* pProxyPin = get_pin(filter, PINDIR_INPUT);
    //pProxyPin->Disconnect();
    //_cvcamMonikers[0]->BindToObject(0, 0, IID_IBaseFilter, (void **)&filter);
    //IMoniker* mon = _cvcamMonikers[camera].value();
    //IMoniker* pmon;
    //_cvcamMonikers[camera]->QueryInterface(IID_IMoniker,(void**)&pmon);
    //pmon->BindToStorage(0,0,IID_IBaseFilter, (void **)&filter);
    //BindMoniker(mon,0,IID_IBaseFilter,(void **)&filter);
    //filter= _cvcamSource.value;
    /*
    IPropertyBag *pBag;
    HRESULT hr = mon->BindToStorage(0, 0, IID_IPropertyBag, (void **)&pBag);
    if(SUCCEEDED(hr)) {
        VARIANT var;
        var.vt = VT_BSTR;
        hr = pBag->Read(L"FriendlyName", &var, NULL);
        pBag->Release();
    }
    */
    //BindMoniker(mon,0,IID_IBaseFilter,(void **)&filter);
    //mon->BindToObject(0,0,IID_IBaseFilter, (void **)&filter);
    //IPin* pPin = get_source_pin(_cvcamSource[camera].value(), PINDIR_OUTPUT);
    //IPin* pPin = get_source_pin(filter, PINDIR_OUTPUT);
    //if(!pPin)
     //   pPin=get_pin(filter, PINDIR_OUTPUT);

    //if(!pPin)
     //   return;

    
    
    IBaseFilter* bf = _cvcamSource[camera].value();
//    IUnknown** ppobject = (IUnknown**)&pPin;
    bf->QueryInterface(IID_ISpecifyPropertyPages, (void**)&pspp);
    if(!pspp)
        return;
        
    

    pspp->GetPages(&uuID);
    pspp->Release();

    /* Disconnect the pin to enable possible changes in the output format... */
    OAFilterState state = State_Stopped;
    if(_cvcamMediaControl.is_valid())
        _cvcamMediaControl->GetState(0, &state);
    if(state != State_Stopped)
        cvcamStop();

/*
    IPin* pTempPin = 
    if(pPin)
*/
   // pPin->Disconnect();
    //IBaseFilter* pFilter;
    //_cvcamProxyTrans->QueryInterface(IID_IBaseFilter, (void**)&pFilter);
    //IPin* pProxyPin = get_pin(pFilter, PINDIR_INPUT);
   // pProxyPin->Disconnect();

    OleCreatePropertyFrame(NULL, 0, 0, L"Video Source", 1, 
        (IUnknown**)&bf, uuID.cElems, uuID.pElems,
        0, 0, NULL);
    //_cvcamGraphBuilder->Connect(pSPin, pProxyPin);
    if(state == State_Running)
        //_cvcamMediaControl->Run();
        cvcamStart();
}


#define CHECK_CAMERA(p) if((p) < 0 || (p) >= cvcam_properties.size()) return -1;
#define CHECK_ZERO if(!value) return -1;
#define CHECK_POSITIVE(p) if((p) < 0) return -1;

/* get/set the property of the camera. returns 0 if the property is not supported */
CVCAM_API int cvcamGetProperty(int camera, const char* property, void* value)
{
    if (camera>=AVIS_START) 
    {
        return cvcamAVIGetProperty(camera,property,value);
    }
    CHECK_CAMERA((uint)camera);
    
    if(strcmp(property, CVCAM_PROP_ENABLE) == 0)
    {
        CHECK_ZERO(value);
        *(int*)value = cvcam_properties[(uint)camera]._enabled;
        return 0;
    }
    else if(strcmp(property, CVCAM_PROP_RENDER) == 0)
    {
        CHECK_ZERO(value);
        *(int*)value = cvcam_properties[(uint)camera].render;
        return 0;
    }
    else if(strcmp(property, CVCAM_PROP_WINDOW) == 0)
    {
        CHECK_ZERO(value);
        *(int*)value = cvcam_properties[(uint)camera].window;
        return 0;
    }
    else if(strcmp(property, CVCAM_VIDEOFORMAT) == 0)
    {
        _cvcamSummonPinPropPage(camera);
        return 0;
    }
    
    else if(strcmp(property, CVCAM_CAMERAPROPS) == 0)
    {
        _cvcamSummonFilterPropPage(camera);
        return 0;
    }

    else if(strcmp(property, CVCAM_DESCRIPTION) == 0)
    {
        IPropertyBag *pBag;
        HRESULT hr = _cvcamMonikers[camera]->BindToStorage
                                (0, 0, IID_IPropertyBag, (void **)&pBag);
        
        if(SUCCEEDED(hr)) 
        {
            VARIANT var;
            var.vt = VT_BSTR;
            hr = pBag->Read(L"FriendlyName", &var, NULL);
            pBag->Release();
            char pcOut[100];
            strcpy (pcOut, "");
            int res = wcstombs(pcOut,var.bstrVal,100);
            strcpy(((CameraDescription*)value)->DeviceDescription, pcOut);
                
            VariantClear(&var);
            
            return (res>=0)-1;
        }
        else
        {
            strcpy(((CameraDescription*)value)->DeviceDescription,"");
            return -1;
 
        }//if(SUCCEEDED(hr)) 
        
    }

    return -2;
}
/////////////////////////////////////////////////////////////////////////////////////////
CVCAM_API int cvcamSetProperty(int camera, const char* property, void* value)
{
    if (camera>=AVIS_START) 
    {
        return cvcamAVISetProperty(camera,property,value);
    }
    if(strcmp(property, CVCAM_PROP_ENABLE) == 0)
    {
        
        int val = (int)value;

        if(cvcam_properties[(uint)camera]._enabled && val)
            return -3;

        CHECK_POSITIVE(camera);
        if((uint)camera >= cvcam_properties.size()) return 0;
        cvcam_properties[(uint)camera]._enabled = val;
        if(val)
        {
        //***
        /*
            IBaseFilter* filter;
            _cvcamMonikers[camera]->BindToObject(0, 
                                                 0,
                                                 IID_IBaseFilter, 
                                                 (void **)&filter);
            if(filter)
            {
            
                _cvcamSource[camera]=filter;

            }
            else
                cvcam_properties[(uint)camera]._enabled = 0;
        */

            if(_cvcamInitCapFilters(camera) < 0)
                cvcam_properties[(uint)camera]._enabled = 0;
        //***
        }

        return 0;
    }
    else if (strcmp(property, CVCAM_PROP_RENDER) == 0)
    {
        int val = (int)value;
        cvcam_properties[(uint)camera].render = val;
        return 0;
    }
    else if (strcmp(property, CVCAM_PROP_WINDOW) == 0)
    {
        int val = *(int*)value;
        cvcam_properties[camera].window = val;
        return 0;
    }
    else if(strcmp(property, CVCAM_PROP_CALLBACK) == 0)
    {
        cvcam_properties[camera].callback = value;
        return 0;
    }

    else if(strcmp(property, CVCAM_STEREO_CALLBACK) == 0)
    {
        stereo_callback = value;
        return 0;