qtatmmgs.cpp

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

		bEntryIdxChanged = TRUE;
		
		m_ulSamplesPerChunk = m_pSampleToChunkAtom->
		    Get_SamplesPerChunk(m_ulCurrentEntryIdx);
		ulEntryFirstChunk = m_pSampleToChunkAtom->
		    Get_FirstChunk(m_ulCurrentEntryIdx);
	    }
	} while (m_ulSampleInChunkNum > m_ulSamplesPerChunk);

	if (bEntryIdxChanged)
	{
	    m_ulSampleDescIdx = m_pSampleToChunkAtom->
		Get_SampleDescID(m_ulCurrentEntryIdx) - 1
#ifdef _STCO_ZERO_BASED_IQ
		+ m_ulChunkNumOffset
#endif	// _STCO_ZERO_BASED_IQ
		;
	}

	if ((m_ulCurrentEntryIdx + 1) < m_ulNumEntries)
	{
	    m_ulNextEntryChunk = m_pSampleToChunkAtom->
		Get_FirstChunk(m_ulCurrentEntryIdx + 1)
#ifdef _STCO_ZERO_BASED_IQ
		+ m_ulChunkNumOffset
#endif	// _STCO_ZERO_BASED_IQ
		;
	}
	else
	{
	    // No more chunk entries
	    m_ulNextEntryChunk = QT_NULL_CHUNK_NUM;
	}
    }

    return TRUE;
}


#define INVALID_COMP_SAMPLE_NUM	    0xFFFFFFFF

/****************************************************************************
 *  Time To Sample Manager
 */
/****************************************************************************
 *  Constructor/Destructor
 */
CQT_TimeToSample_Manager::CQT_TimeToSample_Manager(void)
    : m_pTimeToSampleAtom(NULL)
    , m_pCompOffsetAtom(NULL)
    , m_pSyncSampleAtom(NULL)
    , m_ulNumEntries(0)
    , m_ulCurrentEntryIdx(0)
    , m_ulSampleNumber(0)
    , m_ulSamplesLeftInEntry(0)
    , m_ulSampleDuration(0)
    , m_ulLastSyncTime(0)
    , m_ulNumCompEntries(0)
    , m_ulCurrentCompEntryIdx(0)
    , m_ulCompSampleNumber(INVALID_COMP_SAMPLE_NUM)
    , m_ulSamplesLeftInCompEntry(0)
    , m_ulCompOffset(0)
    , m_ulNumSyncEntries(0)
    , m_ulCurrentSyncEntryIdx(0)
    , m_ulSyncSampleNumber(0)
#ifdef _STSS_ZERO_BASED_IQ
    , m_ulKeyFrameNumOffset(0)
#endif	// _STSS_ZERO_BASED_IQ
{
    ;
}

CQT_TimeToSample_Manager::~CQT_TimeToSample_Manager()
{
    HX_RELEASE(m_pTimeToSampleAtom);
    HX_RELEASE(m_pCompOffsetAtom);
    HX_RELEASE(m_pSyncSampleAtom);
}

/****************************************************************************
 *  Init
 */
HX_RESULT CQT_TimeToSample_Manager::Init(CQTAtom* pAtom)
{
    HX_RESULT retVal = HXR_OK;

    HX_RELEASE(m_pTimeToSampleAtom);
    HX_RELEASE(m_pCompOffsetAtom);
    HX_RELEASE(m_pSyncSampleAtom);
    
    m_ulNumEntries = 0;
    m_ulCompSampleNumber = INVALID_COMP_SAMPLE_NUM;

    if (pAtom)
    {
	if (pAtom->GetType() == QT_stts)
	{
	    m_pTimeToSampleAtom = (CQT_stts_Atom*) pAtom;
	}
	else
	{
	    m_pTimeToSampleAtom = (CQT_stts_Atom*) pAtom->
				    FindPresentChild(QT_stts);
	    m_pCompOffsetAtom = (CQT_ctts_Atom*) pAtom->
				    FindPresentChild(QT_ctts);
	}

	if (m_pTimeToSampleAtom)
	{
	    m_pTimeToSampleAtom->AddRef();
	    m_ulNumEntries = m_pTimeToSampleAtom->Get_NumEntries();
	}

	if (m_pCompOffsetAtom)
	{
	    m_pCompOffsetAtom->AddRef();
	    m_ulNumCompEntries = m_pCompOffsetAtom->Get_NumEntries();
	}
    }

    if (m_ulNumEntries > 0)
    {
	if (pAtom != m_pTimeToSampleAtom)
	{
	    m_pSyncSampleAtom = (CQT_stss_Atom*) pAtom->
				    FindPresentChild(QT_stss);
	    if (m_pSyncSampleAtom)
	    {
		ULONG32 ulNumSyncEntries = 0;

		ulNumSyncEntries = m_pSyncSampleAtom->Get_NumEntries();

#ifdef _STSS_ZERO_BASED_IQ
		if (ulNumSyncEntries > 0)
		{
		    ULONG32 ulKeyFrameSample;

		    ulKeyFrameSample = m_pSyncSampleAtom->
					    Get_SampleNum(0);
		    if (ulKeyFrameSample == 0)
		    {
			m_ulKeyFrameNumOffset = 1;
		    }
		}
#endif	// _STSS_ZERO_BASED_IQ

#ifdef _STSS_TRACK_SYNC
		m_ulNumSyncEntries = ulNumSyncEntries;
#endif // _STSS_TRACK_SYNC

		m_pSyncSampleAtom->AddRef();
	    }
	}
    }

    retVal = EstablishByMediaTime(0) ? HXR_OK : HXR_NO_DATA;

    return retVal;
}

/****************************************************************************
 *  EstablishAtKeyByMediaTime
 */
BOOL CQT_TimeToSample_Manager::EstablishAtKeyByMediaTime(ULONG32 ulMediaTime)
{
    ULONG32 ulSyncEntryIdx;
    ULONG32 ulKeyFrameSample;
    ULONG32 ulNumSyncEntries = 0;
    BOOL bEstablished = FALSE;

    if (EstablishByMediaTime(ulMediaTime))
    {
	ulNumSyncEntries = m_ulNumSyncEntries;
	if ((ulNumSyncEntries == 0) && m_pSyncSampleAtom)
	{
	    ulNumSyncEntries = m_pSyncSampleAtom->Get_NumEntries();
	}

	bEstablished = (ulNumSyncEntries == 0);

	for (ulSyncEntryIdx = m_ulCurrentSyncEntryIdx; 
	     ulSyncEntryIdx < ulNumSyncEntries;
	     ulSyncEntryIdx++)
	{
	    ulKeyFrameSample = m_pSyncSampleAtom->
		Get_SampleNum(ulSyncEntryIdx) + m_ulKeyFrameNumOffset;
	    while (ulKeyFrameSample >= m_ulSampleNumber)
	    {
		if (ulKeyFrameSample == m_ulSampleNumber)
		{
		    // Key Sample lined up with the Sample
		    return TRUE;
		}

		// We'll try to line up the Sample with the key sample
		if (!AdvanceBySample())
		{
		    return FALSE;
		}

		// Keep track of how for beyond initally requested time
		// the key frame was found.
		m_ulLastSyncTime += m_ulSampleDuration;
	    }
	}
    }

    return bEstablished;
}

/****************************************************************************
 *  EstablishByMediaTime
 */
BOOL CQT_TimeToSample_Manager::EstablishByMediaTime(ULONG32 ulMediaTime)
{
    BOOL bIsEstablished;

    m_ulCurrentEntryIdx = 0;
    m_ulLastSyncTime = 0;
    m_ulCurrentSyncEntryIdx = 0;
    
    if (m_ulNumEntries > 0)
    {
	m_ulSampleNumber = 0;
	m_ulSamplesLeftInEntry = m_pTimeToSampleAtom->Get_SampleCount(0);
	m_ulSampleDuration = m_pTimeToSampleAtom->Get_SampleDuration(0);
    }
    else
    {
	m_ulSampleNumber = 0;
	m_ulSamplesLeftInEntry = 0;
	m_ulSampleDuration = 0;
    }

    if (m_ulNumSyncEntries > 0)
    {
	m_ulSyncSampleNumber = m_pSyncSampleAtom->Get_SampleNum(0) +
			       m_ulKeyFrameNumOffset;
    }
    else
    {
	m_ulSyncSampleNumber = 0;
    }

    bIsEstablished = EstablishCompBySample(0);

    if (bIsEstablished)
    {
	bIsEstablished = AdvanceBySample();
    }

    if (bIsEstablished)
    {
	while (ulMediaTime > 0)
	{
	    if (ulMediaTime >= m_ulSampleDuration)
	    {
		ulMediaTime -= m_ulSampleDuration;
	    }
	    else
	    {
		m_ulLastSyncTime = m_ulSampleDuration - ulMediaTime;
		ulMediaTime = 0;
	    }

	    if (!AdvanceBySample())
	    {
		bIsEstablished = FALSE;
		break;
	    }
	}
    }

    return bIsEstablished;
}

/****************************************************************************
 *  EstablishCompByOffset
 */
BOOL CQT_TimeToSample_Manager::EstablishCompBySample(ULONG32 ulSampleNum)
{
    BOOL bIsEstablished = TRUE;

    if (m_ulNumCompEntries == 0)
    {
	return bIsEstablished;
    }

    if (m_ulCompSampleNumber >= ulSampleNum)
    {
	m_ulCompSampleNumber = 0;
	m_ulCurrentCompEntryIdx = 0;
	m_ulSamplesLeftInCompEntry = m_pCompOffsetAtom->Get_SampleCount(0);
	m_ulCompOffset = m_pCompOffsetAtom->Get_SampleOffset(0);
    }

    while (m_ulCompSampleNumber < ulSampleNum)
    {
	if (!(bIsEstablished = AdvanceCompBySample()))
	{
	    break;
	}
    }
	
    return bIsEstablished;
}


/****************************************************************************
 *  Sample Size Manager
 */
/****************************************************************************
 *  Constructor/Destructor
 */
CQT_SampleSize_Manager::CQT_SampleSize_Manager(void)
    : m_pSampleSizeAtom(NULL)
    , m_ulGenericSize(0)
    , m_ulNumEntries(0)
    , m_ulSampleSize(0)
    , m_ulChunkSize(0)
    , m_ulChunkSampleOffset(0)
    , m_ulChunkStartSampleNum(QT_BAD_IDX)
    , m_ulSampleNum(QT_BAD_IDX)
{
    ;
}

CQT_SampleSize_Manager::~CQT_SampleSize_Manager()
{
    HX_RELEASE(m_pSampleSizeAtom);
}

/****************************************************************************
 *  Init
 */
HX_RESULT CQT_SampleSize_Manager::Init(CQTAtom *pAtom)
{
    HX_RESULT retVal = HXR_OK;

    HX_RELEASE(m_pSampleSizeAtom);
    m_ulGenericSize = 0;
    m_ulSampleSize = 0;
    m_ulChunkSampleOffset = 0;
    m_ulChunkSize = 0;
    m_ulNumEntries = 0;
    m_ulChunkStartSampleNum = QT_BAD_IDX;
    m_ulSampleNum = QT_BAD_IDX;

    if (pAtom)
    {
	if (pAtom->GetType() == QT_stsz)
	{
	    m_pSampleSizeAtom = (CQT_stsz_Atom*) pAtom;
	}
	else
	{
	    m_pSampleSizeAtom = (CQT_stsz_Atom*) pAtom->FindPresentChild(QT_stsz);
	}

	if (m_pSampleSizeAtom)
	{
	    m_pSampleSizeAtom->AddRef();
	    m_ulGenericSize = m_pSampleSizeAtom->Get_SampleSize();
	    m_ulNumEntries = m_pSampleSizeAtom->Get_NumEntries();
	}
    }

    if (m_ulGenericSize == 0)
    {
	if (m_ulNumEntries == 0)
	{
	    retVal = HXR_NO_DATA;
	}
    }
    else
    {
	m_ulSampleSize = m_ulGenericSize;
	// All samples have the same size - do not need the table
	HX_RELEASE(m_pSampleSizeAtom);
	m_ulNumEntries = 0;
    }

    return retVal;
}

/****************************************************************************
 *  EstablishBySample
 */
BOOL CQT_SampleSize_Manager::EstablishBySample(ULONG32 ulSampleNum, 
					       ULONG32 ulChunkSampleNum,
					       ULONG32 ulSamplesPerChunk)
{
    ULONG32 ulChunkStartSampleNum;
    ULONG32 ulChunkEndSampleNum;

    if ((ulChunkSampleNum > 0) &&
	(ulSampleNum >= ulChunkSampleNum))
    {
	if (ulSamplesPerChunk < ulChunkSampleNum)
	{
	    ulSamplesPerChunk = ulChunkSampleNum;
	}

	if (m_ulGenericSize)
	{
	    m_ulChunkSampleOffset = (ulChunkSampleNum - 1) * m_ulGenericSize;
	    m_ulChunkSize = ulSamplesPerChunk * m_ulGenericSize;
	    return TRUE;
	}
	
	ulChunkStartSampleNum = ulSampleNum - ulChunkSampleNum;
	ulChunkEndSampleNum = ulChunkStartSampleNum + ulSamplesPerChunk;

	if (ulChunkEndSampleNum
	    <= m_ulNumEntries)
	{
	    // Convert to 0 based index for efficiency
	    ulSampleNum--;
	    
	    if (m_ulChunkStartSampleNum == ulChunkStartSampleNum)
	    {
		if (m_ulSampleNum == ulSampleNum)   // m_ulSampleNum is 1 based
		{
		    m_ulChunkSampleOffset += m_ulSampleSize;
		    m_ulSampleSize = m_pSampleSizeAtom->Get_SampleSize(m_ulSampleNum++);
		    return TRUE;
		}
		else if (m_ulSampleNum == (ulSampleNum + 1))
		{
		    // Already computed
		    return TRUE;
		}
	    }

	    // Convert to 0 based index for efficiency
	    ulChunkSampleNum--;
	    
	    m_ulSampleSize = m_pSampleSizeAtom->Get_SampleSize(ulSampleNum);
	    m_ulChunkStartSampleNum = ulChunkStartSampleNum;
	    m_ulSampleNum = ulSampleNum + 1;
	    
	    for (m_ulChunkSampleOffset = 0;
		 ulChunkStartSampleNum < ulSampleNum;
		 ulChunkStartSampleNum++)
	    {
		m_ulChunkSampleOffset += m_pSampleSizeAtom->
		    Get_SampleSize(ulChunkStartSampleNum);
	    }
	
	    /*** Not needed
	    m_ulChunkSize = m_ulChunkSampleOffset;
	    do
	    {
		m_ulChunkSize += m_pSampleSizeAtom->
		    Get_SampleSize(ulChunkStartSampleNum++);
	    } while (ulChunkStartSampleNum < ulChunkEndSampleNum);
	    ***/
	    
	    return TRUE;
	}
    }

    return FALSE;
}


/****************************************************************************
 *  Chunk To Offset Manager
 */
/****************************************************************************
 *  Constructor/Destructor
 */
CQT_ChunkToOffset_Manager::CQT_ChunkToOffset_Manager(void)
    : m_pChunkToOffsetAtom(NULL)
    , m_ulChunkOffset(0)
    , m_ulNumEntries(0)
{
    ;
}

CQT_ChunkToOffset_Manager::~CQT_ChunkToOffset_Manager()
{
    HX_RELEASE(m_pChunkToOffsetAtom);
}

/****************************************************************************
 *  Main Interface
 */
HX_RESULT CQT_ChunkToOffset_Manager::Init(CQTAtom* pAtom)
{
    HX_RESULT retVal = HXR_OK;

    HX_RELEASE(m_pChunkToOffsetAtom);
    m_ulChunkOffset = 0;
    m_ulNumEntries = 0;

    if (pAtom)
    {
	if (pAtom->GetType() == QT_stco)
	{
	    m_pChunkToOffsetAtom = (CQT_stco_Atom*) pAtom;
	}
	else
	{
	    m_pChunkToOffsetAtom = (CQT_stco_Atom*) pAtom->FindPresentChild(QT_stco);
	}

	if (m_pChunkToOffsetAtom)
	{
	    m_pChunkToOffsetAtom->AddRef();
	    m_ulNumEntries = m_pChunkToOffsetAtom->Get_NumEntries();
	}
    }

    if (m_ulNumEntries == 0)
    {
	retVal = HXR_FAIL;
	HX_RELEASE(m_pChunkToOffsetAtom);
    }
   
    return retVal;
}


/****************************************************************************
 *  Sample Description Manager
 */
/****************************************************************************
 *  Constructor/Destructor
 */
CQT_SampleDescription_Manager::CQT_SampleDescription_Manager(void)
    : m_ulSampleDescIdx(QT_BAD_IDX)
    , m_pSampleDescriptionAtom(NULL)
    , m_pSampleDesc(NULL)
    , m_ulDataRefIdx(QT_BAD_IDX)
    , m_ulDataFormat(0)
    , m_ulRTPTimeScale(0)
    , m_lTimeStampOffset(0)
    , m_lSequenceNumOffset(0)
    , m_ulNumEntries(0)
    , m_ulDataRefIdxOffset(1)
{
    ;
}

CQT_SampleDescription_Manager::~CQT_SampleDescription_Manager()
{
    HX_RELEASE(m_pSampleDescriptionAtom);
}

/****************************************************************************
 *  Main Interface Manager
 */
HX_RESULT CQT_SampleDescription_Manager::Init(CQTAtom* pAtom)
{
    HX_RESULT retVal = HXR_OK;

    HX_RELEASE(m_pSampleDescriptionAtom);
    m_ulSampleDescIdx = QT_BAD_IDX;
    m_pSampleDesc = NULL;