advgroup.cpp

linux下的一款播放器

    if (HXR_OK != rc)
    {
	goto cleanup;
    }

    if (!m_pPrefetchTrackMap)
    {
	m_pPrefetchTrackMap = new CHXMapLongToObj;
    }

    (*m_pPrefetchTrackMap)[uPrefetchIndex] = pTrack;
    pTrack->AddRef();

    m_uPrefetchTrackCount++;

    if (m_pPrefetchSinkList)
    {
	CHXSimpleList::Iterator ndx = m_pPrefetchSinkList->Begin();
	for (; ndx != m_pPrefetchSinkList->End(); ++ndx)
	{
	    IHXPrefetchSink* pPrefetchSink = (IHXPrefetchSink*) (*ndx);
	    pPrefetchSink->PrefetchTrackAdded(m_uGroupIndex, uPrefetchIndex, pTrack);
	}
    }

cleanup:

    HX_RELEASE(pPrefetch);

    return rc;
}

/************************************************************************
*  Method:
*      IHXPrefetch::RemovePrefetchTrack
*  Purpose:
*      removes prefetched track
*/
STDMETHODIMP
HXAdvancedGroup::RemovePrefetchTrack(UINT16 /*IN*/ uTrackIndex)
{
    HX_RESULT		rc = HXR_OK;
    int			i = 0;
    IHXValues*		pTrack = NULL;
    IHXValues*		pUpdateValues = NULL;
    CHXMapLongToObj*	pNewPrefetchTrackMap = NULL;

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

    if (!m_pPrefetchTrackMap->Lookup(uTrackIndex, (void*&)pTrack))
    {
	rc = HXR_FAILED;
	goto cleanup;
    }

    m_pPrefetchTrackMap->RemoveKey(uTrackIndex);

    if (HXR_OK != m_pPlayer->RemovePrefetchTrack(m_uGroupIndex, uTrackIndex, pTrack))
    {
	rc = HXR_FAILED;
	goto cleanup;
    }

    if (m_pPrefetchSinkList)
    {
	CHXSimpleList::Iterator ndx = m_pPrefetchSinkList->Begin();
	for (; ndx != m_pPrefetchSinkList->End(); ++ndx)
	{
	    IHXPrefetchSink* pPrefetchSink = (IHXPrefetchSink*) (*ndx);
	    pPrefetchSink->PrefetchTrackRemoved(m_uGroupIndex, uTrackIndex, pTrack);
	}
    }

    HX_RELEASE(pTrack);

    // adjust track map index
    pNewPrefetchTrackMap = new CHXMapLongToObj;
    for (i = 0; i < uTrackIndex; i++)
    {
	pTrack = (IHXValues*)(*m_pPrefetchTrackMap)[i];
	HX_ASSERT(pTrack);
	(*pNewPrefetchTrackMap)[i] = pTrack;
    }

    for (i = uTrackIndex + 1; i < m_uPrefetchTrackCount; i++)
    {
	pTrack = (IHXValues*)(*m_pPrefetchTrackMap)[i];	
	HX_ASSERT(pTrack);
	(*pNewPrefetchTrackMap)[i - 1] = pTrack;

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

	pUpdateValues->SetPropertyULONG32("TrackIndex", i - 1);
	m_pPlayer->UpdatePrefetchTrack(m_uGroupIndex, i, pUpdateValues);

	HX_RELEASE(pUpdateValues);
    }
    HX_DELETE(m_pPrefetchTrackMap);

    m_pPrefetchTrackMap = pNewPrefetchTrackMap;
    m_uPrefetchTrackCount--;

cleanup:

    return rc;
}

/************************************************************************
*  Method:
*      IHXPrefetch::GetPrefetchTrackCount
*  Purpose:
*      get number of prefetch tracks added
*/
STDMETHODIMP_(UINT16)
HXAdvancedGroup::GetPrefetchTrackCount()
{
    return m_uPrefetchTrackCount;
}

/************************************************************************
*  Method:
*      IHXPrefetch::GetPrefetchTrack
*  Purpose:
*      get prefetch track based on the index
*/
STDMETHODIMP
HXAdvancedGroup::GetPrefetchTrack(UINT16            /*IN*/  uTrackIndex,
			          REF(IHXValues*)   /*OUT*/ pTrack)
{
    HX_RESULT	rc = HXR_OK;

    pTrack = NULL;

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

    if (!m_pPrefetchTrackMap->Lookup(uTrackIndex, (void*&)pTrack))
    {
	rc = HXR_FAILED;
	goto cleanup;
    }

cleanup:

    return rc;
}

/************************************************************************
*  Method:
*      IHXPrefetch::AddPrefetchSink
*  Purpose:
*      add prefetch sink
*/
STDMETHODIMP
HXAdvancedGroup::AddPrefetchSink(IHXPrefetchSink* /*IN*/ pSink)
{
    HX_RESULT	rc = HXR_OK;

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

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

    m_pPrefetchSinkList->AddTail(pSink);
    pSink->AddRef();

cleanup:

    return rc;
}

/************************************************************************
*  Method:
*      IHXPrefetch::RemovePrefetchSink
*  Purpose:
*      remove prefetch sink
*/
STDMETHODIMP
HXAdvancedGroup::RemovePrefetchSink(IHXPrefetchSink* /*IN*/ pSink)
{
    HX_RESULT	    rc = HXR_OK;
    LISTPOSITION    lPosition = 0;

    if (!m_pPrefetchSinkList || !pSink)
    {
	rc = HXR_FAILED;
	goto cleanup;
    }

    lPosition = m_pPrefetchSinkList->Find(pSink);
    if (!lPosition)
    {
	rc = HXR_FAILED;
	goto cleanup;
    }

    m_pPrefetchSinkList->RemoveAt(lPosition);
    HX_RELEASE(pSink);
    
cleanup:

    return rc;
}

/************************************************************************
*  Method:
*	    IHXPrefetchSink::PrefetchTrackAdded()
*  Purpose:
*	    prefetch track is added
*/
STDMETHODIMP
HXAdvancedGroup::PrefetchTrackAdded(UINT16      uGroupIndex,
			            UINT16      uTrackIndex,
			            IHXValues*  pTrack)
{
    return HXR_OK;
}

/************************************************************************
*  Method:
*	    IHXPrefetchSink::PrefetchTrackRemoved()
*  Purpose:
*	    prefetch track is removed
*/
STDMETHODIMP
HXAdvancedGroup::PrefetchTrackRemoved(UINT16	    uGroupIndex,
			              UINT16        uTrackIndex,
			              IHXValues*    pTrack)
{
    return HXR_OK;
}

/************************************************************************
*  Method:
*	    IHXPrefetchSink::PrefetchTrackDone()
*  Purpose:
*	    prefetch track is done
*/
STDMETHODIMP
HXAdvancedGroup::PrefetchTrackDone(UINT16	uGroupIndex,
			           UINT16	uTrackIndex,			    
			           HX_RESULT	status)
{
    HX_RESULT	rc = HXR_OK;

    if (m_pPrefetchSinkList)
    {
	CHXSimpleList::Iterator ndx = m_pPrefetchSinkList->Begin();
	for (; ndx != m_pPrefetchSinkList->End(); ++ndx)
	{
	    IHXPrefetchSink* pPrefetchSink = (IHXPrefetchSink*) (*ndx);
	    pPrefetchSink->PrefetchTrackDone(uGroupIndex, uTrackIndex, status);
	}
    }

    return rc;
}
#endif /* HELIX_FEATURE_PREFETCH */

void
HXAdvancedGroup::Close(void)
{
    HXBasicGroup::Close();

    HX_RELEASE(m_pGroupProperties);

    IHXPrefetch*   pPrefetch = NULL;
    CHXMapLongToObj::Iterator i;
    CHXSimpleList::Iterator j;

    m_uPrefetchTrackCount = 0;

    if (m_pTrackSinkList)
    {
	CHXSimpleList::Iterator ndx = m_pTrackSinkList->Begin();
	for (; ndx != m_pTrackSinkList->End(); ++ndx)
	{
	    IHXTrackSink* pTrackSink = (IHXTrackSink*) (*ndx);
	    HX_RELEASE(pTrackSink);
	}
	HX_DELETE(m_pTrackSinkList);
    }

#if defined(HELIX_FEATURE_PREFETCH)
    if (m_pPrefetchTrackMap)
    {
	i = m_pPrefetchTrackMap->Begin();
	for(; i != m_pPrefetchTrackMap->End(); ++i)
	{
	    IHXValues* pTrack = (IHXValues*)(*i);
	    HX_RELEASE(pTrack);
	}
	HX_DELETE(m_pPrefetchTrackMap);
    }

    if (m_pPrefetchSinkList)
    {
	j = m_pPrefetchSinkList->Begin();
	for (; j != m_pPrefetchSinkList->End(); ++j)
	{
	    IHXPrefetchSink* pPrefetchSink = (IHXPrefetchSink*) (*j);
	    HX_RELEASE(pPrefetchSink);
	}
	HX_DELETE(m_pPrefetchSinkList);
    }

    if (m_bPrefetchSinkAdded)
    {
	if (HXR_OK == m_pPlayer->QueryInterface(IID_IHXPrefetch, (void**)&pPrefetch))
	{
	    pPrefetch->RemovePrefetchSink(this);
	    m_bPrefetchSinkAdded = FALSE;
	}
	HX_RELEASE(pPrefetch);
    }
#endif /* HELIX_FEATURE_PREFETCH */

    if (m_pPersistentComponentPropertyMap)
    {
	i = m_pPersistentComponentPropertyMap->Begin();
	for(; i != m_pPersistentComponentPropertyMap->End(); ++i)
	{
	    IHXValues* pValues = (IHXValues*)(*i);
	    HX_RELEASE(pValues);
	}
	HX_DELETE(m_pPersistentComponentPropertyMap);
    }
}

/*HXAdvancedGroupManager*/

HXAdvancedGroupManager::HXAdvancedGroupManager(HXPlayer* pPlayer)
                       :HXBasicGroupManager(pPlayer)
                       ,m_pMasterTAC(NULL)

{
}

HXAdvancedGroupManager::~HXAdvancedGroupManager(void)
{
    Close();
}

void HXAdvancedGroupManager::SetMasterTAC(HXMasterTAC* pMasterTAC)
{
    m_pMasterTAC = pMasterTAC;
    m_pMasterTAC->AddRef();
}

void
HXAdvancedGroupManager::PersistentComponentAdded(UINT16 uGroupIndex, UINT16 uTrackIndex)
{
    HXAdvancedGroup* pGroup = NULL;
    CHXSimpleList::Iterator ndx;

    if (HXR_OK == GetGroup(uGroupIndex, (IHXGroup*&)pGroup))
    {
	pGroup->PersistentComponentAdded(uTrackIndex);
    }
    HX_RELEASE(pGroup);

    return;
}

void 
HXAdvancedGroupManager::PersistentComponentRemoved(UINT16 uGroupIndex, UINT16 uTrackIndex)
{    
    HXAdvancedGroup* pGroup = NULL;
    CHXSimpleList::Iterator ndx;

    if (HXR_OK == GetGroup(uGroupIndex, (IHXGroup*&)pGroup))
    {
	pGroup->PersistentComponentRemoved(uTrackIndex);
    }

    return;
}

/*
 *  IHXGroupManager methods
 */

/************************************************************************
*  Method:
*      IHXGroupManager::CreateGroup
*  Purpose:
*		Create a group
*/
STDMETHODIMP
HXAdvancedGroupManager::CreateGroup(REF(IHXGroup*) pGroup)
{
    pGroup = new HXAdvancedGroup(this);
    if (!pGroup)
    {
	return HXR_OUTOFMEMORY;
    }
    
    pGroup->AddRef();

    return HXR_OK;
}

/************************************************************************
*  Method:
*      IHXGroupManager::AddGroup
*  Purpose:
*		Add a group to the presentation.
*/
STDMETHODIMP
HXAdvancedGroupManager::AddGroup(IHXGroup*	/*IN*/ pGroup)
{
    HX_RESULT	        theErr = HXR_OK;
    UINT16	        uInsertGroupAt = 0;
    UINT32	        ulLastGroupInRAM20 = 0;
    UINT32	        ulPersistentComponentID = 0;
    IHXValues*	        pGroupProperties = NULL;
    HXAdvancedTrack*    pHXTrack = NULL;
    IHXPersistentComponent* pPersistentComponent = NULL;
    HXPersistentComponentManager* pPersistentComponentManager = NULL;

    if (!pGroup)
    {
	return HXR_UNEXPECTED;
    }
    
    pGroupProperties = ((HXAdvancedGroup*)pGroup)->m_pGroupProperties;

#if defined(HELIX_FEATURE_NESTEDMETA)
    if (pGroupProperties)
    {
	if (HXR_OK != pGroupProperties->GetPropertyULONG32("LastGroupInRAM20", ulLastGroupInRAM20) &&
	    HXR_OK == pGroupProperties->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
	{
	    pPersistentComponentManager = m_pPlayer->m_pPersistentComponentManager;	
	    if (HXR_OK == pPersistentComponentManager->GetPersistentComponent(ulPersistentComponentID,
									      pPersistentComponent))
	    {
		((HXPersistentComponent*)pPersistentComponent)->m_uGroups++;
		uInsertGroupAt = ((HXPersistentComponent*)pPersistentComponent)->m_pSourceInfo->m_uGroupID +
				 ((HXPersistentComponent*)pPersistentComponent)->m_uGroups;

		theErr = InsertGroupAt(uInsertGroupAt, pGroup);
	    }
	    else
	    {
		HX_ASSERT(FALSE);
	    }
	}
	else
	{
	    HX_ASSERT(ulLastGroupInRAM20);
	    InsertGroupAt(m_uGroupCount, pGroup);
	}
    }
    else
#endif /* HELIX_FEATURE_NESTEDMETA */
    {
	InsertGroupAt(m_uGroupCount, pGroup);
    }
    
    HX_RELEASE(pPersistentComponent);

    return theErr;
}

/************************************************************************
*  Method:
*      IHXGroupManager::RemoveGroup
*  Purpose:
*		Remove an already added group
*/
STDMETHODIMP
HXAdvancedGroupManager::RemoveGroup(UINT16 	/*IN*/ uGroupIndex)
{
    HX_RESULT		theErr = HXR_OK;
    int			i = 0;
    CHXMapLongToObj*	pNewGroupMap = NULL;
    IHXGroup*		pHXGroupRemoved = NULL;
    IHXGroup*		pHXGroup = NULL;
    CHXSimpleList::Iterator ndx;

    if (!m_pGroupMap->Lookup(uGroupIndex, (void*&)pHXGroupRemoved))
    {
	theErr = HXR_UNEXPECTED;
	goto cleanup;
    }

    m_pGroupMap->RemoveKey(uGroupIndex);

    // adjust track map index
    pNewGroupMap = new CHXMapLongToObj;
    for (i = 0; i < uGroupIndex; i++)
    {
	m_pGroupMap->Lookup(i, (void*&)pHXGroup);
	HX_ASSERT(pHXGroup);

	(*pNewGroupMap)[i] = pHXGroup;
    }

    for (i = uGroupIndex + 1; i < m_uGroupCount; i++)
    {
	m_pGroupMap->Lookup(i, (void*&)pHXGroup);
	HX_ASSERT(pHXGroup);

	((HXAdvancedGroup*)pHXGroup)->m_uGroupIndex = i - 1;
	(*pNewGroupMap)[i - 1] = pHXGroup;
    }
    HX_DELETE(m_pGroupMap);

    m_pGroupMap = pNewGroupMap;
    m_uGroupCount--;
    
    ndx = m_pSinkList->Begin();
    for (; ndx != m_pSinkList->End(); ++ndx)
    {
	IHXGroupSink* pGroupSink = (IHXGroupSink*) (*ndx);
	pGroupSink->GroupRemoved(uGroupIndex, pHXGroupRemoved);
    }

cleanup:

    HX_RELEASE(pHXGroupRemoved);

    return theErr;
}    

STDMETHODIMP
HXAdvancedGroupManager::SetCurrentGroup(UINT16 uGroupIndex)
{
    HX_RESULT res = HXBasicGroupManager::SetCurrentGroup(uGroupIndex);

#if defined(HELIX_FEATURE_MASTERTAC)
    if (SUCCEEDED(res) && m_pMasterTAC)
    {
       // check for TAC info from new group
       m_pMasterTAC->ResetTAC(TRUE, TRUE); // reset status & clear master props
       m_pMasterTAC->CheckGroupForTACInfo(uGroupIndex);
    }
#endif // defined(HELIX_FEATURE_MASTERTAC)

    return res;
}

HX_RESULT	    
HXAdvancedGroupManager::RepeatTrackAdded(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pTrack)
{
    return m_pPlayer->RepeatTrackAdded(uGroupIndex, uTrackIndex, pTrack);
}

void
HXAdvancedGroupManager::Close(void)
{
    HX_RELEASE(m_pMasterTAC);
    HXBasicGroupManager::Close();
}