sm1doc.cpp

linux下的一款播放器

	    }
#else
#if defined(PRE_SHAZAM_SMIL_1_0_CODE)
	    IHXGroup* pTempGroup = NULL;
	    if (m_pRepeatIDMap->Lookup(pElement->m_pNode->m_repeatid, (void*&)pTempGroup))
	    {
		IHXGroup2* pTempGroup2 = NULL;

		if (HXR_OK == pTempGroup->QueryInterface(IID_IHXGroup2, (void**)&pTempGroup2))
		{
		    pTempGroup2->AddRepeat(pValues);
		}
		HX_RELEASE(pTempGroup2);
	    }
	    else
#else
	    // /The following was added for SHAZAM since
	    // IHXGroup2's AddRepeatTrack() has been deprecated
	    // in favor of calling IHXTrack's AddTrack():
	    BOOL bRepeatTrackHandled = FALSE;
	    SMIL1PlayToAssoc*    pPlayToAssoc = NULL;
 	    if(m_pPlayToAssocList)
	    {
		CHXSimpleList::Iterator i = m_pPlayToAssocList->Begin();
		for ( ;i!=m_pPlayToAssocList->End()  &&  !bRepeatTrackHandled; ++i)
		{
		    SMIL1PlayToAssoc* pThisAssoc = (SMIL1PlayToAssoc*)(*i);
		    if (pThisAssoc->m_repeatid ==
			    pElement->m_pNode->m_repeatid)
		    {
			IHXGroup2* pGroup2 = NULL;
			IHXTrack*	pHXTrack = NULL;

			if (HXR_OK == pGroup->QueryInterface(IID_IHXGroup2,
				(void**)&pGroup2))
			{
			    if (HXR_OK == pGroup2->GetIHXTrack(
				    pThisAssoc->m_uTrackIndex, pHXTrack)  &&
				    pHXTrack)
			    {
				pHXTrack->AddRepeat(pValues);
				bRepeatTrackHandled = TRUE;
			    }
			    HX_RELEASE(pHXTrack);
			}
			HX_RELEASE(pGroup2);
		    }
		}
	    }
	    if (!bRepeatTrackHandled)
#endif
	    {
		(*m_pRepeatIDMap)[pElement->m_pNode->m_repeatid] = pGroup;
		pGroup->AddTrack(pValues);
	    }
#endif
	    pValues->Release();
	}
    }

    return rc;
}

HX_RESULT
CSmil1DocumentRenderer::handleSourceUpdate(CSmil1SourceUpdate* pElement)
{
    HX_RESULT rc = HXR_OK;

    const char* pID = (const char*)pElement->m_srcID;

    // determine whether this source has been initialized yet...
    SMIL1PlayToAssoc* pPlayToAssoc = 0;
    if(m_pPlayToAssocList)
    {
	CHXSimpleList::Iterator i;
	for(i=m_pPlayToAssocList->Begin();i!=m_pPlayToAssocList->End();++i)
	{
	    SMIL1PlayToAssoc* pThisAssoc = (SMIL1PlayToAssoc*)(*i);
	    if(pThisAssoc->m_id == pID)
	    {
		pPlayToAssoc = pThisAssoc;
		break;
	    }
	}
    }
    if(pPlayToAssoc &&
	pPlayToAssoc->m_sourceMap.GetCount() > 0)
    {
        CSmil1Element* pThisElement = 
	    m_pSmilParser->findElement(pID);
	if(pThisElement->m_ulBeginOffset != (UINT32)-1)
	{
	    if(pElement->m_ulUpdatedDuration > pThisElement->m_ulBeginOffset)
	    {
		updateStreamTiming(pID, pElement->m_ulUpdatedDuration -
		    pThisElement->m_ulBeginOffset);
	    }
	    else
	    {
		updateStreamTiming(pID, 0);
	    }
	}
	else
	{
	    updateStreamTiming(pID, pElement->m_ulUpdatedDuration);
	}
    }
    else
    {
	// stick it into the deferred map,
	// it will be handled in RendererInitialized()
	if(!m_pDeferredSourceMap)
	{
	    m_pDeferredSourceMap = new CHXMapStringToOb;
	}
	
	SMIL1DeferredSourceInfo* pInfo = new SMIL1DeferredSourceInfo;
	pInfo->m_ulDuration = pElement->m_ulUpdatedDuration;
	pInfo->m_ulDelay = 0;
	// /Fixes mem leak when pID is already in the map:
	SMIL1DeferredSourceInfo* pTmpInfo;
	if (m_pDeferredSourceMap->Lookup(pID, (void*&)pTmpInfo))
	{
	    HX_DELETE(pTmpInfo);
	}
	(*m_pDeferredSourceMap)[pID] = pInfo;
    }

    return rc;
}

HX_RESULT
CSmil1DocumentRenderer::handleEndLayout(CSmil1EndLayout* pElement)
{
    return setupRootLayout();
}

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

    IUnknown* pThisUnk = 0;
    if(HXR_OK == QueryInterface(IID_IUnknown, (void**)&pThisUnk))
    {
	m_pParent->HandleAddLayoutSiteGroup(pThisUnk);
	pThisUnk->Release();
	m_bSiteLayoutComplete = TRUE;
    }
    createRegionSites();

    // force initial redraw
    HXxSize siteWinSize;
    if (m_pMISUSSite)
    {
	m_pMISUSSite->GetSize(siteWinSize);
	CHXxRect updateRect(0, 0, siteWinSize.cx, siteWinSize.cy);
	m_pMISUSSite->DamageRect(updateRect);
#ifndef  _WIN32
	m_pMISUSSite->ForceRedraw();
#endif
    }

    return rc;
}

HX_RESULT
CSmil1DocumentRenderer::handleMeta(CSmil1Meta* pElement)
{
    HX_RESULT rc = HXR_OK;

    IHXPlayer* pPlayer = m_pParent->getPlayer();
    IHXGroupManager* pMgr = NULL;
    IHXValues* pValues = NULL;

    if(pElement->m_name.GetLength() > 0)
    {
	if(HXR_OK == pPlayer->QueryInterface(IID_IHXGroupManager, (void**)&pMgr))
	{
	    pValues = pMgr->GetPresentationProperties();
	    if(!pValues)
	    {
		pValues = new CHXOrderedValues;
		pValues->AddRef();
		pMgr->SetPresentationProperties(pValues);
	    }

	    IHXBuffer* pBuf = new CHXBuffer;
	    pBuf->AddRef();
	    pBuf->Set((BYTE*)(const char*)pElement->m_content,
		pElement->m_content.GetLength()+1);
	    pValues->SetPropertyCString((const char*)pElement->m_name,
		pBuf);
	    pBuf->Release();
	    pValues->Release();
	    pMgr->Release();
	}
    }

    return rc;
}

HX_RESULT
CSmil1DocumentRenderer::handleRendererPreFetch(CSmil1RendererPreFetch *pRend)
{
    HX_RESULT rc = HXR_OK;
    const char* pMimeType = (const char*)pRend->m_mimeType;

    IHXRendererUpgrade* pUpgrade = 0;

    if(m_pContext)
    {
	IHXSystemRequired* pISystemRequired = NULL;
	m_pContext->QueryInterface(IID_IHXSystemRequired, 
	    (void**)&pISystemRequired);
	
	CHXBuffer* pBuffer = new CHXBuffer;
	pBuffer->AddRef();
	pBuffer->Set((BYTE*)pMimeType, strlen(pMimeType)+1);
	if (pISystemRequired)
	{
	    IHXUpgradeCollection* pUpgradeCollection = NULL;
	    IHXPlayer* pPlayer = m_pParent->getPlayer();	    
	    if(pPlayer)
		pPlayer->QueryInterface(IID_IHXUpgradeCollection, (void**)&pUpgradeCollection);

	    if(pUpgradeCollection)
	    {
		pUpgradeCollection->Add(eUT_Required, pBuffer, 0, 0);
		// HasFeatures() calls removes all existing features from pUpgradeCollection.
		pISystemRequired->HasFeatures(pUpgradeCollection);
	    }
	    HX_RELEASE(pUpgradeCollection);
	    HX_RELEASE(pISystemRequired);
	}

	HX_RELEASE(pBuffer);
    }

    return rc;
}

HX_RESULT
CSmil1DocumentRenderer::insertEvent(CSmil1ShowSiteEvent* pEvent)
{
    if(!m_pEventList)
    {
	m_pEventList = new CHXSimpleList;
    }

    LISTPOSITION lPos = m_pEventList->GetHeadPosition();
    LISTPOSITION lPrev = lPos;

    BOOL bInserted = FALSE;
    while(lPos)
    {
	CSmil1ShowSiteEvent* pThisEvent = 
	    (CSmil1ShowSiteEvent*)m_pEventList->GetNext(lPos);

	if(pThisEvent->m_ulEventTime == pEvent->m_ulEventTime &&
	    pThisEvent->getRegionSite() == pEvent->getRegionSite())
	{
	    if(pEvent->showSite())
	    {
		if(!lPos)
		{
		    m_pEventList->AddTail(pEvent);
		    bInserted = TRUE;
		    break;
		}

		// find position of last 'hide' event at this time
		while(lPos &&
		    pThisEvent->m_ulEventTime == pEvent->m_ulEventTime &&
		    pThisEvent->getRegionSite() == pEvent->getRegionSite() &&
		    !pThisEvent->showSite())
		{
		    lPrev = lPos;
		    pThisEvent = (CSmil1ShowSiteEvent*)m_pEventList->GetNext(lPos);
		}
	    }

	    m_pEventList->InsertBefore(lPrev, pEvent);
	    bInserted = TRUE;
	    break;
	}
	else if(pThisEvent->m_ulEventTime > pEvent->m_ulEventTime)
	{
	    m_pEventList->InsertBefore(lPrev, pEvent);
	    bInserted = TRUE;
	    break;
	}
	lPrev = lPos;
    }
    if(!bInserted)
    {
	// not inserted, stick it on the end of the list
	m_pEventList->AddTail(pEvent);
    }

    // set list position member
    m_ulEventListPosition = m_pEventList->GetHeadPosition();

    return HXR_OK;
}

CSmil1ShowSiteEvent* 
CSmil1DocumentRenderer::getShowHideEvent(IHXSite*  pRegionSite,
					 IHXSite*  pRendererSite,
                                         BOOL	    bShowEvent)
{
    CSmil1ShowSiteEvent* pRet = NULL;

    if (m_pEventList && pRegionSite)
    {
        LISTPOSITION pos = m_pEventList->GetHeadPosition();
        while (pos)
        {
            CSmil1ShowSiteEvent* pEvent = (CSmil1ShowSiteEvent*) m_pEventList->GetNext(pos);
            if (pEvent)
            {
                if (pEvent->showSite() == bShowEvent	    &&
		    pEvent->getRegionSite() == pRegionSite  &&
		    pEvent->getRendererSite() == pRendererSite)
                {
                    pRet = pEvent;
                    break;
                }
            }
        }
    }

    return pRet;
}

HX_RESULT
CSmil1DocumentRenderer::insertSiteInfo(void* pVoidInfo)
{
    if(!m_pSiteInfoList)
    {
	m_pSiteInfoList = new CHXSimpleList;
    }

    SMIL1SiteInfo* pInfo = (SMIL1SiteInfo*)pVoidInfo;

    LISTPOSITION lPos = m_pSiteInfoList->GetHeadPosition();
    LISTPOSITION lPrev = lPos;

    BOOL bInserted = FALSE;
    while(lPos)
    {
	SMIL1SiteInfo* pThisInfo = 
	    (SMIL1SiteInfo*)m_pSiteInfoList->GetNext(lPos);

	if(pThisInfo->m_ulDelay > pInfo->m_ulDelay)
	{
	    m_pSiteInfoList->InsertBefore(lPrev, pInfo);
	    bInserted = TRUE;
	    break;
	}
	lPrev = lPos;
    }
    if(!bInserted)
    {
	// not inserted, stick it on the end of the list
	m_pSiteInfoList->AddTail(pInfo);
    }

    return HXR_OK;
}


void
CSmil1DocumentRenderer::resizeSite(IHXSite* pSite,
				  double dXScale,
				  double dYScale)
{
    if (!pSite)
    {
	return;
    }

    HXxSize oldChildSize;
    HXxPoint oldChildPosition;
    pSite->GetSize(oldChildSize);
    pSite->GetPosition(oldChildPosition);
    HXxSize newChildSize;
    HXxPoint newChildPosition;
    newChildSize.cx = (INT32)(dXScale * (double)(oldChildSize.cx) + 0.5);
    newChildSize.cy = (INT32)(dYScale * (double)(oldChildSize.cy) + 0.5);
    newChildPosition.x = (INT32)(dXScale*(double)(oldChildPosition.x) + 0.5);
    newChildPosition.y = (INT32)(dYScale*(double)(oldChildPosition.y) + 0.5);

    CSmil1SiteWatcher* pSiteWatcher = NULL;
    if(m_pSiteWatcherMap && m_pSiteWatcherMap->Lookup(pSite, (void*&)pSiteWatcher))
    {
	pSiteWatcher->SiteChangingSize(TRUE);
//        char szDbgStr[128];
//        DEBUGPRINTF(szDbgStr, "(%ld,%ld) ", newChildSize.cx, newChildSize.cy);
	pSite->SetSize(newChildSize);
	pSiteWatcher->SiteChangingSize(FALSE);
    }
    else
    {
//        char szDbgStr[128];
//        DEBUGPRINTF(szDbgStr, "(%ld,%ld) ", newChildSize.cx, newChildSize.cy);
	pSite->SetSize(newChildSize);
    }
//    char szDbgStr[128];
//    DEBUGPRINTF(szDbgStr, "repos to (%ld,%ld)\n", newChildPosition.x, newChildPosition.y);
    pSite->SetPosition(newChildPosition);

    CHXxRect updateRect(0, 0, newChildSize.cx, newChildSize.cy);
    pSite->DamageRect(updateRect);
#ifndef  _WIN32
    pSite->ForceRedraw();
#endif
}

void CSmil1DocumentRenderer::resizeRegionSiteAbs(CSmil1BasicRegion* pRegion,
                                                double            dXAbsScale,
                                                double            dYAbsScale)
{
    if (pRegion && pRegion->m_pSite)
    {
        HXxSize  cSize = {0, 0};
        HXxPoint cPos  = {0, 0};
        cPos.x         = (INT32) floor(dXAbsScale * ((double) pRegion->m_originalRect.left) + 0.5);
        cPos.y         = (INT32) floor(dYAbsScale * ((double) pRegion->m_originalRect.top)  + 0.5);
        cSize.cx       = (INT32) floor(dXAbsScale * ((double) HXxRECT_WIDTH(pRegion->m_originalRect)) + 0.5);
        cSize.cy       = (INT32) floor(dYAbsScale * ((double) HXxRECT_HEIGHT(pRegion->m_originalRect)) + 0.5);

        CSmil1SiteWatcher* pSiteWatcher = NULL;
        if(m_pSiteWatcherMap && m_pSiteWatcherMap->Lookup(pRegion->m_pSite, (void*&)pSiteWatcher))
        {
	    pSiteWatcher->SiteChangingSize(TRUE);
//            char szDbgStr[128];
//            DEBUGPRINTF(szDbgStr, "(%ld,%ld) ", cSize.cx, cSize.cy);
	    pRegion->m_pSite->SetSize(cSize);
	    pSiteWatcher->SiteChangingSize(FALSE);
        }
        else
        {
//            char szDbgStr[128];
//            DEBUGPRINTF(szDbgStr, "(%ld,%ld) ", cSize.cx, cSize.cy);
	    pRegion->m_pSite->SetSize(cSize);
        }
//        char szDbgStr[128];
//        DEBUGPRINTF(szDbgStr, "repos to (%ld,%ld)\n", cPos.x, cPos.y);
        pRegion->m_pSite->SetPosition(cPos);

        pRegion->m_rect.left   = cPos.x;
        pRegion->m_rect.top    = cPos.y;
        pRegion->m_rect.right  = cPos.x + cSize.cx;
        pRegion->m_rect.bottom = cPos.y + cSize.cy;

        CHXxRect updateRect(0, 0, cSize.cx, cSize.cy);
        pRegion->m_pSite->DamageRect(updateRect);
#ifndef  _WIN32
        pRegion->m_pSite->ForceRedraw();
#endif
    }
}

void
CSmil1DocumentRenderer::resizeSite(HXxSize newSize)
{
    double dXScale = 1.0;
    double dYScale = 1.0;

    if(newSize.cx       > 0 &&
       newSize.cy       > 0 &&
       m_topSiteSize.cx > 0 &&
       m_topSiteSize.cy > 0)
    {
	dXScale = (double)newSize.cx / (double)m_topSiteSize.cx;
	dYScale = (double)newSize.cy / (double)m_topSiteSize.cy;
    }

    double dXAbsScale = 1.0;
    double dYAbsScale = 1.0;
    if (m_topSiteOriginalSize.cx > 0 &&
        m_topSiteOriginalSize.cy > 0)
    {
        dXAbsScale = (double) newSize.cx / (double) m_topSiteOriginalSize.cx;
        dYAbsScale = (double) newSize.cy / (double) m_topSiteOriginalSize.cy;
    }

    m_topSiteSize.cx = newSize.cx;
    m_topSiteSize.cy = newSize.cy;

    BOOL bSetOriginalSize = FALSE;
    if(m_topSiteSize.cx == m_topSiteOriginalSize.cx &&
	m_topSiteSize.cy == m_topSiteOriginalSize.cy)