sm1doc.cpp

linux下的一款播放器

	    m_bShowDependencies = (BOOL)atol((const char*)pBuf->GetBuffer());
	    HX_RELEASE(pBuf);
	}
	pPrefs->Release();
    }
    if(m_bShowDependencies)
    {
	// mark file boundary
	FILE* fp = fopen(SMILDEPFILE, "a");
	if(fp)
	{
    	    fprintf(fp, "===========================\n");
	    fclose(fp);
	}
    }
#endif
}

CSmil1DocumentRenderer::~CSmil1DocumentRenderer()
{
#if defined(_DEBUG) && defined(XXXMEH_CHECK_FOR_LEAKS)
    char szDbgStr[128]; /* Flawfinder: ignore */
    sprintf(szDbgStr, "DES CSmil1DocumentRenderer 0x%08x\n", this); /* Flawfinder: ignore */
    OutputDebugString(szDbgStr);
#endif
    HX_RELEASE(m_pSiteMgr);

#if defined(_UNIX)  &&  (!defined(_BEOS))  &&  defined(USE_XWINDOWS)
    CHXMapPtrToPtr::Iterator i = m_siteToXDataMap.Begin();
    for(; i != m_siteToXDataMap.End(); ++i)
    {
        XData* xData = (XData*)(*i);
	delete xData;
    }

    if (m_pVisualInfo)
    {
	XFree(m_pVisualInfo);
	m_pVisualInfo = NULL;
    }

    if (m_pDisplay && m_hHyperlinkCursor)
    {
	XFreeCursor(m_pDisplay, m_hHyperlinkCursor);
	m_hHyperlinkCursor = 0;
    }
#endif    
#if defined(_MACINTOSH)
    if (m_hHyperlinkCursor)
    {
    	m_pResourceLoader->UnloadResource((Handle)m_hHyperlinkCursor);
    	m_hHyperlinkCursor = NULL;
    	
    	HX_RELEASE(m_pResourceLoader);
    }

    if (m_bResetCursor)
    {
	::InitCursor();
    }
#endif
}

/*
 * IUnknown methods
 */
STDMETHODIMP
CSmil1DocumentRenderer::QueryInterface(REFIID riid, void** ppvObj)
{
    if(IsEqualIID(riid, IID_IUnknown))
    {
	AddRef();
	*ppvObj = this;
	return HXR_OK;
    }
    else if(IsEqualIID(riid, IID_IHXValues))
    {
	AddRef();
	*ppvObj = (IHXValues*)this;
	return HXR_OK;
    }
    else if(IsEqualIID(riid, IID_IHXSiteUser))
    {
	AddRef();
	*ppvObj = (IHXSiteUser*)this;
	return HXR_OK;
    }
    else if(IsEqualIID(riid, IID_IHXRendererAdviseSink))
    {
	AddRef();
	*ppvObj = (IHXRendererAdviseSink*)this;
	return HXR_OK;
    }
    else if(IsEqualIID(riid, IID_IHXGroupSink))
    {
	AddRef();
	*ppvObj = (IHXGroupSink*)this;
	return HXR_OK;
    }
    *ppvObj = NULL;
    return HXR_NOINTERFACE;
}

STDMETHODIMP_(ULONG32)
CSmil1DocumentRenderer::AddRef()
{
    return InterlockedIncrement(&m_lRefCount);
}

STDMETHODIMP_(ULONG32)
CSmil1DocumentRenderer::Release()
{
    if(InterlockedDecrement(&m_lRefCount) > 0)
    {
	return m_lRefCount;
    }

    delete this;
    return 0;
}

HX_RESULT
CSmil1DocumentRenderer::close(CSmil1Renderer* pParent)
{
    if (m_pProcessElementCallback)
    {
	if (m_pScheduler && m_pProcessElementCallback->m_bIsCallbackPending)
	{
    	    m_pProcessElementCallback->m_bIsCallbackPending = FALSE;
	    m_pScheduler->Remove(m_pProcessElementCallback->m_PendingHandle);
	    m_pProcessElementCallback->m_PendingHandle = 0;
	}
	HX_RELEASE(m_pProcessElementCallback);
    }

    IUnknown* pThisUnk = 0;
    if(HXR_OK == QueryInterface(IID_IUnknown, (void**)&pThisUnk))
    {
	pParent->HandleRemoveLayoutSiteGroup(pThisUnk);
	pThisUnk->Release();
    }

    if(m_pEventList)
    {
	CHXSimpleList::Iterator i = m_pEventList->Begin();
	for(; i != m_pEventList->End(); ++i)
	{
	    CSmil1LayoutEvent* pEvent = (CSmil1LayoutEvent*)(*i);
	    delete pEvent;
	}
    }
    HX_DELETE(m_pEventList);

    removeAllPlayToAssoc();

    if (m_bSitesDetached)
    {
        if(m_pRegionMap)
        {
	    CHXMapStringToOb::Iterator i = m_pRegionMap->Begin();
	    for(; i != m_pRegionMap->End(); ++i)
	    {
	        CSmil1BasicRegion* pRegion = (CSmil1BasicRegion*)(*i);
	        delete pRegion;
	    }
        }
        HX_DELETE(m_pRegionMap);
    }

    if(m_pGroupInfoMap)
    {
	CHXMapLongToObj::Iterator i = m_pGroupInfoMap->Begin();
	for(; i != m_pGroupInfoMap->End(); ++i)
	{
	    SMIL1GroupInfo* pGroupInfo = (SMIL1GroupInfo*)(*i);
	    delete pGroupInfo;
	}
    }
    HX_DELETE(m_pGroupInfoMap);

    if(m_pDeferredSourceMap)
    {
	CHXMapStringToOb::Iterator i = m_pDeferredSourceMap->Begin();
	for(; i != m_pDeferredSourceMap->End(); ++i)
	{
	    SMIL1DeferredSourceInfo* pInfo = (SMIL1DeferredSourceInfo*)(*i);
	    delete pInfo;
	}
    }
    HX_DELETE(m_pDeferredSourceMap);

    HX_DELETE(m_pRepeatIDMap);

    if (m_bSitesDetached)
    {
        if(m_pSiteInfoList)
        {
	    CHXSimpleList::Iterator i = m_pSiteInfoList->Begin();
	    for(; i != m_pSiteInfoList->End(); ++i)
	    {
	        SMIL1SiteInfo* pSiteInfo = (SMIL1SiteInfo*)(*i);
	        delete pSiteInfo;
	    }
        }
        HX_DELETE(m_pSiteInfoList);
    }

    if(m_pStatusMessage)
    {
	m_pStatusMessage->SetStatus(NULL);
    }
    HX_RELEASE(m_pStatusMessage);

    if (m_bSitesDetached)
    {
        HX_DELETE(m_pSiteInfoByRendererMap);
    }

    if (m_bSitesDetached)
    {
        if(m_pSiteWatcherMap)
        {
	    CHXMapPtrToPtr::Iterator i= m_pSiteWatcherMap->Begin();
	    for(; i != m_pSiteWatcherMap->End(); ++i)
	    {
	        CSmil1SiteWatcher* pSiteWatcher = (CSmil1SiteWatcher*)(*i);
	        pSiteWatcher->Release();
	    }
	    HX_DELETE(m_pSiteWatcherMap);
        }
    }

    HX_RELEASE(m_pValues);
    HX_DELETE(m_pSmilParser);
    HX_VECTOR_DELETE(m_pFragment);
    HX_RELEASE(m_pScheduler);
    HX_RELEASE(m_pContext);

#ifdef _MACINTOSH
    if (m_bResetCursor)
    {
	m_bResetCursor = FALSE;
	::InitCursor();
    }
#endif

    m_bCloseCalled = TRUE;

    return HXR_OK;
}

HX_RESULT
CSmil1DocumentRenderer::onHeader(IHXValues* pHeader)
{
    m_pValues = new CHXHeader;
    m_pValues->AddRef();
    m_pRegionMap = new CHXMapStringToOb;
    m_pSiteInfoByRendererMap = new CHXMapPtrToPtr;
 
    if (m_pPersistentParentRenderer &&
	HXR_OK == m_pPersistentParentRenderer->GetElementProperties(m_uPersistentGroupID,
								    m_uPersistentTrackID,
								    m_pPersistentProperties))
    {
	m_pPersistentProperties->GetPropertyULONG32("ElementWithinTag", (UINT32&)m_elementWithinTag);
    }
    
    IHXBuffer* pBuffer = 0;
    IHXCommonClassFactory* pFactory = m_pParent->getFactory();
    if(HXR_OK == pFactory->CreateInstance(CLSID_IHXBuffer,
	(void**)&pBuffer))
    {
	pBuffer->Set((const BYTE*)"TopLevelSite", strlen("TopLevelSite")+1);
	SetPropertyCString("name", pBuffer);
	SetPropertyULONG32("GroupIndex", m_uPersistentGroupID);
	SetPropertyULONG32("TrackIndex", m_uPersistentTrackID);
	pBuffer->Release();
    }

    m_pSmilParser = new CSmil1Parser(m_pContext);
    m_pSmilParser->init();
    m_pSmilParser->InitPersistent(m_ulPersistentComponentID, m_elementWithinTag);

    return HXR_OK;
}

HX_RESULT
CSmil1DocumentRenderer::getErrorInfo(REF(UINT32) ulLineNumber,
				    REF(UINT32) ulColumnNumber,
				    REF(IHXBuffer*) pErrorText)
{
    ulLineNumber = m_pSmilParser->m_ulErrorLineNumber;
    ulColumnNumber = m_pSmilParser->m_ulErrorColumnNumber;
    pErrorText = m_pSmilParser->m_pErrorText;
    if(pErrorText)
    {
	pErrorText->AddRef();
    }

    return HXR_OK;
}

HX_RESULT
CSmil1DocumentRenderer::onPacket(IHXBuffer* pBuffer, BOOL bIsLast)
{
    HX_RESULT rc = HXR_OK;

    BOOL bDumpToFile = FALSE;
    getBooleanPreference(m_pContext,
                         "NonObviousKeyNameVer1",
                         bDumpToFile);
    BOOL bShowPacketBoundaries = FALSE;
    getBooleanPreference(m_pContext,
                         "NonObviousKeyNameVer1Option1",
                         bShowPacketBoundaries);
    if (bDumpToFile)
    {
#ifdef _WINDOWS
        const char* pszFile = "c:\\smil1dump.txt";
#else
        const char* pszFile = "smil1dump.txt";
#endif
        FILE* pFoo = fopen(pszFile, m_ulPktnum > 0L ? "a" : "w");
        if (pFoo)
        {
            char* pBuf = (char*) pBuffer->GetBuffer();
            if(pBuf && strlen(pBuf) > 0)
            {
                if (bShowPacketBoundaries)
                {
                    fprintf(pFoo, "[[[packet # %lu]]]:{{{", m_ulPktnum);
                }
                fwrite(pBuf, 1, pBuffer->GetSize(), pFoo);
                if (bShowPacketBoundaries)
                {
                    fprintf(pFoo, "}}}\n");
                }
            }
            else
            {
                if (bShowPacketBoundaries)
                {
                    fprintf(pFoo, "\n[[[Packet %lu empty in onPacket()]]]\n",
                            m_ulPktnum);
                }
            }
        }
        fclose(pFoo);
        if (bIsLast)
            m_ulPktnum = 0L;
        else
            m_ulPktnum++;
    }
    rc = m_pSmilParser->parse(pBuffer, bIsLast);

    return rc;
}

HX_RESULT
CSmil1DocumentRenderer::setDocument(const char* pFragment)
{
    HX_RESULT rc = m_pSmilParser->createElements();
    if(HXR_OK == rc)
    {
	rc = handleElements();
	IHXPlayer* pPlayer = m_pParent->getPlayer();
	IHXGroupManager* pMgr = 0;

	if(HXR_OK == pPlayer->QueryInterface(IID_IHXGroupManager, (void**)&pMgr))
	{
	    if(pFragment)
	    {
		m_pFragment = new_string(pFragment);
		m_bSettingFragment = TRUE;
    	    	m_nFragmentTracks = 0;
		UINT16 uFragmentGroup = 
		    m_pSmilParser->getFragmentGroup(m_pFragment);
		pMgr->SetCurrentGroup(uFragmentGroup);
	    }
	    // /Adding the "else" around this fixes PR 75814; without this,
	    // the code was ignoring the uFragmentGroup set already, above,
	    // and thus "foo.smil#fragmentInHighGroup" links stopped working
	    // in the RealOne Player:
	    else
	    {
		if (m_pParent->m_bUseNestedMeta && !m_bLastGroupInRAM20 && m_uCurrentGroupIndex == -1)
		{
		    pMgr->GetCurrentGroup((UINT16&)m_uCurrentGroupIndex);
		}
		else
		{
		    pMgr->SetCurrentGroup(0);
		}
	    }
	    pMgr->Release();
	}
    }

    return rc;
}

HX_RESULT
CSmil1DocumentRenderer::handleElements()
{
    HX_RESULT rc = HXR_OK;

    if(m_pSmilParser)
    {
	//if(m_ulParseResult != HXR_STREAM_DONE)
	//{
	    while(HXR_OK == rc)
	    {
		rc = m_pSmilParser->handleNextElement(this);
	    }
	    m_ulParseResult = rc;
	//}
    }

    return HXR_OK;
}

HX_RESULT
CSmil1DocumentRenderer::parseDimension(const char* pDimensionString,
				      REF(UINT32) ulValue,
				      REF(BOOL) bIsPercent)
{
    HX_RESULT rc = HXR_OK;

    if(!pDimensionString || strlen(pDimensionString) == 0)
    {
	ulValue = 0L;
	//[SMIL 1.0 compliance] Helps fix PR 16542.  The caller of this
	// function should look at this return value to determine whether
	// or not the string was empty (and thus 0 is returned in ulValue) or
	// whether "0" or "0%" IS the string (and thus 0 is returned in
	// ulValue along with HXR_OK):
	rc = HXR_FAIL;
    }
    else
    {
	char* pEndPtr = 0;
	ulValue = (UINT32)strtod(pDimensionString, &pEndPtr);
	if(pEndPtr && strcmp(pEndPtr, "%") == 0)
	{
	    bIsPercent = TRUE;
	}
	else
	{
	    bIsPercent = FALSE;
	}
    }
    return rc;
}

HX_RESULT
CSmil1DocumentRenderer::regionToRect(CSmil1Region* pElement, 
    HXxRect* pRect, BOOL& bWidthUnspecified, BOOL& bHeightUnspecified)
{
    HX_RESULT rc = HXR_OK;

    bWidthUnspecified = bHeightUnspecified = FALSE;

    UINT32 ulTop = 0;
    UINT32 ulLeft = 0;
    UINT32 ulWidth = 0;
    UINT32 ulHeight = 0;
    BOOL bTopIsPercent = FALSE;
    BOOL bLeftIsPercent = FALSE;
    BOOL bWidthIsPercent = FALSE;
    BOOL bHeightIsPercent = FALSE;

    parseDimension(pElement->m_left, ulLeft, bLeftIsPercent);
    parseDimension(pElement->m_top, ulTop, bTopIsPercent);
    HX_RESULT rsltW =
	    parseDimension(pElement->m_width, ulWidth, bWidthIsPercent);
    HX_RESULT rsltH =
	    parseDimension(pElement->m_height, ulHeight, bHeightIsPercent);

    /* check for valid region constraints */
    BOOL bRegionError = FALSE;
    char errorBuf[256]; /* Flawfinder: ignore */
    //[SMIL 1.0 compliance] helps fix PR 24630; separate width & height logic
    if((!m_bRootLayoutWidthSet && 
	    (bLeftIsPercent  ||  bWidthIsPercent))  ||
	    (!m_bRootLayoutHeightSet && 
	    (bTopIsPercent  ||  bHeightIsPercent)) )
    {
	//XXXE: needs err msg: "Region can't use % without root-layout"
	rc = HXR_FAIL;
	SafeSprintf(errorBuf, 256, "region %s",
	    (const char*)pElement->m_pNode->m_id);
	CSmil1SMILSyntaxErrorHandler errHandler(m_pContext);
	errHandler.ReportError(SMILErrorBadAttribute, errorBuf, 0);