Here is a sample showing you how to detect if the logitech webcam using their new LVUVC driver.

HRESULT hr = 0;
m_pCameraControl = 0;
long omin, omax, ostep, odef, oflags;

// Get a pointer to the IAMCameraControl interface used to control the camera
hr = m_pCaptureFilter->QueryInterface(IID_IAMCameraControl, (void **)&m_pCameraControl);
if(hr != S_OK)
{
qDebug(“ERROR: Unable to access IAMCameraControl interface.”);
m_pCameraControl = 0;
goto LVUVC;
return;
}

// Retrieve information about the pan and tilt controls
hr = m_pCameraControl->GetRange(CameraControl_Pan, &omin, &omax, &ostep, &odef, &oflags);
if(hr != S_OK)
{
qDebug(“ERROR: Unable to retrieve CameraControl_Pan property information.”);
m_pCameraControl = 0;
goto LVUVC;
return;
}
qDebug(“      Pan control:”);
printControlInfo(1, omin, omax, ostep, odef, oflags);

hr = m_pCameraControl->GetRange(CameraControl_Tilt, &omin, &omax, &ostep, &odef, &oflags);
if(hr != S_OK)
{
qDebug(“ERROR: Unable to retrieve CameraControl_Tilt property information.”);
m_pCameraControl = 0;
goto LVUVC;
return;
}
qDebug(“      Tilt control:”);
printControlInfo(2, omin, omax, ostep, odef, oflags);

hr = m_pCameraControl->GetRange(CameraControl_Zoom, &omin, &omax, &ostep, &odef, &oflags);
if(hr != S_OK)
{
qDebug(“ERROR: Unable to retrieve CameraControl_Zoom property information.”);
//m_pCameraControl = 0;
omin = 50;
omax = 200;
ostep = 1;
odef = 50;
oflags = 0×00000003;
goto LVUVC;
return;
}
qDebug(“      Zoom control:”);
printControlInfo(3, omin, omax, ostep, odef, oflags);
return;

LVUVC:
{
m_isNewLWS = false;
qDebug(“=== try using Logitech UVC Driver Public Property Sets ===”);
HRESULT hr2 = m_pCaptureFilter->QueryInterface(IID_IKsPropertySet, (void**)&m_pKsPropertySet);

DWORD dwReturned = 0;
//get version
KSPROPERTY_LP1_VERSION_S version2 = {0, 0};
hr2 = m_pKsPropertySet->Get(PROPSETID_LOGITECH_PUBLIC1,
KSPROPERTY_LP1_VERSION,
NULL, 0, &version2, sizeof(version2), &dwReturned);
if (hr2 == S_OK)
qDebug(“LVUVC version = %d.%d  ret=%d”, version2.usMajor, version2.usMinor, dwReturned);
else
{
qDebug(“LVUVC version failed %x %d”, hr2, dwReturned);
return;
}

//digital pan
KSPROPERTY_LP1_DIGITAL_PAN_S pan2 = {0};
hr2 = m_pKsPropertySet->Get(PROPSETID_LOGITECH_PUBLIC1,
KSPROPERTY_LP1_DIGITAL_PAN,
NULL, 0, &pan2, sizeof(pan2), &dwReturned);
if (hr2 == S_OK)
qDebug(“LVUVC digital pan = %d  ret=%d”, pan2.lPan, dwReturned);
else
{
qDebug(“LVUVC digital pan failed %x %d”, hr2, dwReturned);
return;
}

//digital tilt
KSPROPERTY_LP1_DIGITAL_TILT_S tilt2 = {0};
hr2 = m_pKsPropertySet->Get(PROPSETID_LOGITECH_PUBLIC1,
KSPROPERTY_LP1_DIGITAL_TILT,
NULL, 0, &tilt2, sizeof(tilt2), &dwReturned);
if (hr2 == S_OK)
qDebug(“LVUVC digital tilt = %d  ret=%d”, tilt2.lTilt, dwReturned);
else
{
qDebug(“LVUVC digital tilt failed %x %d”, hr2, dwReturned);
return;
}

//digital zoom
KSPROPERTY_LP1_DIGITAL_ZOOM_S zoom2 = {0};
hr2 = m_pKsPropertySet->Get(PROPSETID_LOGITECH_PUBLIC1,
KSPROPERTY_LP1_DIGITAL_ZOOM,
NULL, 0, &zoom2, sizeof(zoom2), &dwReturned);
if (hr2 == S_OK)
qDebug(“LVUVC digital zoom = %d  ret=%d”, zoom2.ulZoom, dwReturned);
else
{
qDebug(“LVUVC digital zoom failed %x %d”, hr2, dwReturned);
return;
}

m_isNewLWS = true;
}

I wrote this class in QT3 to capture/preview a webcam. Also, it can control logitech orbit PTZ functions.

Header File:

#ifndef _DWMANAGER_H
#define _DWMANAGER_H

#include <qstringlist.h>
#include <qcstring.h>
#include <qdict.h>
#include <qobject.h>
#include <qmutex.h>

#include <qedit.h>
#include <dshow.h>

#include <qdatetime.h>

#define USE_GRABTHREAD     1
#ifndef USE_GRABTHREAD
  #include <qtimer.h>
#else
  #include “interruptablethread.h”
  #include “threadsignal.h”
#endif

#pragma warning(disable : 4995)
#define SAFE_RELEASE(x) { if (x) x->Release(); x = NULL; }
//=====================================================
class DWDevice
{
public:
    DWDevice() : name(QString()), id (-1), devicePath(QString()) { }
    virtual ~DWDevice() {}
    QString name;
    int id;   
    QString devicePath;
    QString vidpid;
};

enum DWSTATE {
    DWSTATE_STOPPED,
    DWSTATE_RUNNING
};

//====================================
class PTZINFO
{
public:
    PTZINFO()
    {
        canM_P = false;
        canM_T = false;
        canD_P = false;
        canD_T = false;
        canD_Z = false;
        minPan = 0;
        maxPan = 0;
        curPan = minPan;
        minTilt = 0;
        maxTilt = 0;
        curTilt = minTilt;
        minZoom = 0;
        maxZoom = 0;
        curZoom = minZoom;
        isMTC = false; //true = seedonk’s black ptz webcam
        isCurrentAutoOrManualTracking = false;
    }

    bool canPTZ()
    {
        return (canD_P && canD_T && canD_Z) || canMechanical();
    }

    bool canMechanical()
    {
        return (canM_P && canM_T);
    }

    bool    canM_P;
    bool    canM_T;
    bool    canD_P;
    bool    canD_T;
    bool    canD_Z;
    int     minPan;
    int     maxPan;
    int     curPan;
    int     minTilt;
    int     maxTilt;
    int     curTilt;
    int     minZoom;
    int     maxZoom;
    int     curZoom;
    bool    isMTC; //Motion Tracking Camera
    bool    isCurrentAutoOrManualTracking; //true=AutoTracking, false=ManualTracking; TODO: mtc only currently
};
class BAMBINOINFO;
//================================================
class DShowVideoManager : public QObject
{
    Q_OBJECT

public:
    DShowVideoManager();
    ~DShowVideoManager();

    bool enumDevices();
    QDict<DWDevice> getDeviceList();

    bool setDevice(const QString & deviceName, HWND hwnd, int width, int height, int fps);
    bool showPreviewWindow(bool on, HWND hwnd);
    void releaseDevice();
    void startCapture();
    void stopCapture();
    bool isStarted() const { return m_isStarted; }

    //=== PTZ related func ======
    bool set_mechanical_pan_relative(long value);
    bool set_mechanical_tilt_relative(long value);
    void reset_mechanical_pan_tilt();
    bool set_digital_zoom_absolute(long value);
    void reset_digital_zoom();
    int mtc_SetMotorUp(LONG Step_Y, LONG &MotorPos_Y);
    int mtc_SetMotorDown(LONG Step_Y, LONG &MotorPos_Y);
    int mtc_SetMotorLeft(LONG Step_X, LONG &MotorPos_X);
    int mtc_SetMotorRight(LONG Step_X, LONG &MotorPos_X);
    int mtc_SetMotorHome();
    int mtc_SetZoomInOut(int zoomValue); //0=reset, 0 ~ 60
    int mtc_SetAutoTracking(bool on); //false=ManualTracking

    PTZINFO m_ptzInfo;
    bool isMissile() const { return m_isMissile; }
private:
    bool dshowInitOk();
    bool dshowEnumDevices(QDict<DWDevice>& retDeviceList);
    bool dshowBindDevice(const QString& name, IBaseFilter **ppCaptureFilter);
    bool dshowShowPreviewWindow(bool flag, HWND hwnd = 0, int w = 0, int h = 0);

    //==== PTZ related ====
    //dshow ptz
    void queryCameraControl();
    void printControlInfo(int ptzType, long imin, long imax, long istep, long idef, long iflags);
    //robot-o ptz
    void checkIsMTC(const QString& deviceName);
    HRESULT mtc_GetPropertyValue(IKsPropertySet *pKsPropSet,
                                 REFGUID guid,
                                 ULONG uID,
                                 LONG &value);
    HRESULT mtc_SetPropertyValue(IKsPropertySet *pKsPropSet,
                                 REFGUID guid,
                                 ULONG uID,
                                 LONG value);
    int mtc_GetCurrentInfoParam(LONG &nVID,
                                LONG &nPID,
                                LONG &nPreview,
                                LONG &nMTMode);
signals:
    void fireCaptureVideoReceived(QByteArray data, int bitCount);

private slots:
    void dshowTimerTick();

private:
    HRESULT dshowGetNamePin(IBaseFilter *pFilter, const QString& name, IPin **ppPin);
    bool    dshowSetMediaType(int w, int h, int fps);
    void    dshowDeleteMediaType(AM_MEDIA_TYPE *pmt);
#ifdef USE_GRABTHREAD
    //===========================================
    class GrabThread : public InterruptableThread
    {
    public:
        GrabThread(DShowVideoManager *dshowVideoMgr);
        void setMs(int ms) { m_ms = ms; }

    protected:
        virtual void run();

    private:
        DShowVideoManager *m_dshowVideoMgr;
        int                m_ms;
        ThreadSignal       m_threadSignal;
    };
    friend class GrabThread;
    //===========================================
#endif
    IGraphBuilder           *m_pGraph;
    ICaptureGraphBuilder2   *m_pBuilder;
    IBaseFilter             *m_pCaptureFilter;
    IBaseFilter             *m_pGrabber;
    ISampleGrabber          *m_pIGrabber;
    IVideoWindow            *m_video_window;
    IMediaControl           *m_media_control;
    QDict<DWDevice>          m_device_list;
#ifndef USE_GRABTHREAD
    QTimer                   m_timer;
#else
    GrabThread               m_grabThread;
#endif
    char                    *m_buffer;
    int                      m_bufferSize;
    int                      m_width;
    int                      m_height;
    int                      m_fps;
    bool                     m_isSetDeviceOk;
    bool                     m_isStarted;
    HWND                     m_hwnd;

    //PTZ related
    IAMCameraControl        *m_pCameraControl;
    LONG                     m_mtc_MotorPosX;
    LONG                     m_mtc_MotorPosY;
    int                      m_mtc_DriveMode;
    IKsPropertySet          *m_pKsPropertySet;
    bool                     m_isNewLWS;
    bool                     m_isMissile;

};

#endif //_DWMANAGER_H

 Source File:
#include <windows.h>
#include “dwmanager.h”
#include “colorconversion.h”
#include “alpssystem.h”
#include <Ks.h>    // Required by KsMedia.h
#include <KsMedia.h>  // For KSPROPERTY_CAMERACONTROL_FLAGS_*
#include <qregexp.h>

//Motion Tracking Camera
//=====================================================================
DShowVideoManager::DShowVideoManager()
                  :m_pGraph(0),
                   m_pBuilder(0),
                   m_pCaptureFilter(0),
                   m_pGrabber(0),
                   m_pIGrabber(0),
                   m_video_window(0),
                   m_media_control(0),
                   m_device_list(),
#ifndef USE_GRABTHREAD
                   m_timer(),
#else
                   m_grabThread(this),
#endif
                   m_buffer(0),
                   m_width(0),
                   m_height(0),
                   m_fps(0),
                   m_isSetDeviceOk(false),
                   m_isStarted(false),
                   m_hwnd(0),
                   m_pCameraControl(0),
                   m_mtc_MotorPosX(0),
                   m_mtc_MotorPosY(0),
                   m_mtc_DriveMode(0),
                   m_pKsPropertySet(0),
                   m_isNewLWS(false),
                   m_isMissile(false)
{
    CoInitialize(NULL);
    enumDevices();
}//ctor()

DShowVideoManager::~DShowVideoManager()
{
    stopCapture();
    releaseDevice();
    CoUninitialize( );
}//dtor()

bool DShowVideoManager::enumDevices()
{
    m_device_list.clear();

    ICreateDevEnum *pDevEnum = NULL;
    IEnumMoniker *pEnum = NULL;
   
    // Create the System Device Enumerator.
    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 (FAILED(hr))
            return false;
    }
    else
        return false;

    int index = 0;
    IMoniker *pMoniker = NULL;
    while (pEnum && pEnum->Next(1, &pMoniker, NULL) == S_OK)
    {
        QString devicePath = QString::null;
        QString friendlyName = QString::null;
        QString vidpid = QString::null;

        IPropertyBag *pPropBag = NULL;
        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 DevicePath & FriendlyName.
        VARIANT varName1;
        VariantInit(&varName1);
        hr = pPropBag->Read(L”DevicePath”, &varName1, 0);
        if (SUCCEEDED(hr))
        {
            devicePath = qt_winQString(varName1.bstrVal);
            qDebug(“DSVideoManager::dshowEnumDevices real device path=”+ devicePath);
            int firstPound = devicePath.find(‘#’);
            int lastPound = devicePath.findRev(‘#’);
            if (firstPound >= 0 && lastPound >= 0 &&
                lastPound > firstPound &&
                lastPound – firstPound – 1 > 0)
            {
                devicePath = devicePath.mid(firstPound+1, lastPound-firstPound-1);
            }
            devicePath.replace(‘#’, ‘-’);
            devicePath.replace(‘&’, ‘-’);
            QRegExp reg1(“vid_(\\S\\S\\S\\S)-pid_(\\S\\S\\S\\S)”, false);
            if (reg1.search(devicePath) > -1)
            {
                QString vid = reg1.cap(1);
                QString pid = reg1.cap(2);
                vidpid = “vid_” + vid + “-pid_” + pid;
            }

        }
        VariantClear(&varName1);

        VARIANT varName2;
        VariantInit(&varName2);
        hr = pPropBag->Read(L”FriendlyName”, &varName2, 0);
        if (SUCCEEDED(hr))
        {
            friendlyName = qt_winQString(varName2.bstrVal);
        }
        VariantClear(&varName2);

        if (!devicePath.isNull() && !friendlyName.isNull())
        {
            DWDevice *dwDevice = new DWDevice();
            dwDevice->id = index++;
            dwDevice->name = friendlyName;
            dwDevice->devicePath = devicePath;
            dwDevice->vidpid = vidpid;
            qDebug(QString(“DShowVideoManager::dshowEnumDevices(): name [=%1] id=%2 devPath=%3″).arg(friendlyName).arg(dwDevice->id).arg(devicePath));
            m_device_list.insert(dwDevice->name, dwDevice);
        }

        pPropBag->Release();
        pMoniker->Release();
    }//while

    SAFE_RELEASE(pEnum);
    SAFE_RELEASE(pDevEnum);

    return true;
}//enumDevices()

QDict<DWDevice> DShowVideoManager::getDeviceList()
{
    return m_device_list;
}

bool DShowVideoManager::showPreviewWindow(bool on, HWND hwnd)
{
    if (on)
    {
        m_hwnd = hwnd;
        return dshowShowPreviewWindow(true, m_hwnd, m_width, m_height);
    }
    else
        return dshowShowPreviewWindow(false);
}

bool DShowVideoManager::setDevice(const QString &deviceName, HWND hwnd, int width, int height, int fps)
{
    releaseDevice();

    if (m_device_list.count() <= 0)
        return false;

    HRESULT hr = CoCreateInstance(CLSID_FilterGraph, NULL,
                                  CLSCTX_INPROC_SERVER,
                                  IID_IGraphBuilder,
                                  (void **)&m_pGraph);
    if (SUCCEEDED(hr))
    {
        hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL,
                              CLSCTX_INPROC_SERVER,
                              IID_ICaptureGraphBuilder2,
                              (void **)&m_pBuilder);
        if (SUCCEEDED(hr))
            m_pBuilder->SetFiltergraph(m_pGraph);
        else
        {
            releaseDevice();
            return false;
        }
    }
    else
    {
        releaseDevice();
        return false;
    }

    if (!dshowInitOk())
        return false;

    m_width = width;
    m_height = height;
    m_fps = fps;
    m_hwnd = hwnd;
    //bind device first
    if (dshowBindDevice(deviceName, &m_pCaptureFilter))
    {
        queryCameraControl();
        checkIsMTC(deviceName);

        if (m_device_list.find(deviceName) != 0)
        {
            DWDevice *dwDevice = m_device_list[deviceName];
            QString vpidstr = dwDevice->vidpid.lower();
        }
        hr = m_pGraph->AddFilter(m_pCaptureFilter, L”Capture Filter”);
        if (FAILED(hr))
        {
            releaseDevice();
            return false;
        }
    }
    else
    {
        releaseDevice();
        return false;
    }

    //add grabber
    hr = CoCreateInstance(CLSID_SampleGrabber, NULL,
                          CLSCTX_INPROC_SERVER,
                          IID_IBaseFilter, (void **)&m_pGrabber);
    if (FAILED(hr))
    {
        qDebug(“DShowVideoManager::dshowStart() get grabber failed”);
        releaseDevice();
        return false;
    }

    m_pGrabber->QueryInterface(IID_ISampleGrabber, (void**)&m_pIGrabber);
    AM_MEDIA_TYPE mt;
    ZeroMemory(&mt, sizeof(AM_MEDIA_TYPE));
    mt.majortype = MEDIATYPE_Video;
    mt.subtype = MEDIASUBTYPE_RGB24;
    mt.bFixedSizeSamples = true;
    mt.bTemporalCompression = false;
    mt.lSampleSize = m_width * m_height * 3;
    hr = m_pIGrabber->SetMediaType(&mt);
    if (FAILED(hr))
    {
        qDebug(“DShowVideoManager::dshowStart() failed to set mediaType”);
        releaseDevice();
        return false;
    }

    if (!dshowSetMediaType(m_width, m_height, fps))
    {
        qDebug(“DShowVideoManager::dshowStart() failed to set w/h/fps”);
        releaseDevice();
        return false;
    }

    //render preview
    hr = m_pBuilder->RenderStream(&PIN_CATEGORY_PREVIEW,
                                  &MEDIATYPE_Video,
                                  m_pCaptureFilter,
                                  NULL,
                                  NULL);
    if (FAILED(hr))
    {
        qDebug(“DShowVideoManager::dshowStart() preview failed”);
        releaseDevice();
        return false;
    }
    m_pGraph->AddFilter(m_pGrabber, L”Sample Grabber”);
    //render capture, connect grabber
    hr = m_pBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,
                                  &MEDIATYPE_Video,
                                  m_pCaptureFilter,
                                  NULL,
                                  m_pGrabber);

    m_pGraph->QueryInterface(IID_IVideoWindow, (void **)&m_video_window);
    m_pGraph->QueryInterface(IID_IMediaControl, (void **)&m_media_control);

    if (!m_video_window || !m_media_control)
    {
        qDebug(“DShowVideoManager::dshowStart() !m_video_window || !m_media_control”);
        releaseDevice();
        return false;
    }

    //dshowShowPreviewWindow(true, hwnd, m_width, m_height);
    //hide preview first
    m_video_window->put_AutoShow(OAFALSE);
    m_video_window->put_Visible(OAFALSE);

    m_bufferSize = m_width * m_height * 3; //RGB24
    m_buffer = new char[m_bufferSize];

    hr = m_media_control->Run();
    if (FAILED(hr))
    {
        qDebug(“Cannot grab the webcam; other program might get the control”);
        releaseDevice();
        return false;
    }
    m_media_control->Stop();

    m_pIGrabber->SetOneShot(false);
    m_pIGrabber->SetBufferSamples(true);

#ifndef USE_GRABTHREAD
    connect(&m_timer, SIGNAL(timeout()), SLOT(dshowTimerTick()));
#endif

    m_isSetDeviceOk = true;

    return true;
}//setDevice()

void DShowVideoManager::releaseDevice()
{
#ifndef USE_GRABTHREAD
    m_timer.stop();
#else
    m_grabThread.interruptAndTerminate(200, 200);
#endif
    if (m_media_control)
        m_media_control->Stop();

    SAFE_RELEASE(m_media_control);
    SAFE_RELEASE(m_video_window);
    SAFE_RELEASE(m_pIGrabber);
    SAFE_RELEASE(m_pGrabber);
    SAFE_RELEASE(m_pCaptureFilter);
    SAFE_RELEASE(m_pBuilder);
    SAFE_RELEASE(m_pGraph);

    delete[] m_buffer;
    m_buffer = 0;
    m_bufferSize = 0;

    m_isSetDeviceOk = false;
}//releaseDevice()

void DShowVideoManager::startCapture()
{
    if (!m_isStarted)
    {
        if (m_media_control)
            m_media_control->Run();
#ifndef USE_GRABTHREAD
        m_timer.start(1000/m_fps, false);
#else
        m_grabThread.setMs(1000/m_fps);
        m_grabThread.start(QThread::LowPriority);
#endif
    }
    m_isStarted = true;
}//startCapture()

void DShowVideoManager::stopCapture()
{
    if (m_isStarted)
    {
#ifndef USE_GRABTHREAD
        m_timer.stop();
#else
        m_grabThread.interruptAndTerminate(500, 500);
#endif
        if (m_media_control)
            m_media_control->Pause();
    }
    m_isStarted = false;
}//stopCapture()
bool DShowVideoManager::dshowInitOk()
{
    if (m_pGraph == 0 || m_pBuilder == 0)
        return false;
    return true;
}

bool DShowVideoManager::dshowBindDevice(const QString& name, IBaseFilter **ppCaptureFilter)
{
    ICreateDevEnum *pDevEnum = NULL;
    IEnumMoniker *pEnum = NULL;
   
    // Create the System Device Enumerator.
    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);
    }
    else
        return false;

    IMoniker *pMoniker = NULL;
    bool bindOK = false;
    while (pEnum->Next(1, &pMoniker, NULL) == S_OK)
    {
        QString friendlyName = QString::null;

        IPropertyBag *pPropBag = NULL;
        hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag,
                                (void**)(&pPropBag));
        if (FAILED(hr))
        {
            SAFE_RELEASE(pMoniker);
            continue;  // Skip this one, maybe the next one will work.
        }
        // Find the FriendlyName.
        VARIANT varName1;
        VariantInit(&varName1);
        hr = pPropBag->Read(L”FriendlyName”, &varName1, 0);
        if (SUCCEEDED(hr))
        {
            friendlyName = qt_winQString(varName1.bstrVal);
            if (friendlyName == name)
            {
                IBaseFilter *pCap = NULL;
                hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)(&pCap));
                if (SUCCEEDED(hr))
                {
                    bindOK = true;
                    *ppCaptureFilter = pCap;
                }
                else
                    SAFE_RELEASE(pCap);
            }
        }
        VariantClear(&varName1);

        SAFE_RELEASE(pPropBag);
        SAFE_RELEASE(pMoniker);

        if (bindOK)
            break;
    }//while

    SAFE_RELEASE(pEnum);
    SAFE_RELEASE(pDevEnum);

    return bindOK;
}//dshowBindDevice()

bool DShowVideoManager::dshowShowPreviewWindow(bool flag, HWND hwnd, int w, int h)
{
    if (m_video_window)
    {
        if (flag)
        {
            m_video_window->put_AutoShow(OAFALSE);
            m_video_window->SetWindowPosition(0, 0, w, h);
            m_video_window->put_Owner((OAHWND)hwnd);
            m_video_window->put_WindowStyle(WS_CHILD|WS_CLIPSIBLINGS);
            m_video_window->put_Visible(OATRUE);
        }
        else
        {
            m_video_window->put_AutoShow(OAFALSE);
            m_video_window->put_Visible(OAFALSE);
        }

        return true;
    }

    return false;

}//dshowShowPreviewWindow()

//called in GrabThread::run() if USE_GRABTHREAD is defined
void DShowVideoManager::dshowTimerTick()
{
    long lbufferSize = 0;
    HRESULT hr;

    if (!m_pIGrabber)
        return;

    hr = m_pIGrabber->GetCurrentBuffer(&lbufferSize, NULL);
    if (FAILED(hr))
    {
        return;
    }

    if (lbufferSize != m_bufferSize)
    {
        qDebug(“DShowVideoManageR::dshowTimerTick() buffer count not match %ld”, lbufferSize);
        return;
    }

    hr = m_pIGrabber->GetCurrentBuffer(&lbufferSize, (long *)m_buffer);
    if (FAILED(hr))
    {
        qDebug(“DShowVideoManageR::dshowTimerTick() can’t get buffer”);
        return;
    }

    QByteArray data;
    data.fill(0×00, m_width * m_height * 1.5);
    QByteArray flipVertRGB;
    flipVertRGB = convert24to24(m_buffer, m_width, m_height, true, true);
    rgb24toyuv420(reinterpret_cast<const unsigned char *>(flipVertRGB.data()),
                  m_width,
                  m_height,
                  (unsigned char *)(data.data()));
 emit fireCaptureVideoReceived(data, 12);
    emit fireCaptureVideoReceived(flipVertRGB, 24);
}//dshowTimerTick()

HRESULT DShowVideoManager::dshowGetNamePin(IBaseFilter *pFilter, const QString& name, IPin **ppPin)
{
    IEnumPins  *pEnum;
    IPin       *pPin;
    pFilter->EnumPins(&pEnum);
    while(pEnum->Next(1, &pPin, 0) == S_OK)
    {
        IPin *curPin = pPin;
        PIN_INFO fInfo;
        if (curPin->QueryPinInfo(&fInfo) == S_OK)
        {
            QString sss = qt_winQString((void *)fInfo.achName);
            if (sss == name)
            {
                *ppPin = pPin;
                return S_OK;
            }
        }
        pPin->Release();
    }
    pEnum->Release();
    return E_FAIL;
}//dshowGetNamePin()

bool DShowVideoManager::dshowSetMediaType(int w, int h, int fps)
{
    if (!m_pCaptureFilter)
        return false;

    IEnumMediaTypes *enumMediaTypes = NULL;
    AM_MEDIA_TYPE *mediaType = NULL;
    bool  foundIt = false;
    bool  setIt = false;

    IPin *pVideoCaptureOutCapture = 0;
    HRESULT hr = dshowGetNamePin(m_pCaptureFilter, “Capture”, &pVideoCaptureOutCapture);
    if (FAILED(hr))
        return false;

    hr = pVideoCaptureOutCapture->EnumMediaTypes(&enumMediaTypes);
    if(SUCCEEDED(hr))
    {
        while(enumMediaTypes->Next(1, &mediaType, 0) == S_OK)
        {
            if(mediaType->majortype == MEDIATYPE_Video)
            {
                VIDEOINFOHEADER *vih = (VIDEOINFOHEADER *)mediaType->pbFormat;
                DWORD biCompression = vih->bmiHeader.biCompression;
                int   biWidth = vih->bmiHeader.biWidth;
                int   biHeight = vih->bmiHeader.biHeight;
                qDebug(“DShowVideoManager::dshowSetMediaType() biCompression=%d biW=%d biH=%d”, biCompression, biWidth, biHeight);
                if (biWidth == w && biHeight == h)
                {
                    vih->AvgTimePerFrame = (REFERENCE_TIME) (10000000 / fps);
                    foundIt = true;

                    IAMStreamConfig *streamConfig = 0;
                    hr = pVideoCaptureOutCapture->QueryInterface(IID_IAMStreamConfig, (void **)&streamConfig);
                    if(SUCCEEDED(hr))
                    {
                        hr = streamConfig->SetFormat(mediaType);
                        if (SUCCEEDED(hr))
                            setIt = true;
                    }
                }

                if (foundIt)
                    break;
            }
            dshowDeleteMediaType(mediaType);
        }//while
        enumMediaTypes->Release();
    }

    return (foundIt & setIt);
}//dshowSetMediaType()

void DShowVideoManager::dshowDeleteMediaType(AM_MEDIA_TYPE * mediaType)
{
    if (mediaType == NULL)
        return;

    if (mediaType->cbFormat != 0) {
        CoTaskMemFree((PVOID)mediaType->pbFormat);
        mediaType->cbFormat = 0;
        mediaType->pbFormat = NULL;
    }

    if (mediaType->pUnk != NULL) {
        mediaType->pUnk->Release();
        mediaType->pUnk = NULL;
    }

    CoTaskMemFree((PVOID)mediaType);
}//dshowDeleteMediaType()

//===== PTZ related =======================
void DShowVideoManager::queryCameraControl()
{
    if (!m_pCaptureFilter)
        return;

    HRESULT hr = 0;
    m_pCameraControl = 0;
    long omin, omax, ostep, odef, oflags;

 // Get a pointer to the IAMCameraControl interface used to control the camera
 hr = m_pCaptureFilter->QueryInterface(IID_IAMCameraControl, (void **)&m_pCameraControl);
 if(hr != S_OK)
 {
  qDebug(“ERROR: Unable to access IAMCameraControl interface.”);
        m_pCameraControl = 0;
        goto LVUVC;
  return;
 }

 // Retrieve information about the pan and tilt controls
 hr = m_pCameraControl->GetRange(CameraControl_Pan, &omin, &omax, &ostep, &odef, &oflags);
 if(hr != S_OK)
 {
  qDebug(“ERROR: Unable to retrieve CameraControl_Pan property information.”);
        m_pCameraControl = 0;
        goto LVUVC;
  return;
 }
 qDebug(“      Pan control:”);
 printControlInfo(1, omin, omax, ostep, odef, oflags);

 hr = m_pCameraControl->GetRange(CameraControl_Tilt, &omin, &omax, &ostep, &odef, &oflags);
 if(hr != S_OK)
 {
  qDebug(“ERROR: Unable to retrieve CameraControl_Tilt property information.”);
        m_pCameraControl = 0;
        goto LVUVC;
  return;
 }
 qDebug(“      Tilt control:”);
 printControlInfo(2, omin, omax, ostep, odef, oflags);

 hr = m_pCameraControl->GetRange(CameraControl_Zoom, &omin, &omax, &ostep, &odef, &oflags);
 if(hr != S_OK)
 {
  qDebug(“ERROR: Unable to retrieve CameraControl_Zoom property information.”);
        //m_pCameraControl = 0;
        omin = 50;
        omax = 200;
        ostep = 1;
        odef = 50;
        oflags = 0×00000003;
        goto LVUVC;
  return;
 }
 qDebug(“      Zoom control:”);
 printControlInfo(3, omin, omax, ostep, odef, oflags);
    return;

LVUVC:
    {
        m_isNewLWS = false;
        qDebug(“=== try using Logitech UVC Driver Public Property Sets ===”);
        HRESULT hr2 = m_pCaptureFilter->QueryInterface(IID_IKsPropertySet, (void**)&m_pKsPropertySet);

        DWORD dwReturned = 0;
        //get version
        KSPROPERTY_LP1_VERSION_S version2 = {0, 0};
        hr2 = m_pKsPropertySet->Get(PROPSETID_LOGITECH_PUBLIC1,
                                  KSPROPERTY_LP1_VERSION,
                                  NULL, 0, &version2, sizeof(version2), &dwReturned);
        if (hr2 == S_OK)
            qDebug(“LVUVC version = %d.%d  ret=%d”, version2.usMajor, version2.usMinor, dwReturned);
        else
        {
            qDebug(“LVUVC version failed %x %d”, hr2, dwReturned);
            return;
        }

        //digital pan
        KSPROPERTY_LP1_DIGITAL_PAN_S pan2 = {0};
        hr2 = m_pKsPropertySet->Get(PROPSETID_LOGITECH_PUBLIC1,
                                  KSPROPERTY_LP1_DIGITAL_PAN,
                                  NULL, 0, &pan2, sizeof(pan2), &dwReturned);
        if (hr2 == S_OK)
            qDebug(“LVUVC digital pan = %d  ret=%d”, pan2.lPan, dwReturned);
        else
        {
            qDebug(“LVUVC digital pan failed %x %d”, hr2, dwReturned);
            return;
        }

        //digital tilt
        KSPROPERTY_LP1_DIGITAL_TILT_S tilt2 = {0};
        hr2 = m_pKsPropertySet->Get(PROPSETID_LOGITECH_PUBLIC1,
                                  KSPROPERTY_LP1_DIGITAL_TILT,
                                  NULL, 0, &tilt2, sizeof(tilt2), &dwReturned);
        if (hr2 == S_OK)
            qDebug(“LVUVC digital tilt = %d  ret=%d”, tilt2.lTilt, dwReturned);
        else
        {
            qDebug(“LVUVC digital tilt failed %x %d”, hr2, dwReturned);
            return;
        }

        //digital zoom
        KSPROPERTY_LP1_DIGITAL_ZOOM_S zoom2 = {0};
        hr2 = m_pKsPropertySet->Get(PROPSETID_LOGITECH_PUBLIC1,
                                  KSPROPERTY_LP1_DIGITAL_ZOOM,
                                  NULL, 0, &zoom2, sizeof(zoom2), &dwReturned);
        if (hr2 == S_OK)
            qDebug(“LVUVC digital zoom = %d  ret=%d”, zoom2.ulZoom, dwReturned);
        else
        {
            qDebug(“LVUVC digital zoom failed %x %d”, hr2, dwReturned);
            return;
        }

        m_isNewLWS = true;
    }
}//queryCameraControl()

void DShowVideoManager::printControlInfo(int ptzType, long imin, long imax, long istep, long idef, long iflags)
{
 QString flagStr;

 if(iflags & KSPROPERTY_CAMERACONTROL_FLAGS_AUTO)
  flagStr += QString(“AUTO | “);
 else if(iflags & KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL)
  flagStr += QString(“MANUAL | “);

 if(iflags & KSPROPERTY_CAMERACONTROL_FLAGS_RELATIVE)
    {
  flagStr += QString(“RELATIVE”);
        if (ptzType == 1) //pan
            m_ptzInfo.canM_P = true;
        else if (ptzType == 2) //tilt
            m_ptzInfo.canM_T = true;
    }
 else
    {
  flagStr += QString(“ABSOLUTE”);
        if (ptzType == 1) //pan
            m_ptzInfo.canD_P = true;
        else if (ptzType == 2) //tilt
            m_ptzInfo.canD_T = true;
        else if (ptzType == 3) //zoom
            m_ptzInfo.canD_Z = true;
    }

    if (ptzType == 1) //pan
    {
        m_ptzInfo.minPan = imin;
        m_ptzInfo.maxPan = imax;
        m_ptzInfo.curPan = idef;
    }
    else if (ptzType == 2) //tilt
    {
        m_ptzInfo.minTilt = imin;
        m_ptzInfo.maxTilt = imax;
        m_ptzInfo.curTilt = idef;
    }
    else if (ptzType == 3) //zoom
    {
        m_ptzInfo.minZoom = imin;
        m_ptzInfo.maxZoom = imax;
        m_ptzInfo.curZoom = idef;
    }

    QString totalMsg;
    totalMsg.sprintf(“        min:   %d\n”
               “        max:   %d\n”
               “        step:  %d\n”
               “        def:   %d\n”
               “        flags: 0x%08X (%s)\n”,
  imin, imax, istep, idef, iflags, flagStr.data());
    qDebug(“   totalMsg=” + totalMsg);
}//printControlInfo()

bool DShowVideoManager::set_mechanical_pan_relative(long _value)
{
/*
 * Pans the camera by a given angle.
 *
 * The angle is given in degrees, positive values are clockwise rotation (seen from the top),
 * negative values are counter-clockwise rotation. If the “Mirror horizontal” option is
 * enabled, the panning sense is reversed.
 */
    //old +180 <–> -180
    //new +70  <–> -70
   
    if (!m_pCameraControl)
        return false;

    long value = _value;
    if (m_isNewLWS)
        value /= 2;
       
 HRESULT hr = 0;
 long flags = KSPROPERTY_CAMERACONTROL_FLAGS_RELATIVE | KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;

 hr = m_pCameraControl->Set(CameraControl_Pan, value, flags);
 if(hr != S_OK)
  qDebug(“ERROR: Unable to set CameraControl_Pan property value to %d. (Error 0x%08X)”, value, hr);

 // Note that we need to wait until the movement is complete, otherwise the next request will
 // fail with hr == 0×800700AA == HRESULT_FROM_WIN32(ERROR_BUSY).
 return (hr == S_OK);
}//set_mechanical_pan_relative()

bool DShowVideoManager::set_mechanical_tilt_relative(long _value)
{
/*
 * Tilts the camera by a given angle.
 *
 * The angle is given in degrees, positive values are downwards, negative values are upwards.
 * If the “Mirror vertical” option is enabled, the tilting sense is reversed.
 */
    //old -180
    //     |
    //    +180

    //new +30
    //     |
    //    -30

    if (!m_pCameraControl)
        return false;

    long value = _value;
    if (m_isNewLWS)
    {
        value /= 2;
        value = 0 – value;
    }

 HRESULT hr = 0;
 long flags = KSPROPERTY_CAMERACONTROL_FLAGS_RELATIVE | KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;

 hr = m_pCameraControl->Set(CameraControl_Tilt, value, flags);
 if(hr != S_OK)
  qDebug(“ERROR: Unable to set CameraControl_Tilt property value to %d. (Error 0x%08X)”, value, hr);

 // Note that we need to wait until the movement is complete, otherwise the next request will
 // fail with hr == 0×800700AA == HRESULT_FROM_WIN32(ERROR_BUSY).
 return (hr == S_OK);
}//set_mechanical_tilt_relative()

void DShowVideoManager::reset_mechanical_pan_tilt()
{
/*
 * Resets the camera’s pan/tilt position by moving into a corner and then back to the center.
 */
    if (!m_pCameraControl)
        return;
    set_mechanical_pan_relative(180);
 Sleep(800);
    set_mechanical_tilt_relative(180);
 Sleep(800);
    set_mechanical_pan_relative(-64);
 Sleep(800);
    set_mechanical_tilt_relative(-24);
 Sleep(800);

}//reset_machanical_pan_tile()

bool DShowVideoManager::set_digital_zoom_absolute(long _value)
{
    //old 50, 100, 150, 200;   50 = no zoom = 1x, 200 = 4x
    //new 100, 200, 300, 400;  100 = no zoom = 1x, 400 = 4x
    if (!m_pCameraControl)
        return false;

    long value = _value;
    if (m_isNewLWS)
    {
        //<50 -> 100, 100 -> 200, 150 -> 300, >200 -> 400,
        if (value <= 50)
            value = 100;
        else if (value == 100)
            value = 200;
        else if (value == 150)
            value = 300;
        else if (value >= 200)
            value = 400;
    }

 HRESULT hr = 0;
 long flags = KSPROPERTY_CAMERACONTROL_FLAGS_ABSOLUTE | KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;

 hr = m_pCameraControl->Set(CameraControl_Zoom, value, flags);
 if(hr != S_OK && m_isNewLWS)
    {
  qDebug(“ERROR: Unable to set CameraControl_Zoom property value to %d. (Error 0x%08X)”, value, hr);

        qDebug(“try using Logitech UVC Driver Public Property Sets”);
        KSPROPERTY_LP1_DIGITAL_ZOOM_S zoom2 = {0};
        zoom2.ulZoom = value;
        HRESULT hr2 = m_pKsPropertySet->Set(PROPSETID_LOGITECH_PUBLIC1,
                                  KSPROPERTY_LP1_DIGITAL_ZOOM,
                                  NULL, 0, &zoom2, sizeof(zoom2));

    }

 return (hr == S_OK);
}//set_digital_zoom_absolute()

void DShowVideoManager::reset_digital_zoom()
{
    if (!m_pCameraControl)
        return;
 set_digital_zoom_absolute(50);
}//reset_digital_zoom()

//Motion Tracking Camera
HRESULT DShowVideoManager::mtc_GetPropertyValue(IKsPropertySet *pKsPropSet,
                                        REFGUID guid,
                                        ULONG uID,
                                        LONG &value)
{
    KSPROPERTY_VIDEOPROCAMP_S CustomProperty;
    HRESULT hr;
    DWORD cbReturned;
    // GPIO Output
    memset(&CustomProperty, 0, sizeof(KSPROPERTY_VIDEOPROCAMP_S));
    CustomProperty.Property.Set   = guid;
    CustomProperty.Property.Id    = uID;
    CustomProperty.Property.Flags = KSPROPERTY_TYPE_GET;
    CustomProperty.Value = value;
    hr = pKsPropSet->Get(guid,
                        uID,
                        &CustomProperty,
                        sizeof(CustomProperty),
                        &CustomProperty,
                        sizeof(CustomProperty),
                        &cbReturned
                        );
    if (!FAILED(hr)) value = CustomProperty.Value;
    return hr;
}

HRESULT DShowVideoManager::mtc_SetPropertyValue(IKsPropertySet *pKsPropSet,
                                        REFGUID guid,
                                        ULONG uID,
                                        LONG value)
{
    KSPROPERTY_VIDEOPROCAMP_S CustomProperty;
    HRESULT hr;
    // GPIO Output
    memset(&CustomProperty, 0, sizeof(KSPROPERTY_VIDEOPROCAMP_S));
    CustomProperty.Property.Set   = guid;
    CustomProperty.Property.Id    = uID;
    CustomProperty.Property.Flags = KSPROPERTY_TYPE_SET;
    CustomProperty.Value = value;
    hr = pKsPropSet->Set(guid,
                        uID,
                        &CustomProperty,
                        sizeof(CustomProperty),
                        &CustomProperty,
                        sizeof(CustomProperty)
                        );
    return hr;
}

int DShowVideoManager::mtc_GetCurrentInfoParam(LONG &nVID,
                                       LONG &nPID,
                                       LONG &nPreview,
                                       LONG &nMTMode)
{
    //LONG nVID, nPID, nPreview, nMTMode;
    int nRet = 0;
    HRESULT hr;
    IKsPropertySet   *pKsPropSet = NULL;
    //     
    if (!m_pCaptureFilter) return -1;
    hr = m_pCaptureFilter->QueryInterface(IID_IKsPropertySet,
                                        (void**)&pKsPropSet);
    if (FAILED(hr)) return -2;

    switch(m_mtc_DriveMode)
    {
    case 0:
        m_mtc_MotorPosX = m_mtc_MotorPosY = 0;
        // VID
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_VID,
                                  nVID);
        if (FAILED(hr)) nRet += 0×01;
        // PID
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_PID,
                                  nPID);
        if (FAILED(hr)) nRet += 0×02;
        // Preview
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_PREVIEW,
                                  nPreview);
        if (FAILED(hr)) nRet += 0×04;
        //MTMode
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MT,
                                  nMTMode);
        if (FAILED(hr)) nRet += 0×08;

        if (!nRet)
        {
            //Check OK is Old Mode…
            m_mtc_MotorPosX = m_mtc_MotorPosY = 0;
            m_mtc_DriveMode = 1;
            pKsPropSet->Release();
            return 0;
        }
        else
            m_mtc_DriveMode = 2;

        //Start Check New Mode
        nRet=0;
        // VID
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_VID,
                                  nVID);
        if (FAILED(hr)) nRet += 0×01;
        // PID
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_PID,
                                  nPID);
        if (FAILED(hr)) nRet += 0×02;
        // Preview
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_PREVIEW,
                                  nPreview);
        if (FAILED(hr)) nRet += 0×04;
        //MTMode
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_MT,
                                  nMTMode);
        if (FAILED(hr)) nRet += 0×08;
        //
        if (nRet)
            m_mtc_DriveMode = 0;
        else
            m_mtc_MotorPosX = m_mtc_MotorPosY = 0;
    break;

    case 1:  //Old Mode
        // VID
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_VID,
                                  nVID);
        if (FAILED(hr)) nRet += 0×01;
        // PID
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_PID,
                                  nPID);
        if (FAILED(hr)) nRet += 0×02;
        // Preview
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_PREVIEW,
                                  nPreview);
        if (FAILED(hr)) nRet += 0×04;
        //MTMode
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MT,
                                  nMTMode);
        if (FAILED(hr)) nRet += 0×08;
    break;

    case 2:
        // VID
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_VID,
                                  nVID);
        if (FAILED(hr)) nRet += 0×01;
        // PID
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_PID,
                                  nPID);
        if (FAILED(hr)) nRet += 0×02;
        // Preview
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_PREVIEW,
                                  nPreview);
        if (FAILED(hr)) nRet += 0×04;
        //MTMode
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_MT,
                                  nMTMode);
        if (FAILED(hr)) nRet += 0×08;

    default:
    break;
    }
    //
    pKsPropSet->Release(); 
    return nRet;
}//GetCurrentInfoParam()

int DShowVideoManager::mtc_SetMotorUp(LONG Step_Y, LONG &MotorPos_Y)
{
    int nRet = 0;
    HRESULT hr;
    IKsPropertySet   *pKsPropSet = NULL;
    //     
    if (!m_pCaptureFilter) return -1;
    hr = m_pCaptureFilter->QueryInterface(IID_IKsPropertySet,
                                         (void**)&pKsPropSet);
    if (FAILED(hr)) return -2;

    if (m_mtc_DriveMode == 1)
    {

        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MOTORPOS_Y,
                                  MotorPos_Y);
        if (FAILED(hr))
        {
            MotorPos_Y = m_mtc_MotorPosY;
            return -3;
        }
        else
            m_mtc_MotorPosY = MotorPos_Y;
    }
    else
    {
     MotorPos_Y = m_mtc_MotorPosY;
     Step_Y=40;
    }

    MotorPos_Y -= Step_Y;
    if(MotorPos_Y<0) MotorPos_Y = 0;

    if (m_mtc_DriveMode == 1)
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MOTORPOS_Y,
                                  MotorPos_Y);
    else
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_MOTORPOS_Y,
                                  6);
    if (FAILED(hr)) nRet += 0×02;
 else
  m_mtc_MotorPosY = MotorPos_Y;

    pKsPropSet->Release(); 
    return nRet;
}

int DShowVideoManager::mtc_SetMotorDown(LONG Step_Y, LONG &MotorPos_Y)
{
    int nRet = 0;
    HRESULT hr;
    IKsPropertySet   *pKsPropSet = NULL;
 LONG MaxY = MOTORRANGE_Y;
    //     
    if (!m_pCaptureFilter) return -1;
    hr = m_pCaptureFilter->QueryInterface(IID_IKsPropertySet,
                                         (void**)&pKsPropSet);
    if (FAILED(hr)) return -2;

    if (m_mtc_DriveMode == 1)
    {
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MOTORPOS_Y,
                                  MotorPos_Y);
        if (FAILED(hr))
            return -3;
        else
            m_mtc_MotorPosY = MotorPos_Y;
    }
    else
    {
     MotorPos_Y = m_mtc_MotorPosY;
     Step_Y = 40;
     MaxY = 720;
    }

    MotorPos_Y += Step_Y;
    if(MotorPos_Y > MaxY) MotorPos_Y = MaxY;

    if (m_mtc_DriveMode == 1)
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MOTORPOS_Y,
                                  MotorPos_Y);
    else
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_MOTORPOS_Y,
                                  -6);
    if (FAILED(hr)) nRet += 0×02;
 else
  m_mtc_MotorPosY = MotorPos_Y;
    //
    pKsPropSet->Release(); 
    return nRet;
}

int DShowVideoManager::mtc_SetMotorLeft(LONG Step_X, LONG &MotorPos_X)
{
    int nRet = 0;
    HRESULT hr;
    IKsPropertySet   *pKsPropSet = NULL;
    //     
    if (!m_pCaptureFilter) return -1;
    hr = m_pCaptureFilter->QueryInterface(IID_IKsPropertySet,
                                         (void**)&pKsPropSet);
    if (FAILED(hr)) return -2;

    if (m_mtc_DriveMode == 1)
    {
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MOTORPOS_X,
                                  MotorPos_X);
        if (FAILED(hr))
            return -3;
        else
            m_mtc_MotorPosX = MotorPos_X;
    }
    else
    {
     MotorPos_X = m_mtc_MotorPosX;
     Step_X = 40;
    }

    MotorPos_X -= Step_X;
    if(MotorPos_X < 0) MotorPos_X = 0;

    if (m_mtc_DriveMode == 1)
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MOTORPOS_X,
                                  MotorPos_X);
    else
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_MOTORPOS_X,
                                  -6);
    if (FAILED(hr)) nRet += 0×02;
 else
  m_mtc_MotorPosX = MotorPos_X;

    //
    pKsPropSet->Release(); 
    return nRet;
}

int DShowVideoManager::mtc_SetMotorRight(LONG Step_X, LONG &MotorPos_X)
{
 LONG MaxPos;
    int nRet = 0;
    HRESULT hr;
    IKsPropertySet   *pKsPropSet = NULL;
    //     
    if (!m_pCaptureFilter) return -1;
    hr = m_pCaptureFilter->QueryInterface(IID_IKsPropertySet,
                                         (void**)&pKsPropSet);
    if (FAILED(hr)) return -2;

    if (m_mtc_DriveMode == 1)
    {
        hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MOTORPOS_X,
                                  MotorPos_X);
        if (FAILED(hr))
            return -3;
        else
            m_mtc_MotorPosX = MotorPos_X;
    }
    else
    {
     MotorPos_X = m_mtc_MotorPosX;
     Step_X = 40;
    }

    MotorPos_X += Step_X;
    MaxPos = (m_mtc_DriveMode == 1) ? MOTORRANGE_X : 720;
    if(MotorPos_X > MaxPos) MotorPos_X = MaxPos;

    if (m_mtc_DriveMode == 1)
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MOTORPOS_X,
                                  MotorPos_X);
    else
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_MOTORPOS_X,
                                  6);
    if (FAILED(hr)) nRet += 0×02;
 else
  m_mtc_MotorPosX = MotorPos_X;

    //
    pKsPropSet->Release(); 
    return nRet;
}

int DShowVideoManager::mtc_SetMotorHome()
{
    int nRet = 0;
    HRESULT hr;
    IKsPropertySet   *pKsPropSet = NULL;
    //     
    if (!m_pCaptureFilter) return -1;
    hr = m_pCaptureFilter->QueryInterface(IID_IKsPropertySet,
                                         (void**)&pKsPropSet);
    if (FAILED(hr)) return -2;

    //X
    if (m_mtc_DriveMode == 1)
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MOTORPOS_X,
                                  MOTORRANGE_X>>1);
    else
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_MOTORPOS_X,
                                  MOTOR2RANGE_X);
    if (FAILED(hr))
    {
        nRet += 0×01;
        return nRet;
    }
 else
        m_mtc_MotorPosX = (m_mtc_DriveMode == 1) ? (MOTORRANGE_X>>1) : 360;

    //Y
    if (m_mtc_DriveMode == 1)
        hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MOTORPOS_Y,
                                  MOTORRANGE_Y>>1);

    if (FAILED(hr)) nRet += 0×02;
 else
  m_mtc_MotorPosY = (m_mtc_DriveMode == 1) ? (MOTORRANGE_Y>>1) : 360;

    //reset
    if (m_mtc_DriveMode == 1)
    {
        hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MOTORRESET,
                                  1);
        if (FAILED(hr)) nRet += 0×04;
    }

    pKsPropSet->Release(); 
    return nRet;
}

int DShowVideoManager::mtc_SetZoomInOut(int zoomValue) //0=reset, 0 ~ 60
{
    int nRet = 0;
    HRESULT hr;
    IKsPropertySet   *pKsPropSet = NULL;
    LONG DigitalZoomState = 0L;
    //     
    if (!m_pCaptureFilter) return -1;
    hr = m_pCaptureFilter->QueryInterface(IID_IKsPropertySet,
                                         (void**)&pKsPropSet);
    if (FAILED(hr)) return -2;

    if (m_mtc_DriveMode == 1)
     hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_DIGITALZOOMSTATE,
                                  DigitalZoomState);
    else
     hr = mtc_GetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_DIGITALZOOMSTATE,
                                  DigitalZoomState);
    if (FAILED(hr))
    {
        nRet += 0×01;
        return nRet;
    }

    if (zoomValue > 59)
        zoomValue = 60;
    if (zoomValue < 0)
        zoomValue = 0;

    DigitalZoomState = zoomValue;

    if (m_mtc_DriveMode == 1)
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_DIGITALZOOMSTATE,
                                  DigitalZoomState);
    else
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_DIGITALZOOMSTATE,
                                  DigitalZoomState);
    if (FAILED(hr)) nRet += 0×02;

    pKsPropSet->Release(); 
    return nRet;
}

int DShowVideoManager::mtc_SetAutoTracking(bool on)
{
    int nRet = 0;
    HRESULT hr;
    IKsPropertySet   *pKsPropSet = NULL;
    LONG MTMode = (on == true) ? 1L : 0L;
    //     
    if (!m_pCaptureFilter) return -1;
    hr = m_pCaptureFilter->QueryInterface(IID_IKsPropertySet,
                                         (void**)&pKsPropSet);
    if (FAILED(hr)) return -2;

    if (m_mtc_DriveMode == 1)
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_OPTIONS,
                                  KSPROPERTY_CUSTOM_OPTIONS_MT,
                                  MTMode);
    else
     hr = mtc_SetPropertyValue(pKsPropSet,
                                  PROPSETID_CUSTOM_PROPERTY,
                                  KSPROPERTY_CUSTOM_OPTION2_MT,
                                  MTMode);
    if (FAILED(hr)) nRet += 0×01;

    pKsPropSet->Release(); 
    return nRet;
}

void DShowVideoManager::checkIsMTC(const QString& deviceName)
{
    LONG VidNo = 0L, PidNo = 0L, PreviewNo = 0L, MTModeNo = 0L;
    if (mtc_GetCurrentInfoParam(VidNo, PidNo, PreviewNo, MTModeNo) == 0)
    {
        if ((VidNo == 0×2770 && PidNo == 0×930B) ||
            (VidNo == 0×0AD2 && PidNo == 0×931B))
        {
            m_ptzInfo.isMTC = true;
            m_ptzInfo.isCurrentAutoOrManualTracking = MTModeNo;
        }
    }
}
#ifdef USE_GRABTHREAD
//===================================================
DShowVideoManager::GrabThread::GrabThread(DShowVideoManager *dshowVideoMgr)
                              :InterruptableThread(“GrabThread”),
                               m_dshowVideoMgr(dshowVideoMgr),
                               m_ms(100),
                               m_threadSignal()
{
    setThreadSignal(&m_threadSignal);
}

void DShowVideoManager::GrabThread::run()
{
    while (!isInterrupted())
    {
        m_dshowVideoMgr->dshowTimerTick();
        m_threadSignal.wait(m_ms);
    }
}
//==========================================================
#endif

FFDshow is a DirectShow decoding filter for decompressing DivX, XviD, H.264, FLV, WMV, MPEG-1 and MPEG-2, MPEG-4 movies. It uses libavcodec from ffmpeg project for video decompression, postprocessing code from mplayer to enhance visual quality of low bitrate movies, and is based on original DirectShow filter from XviD, which is GPL’ed educational implementation of MPEG4 encoder. FFDshow can be configured to display subtitles, to enable or disable various built-in codecs, to grab screenshots, to enable keyboard control, and to enhance movies with increased resolution, sharpness, and many other post-processing filters. It has the ability to manipulate audio with effects like an equalizer, a Dolby decoder, reverb, Winamp DSP plugins, and more. Some of the postprocessing is borrowed from the MPlayer project and AviSynth filters.

- Download FFDShow MPEG-4 Video Decoder Rev 3036 x86/x64
- Download FFDShow MPEG-4 Video Decoder Rev 3036 x86/x64 (mirror 1)
- Download FFDShow MPEG-4 Video Decoder Rev 3036 x86/x64 (mirror 2)
- Download FFDShow MPEG-4 Video Decoder Rev 3036 x86/x64 (mirror 3)
- Download FFDShow MPEG-4 Video Decoder Rev 3036 x86/x64 (mirror 4)

Los investigadores no se ponen de acuerdo en torno a la intensidad de los ataques, pero sí coinciden al señalar que el fallo de Active X es una gran amenaza.

Los ataques que explotan la última vulnerabilidad de Microsoft están creciendo rápidamente en cantidad e intensidad, tal y como han advertido numerosas compañías de seguridad, mientras hacen sonar las alarmas sobre el avance de estas amenazas.

Symantec, Sunbelt Software y el Internet Storm Center (ISC) de SANS han aumentado sus advertencias al respecto, después de que Microsoft anunciara que los atacantes estaban explotando un fallo en un control ActiveX utilizado por Internet Explorer para mostrar hojas de cálculo de Excel. No hay, por ahora, solución para esta vulnerabilidad, ni tampoco Microsoft tiene previsto lanzar una en breve. Lo que sí está disponible es un parche temporal, pero los expertos creen que la mayoría de los usuarios no sacarán partido de esta protección.

Symantec elevó su ranking ThreatCon al segundo puesto de cuatro niveles. “Estamos viendo que ha sido explotado pero, por ahora, sólo a una escala limitada”, ha explicado Ben Greenbaum, investigador senior de Symantec.

Sunbelt también ha elevado su ranking a un nivel más alto. “Hemos llevado el nivel de amenazas Sunbelt hasta un grado más elevado desde que nuestros investigadores y al menos otras dos grandes compañías encontraran este código vulnerable”, ha declarado Tom Kelchner, investigador de malware de la firma con sede en Florida.

Mientras tanto, en ISC han establecido el nivel Amarillo tras descubrir que numerosas páginas Web contenían estos códigos de ataque. “Se estaba produciendo un ataque de alto nivel contra una empresa que recibió un documento de Microsoft Office con código HTML embebido”, han declarado desde la ISC en un blog. “Era particularmente desagradable, había sido diseñado específicamente para el objetivo al que se dirigía, con el documento etiquetado con la información apropiada del contacto y con el asunto específicamente dirigido al receptor del mismo”.

Otro tipo de ataques más amplios se originan habitualmente desde páginas webs de China, señalan desde ISC. “Un dominio .cn está utilizando una versión del fallo, lo que puede convertirse en un paquete de ataque y es similar a recientes ataques a DirectShow”.

La semana pasada, Microsoft confirmó que diferentes hackers estaban explotando un fallo no resuelto en un control ActiveX que es parte de DirectShow, un componente de la plataforma gráfica DirectX de Windows.

Por su parte, McAfee se ha hecho eco de las últimas informaciones de ISC, confirmando que ese código de ataque que se dirigía al fallo de ActiveX ha sido añadido a un conjunto de herramientas Web y está siendo distribuido desde diferentes páginas piratas chinas.

Este conjunto de herramientas también contienen código de ataque para la última vulnerabilidad de DirectShow. Así, algunos equipos de España, Reino Unido y Alemania también mostraron evidencias de haber sido comprometidos por estos ataques. Al menos es lo que afirma el investigador de McAfee Haowei Ren en un post de la firma.

Por su parte, Greenbaum, de Symantec, ha añadido que, mientras que la compañía está viendo cómo se produce sólo un pequeño número de ataques, sí tiene el potencial suficiente como para convertirse en algo grande rápidamente. “Es el tipo de ataque que puede ser muy fácilmente hospedado en un servidor Web y cumple todos los criterios de los ataques a gran escala en un futuro relativamente cercano”. El número y diversidad de ataques podría seguir creciendo porque el citado código está públicamente disponible.

Aunque Microsoft está trabajando en una solución para esta nueva vulnerabilidad, aún no está claro cuándo estará disponible. Los usuarios no recibirán a lo largo del día de hoy una protección automática. “Desafortunadamente, la actualización para esta vulnerabilidad no está aún lista para su distribución a gran escala”, ha declarado un portavoz de la firma, “recomendamos a nuestros clientes que realicen una reparación automática para ayudar a asegurar su entorno contra esta vulnerabilidad mientras finalizamos el desarrollo y pruebas de esta actualización”.

Fix It precisa que los usuarios se dirijan hasta la Web de soporte de Microsoft y desde allí se descarguen, instalen y pongan en marcha la herramienta para desactivar este control ActiveX. Eso significa que muchos usuarios no estarán protegidos contra este fallo. “Muchos usuarios no realizarán esta tarea manualmente”, apunta Greenbaum.

OTRAS REFERENCIAS

SOLUCIONES SEGUN MICROSOFT

fuente: idg.es

El código de explotación de una vulnerabilidad aún no parcheada en Microsoft 2000, Windows XP y Server 2003 ha sido añadida a un toolkit multiataque, según ha advertido Symantec, lo que podría hacer que los intentos de explotación de la brecha aumenten pronto.

Symantec ha explicado que el código de ataque en cuestión, diseñado para aprovechar el agujero DirectShow cuya existencia Microsoft reconoció hace casi un mes, ha sido añadido al menos a un kit de ataque basado en Web. “Esto probablemente provocará un uso extensivo de este malware”, asegura Liam Murchu, investigador del grupo de respuesta de seguridad de Symantec en una entrada de blog corporativa.

La brecha en cuestión no afecta a las últimas versiones del sistema operativo de Microsoft, como Windows Vista o Server 2008, ni tampoco a la próxima versión de la plataforma, Windows 7, actualmente en fase de “edición candidata” (último paso antes de su lanzamiento comercial).

A diferencia de otras ataques a vulnerabilidades de día cero contra agujeros del software de Microsoft, los lanzados contra DirectShow no están dirigidos a individuos u organizaciones específicas. “No se trata de un ataque enfocado, pero sí es de distribución limitada”, señala Ben Greenbaum, director senior de investigación de Symantec.

Funciona como un ataque de phishing en el que una falsa página de log-in para el software Windows Live de Microsoft hospeda malware que intenta secuestrar los PC de los usuarios. El sitio de phishing redirige inadvertidamente al visitante a otra URL que hospeda el código de ataque, que tiene la forma de un archivo .avi malicioso. También pueden descargarse en el sistema de la víctima múltiples archivos .dll malformateados. Éstos, a su vez contienen un archivo .exe que descarga e instala un troyano que suma el PC comprometido a una botnet en crecimiento.

Aunque el parche para el problema aún no está disponible, Microsoft ha sugerido a los usuarios deshabilitar la funcionalidad de análisis gramatical de QuickTime sobre Windows 2000, XP y Server 2003. QuickTime, el reproductor multimedia de Apple no es la fuente de la vulnerabilidad, pero el analizador QuickTime en DirectShow, uno de los componentes de DirectX, sí.

Microsof ha publicado una herramienta que automatiza el proceso de cancelación de esta capacidad en Windows, que sin ella requeriría editar el registro Windows, y espera publicar el parche para la brecha en su próximo boletín de seguridad.

fuente: idg.es

FFDshow is a DirectShow decoding filter for decompressing DivX, XviD, H.264, FLV, WMV, MPEG-1 and MPEG-2, MPEG-4 movies. It uses libavcodec from ffmpeg project for video decompression, postprocessing code from mplayer to enhance visual quality of low bitrate movies, and is based on original DirectShow filter from XviD, which is GPL’ed educational implementation of MPEG4 encoder. FFDshow can be configured to display subtitles, to enable or disable various built-in codecs, to grab screenshots, to enable keyboard control, and to enhance movies with increased resolution, sharpness, and many other post-processing filters. It has the ability to manipulate audio with effects like an equalizer, a Dolby decoder, reverb, Winamp DSP plugins, and more. Some of the postprocessing is borrowed from the MPlayer project and AviSynth filters.

- Download FFDShow MPEG-4 Video Decoder Rev 3014 x86/x64
- Download FFDShow MPEG-4 Video Decoder Rev 3014 x86/x64 (mirror 1)
- Download FFDShow MPEG-4 Video Decoder Rev 3014 x86/x64 (mirror 2)
- Download FFDShow MPEG-4 Video Decoder Rev 3014 x86/x64 (mirror 3)
- Download FFDShow MPEG-4 Video Decoder Rev 3014 x86/x64 (mirror 4)

FFDshow is a DirectShow decoding filter for decompressing DivX, XviD, H.264, FLV, WMV, MPEG-1 and MPEG-2, MPEG-4 movies. It uses libavcodec from ffmpeg project for video decompression, postprocessing code from mplayer to enhance visual quality of low bitrate movies, and is based on original DirectShow filter from XviD, which is GPL’ed educational implementation of MPEG4 encoder. FFDshow can be configured to display subtitles, to enable or disable various built-in codecs, to grab screenshots, to enable keyboard control, and to enhance movies with increased resolution, sharpness, and many other post-processing filters. It has the ability to manipulate audio with effects like an equalizer, a Dolby decoder, reverb, Winamp DSP plugins, and more. Some of the postprocessing is borrowed from the MPlayer project and AviSynth filters.

- Download FFDShow MPEG-4 Video Decoder Rev 3008 x86/x64
- Download FFDShow MPEG-4 Video Decoder Rev 3008 x86/x64 (mirror 1)
- Download FFDShow MPEG-4 Video Decoder Rev 3008 x86/x64 (mirror 2)
- Download FFDShow MPEG-4 Video Decoder Rev 3008 x86/x64 (mirror 3)
- Download FFDShow MPEG-4 Video Decoder Rev 3008 x86/x64 (mirror 4)