baserend.cpp

linux下的一款播放器

            HX_RELEASE(m_pBackChannel);
            pSource->QueryInterface(IID_IHXBackChannel, (void**) &m_pBackChannel);
            HX_RELEASE(pSource);
        }

        // Get an IHXASMStream interface if it's support - OK if it doesn't
        HX_RELEASE(m_pASMStream);
        m_pStream->QueryInterface(IID_IHXASMStream, (void**) &m_pASMStream);
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::OnPreSeek(UINT32 ulOldTime, UINT32 ulNewTime)
{
    return HXR_OK;
}

STDMETHODIMP CRNBaseRenderer::OnPostSeek(UINT32 ulOldTime, UINT32 ulNewTime)
{
    return HXR_OK;
}

STDMETHODIMP CRNBaseRenderer::OnBegin(UINT32 ulTime)
{
    return HXR_OK;
}

STDMETHODIMP CRNBaseRenderer::OnPause(UINT32 ulTime)
{
    return HXR_OK;
}

STDMETHODIMP CRNBaseRenderer::OnBuffering(UINT32 ulFlags, UINT16 usPercentComplete)
{
    return HXR_OK;
}

STDMETHODIMP CRNBaseRenderer::OnEndofPackets(void)
{
    return HXR_OK;
}

STDMETHODIMP CRNBaseRenderer::SetPropertyULONG32(const char* pName, ULONG32 ulVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->SetPropertyULONG32(pName, ulVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::GetPropertyULONG32(const char* pName, REF(ULONG32) rulVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetPropertyULONG32(pName, rulVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::GetFirstPropertyULONG32(REF(const char*) rpName, REF(ULONG32) rulVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetFirstPropertyULONG32(rpName, rulVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::GetNextPropertyULONG32(REF(const char*) rpName, REF(ULONG32) rulVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetNextPropertyULONG32(rpName, rulVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::SetPropertyBuffer(const char* pName, IHXBuffer* pVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->SetPropertyBuffer(pName, pVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::GetPropertyBuffer(const char* pName, REF(IHXBuffer*) rpVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetPropertyBuffer(pName, rpVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::GetFirstPropertyBuffer(REF(const char*) rpName, REF(IHXBuffer*) rpVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetFirstPropertyBuffer(rpName, rpVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::GetNextPropertyBuffer(REF(const char*) rpName, REF(IHXBuffer*) rpVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetNextPropertyBuffer(rpName, rpVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::SetPropertyCString(const char* pName, IHXBuffer* pVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->SetPropertyCString(pName, pVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::GetPropertyCString(const char* pName, REF(IHXBuffer*) rpVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetPropertyCString(pName, rpVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::GetFirstPropertyCString(REF(const char*) rpName, REF(IHXBuffer*) rpVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetFirstPropertyCString(rpName, rpVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::GetNextPropertyCString(REF(const char*) rpName, REF(IHXBuffer*) rpVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetNextPropertyCString(rpName, rpVal);
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::UpdatePacketTimeOffset(INT32 lTimeOffset)
{
    HX_RESULT retVal = HXR_OK;

    // Save the offset time
    m_lTimeOffset = -lTimeOffset;

    return retVal;
}

STDMETHODIMP
CRNBaseRenderer::UpdatePlayTimes(IHXValues* pProps)
{
    return HXR_OK;
}

STDMETHODIMP CRNBaseRenderer::EndStream()
{
    // Can't use IHXStream, IHXBackChannel, or IHXASMStream
    // after EndStream() is called.
    HX_RELEASE(m_pStream);
    HX_RELEASE(m_pBackChannel);
    HX_RELEASE(m_pASMStream);

    return HXR_OK;
}

STDMETHODIMP CRNBaseRenderer::OnPacket(IHXPacket *pPacket, INT32 lTimeOffset)
{
    // Save the offset time
    m_lTimeOffset = lTimeOffset;

    return OnPacketNoOffset(pPacket);
}

STDMETHODIMP CRNBaseRenderer::OnTimeSync(UINT32 ulTime)
{
    HX_RESULT retVal = HXR_OK;
    
    // Adjust the time
    UINT32 ulAdjustedTime = 0;
    if (m_lTimeOffset < 0 && ulTime < (UINT32)(-m_lTimeOffset))
    {
        ulAdjustedTime = 0;
    }
    else
    {
        ulAdjustedTime = ulTime + m_lTimeOffset;
    }

    // Save the last time sync
    m_ulLastTimeSync = ulAdjustedTime;

    if(_IsValidRendererSurface())
    {
        retVal = OnTimeSyncOffset(ulAdjustedTime);
    }
    
    return retVal;
}

STDMETHODIMP CRNBaseRenderer::CheckStreamVersions(IHXValues* pHeader)
{
    BOOL bVersionOK = TRUE;

    HX_RESULT retVal = pHeader->GetPropertyULONG32("StreamVersion", m_ulStreamVersion);
    if (SUCCEEDED(retVal))
    {
        UINT32 ulDataMajor = HX_GET_MAJOR_VERSION(m_ulStreamVersion);
        UINT32 ulDataMinor = HX_GET_MINOR_VERSION(m_ulStreamVersion);
        UINT32 ulRendMajor = HX_GET_MAJOR_VERSION(GetHighestSupportedStreamVersion());
        UINT32 ulRendMinor = HX_GET_MINOR_VERSION(GetHighestSupportedStreamVersion());

        if((ulDataMajor >  ulRendMajor) ||
           (ulDataMajor == ulRendMajor && ulDataMinor > ulRendMinor))
        {
            bVersionOK = FALSE;
        }
    }

    retVal = pHeader->GetPropertyULONG32("ContentVersion", m_ulContentVersion);
    if(bVersionOK && SUCCEEDED(retVal))
    {
        UINT32 ulDataMajor = HX_GET_MAJOR_VERSION(m_ulContentVersion);
        UINT32 ulDataMinor = HX_GET_MINOR_VERSION(m_ulContentVersion);
        UINT32 ulRendMajor = HX_GET_MAJOR_VERSION(GetHighestSupportedContentVersion());
        UINT32 ulRendMinor = HX_GET_MINOR_VERSION(GetHighestSupportedContentVersion());

        if((ulDataMajor >  ulRendMajor) ||
           (ulDataMajor == ulRendMajor && ulDataMinor > ulRendMinor))
        {
            bVersionOK = FALSE;
        }
    }

    if(bVersionOK)
    {
        retVal = HXR_OK;
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;
}

STDMETHODIMP CRNBaseRenderer::AddMimeToUpgradeCollection(const char* pszMimeType)
{
    return AddToAutoUpgradeCollection(pszMimeType, m_pContext);
}

STDMETHODIMP CRNBaseRenderer::GetPreference(const char*      pszPrefName,
                                            REF(BOOL)        rbPresent,
                                            REF(IHXBuffer*) rpBuffer)
{
    HX_RESULT retVal  = HXR_OK;

    if (pszPrefName)
    {
        // Set defaults
        rbPresent = FALSE;
        rpBuffer  = NULL;

        if (m_pPreferences)
        {
            HX_RESULT rv = m_pPreferences->ReadPref(pszPrefName, rpBuffer);
            if (SUCCEEDED(rv))
            {
                rbPresent = TRUE;
            }
        }
        else
        {
            retVal = HXR_NOT_INITIALIZED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

BOOL CRNBaseRenderer::_IsValidRendererSurface()
{
    return TRUE;
}

STDMETHODIMP_(BOOL) CRNBaseRenderer::GetLoadMultiple()
{
    return TRUE;
}

STDMETHODIMP CRNBaseRenderer::GetCopyright(REF(const char*) rpszCopyright)
{
    rpszCopyright = (const char*) m_pszBaseCopyright;
    return HXR_OK;
}

STDMETHODIMP CRNBaseRenderer::GetMoreInfoURL(REF(const char*) rpszMoreInfoURL)
{
    rpszMoreInfoURL = (const char*) m_pszBaseMoreInfoURL;
    return HXR_OK;
}

STDMETHODIMP_(UINT32) CRNBaseRenderer::GetInitialGranularity()
{
    return 33;
}

STDMETHODIMP_(UINT32) CRNBaseRenderer::GetDisplayFlags()
{
    UINT32 ulRet = HX_DISPLAY_WINDOW          |
                   HX_DISPLAY_SUPPORTS_RESIZE |
                   HX_DISPLAY_SUPPORTS_FULLSCREEN;
    return ulRet;
}

STDMETHODIMP_(UINT32) CRNBaseRenderer::GetHighestSupportedContentVersion()
{
    return HX_ENCODE_PROD_VERSION(0, 0, 0, 0);
}

STDMETHODIMP_(UINT32) CRNBaseRenderer::GetHighestSupportedStreamVersion()
{
    return HX_ENCODE_PROD_VERSION(0, 0, 0, 0);
}