basgroup.cpp

linux下的一款播放器

    {
        AddRef();
        *ppvObj = (IHXGroupManager*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXPreCacheGroupMgr))
    {
        AddRef();
        *ppvObj = (IHXPreCacheGroupMgr*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IUnknown))
    {
	AddRef();
	*ppvObj = this;
	return HXR_OK;
    }

    *ppvObj = NULL;
    return HXR_NOINTERFACE;
}

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

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

    delete this;
    return 0;
}


/*
 *  IHXGroupManager methods
 */

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

    return HXR_OK;
}
/************************************************************************
*  Method:
*      IHXBasicGroupManager::GetGroupCount
*  Purpose:
*		Get the number of groups within the presentation.
*/
STDMETHODIMP_(UINT16)
HXBasicGroupManager::GetGroupCount(void)
{
    return m_uGroupCount;
}

/************************************************************************
*  Method:
*      IHXBasicGroupManager::GetGroup
*  Purpose:
*		Get ith group in the presentation
*/
STDMETHODIMP
HXBasicGroupManager::GetGroup(UINT16 	    /*IN*/ uGroupIndex,
			  REF(IHXGroup*)  /*OUT*/ pGroup)
{
    HX_RESULT	rc = HXR_OK;

    pGroup = NULL;

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

    pGroup->AddRef();

cleanup:
    
    return rc;
}

/************************************************************************
*  Method:
*      IHXBasicGroupManager::SetCurrentGroup
*  Purpose:
*		Play this group in the presentation.
*/
STDMETHODIMP
HXBasicGroupManager::SetCurrentGroup(UINT16 	    /*IN*/ uGroupIndex)
{
    HX_RESULT	rc = HXR_OK;
    IHXGroup*	pHXGroup = NULL;
    CHXSimpleList::Iterator ndx;

    if (m_bCurrentGroupInitialized)
    {
	// XXX HP
	// we should not receive multiple SetCurrentGroup() calls
	// on the same group, it would screw-up the layout stuff!!
	HX_ASSERT(m_uCurrentGroup != uGroupIndex);
    }

    if (HXR_OK != GetGroup(uGroupIndex, pHXGroup))
    {
	rc = HXR_UNEXPECTED;
	goto cleanup;
    }

    ndx = m_pSinkList->Begin();
    for (; ndx != m_pSinkList->End(); ++ndx)
    {
	IHXGroupSink* pGroupSink = (IHXGroupSink*) (*ndx);
	pGroupSink->CurrentGroupSet(uGroupIndex, pHXGroup);
    }

    // add repeated sources
#if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
    ((HXAdvancedGroup*)pHXGroup)->CurrentGroupSet();
#else
    ((HXBasicGroup*)pHXGroup)->CurrentGroupSet();
#endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */

    m_uCurrentGroup = uGroupIndex;
    m_bCurrentGroupInitialized = TRUE;

cleanup:

    HX_RELEASE(pHXGroup);

    return rc;
}

/************************************************************************
*  Method:
*      IHXBasicGroupManager::GetCurrentGroup
*  Purpose:
*		Get the current presentation group index
*/
STDMETHODIMP
HXBasicGroupManager::GetCurrentGroup(REF(UINT16)	/*OUT*/ uGroupIndex)
{
    uGroupIndex = m_uCurrentGroup;
    return HXR_OK;
}

/************************************************************************
*  Method:
*      IHXBasicGroupManager::AddGroup
*  Purpose:
*		Add a group to the presentation.
*/
STDMETHODIMP
HXBasicGroupManager::AddGroup(IHXGroup*	/*IN*/ pGroup)
{
    HX_RESULT	    theErr = HXR_OK;

    if (!pGroup)
    {
	return HXR_UNEXPECTED;
    }
    
    theErr = InsertGroupAt(m_uGroupCount, pGroup);

    return theErr;
}

/************************************************************************
*  Method:
*      IHXBasicGroupManager::RemoveGroup
*  Purpose:
*		Remove an already added group
*/
STDMETHODIMP
HXBasicGroupManager::RemoveGroup(UINT16 	/*IN*/ uGroupIndex)
{
    return HXR_NOTIMPL;
}    

/************************************************************************
*  Method:
*      IHXBasicGroupManager::AddSink
*  Purpose:
*		Add a sink to get notifications about any tracks or groups
*		being added to the presentation.
*/
STDMETHODIMP
HXBasicGroupManager::AddSink(IHXGroupSink* /*IN*/ pGroupSink)
{
    if (!pGroupSink)
    {
	return HXR_UNEXPECTED;
    }

    pGroupSink->AddRef();
    m_pSinkList->AddTail(pGroupSink);

    return HXR_OK;
}


/************************************************************************
*  Method:
*      IHXBasicGroupManager::RemoveSink
*  Purpose:
*		Remove Sink
*/
STDMETHODIMP
HXBasicGroupManager::RemoveSink(IHXGroupSink* /*IN*/ pGroupSink)
{

    LISTPOSITION lPosition = m_pSinkList->Find(pGroupSink);

    if (!lPosition)
    {
	return HXR_UNEXPECTED;
    }

    m_pSinkList->RemoveAt(lPosition);
    pGroupSink->Release();
    
    return HXR_OK;
}

/************************************************************************
*  Method:
*      IHXGroupManager::SetNextGroup
*  Purpose:
*		Set the next group to play
*/
STDMETHODIMP
HXBasicGroupManager::SetNextGroup(UINT16 /*IN*/ uGroupIndex)
{
    // setting group index to total number of groups is valid; it means we are done
    // record the next group index
    m_uNextGroup = uGroupIndex;
    m_bDefaultNextGroup = FALSE;

    // tell the player about the next group
    if (m_pPlayer)
    {
        m_pPlayer->NextGroupSet(uGroupIndex);
    }
	
    return HXR_OK;
}	

/************************************************************************
*  Method:
*      IHXGroupManager::GetNextGroup
*  Purpose:
*		Get the next group to play
*/
STDMETHODIMP
HXBasicGroupManager::GetNextGroup(REF(UINT16) uGroupIndex)
{
    HX_RESULT	theErr = HXR_OK;
    IHXGroup*	pNextGroup = NULL;

    if (m_bDefaultNextGroup)
	uGroupIndex = m_uCurrentGroup + 1;
    else
	uGroupIndex = m_uNextGroup;
	
    // make sure the next group we returned has >= 1 track
    while (m_pGroupMap->Lookup(uGroupIndex, (void*&)pNextGroup))
    {
	if (pNextGroup->GetTrackCount() > 0)
	{
	    break;
	}
	uGroupIndex++;
    }

    return HXR_OK;
}	

/************************************************************************
*  Method:
*      IHXGroupManager::DefaultNextGroup
*  Purpose:
*		reset to default the next group to play
*/
STDMETHODIMP
HXBasicGroupManager::DefaultNextGroup(void)
{
    m_bDefaultNextGroup = TRUE;
    return HXR_OK;
}	

/************************************************************************
*  Method:
*      IHXBasicGroupManager::SetPresentationProperties
*  Purpose:
*		Set any presentation information like Title Author 
*		Copyright etc. 
*/
STDMETHODIMP
HXBasicGroupManager::SetPresentationProperties(IHXValues*  /*IN*/ pProperties)
{
    if(!pProperties)
    {
	return HXR_UNEXPECTED;
    }

    HX_RELEASE(m_pPresentationProperties);

    m_pPresentationProperties = pProperties;
    m_pPresentationProperties->AddRef();
    return HXR_OK;
}

/************************************************************************
*  Method:
*      IHXBasicGroupManager::GetPresentationProperties
*  Purpose:
*		Get any presentation information. May return NULL.
*/
STDMETHODIMP_(IHXValues*)
HXBasicGroupManager::GetPresentationProperties(void)
{
    if (m_pPresentationProperties)
    {
	m_pPresentationProperties->AddRef();
    }

    return m_pPresentationProperties;
}

HX_RESULT	    
HXBasicGroupManager::TrackAdded(UINT16 uGroupIndex, UINT16 uTrackIndex, 
			    IHXValues* pTrack)
{
    HX_RESULT	rc = HXR_OK;

    CHXSimpleList::Iterator ndx = m_pSinkList->Begin();
    for (; ndx != m_pSinkList->End(); ++ndx)
    {
	IHXGroupSink* pGroupSink = (IHXGroupSink*) (*ndx);
	pGroupSink->TrackAdded(uGroupIndex, uTrackIndex, pTrack);
    }

    return rc;
}

HX_RESULT
HXBasicGroupManager::TrackRemoved(UINT16 uGroupIndex, UINT16 uTrackIndex, 
			      IHXValues* pTrack)
{
    HX_RESULT	rc = HXR_OK;

    CHXSimpleList::Iterator ndx = m_pSinkList->Begin();
    for (; ndx != m_pSinkList->End(); ++ndx)
    {
	IHXGroupSink* pGroupSink = (IHXGroupSink*) (*ndx);
	pGroupSink->TrackRemoved(uGroupIndex, uTrackIndex, pTrack);
    }

    return rc;
}

void 
HXBasicGroupManager::SetMasterTAC(HXMasterTAC* pMasterTAC)
{
    return;
}

HX_RESULT	    
HXBasicGroupManager::TrackStarted(UINT16 uGroupIndex, UINT16 uTrackIndex)
{
    HX_RESULT	rc = HXR_OK;
    IHXGroup*	pHXGroup = NULL;
    IHXValues* pValues = NULL;
    CHXSimpleList::Iterator ndx;

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

    if (HXR_OK != pHXGroup->GetTrack(uTrackIndex, pValues))
    {
	rc = HXR_UNEXPECTED;
	goto cleanup;
    }
    
    ndx = m_pSinkList->Begin();
    for (; ndx != m_pSinkList->End(); ++ndx)
    {
	IHXGroupSink* pGroupSink = (IHXGroupSink*) (*ndx);
	pGroupSink->TrackStarted(uGroupIndex, uTrackIndex, pValues);
    }

cleanup:

    HX_RELEASE(pValues);    
    return rc;
}

HX_RESULT	    
HXBasicGroupManager::TrackStopped(UINT16 uGroupIndex, UINT16 uTrackIndex)
{
    HX_RESULT	rc = HXR_OK;
    IHXGroup*	pHXGroup = NULL;
    IHXValues* pValues = NULL;
    CHXSimpleList::Iterator ndx;

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

    if (HXR_OK != pHXGroup->GetTrack(uTrackIndex, pValues))
    {
	rc = HXR_UNEXPECTED;
	goto cleanup;
    }
    
    ndx = m_pSinkList->Begin();
    for (; ndx != m_pSinkList->End(); ++ndx)
    {
	IHXGroupSink* pGroupSink = (IHXGroupSink*) (*ndx);
	pGroupSink->TrackStopped(uGroupIndex, uTrackIndex, pValues);
    }

cleanup:

    HX_RELEASE(pValues);
    return rc;
}

void
HXBasicGroupManager::PersistentComponentAdded(UINT16 uGroupIndex, UINT16 uTrackIndex)
{
    return;
}

void 
HXBasicGroupManager::PersistentComponentRemoved(UINT16 uGroupIndex, UINT16 uTrackIndex)
{    
    return;
}

HX_RESULT
HXBasicGroupManager::InsertGroupAt(UINT16 uGroupIndex, IHXGroup* pGroup)
{
    HX_RESULT		rc = HXR_OK;
    int			i = 0;
    CHXMapLongToObj*	pNewGroupMap = NULL;
    IHXGroup*		pHXGroup = NULL;

    HX_ASSERT(uGroupIndex <= m_uGroupCount);

    // make the spot for insertion
    if (uGroupIndex < m_uGroupCount)
    {
	// adjust group 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; i < m_uGroupCount; i++)
	{
	    m_pGroupMap->Lookup(i, (void*&)pHXGroup);
	    HX_ASSERT(pHXGroup);

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

	m_pGroupMap = pNewGroupMap;
    }

    pGroup->AddRef();
    ((HXBasicGroup*)pGroup)->m_uGroupIndex = uGroupIndex;
    (*m_pGroupMap)[uGroupIndex] = pGroup;

    m_uGroupCount++;

    ((HXBasicGroup*)pGroup)->StartTrackNotification();

    CHXSimpleList::Iterator ndx = m_pSinkList->Begin();
    for (; ndx != m_pSinkList->End(); ++ndx)
    {
	IHXGroupSink* pGroupSink = (IHXGroupSink*) (*ndx);
	// XXX HP replace this with the commented out line
	// after the TLC supports new IHXGroupSink2
	pGroupSink->GroupAdded(m_uGroupCount-1, pGroup);
	//pGroupSink->GroupInsertedAfter(uGroupIndex, pGroup);
    }

    return rc;
}

void 
HXBasicGroupManager::RemoveAllGroup(void)
{
    HX_RELEASE(m_pPresentationProperties);
    
    m_uGroupCount = 0;
    m_uCurrentGroup = 0;
    m_uNextGroup = 0;

    m_bCurrentGroupInitialized = FALSE;
    m_bDefaultNextGroup = TRUE;

    if (m_pGroupMap)
    {
        CHXMapLongToObj::Iterator i = m_pGroupMap->Begin();    
        for (; i != m_pGroupMap->End(); ++i)
        {
	    IHXGroup* pGroup = (IHXGroup*) (*i);
	    HX_RELEASE(pGroup);
        }
        m_pGroupMap->RemoveAll();
    }

    if (m_pSinkList)
    {
        CHXSimpleList::Iterator ndx = m_pSinkList->Begin();
        for (; ndx != m_pSinkList->End(); ++ndx)
        {
	    IHXGroupSink* pGroupSink = (IHXGroupSink*) (*ndx);
	    pGroupSink->AllGroupsRemoved();
        }
    }
}

void
HXBasicGroupManager::Close(void)
{
    RemoveAllGroup();

    HX_DELETE(m_pGroupMap);
    
    if (m_pSinkList)
    {
        CHXSimpleList::Iterator ndx = m_pSinkList->Begin();
        for (; ndx != m_pSinkList->End(); ++ndx)
        {
	    IHXGroupSink* pGroupSink = (IHXGroupSink*) (*ndx);
	    HX_RELEASE(pGroupSink);
        }
        HX_DELETE(m_pSinkList);
    }
	
    HX_RELEASE(m_pPlayer);
    HX_RELEASE(m_pPresentationProperties);
}