smlrendr.cpp

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

    IHXPersistentRenderer* pPersistentParentRenderer = NULL;

    pPersistentParentRenderer = m_pSmilDocRenderer->m_pPersistentParentRenderer;

    // nested meta, remove layout from its parent
    if (pPersistentParentRenderer)
    {
	rc = pPersistentParentRenderer->DetachElementLayout(pLSG);
    }
    else if (m_pPlayer)
    {
	IHXLayoutSiteGroupManager* pLSGMgr = 0;
	if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXLayoutSiteGroupManager, (void**)&pLSGMgr))
	{
	    rc = pLSGMgr->RemoveLayoutSiteGroup(pLSG);
	    pLSGMgr->Release();
	}
    }
    return rc;
}

HX_RESULT
CSmilRenderer::HandleAttachElementLayout(IUnknown* pLSG, IHXValues* pProps)
{
    HX_RESULT	rc = HXR_OK;

    if (m_pPersistentComponentManager)
    {
	rc = m_pPersistentComponentManager->AttachPersistentComponentLayout(pLSG, pProps);
    }

    return rc;
}

HX_RESULT
CSmilRenderer::handleSMILDocumentPacket(CSmilDocumentPacket* pPacket)
{
    HX_RESULT rc = HXR_OK;

    if(pPacket->m_version == RMA_DRIVER_VERSION)
    {
	CHXBuffer* pBuffer = new CHXBuffer;
	pBuffer->AddRef();
	BOOL bLastPacket = FALSE;
	UINT32 ulDocLen = (UINT32)pPacket->m_document.GetLength();
	HX_ASSERT(ulDocLen);
	// /Extra safety check:
	if (0 == ulDocLen)
	{
	    rc = HXR_UNEXPECTED;
	    bLastPacket = FALSE;
	}
	else
	{
	    pBuffer->Set((const BYTE*)(const char*)pPacket->m_document,
		    pPacket->m_document.GetLength());
	    m_ulTotalSMILPackets++;
	    bLastPacket = pPacket->m_ulTotalPackets == m_ulTotalSMILPackets;
	    rc = m_pSmilDocRenderer->onPacket(pBuffer, bLastPacket);

	    const char* pPktContents = (const char*)pPacket->m_document;
	    while (pPktContents)
	    {
		// /See if there is a <metadata> tag; if so, add it and all
		// the rest of the text up to </metadata> to m_metadata:
		// /XXXEH- TODO: make sure we're not inside a <!--comment-->!:
		// Note, however, that comments are being stripped by the
		// file format, so we need only do this if the ff changes
		// in this respect.
		char* pMetadataTag =
			(char*)strstr(pPktContents, "<metadata");
		char* pMetadataEndTag =
			(char*)strstr(pPktContents, "</metadata");
		char* pVeryEndOfTag = pMetadataEndTag != NULL ?
		    (char*)strchr(pMetadataEndTag, '>') : NULL;
		if (m_bInMetadata)
		{
		    m_bInMetadata = (NULL == pMetadataEndTag);
		    // /Concatinate all the stuff up to the end tag; if there's
		    // no end tag, then concatinate the whole packet:
		    if (NULL != pMetadataEndTag)
		    {
			if (strlen(pVeryEndOfTag) > 1)
			{
			    char savedChar = pVeryEndOfTag[1];
			    pVeryEndOfTag[1] = NULL;
			    m_pSmilDocRenderer->m_metadata += pPktContents;
			    pVeryEndOfTag[1] = savedChar;
			}
		    }
		    else
		    {
			m_pSmilDocRenderer->m_metadata += pPktContents;
		    }
		}
		if (pMetadataTag)
		{
		    HX_ASSERT(!m_bInMetadata);
		    // /In case there is another end tag (multiple metadata tags):
		    if (pMetadataTag > pMetadataEndTag  &&  NULL != pMetadataEndTag)
		    {
			pMetadataEndTag = pVeryEndOfTag != NULL?
				strstr(pVeryEndOfTag, "</metadata") : NULL;
			pVeryEndOfTag = pMetadataEndTag!=NULL?
				strchr(pMetadataEndTag, '>') : NULL;
		    }
		    // /Concatinate all the stuff up to the end tag; if there's
		    // no end tag, then concatinate the whole packet:
		    if (NULL != pMetadataEndTag)
		    {
			char* pVeryEndOfTag = strchr(pMetadataEndTag, '>');
			if (strlen(pVeryEndOfTag) > 1)
			{
			    char savedChar = pVeryEndOfTag[1];
			    pVeryEndOfTag[1] = NULL;
			    m_pSmilDocRenderer->m_metadata += pMetadataTag;
			    pVeryEndOfTag[1] = savedChar;
			}
		    }
		    else
		    {
			m_bInMetadata = TRUE;
			m_pSmilDocRenderer->m_metadata += pMetadataTag;
		    }
		}
		pPktContents = (const char*)pVeryEndOfTag;
	    }

	    // /See if the <smil ...> tag had a default namespace declared
	    // in it; if so, see if we recognize it.  If there is none or
	    // if we don't recognize it, try an auto upgrade:
	    BOOL bDefaultNamespaceRecognized = FALSE;
	    const char* pDefaultNamespace =
		    m_pSmilDocRenderer->getDefaultNamespace();
	    if (pDefaultNamespace  &&  strlen(pDefaultNamespace)>0)
	    {
		UINT32 ui=0;
		for (ui = 0; ui < NUM_RECOGNIZED_DEFAULT_NAMESPACES; ui++)
		{
		    if (0 == strcmp(
			    (const char*) zm_pRecognizedDefaultNamespaces[ui],
			    pDefaultNamespace) )
		    {
			bDefaultNamespaceRecognized = TRUE;
			break;
		    }
		}
	    }
	    else
	    {
#if defined(HANDLE_BETA1_SMIL_1_0_STREAM)  || defined(HANDLE_SMIL_1_0_STREAM)
		bDefaultNamespaceRecognized = TRUE;
#else
		// /No-default-namespace files go to the old renderer so we should
		// never encounter this condition:
		HX_ASSERT(m_pSmilDocRenderer->m_pSmilParser->m_pDefaultNamespace);
#endif
	    }
	    if (!bDefaultNamespaceRecognized)
	    {
		// /We need to auto upgrade if we don't recognize the default
		// namespace.  This can occur under the following conditions
		// (but can not occur if there is no default namespace because
		// those files will all go to the old SMIL 1.0 renderer); note
		// that each of these conditions is a good basis for an AU request
		// except that (3) would best serve our customers if they were
		// notified of the exact reason for the AU request before it
		// happened.
		// /XXXEH- talk to Consumer Group about AU request dialog boxes
		// showing more info.
		// (1) SMIL 3.0 or higher namespace is specified (or whatever
		//     version of SMIL was undefined at the time this renderer was
		//     compiled).
		// (2) Some proprietary namespace that might be handled by some
		//     non-RealNetworks plug-in (or by another RN SMIL renderer).
		// (3) if someone misspells the default namespace that this renderer
		//     otherwise would recognize.
		HX_ASSERT(1);
		IHXUpgradeCollection* pUpColl = NULL;

		if(m_pPlayer &&
		   (HXR_OK == m_pPlayer->QueryInterface(IID_IHXUpgradeCollection,
			(void**)&pUpColl)))
		{
		    CHXBuffer* pBuffer = new CHXBuffer;
		    pBuffer->AddRef();
		    pBuffer->SetSize(strlen(SMIL20_AND_UP_STREAM_MIME_TYPE) +
			    strlen(pDefaultNamespace) + 1 + 1);
		    char* pBuf = (char*)pBuffer->GetBuffer();
		    strcpy(pBuf, SMIL20_AND_UP_STREAM_MIME_TYPE); /* Flawfinder: ignore */
		    strcat(pBuf, "."); /* Flawfinder: ignore */
		    strcat(pBuf, pDefaultNamespace); /* Flawfinder: ignore */
		    pUpColl->Add(eUT_Required, pBuffer, 0, 0);
		    HX_RELEASE(pBuffer);
		    HX_RELEASE(pUpColl);
		}

		return HXR_FAIL;
	    }
	}
	HX_RELEASE(pBuffer);

	if(HXR_OK != rc)
	{
	    // XML parsing error
	    UINT32 ulLineNumber = 0;
	    UINT32 ulColumnNumber = 0;
	    IHXBuffer* pErrorText = NULL;
	    m_pSmilDocRenderer->getErrorInfo(ulLineNumber,
		ulColumnNumber, pErrorText);

	    const char* pActualErrorText = NULL;
	    if(pErrorText)
	    {
		pActualErrorText = (const char*)pErrorText->GetBuffer();
	    }
	    CSmilXMLSyntaxErrorHandler errHandler(m_pContext);
	    errHandler.ReportError(rc, pActualErrorText, ulLineNumber);
	    HX_RELEASE(pErrorText);
	}
	else if(bLastPacket)
	{
	    HX_ASSERT(!m_bInMetadata);
	    m_bInMetadata = FALSE;
	    //[SMIL 1.0 compliance] Handle error from setDocument()
	    // otherwise it "plays" (nothing for 20 seconds) when it
	    // should halt under error conditions:
	    rc = m_pSmilDocRenderer->setDocument(m_pURLFragment);
	}
    }
    return rc;
}

void
CSmilRenderer::generatePreFix()
{
    // get the protocol/server for later...
    IHXStreamSource* pSource = 0;
    m_pStream->GetSource(pSource);
    HX_ASSERT(pSource);
    if (!pSource)
    {
	return;
    }

    const char* pURL = pSource->GetURL();
    HX_ASSERT(pURL);
    
    if (!pURL)
    {
	return;
    }

    CHXURL::GeneratePrefixRootFragment(pURL, m_urlPrefix, m_urlRoot, m_pURLFragment);
    HX_RELEASE(pSource);

    return;
}

HX_RESULT
CSmilRenderer::SmilDocTrackDurationSet(UINT32 ulGroupIndex,
	UINT32 ulTrackIndex, UINT32 ulDuration, UINT32 ulDelay, BOOL bIsLive)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->TrackDurationSet(ulGroupIndex, ulTrackIndex,
		ulDuration, ulDelay, bIsLive);
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocRepeatedTrackDurationSet(const char* pID,
	UINT32 ulDuration, BOOL bIsLive)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->RepeatedTrackDurationSet(pID, ulDuration,
		bIsLive);
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocTrackUpdated(UINT32 ulGroupIndex, UINT32 ulTrackIndex,
	IHXValues* pValues)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->TrackUpdated(ulGroupIndex, ulTrackIndex, pValues);
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocRendererInitialized(IHXRenderer* pRend,
	IUnknown* pStream, IHXValues* pInfo)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->RendererInitialized(pRend, pStream, pInfo);
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocRendererClosed(IHXRenderer* pRend, IHXValues* pInfo)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->RendererClosed(pRend, pInfo);
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocGroupAdded(UINT16 uGroupIndex, IHXGroup* pGroup)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->GroupAdded(uGroupIndex, pGroup);
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocGroupRemoved(UINT16 uGroupIndex, IHXGroup* pGroup)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->GroupRemoved(uGroupIndex, pGroup);
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocAllGroupsRemoved()
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->AllGroupsRemoved();
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocTrackAdded(UINT16 uGroupIndex, UINT16 uTrackIndex,
	IHXValues* pTrack)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->TrackAdded(uGroupIndex, uTrackIndex, pTrack);
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocTrackRemoved(UINT16 uGroupIndex, UINT16 uTrackIndex,
	IHXValues* pTrack)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->TrackRemoved(uGroupIndex, uTrackIndex, pTrack);
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocTrackStarted(UINT16 uGroupIndex, UINT16 uTrackIndex,
	    IHXValues* pTrack)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->TrackStarted(uGroupIndex, uTrackIndex, pTrack);
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocTrackStopped(UINT16 uGroupIndex, UINT16 uTrackIndex,
	IHXValues* pTrack)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->TrackStopped(uGroupIndex, uTrackIndex, pTrack);
    }
    return rc;
}

HX_RESULT
CSmilRenderer::SmilDocCurrentGroupSet(UINT16 uGroupIndex, IHXGroup* pGroup)
{
    HX_RESULT rc = HXR_FAIL;
    if (m_pSmilDocRenderer)
    {
	rc = m_pSmilDocRenderer->CurrentGroupSet(uGroupIndex, pGroup);
    }
    return rc;
}