ramrendr.cpp

linux下的一款播放器

)
{
    ulFlags = HX_DISPLAY_NONE;

    return HXR_OK;
}

/************************************************************************
 *	Method:
 *	    IHXRenderer::OnEndofPackets
 *	Purpose:
 *	    Called by client engine to inform the renderer that all the
 *	    packets have been delivered. However, if the user seeks before
 *	    EndStream() is called, renderer may start getting packets again
 *	    and the client engine will eventually call this function again.
 */
STDMETHODIMP CRAMRenderer::OnEndofPackets(void)
{
    return HXR_OK;
}

#if defined(HELIX_FEATURE_NESTEDMETA)
// IHXGroupSink methods
STDMETHODIMP
CRAMRenderer::GroupAdded(UINT16 uGroupIndex, 
			 IHXGroup* pGroup)
{
    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::GroupRemoved(UINT16 uGroupIndex, 
			   IHXGroup* pGroup)
{
    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::AllGroupsRemoved()
{
    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::TrackAdded(UINT16 uGroupIndex, 
			 UINT16 uTrackIndex, 
			 IHXValues* pTrack)
{
    HX_RESULT	    rc = HXR_OK;
    UINT32	    ulDelay = 0;
    UINT32	    ulDuration = 0;
    const char*	    pszID = NULL;
    IHXBuffer*	    pBuffer = NULL;
    RAMPlayToAssoc* pPlayToAssoc = NULL;

    if (!pTrack)
    {
	rc = HXR_FAILED;
	goto cleanup;
    }

    pPlayToAssoc		= new RAMPlayToAssoc;
    pPlayToAssoc->m_uGroupIndex	= uGroupIndex;
    pPlayToAssoc->m_uTrackIndex	= uTrackIndex;
    pPlayToAssoc->m_ulDelay	= 0;
    pPlayToAssoc->m_ulDuration	= 0;

    if (HXR_OK == pTrack->GetPropertyULONG32("Delay", ulDelay))
    {
	pPlayToAssoc->m_ulDelay = ulDelay;
    }

    if (HXR_OK == pTrack->GetPropertyULONG32("Duration", ulDuration))
    {
	pPlayToAssoc->m_ulDuration = ulDuration;
    }

    if(HXR_OK == pTrack->GetPropertyCString("id", pBuffer))
    {
        pszID = (const char*)pBuffer->GetBuffer();
	pPlayToAssoc->m_id = pszID;
    }
    HX_RELEASE(pBuffer);

    if (!m_pPlayToAssocList)
    {
	m_pPlayToAssocList = new CHXSimpleList;
    }

    m_pPlayToAssocList->AddTail(pPlayToAssoc);

cleanup:

    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::TrackRemoved(UINT16 uGroupIndex, 
			   UINT16 uTrackIndex, 
			   IHXValues* pTrack)
{
    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::TrackStarted(UINT16 uGroupIndex, 
			   UINT16 uTrackIndex, 
			   IHXValues* pTrack)
{
    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::TrackStopped(UINT16 uGroupIndex, 
			   UINT16 uTrackIndex, 
			   IHXValues* pTrack)
{
    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::CurrentGroupSet(UINT16 uGroupIndex, 
			      IHXGroup* pGroup)
{
    return HXR_OK;
}

// IHXRendererAdviseSink methods
STDMETHODIMP
CRAMRenderer::TrackDurationSet(UINT32 ulGroupIndex, 
			       UINT32 ulTrackIndex,
                               UINT32 ulDuration,   
			       UINT32 ulDelay,
			       BOOL   bIsLive)
{
    HX_RESULT		rc = HXR_OK;
    UINT16		uTrackIndex = 0;
    UINT16		uID = 0;
    char		szID[128] = {0}; /* Flawfinder: ignore */
    char*		pTrack = NULL;
    IHXBuffer*		pBuffer = NULL;
    IHXValues*		pTrackProperties = NULL;
    IHXGroup*		pGroup = NULL;
    IHXGroupManager*	pGroupManager = NULL;
    IHXRendererAdviseSink* pRendererAdviseSink = NULL;
    RAMPlayToAssoc* pPlayToAssoc = NULL;

    if (WithinSeqInPar != m_elementWithinTag || bIsLive)
    {
	goto cleanup;
    }

    pPlayToAssoc = GetPlayToAssoc((UINT16)ulGroupIndex, (UINT16)ulTrackIndex);

    if (pPlayToAssoc && m_pTrackMap)
    {
	// m_id is in the format of "<group_id>_<track_id>"
	UINT64 state = 0;
	uID = atoi((const char*)(pPlayToAssoc->m_id.GetNthField('_', 2, state)));
	uTrackIndex = uID + 1;

	if (uTrackIndex < (UINT32)m_pTrackMap->GetCount())
	{	
	    // check for maximum number of tracks
	    if (uTrackIndex > MAX_RAM_URLS)
	    {
		goto cleanup;
	    }

	    if (HXR_OK == m_pContext->QueryInterface(IID_IHXGroupManager, (void**)&pGroupManager))
	    {
		pGroupManager->GetGroup(m_uGroupIndexWithin, pGroup);
    
                pTrack = (char*)(const char*)(*(CHXString*)(*m_pTrackMap)[uTrackIndex]);
		if (HXR_OK == PrepareTrack(pTrack, pTrackProperties))
		{
		    pBuffer = new CHXBuffer();
		    pBuffer->AddRef();

		    sprintf(szID, "%lu_%lu", m_uGroupIndexWithin, uTrackIndex); /* Flawfinder: ignore */
		    pBuffer->Set((UCHAR*)szID, strlen(szID)+1);
		    pTrackProperties->SetPropertyCString("id", pBuffer);

		    HX_RELEASE(pBuffer);

		    pTrackProperties->SetPropertyULONG32("Delay", ulDuration);

		    pGroup->AddTrack(pTrackProperties);
		}
		HX_RELEASE(pTrackProperties);
		HX_RELEASE(pGroup);
	    }
	    HX_RELEASE(pGroupManager);
	}
	else
	{
	    HX_ASSERT(uTrackIndex == m_pTrackMap->GetCount());
	    
	    if (m_pPersistentParentRenderer &&
		HXR_OK == m_pPersistentParentRenderer->QueryInterface(IID_IHXRendererAdviseSink, (void**)&pRendererAdviseSink))
	    {
		if (m_ulPersistentComponentDuration)
		{
		    HX_ASSERT(m_ulPersistentComponentDuration == ulDuration);
		}

		rc = pRendererAdviseSink->TrackDurationSet(m_uPersistentGroupID,
							   m_uPersistentTrackID,
							   ulDuration,
							   m_ulPersistentComponentDelay,
							   bIsLive);
	    }
	    HX_RELEASE(pRendererAdviseSink);
	}
    }

cleanup:

    return rc;
}

STDMETHODIMP
CRAMRenderer::RepeatedTrackDurationSet(const char* pID, 
				       UINT32 ulDuration,
                                       BOOL bIsLive)
{
    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::TrackUpdated(UINT32 ulGroupIndex, 
			   UINT32 ulTrackIndex,
			   IHXValues* pValues)
{
    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::RendererInitialized(IHXRenderer* pRend, 
				  IUnknown* pStream,
				  IHXValues* pInfo)
{
    HX_RESULT		rc = HXR_OK;
    BOOL		bIsWindowed = FALSE;
    HX_DISPLAY_TYPE	ulFlags = HX_DISPLAY_NONE;
    RAMPlayToAssoc*	pPlayToAssoc = NULL;
    IHXBuffer*		pBuffer = NULL;

    UINT32		ulGroupIndex = 0;
    UINT32		ulTrackIndex = 0;
    UINT32		ulDelay = 0;
    UINT32		ulDuration = 0;

    pInfo->GetPropertyULONG32("GroupIndex", ulGroupIndex);
    pInfo->GetPropertyULONG32("TrackIndex", ulTrackIndex);
    pInfo->GetPropertyULONG32("Delay", ulDelay);
    pInfo->GetPropertyULONG32("Duration", ulDuration);  

    if (HXR_OK == pInfo->GetPropertyCString("id", pBuffer))
    {
	pPlayToAssoc = GetPlayToAssocByMedia((const char*)pBuffer->GetBuffer());
    }
    HX_RELEASE(pBuffer);

    if (!pPlayToAssoc)
    {
	// XXX HP we shouldn't be here
	HX_ASSERT(FALSE);	
	pPlayToAssoc = GetPlayToAssoc(ulGroupIndex, ulTrackIndex);
    }
 
    if (pPlayToAssoc)
    {
	pPlayToAssoc->m_ulDelay = ulDelay;
	pPlayToAssoc->m_ulDuration = ulDuration;
    }

    if (HXR_OK == pRend->GetDisplayType(ulFlags, pBuffer) &&
	HX_DISPLAY_WINDOW == (HX_DISPLAY_WINDOW & ulFlags))
    {
	bIsWindowed = TRUE;
    }
    HX_RELEASE(pBuffer);

    if (bIsWindowed && m_pPersistentParentRenderer)
    {
	m_pPersistentParentRenderer->AttachElementLayout(m_uPersistentGroupID,
	    						 m_uPersistentTrackID,
							 pRend,
							 (IHXStream*)pStream,
							 pInfo);
    }

    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::RendererClosed(IHXRenderer* pRend, 
			     IHXValues* pInfo)
{
    return HXR_OK;
}

// IHXPersistentRenderer methods
STDMETHODIMP
CRAMRenderer::InitPersistent(UINT32			ulPersistentComponentID,
			     UINT16			uPersistentGroupID,
			     UINT16			uPersistentTrackID,
			     IHXPersistentRenderer*	pPersistentParent)
{
    m_ulPersistentComponentID = ulPersistentComponentID;
    m_uPersistentGroupID = uPersistentGroupID;
    m_uPersistentTrackID = uPersistentTrackID;
    
    m_pPersistentParentRenderer = pPersistentParent;
    HX_ADDREF(m_pPersistentParentRenderer);

    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::GetPersistentID(REF(UINT32) ulPersistentComponentID)
{
    ulPersistentComponentID = m_ulPersistentComponentID;
    return HXR_OK;
}

STDMETHODIMP
CRAMRenderer::GetPersistentProperties(REF(IHXValues*) pProperties)
{
    HX_RESULT	rc = HXR_OK;

    pProperties = new CHXHeader();
    pProperties->AddRef();

    pProperties->SetPropertyULONG32("PersistentType", m_persistentType);
    pProperties->SetPropertyULONG32("PersistentVersion", m_ulPersistentVersion);

    return rc;
}

STDMETHODIMP
CRAMRenderer::GetElementProperties(UINT16	    uGroupID,
				   UINT16	    uTrackID,
                               	   REF(IHXValues*) pProperties)
{
    HX_RESULT		rc = HXR_OK;
    RAMPlayToAssoc*	pPlayToAssoc = NULL;
    ElementWithinTag	elementWithinTag = WithinUnknown;
    
    pProperties = new CHXHeader;
    pProperties->AddRef();

    elementWithinTag = AdjustElementWithinTag(m_elementWithinTag);
    pProperties->SetPropertyULONG32("ElementWithinTag", elementWithinTag);

    pPlayToAssoc = GetPlayToAssoc(uGroupID, uTrackID);
    HX_ASSERT(pPlayToAssoc);

    if (pPlayToAssoc)
    {
	if (pPlayToAssoc->m_ulDelay)
	{
	    pProperties->SetPropertyULONG32("Delay", pPlayToAssoc->m_ulDelay);
	}

	if (pPlayToAssoc->m_ulDuration)
	{	
	    pProperties->SetPropertyULONG32("Duration", pPlayToAssoc->m_ulDuration);
	}
    }

    return HXR_OK;
}
	
STDMETHODIMP
CRAMRenderer::AttachElementLayout(UINT16	uGroupID,
				  UINT16	uTrackID,
				  IHXRenderer*	pRenderer,
				  IHXStream*	pStream,
				  IHXValues*	pProps)
{
    HX_RESULT               rc = HXR_OK;
    UINT32                  ulPersistentType = 0;
    
    if (!pRenderer)
    {
        rc = HXR_FAILED;
        goto cleanup;
    }
    
    if (m_pPersistentParentRenderer)
    {
        rc = m_pPersistentParentRenderer->AttachElementLayout(m_uPersistentGroupID,
                                                              m_uPersistentTrackID,
                                                              pRenderer,
                                                              pStream,
                                                              pProps);
    }
    else if (pProps &&
	     HXR_OK == pProps->GetPropertyULONG32("PersistentType", ulPersistentType))
    {
        // layout site is only needed for the SMIL renderer
        if (PersistentSMIL == ulPersistentType)
        {
            IHXLayoutSiteGroupManager* pLSGMgr = NULL;
            if (HXR_OK == m_pContext->QueryInterface(IID_IHXLayoutSiteGroupManager, (void**)&pLSGMgr))
            {
                rc = pLSGMgr->AddLayoutSiteGroup((IUnknown*)pRenderer);
            }
            HX_RELEASE(pLSGMgr);
        }
    }
    
cleanup:

    return rc;
}

STDMETHODIMP
CRAMRenderer::DetachElementLayout(IUnknown* pLSG)
{
    HX_RESULT rc = HXR_OK;

    if (m_pPersistentParentRenderer)
    {
	rc = m_pPersistentParentRenderer->DetachElementLayout(pLSG);
    }
    else
    {
	IHXLayoutSiteGroupManager* pLSGMgr = NULL;

	if(HXR_OK == m_pContext->QueryInterface(IID_IHXLayoutSiteGroupManager, (void**)&pLSGMgr))
	{
	    rc = pLSGMgr->RemoveLayoutSiteGroup(pLSG);
	}
	HX_RELEASE(pLSGMgr);
    }

    return rc;
}

STDMETHODIMP
CRAMRenderer::GetElementStatus(UINT16		uGroupID,
			       UINT16		uTrackID,
			       UINT32		ulCurrentTime,
			       REF(IHXValues*)	pStatus)
{
    pStatus = NULL;
    return HXR_NOTIMPL;
}
#endif /* HELIX_FEATURE_NESTEDMETA */

HX_RESULT
CRAMRenderer::ProcessRAM(IHXBuffer* pRAMBuffer)
{
    HX_RESULT		rc = HXR_INVALID_METAFILE;    
    UINT16		uTrackID = 0;
    UINT16		uTotalTracks = 0;
    UINT16		uTrackIndex = 0;
    UINT16		uRAMVersion = 0;
    BOOL		bRAMVersionSectionEnded = TRUE;
    int			i = 0; 
    int			j = 0;
    int			iLen = 0;
    int			iSize = 0;
    int			iNumURLs = 0;
    char		szID[128] = {0}; /* Flawfinder: ignore */
    char*		pUrl = NULL; 
    char*		pContent = NULL;
    IHXValidator*	pValidator = NULL;
    IHXGroupManager*	pGroupManager = NULL;
    IHXGroup*		pGroup = NULL;
    IHXGroup2*		pGroup2 = NULL;
    IHXBuffer*		pBuffer = NULL;
    IHXValues*		pGroupProperties = NULL;
    IHXValues*		pTrackProperties = NULL;

    if (HXR_OK != m_pContext->QueryInterface(IID_IHXValidator, (void**)&pValidator) ||
	HXR_OK != m_pContext->QueryInterface(IID_IHXGroupManager, (void**)&pGroupManager))
    {
	rc = HXR_FAILED;
	goto cleanup;
    }

    pContent = (char*) pRAMBuffer->GetBuffer();
    iLen = pRAMBuffer->GetSize();   
    pUrl = new char[iLen + 1];

    while( i <= iLen )
    {		
	pUrl[j] = pContent[i]; 
	
	// Look for line terminators.
	if (pUrl[j] == '\n' || pUrl[j] == '\r' || pUrl[j] == 0 || i == iLen)
	{
	    pUrl[j] = 0;

	    CHXString* pString = new CHXString(pUrl);

	    pString->TrimLeft();
	    pString->TrimRight();

	    iSize = pString->GetLength();
	    if (iSize)
	    {
		memset(pUrl, 0, iLen + 1);
		SafeStrCpy(pUrl,  pString->GetBuffer(iSize), iLen+1);

		// A URL must have at least 4 chars. for protocol. This will
		// take care of lines with junk or just CR on them.
		
		if (strncasecmp(pUrl, HX_RAM30_START_TAG, HX_RAM30_START_TAGSIZE) == 0)
		{
		    uRAMVersion = 3;
		    // no nested version sections allowed
		    if (!bRAMVersionSectionEnded)
		    {
			HX_DELETE(pString);
			rc = HXR_INVALID_METAFILE;
			goto cleanup;
		    }
		    bRAMVersionSectionEnded = FALSE;
		}
		else if (strncasecmp(pUrl, HX_RAM30_END_TAG, HX_RAM30_END_TAGSIZE) == 0)
		{		    
		    HX_DELETE(pString);
		    bRAMVersionSectionEnded = TRUE;
		    break;
		}
		else if (strncasecmp(pUrl, HX_RAM20_START_TAG, HX_RAM20_START_TAGSIZE) == 0)
		{
		    uRAMVersion = 2;		    
		    // no nested version sections allowed
		    if (!bRAMVersionSectionEnded)
		    {
			HX_DELETE(pString);
			rc = HXR_INVALID_METAFILE;
			goto cleanup;
		    }
		    bRAMVersionSectionEnded = FALSE;
		}
		// we mis-documented the use of "## .RAM_V2.0_STOP"
		else if (strncasecmp(pUrl, HX_RAM20_END_TAG, HX_RAM20_END_TAGSIZE) == 0 ||
		         strncasecmp(pUrl, "## .RAM_V2.0_STOP", 21) == 0)
		{
    		    HX_DELETE(pString);
		    bRAMVersionSectionEnded = TRUE;
		    break;
		}
		// handle "--stop--" tag in 6.0
		else if (strncasecmp(pUrl, "--stop--", 8) == 0)
		{
		    HX_DELETE(pString);
		    break;
		}
		else
		{
		    if (uRAMVersion >= 2)
		    {
			// a URL must have at least 4 chars + "##"
			if (strncasecmp(pUrl, HX_RAM_ENTRY_TAG, HX_RAM_ENTRY_TAGSIZE) == 0 && 
			    (iSize >= (HX_RAM_ENTRY_TAGSIZE + 4)))
			{
			    CHXString* pStringAfterTag = new CHXString(pUrl+2);

			    pStringAfterTag->TrimLeft();
			    pStringAfterTag->TrimRight();
    
			    iSize = pStringAfterTag->GetLength();
			    if (iSize)
			    {				
				memset(pUrl, 0, iLen);
				SafeStrCpy(pUrl,  pStringAfterTag->GetBuffer(iSize), iLen+1);
			    }
			    HX_DELETE(pStringAfterTag);
			}