qttrkmgr.cpp

来自「symbian 下的helix player源代码」· C++ 代码 · 共 1,072 行 · 第 1/2 页

		{
		    if (m_pStreamToTrackMap[uStrmIdx].m_uGroup == uGroup)
		    {
			m_pStreamToTrackMap[uStrmIdx].m_bActive = FALSE;
		    }
		}
	    }

	    m_pStreamToTrackMap[uStreamNum].m_bActive = TRUE;

	    retVal = HXR_OK;
	}
    }

    return retVal;
}

/****************************************************************************
 *  Unsubscribe
 */
HX_RESULT CQTTrackManager::Unsubscribe(UINT16 uStreamNum)
{
    HX_RESULT retVal = HXR_UNEXPECTED;

    if (!m_bSubscriptionWindowClosed)
    {
	HX_ASSERT(uStreamNum < m_uNumStreams);

	retVal = HXR_FAIL;
	if (uStreamNum < m_uNumStreams)
	{
	    m_pStreamToTrackMap[uStreamNum].m_bActive = FALSE;

	    retVal = HXR_OK;
	}
    }

    return retVal;
}
#else	// QTCONFIG_ALTERNATE_STREAMS

HX_RESULT CQTTrackManager::AddStreamToGroup(UINT16 uStreamNumber,
					    UINT16 uGroup,
					    ULONG32 ulBitrate)
{
    return HXR_NOTIMPL;
}

HX_RESULT CQTTrackManager::SubscribeDefault(void)
{
    return HXR_NOTIMPL;
}

HX_RESULT CQTTrackManager::Subscribe(UINT16 uStreamNum)
{
    return HXR_NOTIMPL;
}

HX_RESULT CQTTrackManager::Unsubscribe(UINT16 uStreamNum)
{
    return HXR_NOTIMPL;
}

#endif	// QTCONFIG_ALTERNATE_STREAMS

/****************************************************************************
 *  RemoveInactiveStreams
 */
HX_RESULT CQTTrackManager::RemoveInactiveStreams(BOOL bLeaveReferences)
{
    HX_RESULT retVal = HXR_FAIL;

    HX_ASSERT(m_pStreamToTrackMap);

    UINT16 uActiveStreamCount = GetNumActiveStreams();

    if (uActiveStreamCount > 0)
    {
	CQTStream* pNewStreamToTrackMap = NULL;

	retVal = HXR_OK;

	if (!bLeaveReferences)
	{
	    pNewStreamToTrackMap = new CQTStream [uActiveStreamCount];

	    retVal = HXR_OUTOFMEMORY;
	    if (pNewStreamToTrackMap)
	    {
		retVal = HXR_OK;
	    }
	}

	if (SUCCEEDED(retVal))
	{
	    UINT16 uStrmIdx;
	    UINT16 uNewStrmIdx = 0;

	    for (uStrmIdx = 0; uStrmIdx < m_uNumStreams; uStrmIdx++)
	    {
		if (m_pStreamToTrackMap[uStrmIdx].m_bActive)
		{
		    if (!bLeaveReferences)
		    {
			HX_ASSERT(uNewStrmIdx < uActiveStreamCount);

			pNewStreamToTrackMap[uNewStrmIdx] =
			    m_pStreamToTrackMap[uStrmIdx];
			uNewStrmIdx++;
		    }
		}
		else
		{
		    ReleaseTrack(m_pStreamToTrackMap[uStrmIdx].m_pQTTrack);
		}
	    }

	    if (!bLeaveReferences)
	    {
		delete [] m_pStreamToTrackMap;
		m_pStreamToTrackMap = pNewStreamToTrackMap;
		m_uNumStreams = uActiveStreamCount;
	    }
	}

	m_bSubscriptionWindowClosed = TRUE;
    }

    return retVal;
}

/****************************************************************************
 *  IsStreamTrack
 */
BOOL CQTTrackManager::IsStreamTrack(CQTTrack* pTrack)
{
    UINT16 uStreamCount = 0;
    CQTStream* pStreamTracer = m_pStreamToTrackMap;

    HX_ASSERT(pTrack);

    while (uStreamCount < m_uNumStreams)
    {
	if (pTrack == pStreamTracer->m_pQTTrack)
	{
	    return TRUE;
	}

	pStreamTracer++;
	uStreamCount++;
    }

    return FALSE;
}


UINT16 CQTTrackManager::GetTrackStreamNum(CQTTrack* pTrack)
{
    UINT16 uStreamCount = 0;
    CQTStream* pStreamTracer = m_pStreamToTrackMap;

    HX_ASSERT(pTrack);

    while (uStreamCount < m_uNumStreams)
    {
	if (pTrack == pStreamTracer->m_pQTTrack)
	{
	    return uStreamCount;
	}

	pStreamTracer++;
	uStreamCount++;
    }

    return INV_STREAM_NUM;
}


/****************************************************************************
 *  GetTrackById
 */
CQTTrack* CQTTrackManager::GetTrackById(ULONG32 ulTrackID)
{
    UINT16 uTrackCount = 0;
    CQTTrackTable* pTableTracer = m_pTrackTable;

    while (uTrackCount < m_uNumTracks)
    {
	if (pTableTracer->m_pTrack && (ulTrackID == pTableTracer->m_pTrack->GetID()))
	{
	    return pTableTracer->m_pTrack;
	}

	uTrackCount++;
	pTableTracer++;
    }

    return NULL;
}

/****************************************************************************
 *  GetAtomById
 */
CQTAtom* CQTTrackManager::GetTrackAtomById(ULONG32 ulTrackID)
{
    UINT16 uTrackCount = 0;
    CQTTrackTable* pTableTracer = m_pTrackTable;

    while (uTrackCount < m_uNumTracks)
    {
	if (ulTrackID == pTableTracer->m_pTrack->GetID())
	{
	    return pTableTracer->m_pTrackAtom;
	}

	uTrackCount++;
	pTableTracer++;
    }

    return NULL;
}

/****************************************************************************
 *  GetTrackAtomHdlr
 */
CQT_hdlr_Atom* CQTTrackManager::GetTrackAtomHdlr(CQT_trak_Atom* pTrakAtom)
{
    CQT_mdia_Atom* pMdiaAtom;
    CQT_hdlr_Atom* pHdlrAtom = NULL;

    pMdiaAtom = (CQT_mdia_Atom*) pTrakAtom->FindPresentChild(QT_mdia);
    if (pMdiaAtom)
    {
	pHdlrAtom = (CQT_hdlr_Atom*) pMdiaAtom->FindPresentChild(QT_hdlr);
    }

    return pHdlrAtom;
}

/****************************************************************************
 *  GetTrackAtomStbl
 */
CQT_stbl_Atom* CQTTrackManager::GetTrackAtomStbl(CQT_trak_Atom* pTrakAtom)
{
    CQT_mdia_Atom* pMdiaAtom;
    CQT_hdlr_Atom* pMinfAtom;
    CQT_stbl_Atom* pStblAtom = NULL;

    pMdiaAtom = (CQT_mdia_Atom*) pTrakAtom->FindPresentChild(QT_mdia);
    if (pMdiaAtom)
    {
	pMinfAtom = (CQT_hdlr_Atom*) pMdiaAtom->FindPresentChild(QT_minf);
	if (pMinfAtom)
	{
	    pStblAtom = (CQT_stbl_Atom*) pMinfAtom->FindPresentChild(QT_stbl);
	}
    }

    return pStblAtom;
}

/****************************************************************************
 *  IsHintTrackAtom
 */
BOOL CQTTrackManager::IsHintTrackAtom(CQT_trak_Atom* pTrakAtom)
{
    CQT_hdlr_Atom* pHdlrAtom = GetTrackAtomHdlr(pTrakAtom);

    if (pHdlrAtom &&
	/*** MBO: To strict for some files
	(pHdlrAtom->Get_CompType() == QT_mhlr) &&
	***/
	(pHdlrAtom->Get_CompSubtype() == QT_hint))
    {
	return TRUE;
    }

    return FALSE;
}

/****************************************************************************
 *  IsNonEmptyTrackAtom
 */
BOOL CQTTrackManager::IsNonEmptyTrackAtom(CQT_trak_Atom* pTrakAtom)
{
    CQT_SampleSize_Manager sampleSize;
    CQT_stbl_Atom* pStblAtom = GetTrackAtomStbl(pTrakAtom);

    if (pStblAtom)
    {
	if (sampleSize.Init(pStblAtom) == HXR_OK)
	{
	    return TRUE;
	}
    }

    return FALSE;
}


/****************************************************************************
 *  Private Methods
 */
/****************************************************************************
 *  AddTracks
 */
void CQTTrackManager::AddTracks(CQTAtom *pRootAtom)
{
    UINT16 uChildCount;

    if (pRootAtom->GetType() == QT_trak)
    {
	BOOL bAdd = TRUE;

	if (IsHintTrackAtom((CQT_trak_Atom *) pRootAtom))
	{
	    bAdd = IsNonEmptyTrackAtom((CQT_trak_Atom*) pRootAtom);

	    if (bAdd)
	    {
		m_pHintTrackIdxList->AddTail(
		    (void *) m_pTrackAtomList->GetCount());
	    }
	}

	if (bAdd)
	{
	    m_pTrackAtomList->AddTail(pRootAtom);
	    pRootAtom->AddRef();
	}
    }
    else if (((pRootAtom->GetType() == QT_HXROOT) ||
	      (pRootAtom->GetType() == QT_moov)) &&
	     (uChildCount = pRootAtom->GetPresentChildCount()))
    {
	CQTAtom::ChildIterator i = pRootAtom->BeginChildren();

	do
	{
	    AddTracks(*i);
	    if ((--uChildCount) == 0)
	    {
		break;
	    }

	    ++i;
	} while (TRUE);
    }
    else if (pRootAtom->GetType() == QT_iods)
    {
	HX_ASSERT(m_pIodsAtom == NULL);
	if (m_pIodsAtom == NULL)
	{
	    m_pIodsAtom = (CQT_iods_Atom*) pRootAtom;
	    m_pIodsAtom->AddRef();
	    m_FType = QT_FTYPE_MP4;
	}
    }
    else if (pRootAtom->GetType() == QT_ftyp)
    {
	HX_ASSERT(m_pFtypAtom == NULL);
	if (m_pFtypAtom == NULL)
	{
	    UINT32 ulBrand;
	    BOOL bKeepLooking;
	    UINT32 ulCompBrandIdx = 0;
	    UINT32 ulNumCompBrands = 0;
	    m_pFtypAtom = (CQT_ftyp_Atom*) pRootAtom;
	    m_pFtypAtom->AddRef();

	    ulBrand = m_pFtypAtom->Get_MajorBrand();
	    ulNumCompBrands = m_pFtypAtom->Get_NumCompatibleBrands();

	    do
	    {
		bKeepLooking = FALSE;

		switch (ulBrand)
		{
		case QT_isom:
		case QT_3gp4:
		case QT_3gp5:
		case QT_mp41:
		case QT_mp42:
		case QT_mmp4:
		case QT_m4a:
		    m_FType = QT_FTYPE_MP4;
		    break;

		default:
		    if (ulCompBrandIdx < ulNumCompBrands)
		    {
			ulBrand = m_pFtypAtom->Get_CompatibleBrand(ulCompBrandIdx);
		    	ulCompBrandIdx++;
			bKeepLooking = TRUE;
		    }
		    break;
		}
	    } while (bKeepLooking);
	}
    }
}

/****************************************************************************
 *  DeleteTrackAtomList
 */
void CQTTrackManager::DeleteTrackAtomList(void)
{
    if (m_pTrackAtomList)
    {
	CQTAtom *pAtom;

	while (!m_pTrackAtomList->IsEmpty())
	{
	    pAtom = (CQTAtom*) m_pTrackAtomList->RemoveHead();
	    HX_ASSERT(pAtom);
	    pAtom->Release();
	}

	delete m_pTrackAtomList;
	m_pTrackAtomList = NULL;
    }
}

/****************************************************************************
 *  Clear
 */
void CQTTrackManager::Clear(void)
{
    HX_VECTOR_DELETE(m_pTrackTable);
    HX_VECTOR_DELETE(m_pStreamToTrackMap);

    DeleteTrackAtomList();
    HX_DELETE(m_pHintTrackIdxList);

    HX_RELEASE(m_pIodsAtom);
    HX_RELEASE(m_pFtypAtom);

    m_uNumTracks = 0;
    m_uNumStreams = 0;
}


/****************************************************************************
 *  GetNumActiveStreams
 */
UINT16 CQTTrackManager::GetNumActiveStreams(void)
{
    UINT16 uStrmIdx;
    UINT16 uActiveCount = 0;

    HX_ASSERT(m_pStreamToTrackMap);

    for (uStrmIdx = 0; uStrmIdx < m_uNumStreams; uStrmIdx++)
    {
	if (m_pStreamToTrackMap[uStrmIdx].m_bActive)
	{
	    uActiveCount++;
	}
    }

    return uActiveCount;
}


/****************************************************************************
 *  ReleaseTrack
 */
void CQTTrackManager::ReleaseTrack(CQTTrack* pQTTrack)
{
    // Remove Track from the Track Table
    if (m_pTrackTable)
    {
	UINT16 uTrackCount = 0;
	CQTTrackTable* pTableTracer = m_pTrackTable;

	while (uTrackCount < m_uNumTracks)
	{
	    if (pTableTracer->m_pTrack == pQTTrack)
	    {
		HX_RELEASE(pTableTracer->m_pTrack);
		HX_RELEASE(pTableTracer->m_pTrackAtom);
		break;
	    }

	    uTrackCount++;
	    pTableTracer++;
	}
    }

    // Remove The track from the Stream Map (if there)
    if (m_pStreamToTrackMap)
    {
	UINT16 uStreamCount = 0;
	CQTStream* pStreamTracer = m_pStreamToTrackMap;

	while (uStreamCount < m_uNumStreams)
	{
	    if (pStreamTracer->m_pQTTrack == pQTTrack)
	    {
		pStreamTracer->m_pQTTrack = NULL;
		pStreamTracer->m_bActive = FALSE;
		pStreamTracer->m_bGroupped = FALSE;
		pStreamTracer->m_uGroup = 0;
		pStreamTracer->m_ulBitrate = 0;

		break;
	    }

	    uStreamCount++;
	    pStreamTracer++;
	}
    }
}



/****************************************************************************
 *  CQTTrackManager::CQTTrackTable
 */
/****************************************************************************
 *  Destructor
 */
CQTTrackManager::CQTTrackTable::~CQTTrackTable()
{
    if (m_pTrack)
    {
	m_pTrack->Release();
    }

    if (m_pTrackAtom)
    {
	m_pTrackAtom->Release();
    }
}