cvcam.cpp

Using open CV draw color histogram, convert RGB To HSI

        CHECK_ZERO(value);
        *(int*)value = cvcam_properties[(uint)camera].srcwidth;
        return 0;
    }
    else if	(strcmp(property, CVCAM_SRCHEIGHT) == 0)
    {
        CHECK_ZERO(value);
        *(int*)value = cvcam_properties[(uint)camera].srcheight;
        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)
        {
            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)
    {
        stereo2_callback = value;
        nb_cameras=2;
        return 0;
    }

    else if(strcmp(property, CVCAM_STEREO3_CALLBACK) == 0)
    {
        stereo3_callback = value;
        nb_cameras=3;
        return 0;
    }
    else if(strcmp(property, CVCAM_STEREO4_CALLBACK) == 0)
    {
        stereo4_callback = value;
        nb_cameras=4;
        return 0;
    }

    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;
    }
    else if	(strcmp(property, CVCAM_PROP_SETFORMAT) == 0)
    {
        _cvcamSetVideoFormat(camera, value);
        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()
{
    vector<SafeUnknown> _objects;

    if(_cvcamNumberOfEnabled() >= 2)
        return _cvcamInitSeveralCams();

    for(;;)
    {
        /* Create a proxy transform filter */
        if(FAILED(CoCreateInstance(CLSID_ProxyTransform, NULL, CLSCTX_INPROC_SERVER,
            IID_IProxyTransform, (void**)&_cvcamProxyTrans)))
        {
            int code = MessageBox( 0,
                "ProxyTrans.ax could not be loaded. Please, register it using regsvr32.exe",
                "Error", MB_ABORTRETRYIGNORE );
            if( code == IDRETRY )
                continue;
            else if( code == IDABORT )
            {
                cvcamExit();
                exit(-1);
            }
            else
                return 0;
        }
        break;
    }

    _cvcamProxyTrans->set_transform(
        (void(__cdecl*)(void*))cvcam_properties[camera_index].callback, 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;

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

/////////////////////////////////////////////////////////////////////////////////////////
//Makes the graph from several cameras and extended cvSync filter
static int _cvcamInitSeveralCams()
{
    int i;
    
    /* Create a cvSync filter */
    if(FAILED(CoCreateInstance(CLSID_SyncFilter, NULL, CLSCTX_INPROC_SERVER,
        IID_ISyncFilter, (void**)&_cvcamCvSync)))
    {
        return 0;
    }

    if (2==nb_cameras && stereo2_callback)
        _cvcamCvSync->SetCallBack2( (void(__cdecl*)(void*, void*))stereo2_callback );
    else if (3==nb_cameras && stereo3_callback)
        _cvcamCvSync->SetCallBack3( (void(__cdecl*)(void*, void*, void*))stereo3_callback );
    else if (4==nb_cameras && stereo4_callback)
        _cvcamCvSync->SetCallBack4( (void(__cdecl*)(void*, void*, void*, void*))stereo4_callback );

    ASSERT(!_cvcamMediaControl.is_valid());
    _cvcamGraphBuilder->QueryInterface(IID_IMediaControl,(void**)&_cvcamMediaControl);
    //_cvcamGraphBuilder->QueryInterface(IID_IMediaEventEx,(void**)&_cvcamMediaEventEx);

    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;
        IPin* pSourceOut[4];
        IPin* pSyncInput[4];
        IPin* pSyncOutput[4];

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

        hr = _cvcamGraphBuilder->AddFilter( pSyncFilter, L"Script processing");
        if(FAILED(hr))
        {
            return hr;
        }


        for (i=0;i<nb_cameras;i++)
        {
            pSourceOut[i] = get_source_pin( _cvcamSource[indexes[i] ].value(),
                PINDIR_OUTPUT );
            if(!pSourceOut[i])
            {
                return 0;

            }
        }

        pSyncFilter->FindPin(L"Input1", &pSyncInput[0]);
        pSyncFilter->FindPin(L"Input2", &pSyncInput[1]);
        pSyncFilter->FindPin(L"Output1", &pSyncOutput[0]);
        pSyncFilter->FindPin(L"Output2", &pSyncOutput[1]);
        if (3==nb_cameras)
        {
            pSyncFilter->FindPin(L"Input3", &pSyncInput[2]);
            pSyncFilter->FindPin(L"Output3", &pSyncOutput[2]);
        }
        else if (4==nb_cameras)
        {
            pSyncFilter->FindPin(L"Input3", &pSyncInput[2]);
            pSyncFilter->FindPin(L"Input4", &pSyncInput[3]);
            pSyncFilter->FindPin(L"Output3", &pSyncOutput[2]);
            pSyncFilter->FindPin(L"Output4", &pSyncOutput[3]);
        }

        for (i=0;i<nb_cameras;i++)
        {
            _objects.push_back(SafeUnknown(pSourceOut[i]));
            _objects.push_back(SafeUnknown(pSyncInput[i]));
            _objects.push_back(SafeUnknown(pSyncOutput[i]));
        }

        for (i=0;i<nb_cameras;i++)
        {
            if( pSourceOut[i] && pSyncInput[i] && pSyncOutput[i] )
            {

                hr = _cvcamGraphBuilder->Connect(pSourceOut[i], pSyncInput[i]);
                if(FAILED(hr))
                {
                    AMGetErrorText(hr, errorText, 100);
                    MessageBox(0, errorText, "cvcam error", MB_OK);
                    return hr;
                }
                int render;
                cvcamGetProperty(indexes[i], CVCAM_PROP_RENDER, &render);
                if(render)
                    hr = _cvcamGraphBuilder->Render( pSyncOutput[i] );
                if(FAILED(hr))
                {
                    AMGetErrorText(hr, errorText, 100);
                    MessageBox(0, errorText, "cvcam error", MB_OK);
                    return hr;
                }
            }
        }
    }


    return 1;
};

/////////////////////////////////////////////////////////////////////////////////////////
int _cvcamStartSeveral()
{
    int i;
    vector<SafeUnknown> _objects;
    IBaseFilter* pcvSync = 0;

    vector<int> indexes;

    for(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;

    bool Render=false;

    for (i=0;i<nb_cameras;i++)
        if (cvcam_properties[indexes[i]].render)
        {
            Render=true;