hxsrc.cpp

linux下的一款播放器

    {
	char* pszTemp = NULL;

	pszTemp = ::HXFindChar(m_pszURL, '?');
	if (pszTemp)
	{
		int lenTemp = strlen(m_pszURL) + strlen("&mimeType=") + strlen(RAM_MIMETYPE) + 1;
	    pszTemp = new char[lenTemp];
	    SafeSprintf(pszTemp, lenTemp, "%s%s%s", m_pszURL, "&mimeType=", RAM_MIMETYPE); /* Flawfinder: ignore */
	}
	else
	{
		int lenTemp = strlen(m_pszURL) + strlen("?mimeType=") + strlen(RAM_MIMETYPE) + 1;
	    pszTemp = new char[lenTemp];
	    SafeSprintf(pszTemp, lenTemp, "%s%s%s", m_pszURL, "?mimeType=", RAM_MIMETYPE); /* Flawfinder: ignore */
	}

	HX_VECTOR_DELETE(m_pszURL);
	m_pszURL = pszTemp;
    }

    return m_pszURL;
}


/************************************************************************
 *	Method:
 *	    IHXStreamSource::GetStreamCount
 *	Purpose:
 *	    Get the number of streams in this source
 *
 */
STDMETHODIMP_(UINT16)
HXSource::GetStreamCount()
{
    return m_HXStreamList.GetCount();
}


/************************************************************************
 *	Method:
 *	    IHXStreamSource::GetStream
 *	Purpose:
 *	    Get the stream with the given index.
 *	Note: 
 *	    Since stream numbers may not be zero based, stream index is not
 *	    equal to the stream number. Actual stream number may be determined 
 *	    from IHXStream::GetStreamNumber()
 *
 */
STDMETHODIMP
HXSource::GetStream
(
    UINT16 nIndex,
    REF(IUnknown*) pUnknown
)
{
    LISTPOSITION lPosition = m_HXStreamList.FindIndex((int) nIndex);
    if (!lPosition)
    {
	pUnknown = NULL;
	return HXR_INVALID_PARAMETER;
    }

    HXStream* pStream = (HXStream*) m_HXStreamList.GetAt(lPosition);
    HX_ASSERT(pStream);

    return pStream->QueryInterface(IID_IUnknown,(void**)&pUnknown);
}


// IHXPrivateStreamSource methods 
STDMETHODIMP_(BOOL) HXSource::IsSaveAllowed()
{
    return mSaveAsAllowed;
}


/*
 * IHXBackChannel method
 */

/************************************************************************
 *	Method:
 *	    IHXBackChannel::PacketReady
 *	Purpose:
 *      A back channel packet sent from Renderer to FileFormat plugin.
 */
STDMETHODIMP
HXSource::PacketReady(IHXPacket* pPacket)
{
    HX_ASSERT(m_pBackChannel);

    if (m_pBackChannel)
    {
	return m_pBackChannel->PacketReady(pPacket);
    }

    return HXR_FAIL;
}


/*
 * IHXASMSource methods
 */

/************************************************************************
 *	Method:
 *	    IHXASMSource::Subscribe
 *	Purpose:
 *      Called to inform a file format that a subscription has occurred,
 *	    to rule number uRuleNumber, for stream uStreamNumber.
 */
STDMETHODIMP
HXSource::Subscribe(UINT16	uStreamNumber,
		     UINT16	uRuleNumber)
{
    HX_ASSERT(m_pASMSource);

    if (m_pASMSource)
    {
	return m_pASMSource->Subscribe(uStreamNumber, uRuleNumber);
    }

    return HXR_FAIL;
}

/************************************************************************
 *	Method:
 *	    IHXASMSource::Unsubscribe
 *	Purpose:
 *      Called to inform a file format that a unsubscription has occurred,
 *	    to rule number uRuleNumber, for stream uStreamNumber.
 */
STDMETHODIMP
HXSource::Unsubscribe(UINT16	uStreamNumber,
		       UINT16	uRuleNumber)
{
    HX_ASSERT(m_pASMSource);

    if (m_pASMSource)
    {
	return m_pASMSource->Unsubscribe(uStreamNumber, uRuleNumber);
    }

    return HXR_FAIL;
}

void	
HXSource::AddHXStream(HXStream* pStream)
{
    pStream->AddRef();
    m_HXStreamList.AddTail(pStream);

    UINT16 uStreamNumber = pStream->GetStreamNumber();
    STREAM_INFO* pStreamInfo;
    if (mStreamInfoTable->Lookup((LONG32) uStreamNumber, (void*& )pStreamInfo))
    {
	pStreamInfo->m_pStream = pStream;
	pStreamInfo->m_pStream->AddRef();

	pStreamInfo->BufferingState().OnStream((IHXStream*)pStream);
    }
}

HX_RESULT
HXSource::CollectAudioStreams(CHXSimpleList*& pAudioStreamList)
{
#if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
    HX_RESULT	    rc = HXR_OK;
    UINT16	    i = 0;
    UINT16	    uNumAudioStreams = 0;
    CHXAudioPlayer* pAudioPlayer = NULL;
    CHXAudioStream* pCHXAudioStream = NULL;
    IHXValues*	    pHeader = NULL;

    pAudioStreamList = NULL;

    if (!m_pPlayer)
    {
	goto cleanup;
    }

    pAudioPlayer = m_pPlayer->GetAudioPlayer();
    if (!pAudioPlayer)
    {
	goto cleanup;
    }

    uNumAudioStreams = pAudioPlayer->GetAudioStreamCount();
    for (i = 0; i < uNumAudioStreams; i++)
    {
	pCHXAudioStream = pAudioPlayer->GetCHXAudioStream(i);
	pCHXAudioStream->AddRef();

	pHeader = ((IHXAudioStream*)pCHXAudioStream)->GetStreamInfo();

	if (pHeader &&
	    IsAudioStreamFromThisSource(pHeader))
	{
	    if (!pAudioStreamList)
	    {
		pAudioStreamList = new CHXSimpleList();
	    }

	    pAudioStreamList->AddTail(pCHXAudioStream);
	}
	else
	{
	    HX_RELEASE(pCHXAudioStream);
	}
	HX_RELEASE(pHeader);	
    }

cleanup:

    if (!pAudioStreamList)
    {	 
	rc = HXR_FAILED;
    }

    return rc;
#else
    return HXR_NOTIMPL;
#endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
}

void		
HXSource::RemoveAudioStreams(void)
{    
#if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
    CHXAudioPlayer* pAudioPlayer = NULL;
    CHXSimpleList*  pAudioStreamList = NULL;

    if (!m_pPlayer)
    {
	goto cleanup;
    }

    pAudioPlayer = m_pPlayer->GetAudioPlayer();
    if (!pAudioPlayer)
    {
	goto cleanup;
    }

    pAudioPlayer->AddRef();

    if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
    {
	pAudioPlayer->ManageAudioStreams(pAudioStreamList, CHXAudioPlayer::STR_REMOVE);

	ReleaseAudioStreams(pAudioStreamList);
	HX_DELETE(pAudioStreamList);
    }

    HX_RELEASE(pAudioPlayer);

cleanup:
#endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */

    return;
}

void
HXSource::PauseAudioStreams(void)
{
#if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
    CHXAudioPlayer* pAudioPlayer = NULL;
    CHXSimpleList*  pAudioStreamList = NULL;

    if (!m_pPlayer)
    {
	goto cleanup;
    }

    pAudioPlayer = m_pPlayer->GetAudioPlayer();
    if (!pAudioPlayer)
    {
	goto cleanup;
    }

    pAudioPlayer->AddRef();

    if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
    {
	pAudioPlayer->ManageAudioStreams(pAudioStreamList, CHXAudioPlayer::STR_PAUSE);

	ReleaseAudioStreams(pAudioStreamList);
	HX_DELETE(pAudioStreamList);
    }

    HX_RELEASE(pAudioPlayer);

cleanup:
#endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */

    return;
}

void
HXSource::ResumeAudioStreams(void)
{
#if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
    CHXAudioPlayer* pAudioPlayer = NULL;
    CHXSimpleList*  pAudioStreamList = NULL;

    if (!m_pPlayer)
    {
	goto cleanup;
    }

    pAudioPlayer = m_pPlayer->GetAudioPlayer();
    if (!pAudioPlayer)
    {
	goto cleanup;
    }

    pAudioPlayer->AddRef();

    if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
    {
	pAudioPlayer->ManageAudioStreams(pAudioStreamList, CHXAudioPlayer::STR_RESUME);

	ReleaseAudioStreams(pAudioStreamList);
	HX_DELETE(pAudioStreamList);
    }

    HX_RELEASE(pAudioPlayer);

cleanup:
#endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */

    return;
}

void
HXSource::ReleaseAudioStreams(CHXSimpleList* pAudioStreamList)
{
#if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
    if (pAudioStreamList && !pAudioStreamList->IsEmpty())
    {
	CHXSimpleList::Iterator lIter = pAudioStreamList->Begin();
	for (; lIter != pAudioStreamList->End(); ++lIter)
	{
	    CHXAudioStream* pAudioStream = (CHXAudioStream*) (*lIter);
	    HX_RELEASE(pAudioStream);
	}
    }
#endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */

    return;
}

HX_RESULT HXSource::Init(HXPlayer * pPlayer, UINT32 unRegistryID)
{
    HX_RESULT	theErr = HXR_OK;
   
    m_pPlayer = pPlayer;
    if (m_pPlayer->QueryInterface(IID_IHXPreferences, (void **) &m_pPreferences) != HXR_OK)
    {
	theErr = HXR_INVALID_PARAMETER;	//HX_INVALID_INTERFACE;
    }

    m_pBufferManager = new CBufferManager(this);
    if(!m_pBufferManager)
    {
        theErr = HXR_OUTOFMEMORY;
    }

    // create registry entries
    if (HXR_OK != m_pPlayer->QueryInterface(IID_IHXRegistry, (void**)&m_pRegistry))
    {
	m_pRegistry = NULL;
    }
    else
    {
	m_ulRegistryID = unRegistryID;
    }

    if (!theErr &&
	m_pPlayer->QueryInterface(IID_IHXScheduler, (void **) &m_pScheduler) != HXR_OK)
    {
	theErr = HXR_INVALID_PARAMETER;	//HX_INVALID_INTERFACE;
    }

    IHXPreferences* pPref = NULL;

    m_pPlayer->QueryInterface(IID_IHXPreferences, (void**)&pPref);
    if (HXR_OK == ReadPrefINT32(pPref, "TurboPushdown", m_ulTurboPushDown))
    {
	m_ulTurboPushDown = (m_ulTurboPushDown / 100) * 100;  // round to multiple of 100
    }
    HX_RELEASE(pPref);

    m_pEngine = m_pPlayer->m_pEngine;
    m_pEngine->AddRef();

    return theErr;
}

HX_RESULT HXSource::SetupRegistry()
{
    HX_RESULT	theErr = HXR_OK;
#if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
    UINT32	ulRepeatedRegistryID = 0;
    IHXBuffer*	pRepeatRegName = NULL;
    char        szSourceName[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */

    HX_ASSERT(m_pSourceInfo);    

    if (m_pSourceInfo->m_bLeadingSource &&
	!m_pSourceInfo->m_pRepeatList)
    {
	m_pStats = new SOURCE_STATS(m_pRegistry, m_ulRegistryID);
    }
    else if (m_pRegistry && 
	    HXR_OK == m_pRegistry->GetPropName(m_pPlayer->m_ulRepeatedRegistryID, pRepeatRegName))
    {
	SafeSprintf(szSourceName, MAX_DISPLAY_NAME, "%s.%ld%ld%ld", 
		pRepeatRegName->GetBuffer(),
		m_pSourceInfo->m_uGroupID,
		m_pSourceInfo->m_uTrackID,
		(int)m_pSourceInfo->m_bLeadingSource);
    
	ulRepeatedRegistryID = m_pRegistry->GetId(szSourceName);
	if (!ulRepeatedRegistryID)
	{
	    ulRepeatedRegistryID = m_pRegistry->AddComp(szSourceName);
	}

	m_pStatsManager = new StatsManager(m_pRegistry, m_ulRegistryID, ulRepeatedRegistryID);
	m_pStatsManager->AddRef();

	m_pStats = new SOURCE_STATS(m_pRegistry, ulRepeatedRegistryID);
        if( !m_pStats )
        {
            theErr = HXR_OUTOFMEMORY;
        }
    }
    else
    {
	// why stats' creation failed??
	HX_ASSERT(FALSE);
    }

    HX_RELEASE(pRepeatRegName);
#endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */

    return theErr;
}

HX_RESULT HXSource::ReadPreferences(void)
{
    UINT32      un16Temp = 10;

    ReadPrefINT32(m_pPreferences, "PerfectPlayTime", un16Temp); 
    m_ulPerfectPlayTime = un16Temp;

    ReadPrefINT32(m_pPreferences, "BufferedPlayTime", un16Temp);
    m_ulBufferedPlayTime = un16Temp;

    ReadPrefBOOL(m_pPreferences, "PerfPlayEntireClip", m_bPerfectPlayEntireClip); 

    return HXR_OK;
}


HX_RESULT HXSource::DeleteStreamTable(void)
{
    HX_RESULT theErr = HXR_OK;

    STREAM_INFO	* sInfo = NULL;
	
    for (CHXMapLongToObj::Iterator i = mStreamInfoTable->Begin();
         i != mStreamInfoTable->End(); ++i) 
    {    
	sInfo = (STREAM_INFO*) (*i);
	
	if (sInfo)
	{
	    HX_DELETE (sInfo);
	}
    }

    mStreamInfoTable->RemoveAll();
    m_ulStreamIndex = 0;
    m_uNumStreams = 0;
    
    return theErr;
}	


IHXValues* HXSource::GetHeaderInfo(UINT16 stream_number)
{
    STREAM_INFO	* pStreamInfo;
    if (mStreamInfoTable->Lookup((LONG32) stream_number, (void*& )pStreamInfo))
    {
	return pStreamInfo->m_pHeader;
    }
    else
    {
	return NULL;
    }
}

HX_RESULT	
HXSource::GetStreamHeaderInfo(UINT16 index, IHXValues*& hdr)
{
    HX_TRACE("HXSource::GetStreamHeaderInfo");
    
    // sanity check
    if (index >= m_uNumStreams)
    {
	return HXR_INVALID_PARAMETER; // HX_INVALID_INDEX;
    }
    
    CHXMapLongToObj::Iterator i = mStreamInfoTable->Begin();
    for (UINT16 j=0; j < index; j++)
    {
	++i;
    }

    STREAM_INFO* pStreamInfo = (STREAM_INFO*) *i;

    hdr = pStreamInfo->m_pHeader;
    if (hdr)
    {
	hdr->AddRef();
    }

    return HXR_OK;
}


void	HXSource::SetFlags(UINT16 flags)
{
    mFlags = flags;