advgroup.cpp

linux下的一款播放器

HXAdvancedGroup::SetPersistentComponentProperties(UINT32        /*IN*/ ulPersistentComponentID,
					          IHXValues*	/*IN*/ pProperties)
{
    HX_RESULT	rc = HXR_OK;
    IHXValues*	pValues = NULL;

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

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

    if (!m_pPersistentComponentPropertyMap->Lookup(ulPersistentComponentID, 
						   (void*&)pValues))
    {
	(*m_pPersistentComponentPropertyMap)[ulPersistentComponentID] = pProperties;
	pProperties->AddRef();
    }

cleanup:

    return rc;
}

/************************************************************************
*  Method:
*      IHXGroup2::GetPersistentComponentProperties
*  Purpose:
*		Get any persistent component specific information associated with 
*		the group.
*		One group may contain multiple persistent components
*/
STDMETHODIMP
HXAdvancedGroup::GetPersistentComponentProperties(UINT32          /*IN*/  ulPersistentComponentID,
					          REF(IHXValues*) /*OUT*/ pProperties)
{	
    HX_RESULT	rc = HXR_OK;
    
    pProperties = NULL;

    if (m_pPersistentComponentPropertyMap &&
	m_pPersistentComponentPropertyMap->Lookup(ulPersistentComponentID, (void*&)pProperties))
    {
	pProperties->AddRef();
    }
    else
    {
	rc = HXR_FAILED;
    }

    return rc;
}

/************************************************************************
*  Method:
*      IHXGroup2::GetTrack2
*  Purpose:
*		Get ith track in this group
*/
STDMETHODIMP
HXAdvancedGroup::GetTrack2(UINT16		/*IN*/	uTrackIndex,
		           REF(IHXValues*)	/*OUT*/ pTrack,
		           REF(IHXValues*)	/*OUT*/	pTrackPropInRequest)
{
    return DoGetTrack(uTrackIndex, pTrack, pTrackPropInRequest);
}

STDMETHODIMP
HXAdvancedGroup::AddTrack(IHXValues*	/*IN*/ pTrack)
{
    HX_RESULT   rc = HXR_OK;

    HXAdvancedTrack* pHXTrack = new HXAdvancedTrack(this);
    pHXTrack->AddRef();

    rc = DoAddTrack(pTrack, NULL, pHXTrack);
    if (HXR_OK != rc)
    {
        HX_RELEASE(pHXTrack);
    }

    return rc;
}

/************************************************************************
*  Method:
*      IHXGroup2::AddTrack2
*  Purpose:
*		Add Tracks to the group, including the props set in RequestHeader
*/
STDMETHODIMP
HXAdvancedGroup::AddTrack2(IHXValues*   /*IN*/ pTrack,
		           IHXValues*   /*IN*/ pTrackPropInRequest)
{
    HX_RESULT   rc = HXR_OK;

    HXAdvancedTrack* pHXTrack = new HXAdvancedTrack(this);
    pHXTrack->AddRef();
   
    rc = DoAddTrack(pTrack, pTrackPropInRequest, pHXTrack);
    if (HXR_OK != rc)
    {
        HX_RELEASE(pHXTrack);
    }

    return rc;
}

/************************************************************************
*  Method:
*      IHXGroup::RemoveTrack
*  Purpose:
*		Remove an already added track
*/
STDMETHODIMP
HXAdvancedGroup::RemoveTrack(UINT16	/*IN*/ uTrackIndex)
{
    HX_RESULT		theErr = HXR_OK;
    int			i = 0;
    IHXValues*		pValues = NULL;
    IHXValues*		pValuesInRequest = NULL;
    IHXValues*		pUpdateValues = NULL;
    CHXMapLongToObj*	pNewTrackMap = NULL;
    HXAdvancedTrack*	pHXTrackRemoved = NULL;
    HXAdvancedTrack*	pHXTrack = NULL;

    if (!m_pTrackMap->Lookup(uTrackIndex, (void*&)pHXTrackRemoved))
    {
	theErr = HXR_UNEXPECTED;
	goto cleanup;
    }

    m_pTrackMap->RemoveKey(uTrackIndex);

    pHXTrackRemoved->GetTrackProperties(pValues, pValuesInRequest);
    HX_ASSERT(pValues);

    HX_ASSERT(m_pPlayer);
    if (HXR_OK != m_pPlayer->RemoveTrack(m_uGroupIndex, uTrackIndex, pValues))
    {
	theErr = HXR_UNEXPECTED;
	goto cleanup;
    }

    if (m_bToNotifyTrack)
    {
	theErr = m_pGroupManager->TrackRemoved(m_uGroupIndex, uTrackIndex, pValues);
    }

    // adjust track map index
    pNewTrackMap = new CHXMapLongToObj;
    for (i = 0; i < uTrackIndex; i++)
    {
	m_pTrackMap->Lookup(i, (void*&)pHXTrack);
	HX_ASSERT(pHXTrack);

	(*pNewTrackMap)[i] = pHXTrack;
    }

    for (i = uTrackIndex + 1; i < m_uTrackCount; i++)
    {
	m_pTrackMap->Lookup(i, (void*&)pHXTrack);
	HX_ASSERT(pHXTrack);

	pHXTrack->m_uTrackIndex = i - 1;
	(*pNewTrackMap)[i - 1] = pHXTrack;

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

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

	HX_RELEASE(pUpdateValues);
    }
    HX_DELETE(m_pTrackMap);

    m_pTrackMap = pNewTrackMap;
    m_uTrackCount--;
    
cleanup:

    HX_RELEASE(pValues);
    HX_RELEASE(pValuesInRequest);
    HX_RELEASE(pHXTrackRemoved);

    return theErr;
}

HX_RESULT
HXAdvancedGroup::BeginTrack(UINT16      /*IN*/ uTrackIndex,
		            IHXValues*  /*IN*/ pTrack)
{
    HX_RESULT	theErr = HXR_OK;

    HX_ASSERT(m_pPlayer);
    theErr = m_pPlayer->BeginTrack(m_uGroupIndex, uTrackIndex, pTrack);

    if (m_pTrackSinkList)
    {
	CHXSimpleList::Iterator ndx = m_pTrackSinkList->Begin();
	for (; ndx != m_pTrackSinkList->End(); ++ndx)
	{
	    IHXTrackSink* pTrackSink = (IHXTrackSink*) (*ndx);
	    pTrackSink->BeginDone(m_uGroupIndex, uTrackIndex);
	}
    }

    return theErr;
}

HX_RESULT
HXAdvancedGroup::PauseTrack(UINT16      /*IN*/ uTrackIndex,
		            IHXValues*  /*IN*/ pTrack)
{
    HX_RESULT	theErr = HXR_OK;

    HX_ASSERT(m_pPlayer);
    theErr = m_pPlayer->PauseTrack(m_uGroupIndex, uTrackIndex, pTrack);

    if (m_pTrackSinkList)
    {
	CHXSimpleList::Iterator ndx = m_pTrackSinkList->Begin();
	for (; ndx != m_pTrackSinkList->End(); ++ndx)
	{
	    IHXTrackSink* pTrackSink = (IHXTrackSink*) (*ndx);
	    pTrackSink->PauseDone(m_uGroupIndex, uTrackIndex);
	}
    }

    return theErr;
}

HX_RESULT
HXAdvancedGroup::SeekTrack(UINT16	    /*IN*/ uTrackIndex,
		           IHXValues*	    /*IN*/ pTrack,
		           UINT32	    /*IN*/ ulSeekTime)
{
    HX_RESULT	theErr = HXR_OK;

    HX_ASSERT(m_pPlayer);
    theErr = m_pPlayer->SeekTrack(m_uGroupIndex, uTrackIndex, pTrack, ulSeekTime);

    if (m_pTrackSinkList)
    {
	CHXSimpleList::Iterator ndx = m_pTrackSinkList->Begin();
	for (; ndx != m_pTrackSinkList->End(); ++ndx)
	{
	    IHXTrackSink* pTrackSink = (IHXTrackSink*) (*ndx);
	    pTrackSink->SeekDone(m_uGroupIndex, uTrackIndex, ulSeekTime);
	}
    }

    return theErr;
}

HX_RESULT
HXAdvancedGroup::StopTrack(UINT16	/*IN*/ uTrackIndex,
		           IHXValues*	/*IN*/ pTrack)
{
    HX_RESULT	theErr = HXR_OK;

    HX_ASSERT(m_pPlayer);    
    theErr = m_pPlayer->StopTrack(m_uGroupIndex, uTrackIndex, pTrack);

    if (m_pTrackSinkList)
    {
	CHXSimpleList::Iterator ndx = m_pTrackSinkList->Begin();
	for (; ndx != m_pTrackSinkList->End(); ++ndx)
	{
	    IHXTrackSink* pTrackSink = (IHXTrackSink*) (*ndx);
	    pTrackSink->StopDone(m_uGroupIndex, uTrackIndex);
	}
    }

    return theErr;
}

HX_RESULT	
HXAdvancedGroup::GetSource(UINT16		uTrackIndex, 
		           IHXStreamSource*&	pStreamSource)
{
    SourceInfo*	pSourceInfo = NULL;
    pStreamSource = NULL;

    HX_ASSERT(m_pPlayer);
    if (HXR_OK == m_pPlayer->GetSourceInfo(m_uGroupIndex, uTrackIndex, pSourceInfo) && 
	pSourceInfo)
    {
	return pSourceInfo->m_pSource->QueryInterface(IID_IHXStreamSource, (void**)&pStreamSource);
    }

    return HXR_FAILED;
}

HX_RESULT
HXAdvancedGroup::SetSoundLevel(UINT16	/*IN*/ uTrackIndex,
			       UINT16	/*IN*/ uSoundLevel,
			       BOOL	/*IN*/ bReflushAudioDevice)
{
    HX_RESULT	theErr = HXR_OK;


    HX_ASSERT(m_pPlayer);
    theErr = m_pPlayer->SetSoundLevel(m_uGroupIndex, 
				      uTrackIndex, 
				      uSoundLevel,
				      bReflushAudioDevice);

    return theErr;
}

HX_RESULT
HXAdvancedGroup::BeginSoundLevelAnimation(UINT16 uTrackIndex, 
				          UINT16 uSoundLevelBeginWith)
{    
    HX_RESULT	        rc = HXR_OK;
    CHXAudioPlayer*     pAudioPlayer = NULL;
    HXAdvancedTrack*	pHXTrack = NULL;

    HX_ASSERT(m_pPlayer);
    if ((pAudioPlayer = m_pPlayer->GetAudioPlayer()) &&
	m_pTrackMap->Lookup(uTrackIndex, (void*&)pHXTrack))
    {	    
	pAudioPlayer->ActualAddPostMixHook((IHXAudioHook*)pHXTrack, 0, 1);

	m_pPlayer->SetSoundLevel(m_uGroupIndex, 
				 uTrackIndex, 
				 uSoundLevelBeginWith, 
				 TRUE);	
    }

    return rc;
}

HX_RESULT
HXAdvancedGroup::EndSoundLevelAnimation(UINT16 uTrackIndex, 
				        UINT16 uSoundLevelEndWith)
{
    HX_RESULT	        theErr = HXR_OK;
    CHXAudioPlayer*     pAudioPlayer = NULL;
    HXAdvancedTrack*	pHXTrack = NULL;

    HX_ASSERT(m_pPlayer);
    if ((pAudioPlayer = m_pPlayer->GetAudioPlayer()) &&
	m_pTrackMap->Lookup(uTrackIndex, (void*&)pHXTrack))
    {	
	pAudioPlayer->ActualRemovePostMixHook((IHXAudioHook*)pHXTrack);
    
	m_pPlayer->SetSoundLevel(m_uGroupIndex, 
				 uTrackIndex, 
				 uSoundLevelEndWith, 
				 FALSE);
    }

    return theErr;
}

HX_RESULT
HXAdvancedGroup::OnSoundLevelAnimation(UINT16 uTrackIndex, 
                                       UINT16 uSoundLevel, 
                                       UINT32 ulSoundLevelAnimationTime)
{
    HX_RESULT	theErr = HXR_OK;

    if (m_pTrackSinkList)
    {
	CHXSimpleList::Iterator ndx = m_pTrackSinkList->Begin();
	for (; ndx != m_pTrackSinkList->End(); ++ndx)
	{
	    IHXTrackSink* pTrackSink = (IHXTrackSink*) (*ndx);
	    pTrackSink->OnSoundLevelAnimation(m_uGroupIndex, uTrackIndex, ulSoundLevelAnimationTime);
	}
    }

    return theErr;
}

void
HXAdvancedGroup::PersistentComponentAdded(UINT16 uTrackIndex)
{
    HXAdvancedTrack*    pPersistentHXTrack = NULL;

    // XXX HP we don't actually remove the track in order
    // to preserve the group/track ID of subsequent sources
    // Need more work on RemoveTrack() so that all the group/
    // track ID get updated across the board(esp. in persistent
    // renderers)!!
    if (m_pTrackMap->Lookup(uTrackIndex, (void*&)pPersistentHXTrack))
    {
	pPersistentHXTrack->m_bActive = FALSE;
    }

    return;
}

void
HXAdvancedGroup::PersistentComponentRemoved(UINT16 uTrackIndex)
{
    return;
}

HX_RESULT
HXAdvancedGroup::CurrentGroupSet(void)
{
    HX_RESULT	rc = HXR_OK;

    CHXMapLongToObj::Iterator i = m_pTrackMap->Begin();
    for(; i != m_pTrackMap->End(); ++i)
    {
	HXAdvancedTrack*    pHXTrack = (HXAdvancedTrack*)(*i);
	CHXSimpleList*	    pRepeatList = pHXTrack->m_pRepeatList;
	
	if (pRepeatList)
	{
	    CHXSimpleList::Iterator ndx = pRepeatList->Begin();
	    for (; ndx != pRepeatList->End(); ++ndx)
	    {
		IHXValues* pRepeatTrack = (IHXValues*) (*ndx);
		((HXAdvancedGroupManager*)m_pGroupManager)->RepeatTrackAdded(m_uGroupIndex, 
                                                                             pHXTrack->m_uTrackIndex, 
                                                                             pRepeatTrack);
	    }
	}
    }

    return rc;
}

HX_RESULT	
HXAdvancedGroup::RepeatTrackAdded(UINT16 uTrackIndex, IHXValues* pValues)
{
    HX_RESULT rc = HXR_OK;

    if (m_bToNotifyTrack)
    {
	rc = ((HXAdvancedGroupManager*)m_pGroupManager)->RepeatTrackAdded(m_uGroupIndex, 
                                                                          uTrackIndex, 
                                                                          pValues);
	HX_ASSERT(rc == HXR_OK);
    }

    return rc;
}

/************************************************************************
*  Method:
*      IHXGroup2::GetIHXTrack
*  Purpose:
*		get the IHXTrack object
*/
STDMETHODIMP
HXAdvancedGroup::GetIHXTrack(UINT16         /*IN*/  uTrackIndex,
		             REF(IHXTrack*) /*OUT*/ pTrack)
{
    HX_RESULT rc = HXR_OK;

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

    pTrack->AddRef();

cleanup:

    return HXR_OK;
}

/************************************************************************
*  Method:
*      IHXGroup2::AddTrackSink
*  Purpose:
*		add advise sink on track
*/
STDMETHODIMP
HXAdvancedGroup::AddTrackSink(IHXTrackSink*   /*IN*/  pSink)
{
    if (!pSink)
    {
	return HXR_UNEXPECTED;
    }

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

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

    return HXR_OK;    
}

/************************************************************************
*  Method:
*      IHXGroup2::RemoveTrackSink
*  Purpose:
*		remove advise sink on track
*/
STDMETHODIMP
HXAdvancedGroup::RemoveTrackSink(IHXTrackSink*   /*IN*/  pSink)
{
    if (!m_pTrackSinkList)
    {
	return HXR_UNEXPECTED;
    }

    LISTPOSITION lPosition = m_pTrackSinkList->Find(pSink);
    if (!lPosition)
    {
	return HXR_UNEXPECTED;
    }

    m_pTrackSinkList->RemoveAt(lPosition);
    HX_RELEASE(pSink);
    
    return HXR_OK;
}

#if defined(HELIX_FEATURE_PREFETCH)
/************************************************************************
*  Method:
*      IHXPrefetch::AddPrefetchTrack
*  Purpose:
*      adds prefetch track by specifying "PrefetchType" and "PrefetchValue"
*      in pTrack's IHXValues
*/
STDMETHODIMP
HXAdvancedGroup::AddPrefetchTrack(IHXValues* /*IN*/  pTrack)
{
    HX_RESULT	    rc = HXR_OK;
    UINT16	    uPrefetchIndex = 0;
    IHXPrefetch*   pPrefetch = NULL;

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

    uPrefetchIndex = m_uPrefetchTrackCount;

    pTrack->SetPropertyULONG32("GroupIndex", m_uGroupIndex);
    pTrack->SetPropertyULONG32("TrackIndex", uPrefetchIndex);

    // give TLC a first bite on prefetch track
    if (HXR_OK == m_pPlayer->QueryInterface(IID_IHXPrefetch, (void**)&pPrefetch))
    {
	rc = pPrefetch->AddPrefetchTrack(pTrack);

	if (HXR_OK == rc && !m_bPrefetchSinkAdded)
	{
	    m_bPrefetchSinkAdded = TRUE;
	    pPrefetch->AddPrefetchSink(this);
	}
	else if (HXR_NOT_SUPPORTED == rc)
	{
	    rc = m_pPlayer->AddPrefetchTrack(m_uGroupIndex, uPrefetchIndex, pTrack);
	}
    }
    else
    {	
	rc = m_pPlayer->AddPrefetchTrack(m_uGroupIndex, uPrefetchIndex, pTrack);
    }