av_upnp_ctrl_internal.h

Windows CE 6.0 Server 源码

        HRESULT hr;
        
        if(SUCCEEDED(hr = pService->QueryInterface(IID_IUPnPServiceCallbackPrivate, (void**)&m_pCallbackPrivate)))
        {
            if(FAILED(hr = m_pCallbackPrivate->AddTransientCallback(static_cast<IUPnPServiceCallbackImpl*>(this), &m_dwCookie)))
            {
                DEBUGMSG(ZONE_AV_ERROR, (AV_TEXT("AddTransientCallback failed with error 0x%08x"), hr));
                return false;
            }
        }
        else
        {
            DEBUGMSG(ZONE_AV_ERROR, (AV_TEXT("QueryInterface(IID_IUPnPServiceCallbackPrivate) failed 0x%08x"), hr));
            return false;
        }
        
        return true;
    }
    
    
    // GetInstance
    DWORD GetInstance(long InstanceID, I** ppInstance)
    {
        if(!ppInstance)
            return ERROR_AV_POINTER;
            
        *ppInstance = NULL;
            
        if(!m_pService)
            return ERROR_AV_NONEXISTANT_SERVICE;
        
        InstanceMap::iterator it;
        
        ce::gate<ce::critical_section>  gate(m_csInstancesMap);
        
        if(m_mapInstances.end() == (it = m_mapInstances.find(InstanceID)) &&
          (m_mapInstances.end() == (it = m_mapInstances.insert(InstanceID, Instance())) || !(it->second.Service.Init(InstanceID, m_pService, this),true)))
        {
            DEBUGMSG(ZONE_AV_ERROR, (AV_TEXT("OOM creating service instance")));
            return ERROR_AV_OOM;
        }
        
        InterlockedIncrement(&it->second.lRefCount);
        *ppInstance = &it->second.Service;
        
        return SUCCESS_AV;
    }
    
    // IVirtualServiceRefCount::ReleaseInstance
    virtual void ReleaseInstance(long InstanceID)
    {
        InstanceMap::iterator it;
        
        ce::gate<ce::critical_section>  gate(m_csInstancesMap);
        
        if(m_mapInstances.end() != (it = m_mapInstances.find(InstanceID)))
        {
            if(!InterlockedDecrement(&it->second.lRefCount))
                m_mapInstances.erase(it);
        }
        else
        {
            assert(false);
        }
    }
    
// IUPnPServiceCallback
public:
    // StateVariableChanged
    STDMETHOD(StateVariableChanged)(
            /* [in] */ IUPnPService *pus,
            /* [in] */ LPCWSTR pcwszStateVarName,
            /* [in] */ VARIANT varValue)
    {
        if(0 != wcscmp(pcwszStateVarName, L"LastChange"))
        {
            DEBUGMSG(ZONE_AV_WARN, (AV_TEXT("Ignoring event for state variable '%s'"), pcwszStateVarName));
            return S_OK;
        }
        
        if(varValue.vt != VT_BSTR)
        {
            DEBUGMSG(ZONE_AV_WARN, (AV_TEXT("Invalid type %d of LastChange state variable"), varValue.vt));
            return S_OK;
        }
        
        if(!varValue.bstrVal[0])
        {
            DEBUGMSG(ZONE_AV_WARN, (AV_TEXT("Received empty string for LastChange event")));
            return S_OK;
        }
        
        ce::SAXReader   Reader;
        HRESULT         hr;
        
        if(Reader.valid())
        {
            hr = Reader->putContentHandler(static_cast<LastChangeParsing*>(this));
            
            assert(SUCCEEDED(hr));

            if(FAILED(hr = Reader->parse(varValue)))
            {
                DEBUGMSG(ZONE_AV_ERROR, (AV_TEXT("Error 0x%08x when parsing LastChange event"), hr));
            }
        }
        else
        {
            DEBUGMSG(ZONE_AV_ERROR, (AV_TEXT("Error 0x%08x instantiating SAXXMLReader"), Reader.Error()));
        }
        
        return S_OK;
    }
    

protected:    
    virtual DWORD OnStateChanged(
        /*[in]*/  int     InstanceID,
        /*[in]*/  LPCWSTR pszStateVariableName,
        /*[in]*/  LPCWSTR pszValue)
    {
        InstanceMap::iterator it;
        
        ce::gate<ce::critical_section>  gate(m_csInstancesMap);
        
        if(m_mapInstances.end() != (it = m_mapInstances.find(InstanceID)))
        {
            return it->second.Service.OnStateChanged(pszStateVariableName,
                                                     pszValue);
        }
        
        return SUCCESS_AV;
    }
        
    virtual DWORD OnStateChanged(
        /*[in]*/  int     InstanceID,
        /*[in]*/  LPCWSTR pszStateVariableName,
        /*[in]*/  long    nValue)
    {
        InstanceMap::iterator it;
        
        ce::gate<ce::critical_section>  gate(m_csInstancesMap);
        
        if(m_mapInstances.end() != (it = m_mapInstances.find(InstanceID)))
        {
            return it->second.Service.OnStateChanged(pszStateVariableName,
                                                     nValue);
        }
        
        return SUCCESS_AV;
    }

    virtual DWORD OnStateChanged(
        /*[in]*/  int     InstanceID,
        /*[in]*/  LPCWSTR pszStateVariableName,
        /*[in]*/  LPCWSTR pszChannel,
        /*[in]*/  long    nValue)
    {
        InstanceMap::iterator it;
        
        ce::gate<ce::critical_section>  gate(m_csInstancesMap);
        
        if(m_mapInstances.end() != (it = m_mapInstances.find(InstanceID)))
        {
            return it->second.Service.OnStateChanged(pszStateVariableName,
                                                     pszChannel,
                                                     nValue);
        }
        
        return SUCCESS_AV;
    }
      

protected:
    struct Instance
    {
        Instance()
            : lRefCount(0)
        {}
        
        T       Service;
        long    lRefCount;
    };
    
    typedef ce::hash_map<long, Instance> InstanceMap;
    
    ce::critical_section                    m_csInstancesMap;
    InstanceMap                             m_mapInstances;
    CComPtr<IUPnPService>                   m_pService;
    CComPtr<IUPnPServiceCallbackPrivate>    m_pCallbackPrivate;
    DWORD                                   m_dwCookie;
};




//
// AVTransportCtrl
//
class AVTransportCtrl : public IEventSourceImpl<IAVTransport>
{
public:
    //
    // Despite the fact that initialization can't fail, we are using Init function
    // rather than a ctor so that we don't have to define copy ctor explicitly
    //
    void Init(long InstanceID, IUPnPService* pService, IVirtualServiceRefCount* pRefCount)
    {
        m_InstanceID = InstanceID;
        m_proxyAVTransport.init(pService);
        m_pRefCount = pRefCount;
    }

// IAVTransport
public:
    virtual DWORD SetAVTransportURI(
            /* [in] */ LPCWSTR pszCurrentURI,
            /* [in] */ LPCWSTR pszCurrentURIMetaData);

    virtual DWORD SetNextAVTransportURI(
            /* [in] */ LPCWSTR pszNextURI,
            /* [in] */ LPCWSTR pszNextURIMetaData);

    virtual DWORD GetMediaInfo(
            /* [in, out] */ MediaInfo* pMediaInfo);

    virtual DWORD GetTransportInfo(
            /* [in, out] */ TransportInfo* pTransportInfo);

    virtual DWORD GetPositionInfo(
            /* [in, out] */ PositionInfo* pPositionInfo);

    virtual DWORD GetDeviceCapabilities(
            /* [in, out] */ DeviceCapabilities* pDeviceCapabilities);

    virtual DWORD GetTransportSettings(
            /* [in, out] */ TransportSettings* pTransportSettings);

    virtual DWORD Stop();

    virtual DWORD Play(
            /* [in] */ LPCWSTR pszSpeed);

    virtual DWORD Pause();

    virtual DWORD Record();

    virtual DWORD Seek(
            /* [in] */ LPCWSTR pszUnit,
            /* [in] */ LPCWSTR pszTarget);

    virtual DWORD Next();

    virtual DWORD Previous();

    virtual DWORD SetPlayMode(
            /* [in] */ LPCWSTR pszNewPlayMode);

    virtual DWORD SetRecordQualityMode(
            /* [in] */ LPCWSTR pszNewRecordQualityMode);

    virtual DWORD GetCurrentTransportActions(
            /* [in, out] */ TransportActions* pActions);

    virtual DWORD InvokeVendorAction(
            /* [in] */ LPCWSTR pszActionName,
            /* [in] */ DISPPARAMS* pdispparams, 
            /* [in, out] */ VARIANT* pvarResult);

// IVirtualService
public:
    virtual void Release()
    {
        assert(m_pRefCount);
        
        m_pRefCount->ReleaseInstance(m_InstanceID);
    }

private:
    ce::upnp_proxy              m_proxyAVTransport;
    long                        m_InstanceID;
    IVirtualServiceRefCount*    m_pRefCount;
};


//
// RenderingControlCtrl
//
class RenderingControlCtrl : public IEventSourceImpl<IRenderingControl>
{
public:
    //
    // Despite the fact that initialization can't fail, we are using Init function
    // rather than a ctor so that we don't have to define copy ctor explicitly
    //
    void Init(long InstanceID, IUPnPService* pService, IVirtualServiceRefCount* pRefCount)
    {
        m_InstanceID = InstanceID;
        m_proxyRenderingControl.init(pService);
        m_pRefCount = pRefCount;
    }

// IRenderingControl
public:
    virtual DWORD ListPresets(
        /* [in, out] */ wstring* pstrPresetNameList);

    virtual DWORD SelectPreset(
        /* [in] */ LPCWSTR pszPresetName);

    virtual DWORD GetBrightness(
        /* [in, out] */ unsigned short* pBrightness);

    virtual DWORD SetBrightness(
        /* [in] */ unsigned short Brightness);

    virtual DWORD GetContrast(
        /* [in, out] */ unsigned short* pContrast);

    virtual DWORD SetContrast(
        /* [in] */ unsigned short Contrast);

    virtual DWORD GetSharpness(
        /* [in, out] */ unsigned short* pSharpness);

    virtual DWORD SetSharpness(
        /* [in] */ unsigned short Sharpness);

    virtual DWORD GetRedVideoGain(
        /* [in, out] */ unsigned short* pRedVideoGain);

    virtual DWORD SetRedVideoGain(
        /* [in] */ unsigned short RedVideoGain);

    virtual DWORD GetGreenVideoGain(
        /* [in, out] */ unsigned short* pGreenVideoGain);

    virtual DWORD SetGreenVideoGain(
        /* [in] */ unsigned short GreenVideoGain);

    virtual DWORD GetBlueVideoGain(
        /* [in, out] */ unsigned short* pBlueVideoGain);

    virtual DWORD SetBlueVideoGain(
        /* [in] */ unsigned short BlueVideoGain);

    virtual DWORD GetRedVideoBlackLevel(
        /* [in, out] */ unsigned short* pRedVideoBlackLevel);

    virtual DWORD SetRedVideoBlackLevel(
        /* [in] */ unsigned short RedVideoBlackLevel);

    virtual DWORD GetGreenVideoBlackLevel(
        /* [in, out] */ unsigned short* pGreenVideoBlackLevel);

    virtual DWORD SetGreenVideoBlackLevel(
        /* [in] */ unsigned short GreenVideoBlackLevel);

    virtual DWORD GetBlueVideoBlackLevel(
        /* [in, out] */ unsigned short* pBlueVideoBlackLevel);

    virtual DWORD SetBlueVideoBlackLevel(
        /* [in] */ unsigned short BlueVideoBlackLevel);

    virtual DWORD GetColorTemperature(
        /* [in, out] */ unsigned short* pColorTemperature);

    virtual DWORD SetColorTemperature(
        /* [in] */ unsigned short ColorTemperature);

    virtual DWORD GetHorizontalKeystone(
        /* [in, out] */ short* pHorizontalKeystone);

    virtual DWORD SetHorizontalKeystone(
        /* [in] */ short HorizontalKeystone);