renderingcontrolservice.cpp

Windows CE 6.0 Server 源码

                                                                  unsigned short DesiredGreenVideoBlackLevel)
{
    SET_CALL(SetGreenVideoBlackLevel, DesiredGreenVideoBlackLevel);
}


STDMETHODIMP RenderingControlServiceImpl::GetBlueVideoBlackLevel(unsigned long InstanceID,
                                                                 unsigned short* pCurrentBlueVideoBlackLevel)
{
    GET_CALL(GetBlueVideoBlackLevel, pCurrentBlueVideoBlackLevel);

}


STDMETHODIMP RenderingControlServiceImpl::SetBlueVideoBlackLevel(unsigned long InstanceID,
                                                                 unsigned short DesiredBlueVideoBlackLevel)
{
    SET_CALL(SetBlueVideoBlackLevel, DesiredBlueVideoBlackLevel);
}


STDMETHODIMP RenderingControlServiceImpl::GetColorTemperature(unsigned long InstanceID,
                                                              unsigned short* pCurrentColorTemperature)
{
    GET_CALL(GetColorTemperature, pCurrentColorTemperature);

}


STDMETHODIMP RenderingControlServiceImpl::SetColorTemperature(unsigned long InstanceID,
                                                              unsigned short DesiredColorTemperature)
{
    SET_CALL(SetColorTemperature, DesiredColorTemperature);
}


STDMETHODIMP RenderingControlServiceImpl::GetHorizontalKeystone(unsigned long InstanceID,
                                                                short* pCurrentHorizontalKeystone)
{
    GET_CALL(GetHorizontalKeystone, pCurrentHorizontalKeystone);

}


STDMETHODIMP RenderingControlServiceImpl::SetHorizontalKeystone(unsigned long InstanceID,
                                                                short DesiredHorizontalKeystone)
{
    SET_CALL(SetHorizontalKeystone, DesiredHorizontalKeystone);
}


STDMETHODIMP RenderingControlServiceImpl::GetVerticalKeystone(unsigned long InstanceID,
                                                              short* pCurrentVerticalKeystone)
{
    GET_CALL(GetVerticalKeystone, pCurrentVerticalKeystone);

}


STDMETHODIMP RenderingControlServiceImpl::SetVerticalKeystone(unsigned long InstanceID,
                                                              short DesiredVerticalKeystone)
{
    SET_CALL(SetVerticalKeystone, DesiredVerticalKeystone);
}


STDMETHODIMP RenderingControlServiceImpl::GetMute(unsigned long InstanceID,
                                                  BSTR Channel,
                                                  VARIANT_BOOL* pCurrentMute)
{
    // Convert argument

    wstring strChannel;

    if(!strChannel.assign(Channel, SysStringLen(Channel)))
        return m_ErrReport.ReportError(ERROR_AV_OOM);


    bool fCurrentMute;

    MAKE_INSTANCE_CALL_2(GetMute, strChannel, &fCurrentMute);


    // Set out arg
    if(fCurrentMute)
        *pCurrentMute = VARIANT_TRUE;
    else
        *pCurrentMute = VARIANT_FALSE;

    return S_OK;
}


STDMETHODIMP RenderingControlServiceImpl::SetMute(unsigned long InstanceID,
                                                  BSTR Channel,
                                                  VARIANT_BOOL DesiredMute)
{
    // Convert arguments

    wstring strChannel;

    if(!strChannel.assign(Channel, SysStringLen(Channel)))
        return m_ErrReport.ReportError(ERROR_AV_OOM);

    bool fDesiredMute;
    
    if(VARIANT_TRUE == DesiredMute)
        fDesiredMute = true;
    else if(VARIANT_FALSE == DesiredMute)
        fDesiredMute = false;
    else // illegal VARIANT_BOOL value
        return m_ErrReport.ReportError(ERROR_AV_UPNP_ACTION_FAILED);


    MAKE_INSTANCE_CALL_2(SetMute, strChannel, fDesiredMute);


    return S_OK;

}


STDMETHODIMP RenderingControlServiceImpl::GetVolume(unsigned long InstanceID,
                                                    BSTR Channel,
                                                    unsigned short* pCurrentVolume)
{
    // Convert argument

    wstring strChannel;

    if(!strChannel.assign(Channel, SysStringLen(Channel)))
        return m_ErrReport.ReportError(ERROR_AV_OOM);


    MAKE_INSTANCE_CALL_2(GetVolume, strChannel, pCurrentVolume);

    return S_OK;
}


STDMETHODIMP RenderingControlServiceImpl::SetVolume(unsigned long InstanceID,
                                                    BSTR Channel,
                                                    unsigned short DesiredVolume)
{
    // Convert arguments

    wstring strChannel;

    if(!strChannel.assign(Channel, SysStringLen(Channel)))
        return m_ErrReport.ReportError(ERROR_AV_OOM);


    MAKE_INSTANCE_CALL_2(SetVolume, strChannel, DesiredVolume);


    return S_OK;

}


STDMETHODIMP RenderingControlServiceImpl::GetVolumeDB(unsigned long InstanceID,
                                                      BSTR Channel,
                                                      short* pCurrentVolume)
{
    // Convert argument

    wstring strChannel;

    if(!strChannel.assign(Channel, SysStringLen(Channel)))
        return m_ErrReport.ReportError(ERROR_AV_OOM);


    MAKE_INSTANCE_CALL_2(GetVolumeDB, strChannel, pCurrentVolume);


    return S_OK;
}


STDMETHODIMP RenderingControlServiceImpl::SetVolumeDB(unsigned long InstanceID,
                                                      BSTR Channel,
                                                      short DesiredVolume)
{
    // Convert arguments

    wstring strChannel;

    if(!strChannel.assign(Channel, SysStringLen(Channel)))
        return m_ErrReport.ReportError(ERROR_AV_OOM);


    MAKE_INSTANCE_CALL_2(SetVolumeDB, strChannel, DesiredVolume);


    return S_OK;

}


STDMETHODIMP RenderingControlServiceImpl::GetVolumeDBRange(unsigned long InstanceID,
                                                           BSTR Channel,
                                                           short* pMinValue,
                                                           short* pMaxValue)
{
    // Convert argument

    wstring strChannel;

    if(!strChannel.assign(Channel, SysStringLen(Channel)))
        return m_ErrReport.ReportError(ERROR_AV_OOM);


    MAKE_INSTANCE_CALL_3(GetVolumeDBRange, strChannel, pMinValue, pMaxValue);


    return S_OK;
}


STDMETHODIMP RenderingControlServiceImpl::GetLoudness(unsigned long InstanceID,
                                                      BSTR Channel,
                                                      VARIANT_BOOL* pCurrentLoudness)
{
    // Convert argument

    wstring strChannel;

    if(!strChannel.assign(Channel, SysStringLen(Channel)))
        return m_ErrReport.ReportError(ERROR_AV_OOM);


    bool fCurrentMute;

    MAKE_INSTANCE_CALL_2(GetLoudness, strChannel, &fCurrentMute);


    // Set out arg
    if(fCurrentMute)
        *pCurrentLoudness = VARIANT_TRUE;
    else
        *pCurrentLoudness = VARIANT_FALSE;

    return S_OK;
}


STDMETHODIMP RenderingControlServiceImpl::SetLoudness(unsigned long InstanceID,
                                                      BSTR Channel,
                                                      VARIANT_BOOL DesiredLoudness)
{
    // Convert arguments

    wstring strChannel;

    if(!strChannel.assign(Channel, SysStringLen(Channel)))
        return m_ErrReport.ReportError(ERROR_AV_OOM);

    bool fDesiredLoudness;

    if(VARIANT_TRUE == DesiredLoudness)
        fDesiredLoudness = true;
    else if(VARIANT_FALSE == DesiredLoudness)
        fDesiredLoudness = false;
    else // illegal VARIANT_BOOL value
        return m_ErrReport.ReportError(ERROR_AV_UPNP_ACTION_FAILED);


    MAKE_INSTANCE_CALL_2(SetLoudness, strChannel, fDesiredLoudness);


    return S_OK;

}



//
// Private
//


HRESULT RenderingControlServiceImpl::InitToolkitErrs()
{
    const int vErrMap[][2] =
    {
        {ERROR_AV_POINTER,          ERROR_AV_UPNP_ACTION_FAILED},
        {ERROR_AV_OOM,              ERROR_AV_UPNP_ACTION_FAILED},
        {ERROR_AV_INVALID_INSTANCE, ERROR_AV_UPNP_RC_INVALID_INSTANCE_ID},
        {ERROR_AV_INVALID_STATEVAR, ERROR_AV_UPNP_ACTION_FAILED},
        {ERROR_AV_ALREADY_INITED,   ERROR_AV_UPNP_ACTION_FAILED},
        {0,                         0} // 0 is used to denote the end of this array
    };


    for(unsigned int i=0; 0 != vErrMap[i][0]; ++i)
    {
        if(ERROR_AV_OOM == m_ErrReport.AddToolkitError(vErrMap[i][0], vErrMap[i][1]))
            return E_OUTOFMEMORY;
    }

    return S_OK;
}


HRESULT RenderingControlServiceImpl::InitErrDescrips()
{
    const int vErrNums[] =
    {
        // UPnP
        ERROR_AV_UPNP_INVALID_ACTION,
        ERROR_AV_UPNP_ACTION_FAILED,
        // RenderingControl
        ERROR_AV_UPNP_RC_INVALID_PRESET_NAME,
        ERROR_AV_UPNP_RC_INVALID_INSTANCE_ID,
        0 // 0 is used to denote the end of this array
    };
    
    const wstring vErrDescrips[] =
    {
        // UPnP
        L"Invalid Action",
        L"Action Failed",
        // ConnectionManager
        L"The specified name is not a valid preset name",
        L"The specified InstanceID is invalid",
    };


    for(unsigned int i=0; 0 != vErrNums[i]; ++i)
    {
        if(ERROR_AV_OOM == m_ErrReport.AddErrorDescription(vErrNums[i], vErrDescrips[i]))
            return E_OUTOFMEMORY;
    }

    return S_OK;
}