// Create the Stream response list.    m_pStreamList	= new CHXSimpleList;#if defined(HELIX_FEATURE_AUDIO_POSTMIXHOOK)    m_pPMixHookList	= new CHXSimpleList;#endif /* HELIX_FEATURE_AUDIO_POSTMIXHOOK */    m_pStreamRespList	= new CHXSimpleList;    if ( !m_pStreamList || !m_pStreamList->IsPtrListValid())	theErr = HXR_OUTOFMEMORY;#if defined(HELIX_FEATURE_AUDIO_POSTMIXHOOK)    if ( !m_pPMixHookList || !m_pPMixHookList->IsPtrListValid())	theErr = HXR_OUTOFMEMORY;#endif /* HELIX_FEATURE_AUDIO_POSTMIXHOOK */    if ( !m_pStreamRespList || !m_pStreamRespList->IsPtrListValid())	theErr = HXR_OUTOFMEMORY;#if defined(HELIX_FEATURE_VOLUME)    if( !theErr )    {        m_pPlayerVolume = (IHXVolume*)new CHXVolume;        if( m_pPlayerVolume )        {            m_pPlayerVolume->AddRef();            m_pPlayerVolume->AddAdviseSink(this);            //Start off with the volume at max.            m_pPlayerVolume->SetVolume(HX_MAX_VOLUME);        }        else        {            theErr = HXR_OUTOFMEMORY;        }    }#endif /* HELIX_FEATURE_VOLUME */    return ( theErr );}/************************************************************************ *  Method: *		CHXAudioPlayer::GetFormat *	Purpose: *		Return the player's device format which was determined in *		InitPlayer() and is based on all the streams. */void CHXAudioPlayer::GetFormat(	HXAudioFormat*   pAudioFormat){    memcpy(pAudioFormat, &m_PlayerFmt, sizeof( HXAudioFormat) );}/* *********************************************************************** *  Method: *      CHXAudioPlayer::GetAudioPrefs *  Purpose: *	Get audio related preferences. */HX_RESULT CHXAudioPlayer::GetAudioPrefs(){    IHXBuffer* pBuffer = NULL;    IHXPreferences* pPreferences = 0;#if defined(HELIX_FEATURE_PREFERENCES)    /* Reason we query for Preferences here and not at Init() is because     * Preferences may have been overwritten in HXPlayer by SetupClient()     * call by upper level client and this happens AFTER CHXAudioPlayer::Init()     * is called     */    if (!m_pContext)    {	return HXR_INVALID_PARAMETER;    }    m_pContext->QueryInterface(IID_IHXPreferences, (void**) &pPreferences);    //  What is the pref for this?    if( pPreferences )    {        if (pPreferences->ReadPref("SamplingRate", pBuffer) == HXR_OK)        {            m_bPrefUse11khz = (11025 == ::atol((const char*) pBuffer->GetBuffer()));            pBuffer->Release();            pBuffer = 0;        }	ReadPrefINT16(pPreferences, "BitsPerSample", m_uPrefBitsPerSample);	ReadPrefINT16(pPreferences, "Quality", m_uPrefAudioQuality);        /* hmmm... Looks like the client override default Preferences implementation*/        if (m_pPreferences != pPreferences)        {            if (m_pPreferences)            {                m_pPreferences->Release();            }            m_pPreferences = pPreferences;            m_pPreferences->AddRef();        }        pPreferences->Release();    }#endif /* HELIX_FEATURE_PREFERENCES */    return HXR_OK;}/************************************************************************ *  Method: *		IHXAudioPlay::CreateAudioStream *	Purpose: *       The renderer calls this to create a unique audio stream with its *	 unique audio format. */STDMETHODIMP CHXAudioPlayer::CreateAudioStream(    IHXAudioStream**		  pAudioStream){   HX_RESULT theErr = HXR_OK;    // Create a new IRMA audio stream    *pAudioStream = 0;    *pAudioStream = (IHXAudioStream*) new CHXAudioStream(this, m_pContext);    if ( !*pAudioStream )    {	theErr = HXR_OUTOFMEMORY;    }    // Add audio stream to my list    if (!theErr)    {	theErr = _CreateAudioStream(pAudioStream);    }    return theErr;}HX_RESULTCHXAudioPlayer::_CreateAudioStream(IHXAudioStream** pAudioStream){    (*pAudioStream)->AddRef();   // once for user    (*pAudioStream)->AddRef();   // once for me    // Add to the stream list.    m_pStreamList->AddTail((void*) *pAudioStream);    ((CHXAudioStream*)(*pAudioStream))->SetLive(m_bIsLive);    m_Owner->CheckIfLastNMilliSecsToBeStored();    /* Already initialized with no streams?*/    if (m_bInited && !m_bHasStreams)    {	/* If we are already initialized and there were no audio streams before	 * initialization, we must be using our fake timer to send time syncs	 * This needs to change now to get time syncs from the audio device	 */	((CHXAudioStream*)(*pAudioStream))->SetupToBeDone();	return HXR_OK;    }    m_bHasStreams = TRUE;    /* If we are already initialized, it means CreateAudioStream was     * called in the midst of the presentation. In this case, we already know     * the granularity and the Device format and thus call Setup right away     */    if ((*pAudioStream) && m_bInited)    {	((CHXAudioStream*)(*pAudioStream))->Setup( &m_DeviceFmt, m_ulGranularity );    }    return HXR_OK;}HX_RESULTCHXAudioPlayer::SetSoundLevel(CHXSimpleList* pAudioStreamList, UINT16 uSoundLevel, BOOL bReflushAudioDevice){    HX_RESULT	rc = HXR_OK;    IHXVolume* pStreamVolume = NULL;    if (pAudioStreamList && !pAudioStreamList->IsEmpty())    {	CHXSimpleList::Iterator lIter = pAudioStreamList->Begin();	for (; lIter != pAudioStreamList->End(); ++lIter)	{	    CHXAudioStream* pAudioStream = (CHXAudioStream*) (*lIter);	    pStreamVolume = pAudioStream->GetAudioVolume();	    if (pStreamVolume)	    {		pStreamVolume->SetVolume(uSoundLevel);	    }	    HX_RELEASE(pStreamVolume);	}	if (bReflushAudioDevice)	{	    AudioStreamStateChanged(E_PLAYING);	}    }    return rc;}HX_RESULT CHXAudioPlayer::ManageAudioStreams( CHXSimpleList* pStreamList,                                              STREAM_ACTION  what,                                              UINT32 ulTime ){    HX_RESULT    rc  = HXR_OK;    LISTPOSITION pos = 0;    if(pStreamList && !pStreamList->IsEmpty())    {	CHXSimpleList::Iterator it = pStreamList->Begin();	while( it != pStreamList->End() )	{	    CHXAudioStream* pAudioStream = (CHXAudioStream*) (*it);            switch(what)            {               case STR_STOP:                   pAudioStream->Stop();                   break;               case STR_SEEK:                   pAudioStream->Seek(ulTime);                   break;               case STR_RESUME:                   pAudioStream->Resume(FALSE);                   break;               case STR_PAUSE:                   pAudioStream->Pause(FALSE);                   break;               case STR_SETHINT:                   pAudioStream->SetAudioDeviceReflushHint(TRUE);                   break;               case STR_REMOVE:                   pos = m_pStreamList->Find(pAudioStream);                   if (pos)                       m_pStreamList->RemoveAt(pos);                   pAudioStream->Stop();                   HX_RELEASE(pAudioStream);                   break;               default:                   HX_ASSERT("bad stream action taken"==NULL);            }            ++it;	}        //Post stream iteration actions.        switch(what)        {           case STR_STOP:               AudioStreamStateChanged(E_STOPPED);               break;           case STR_PAUSE:               AudioStreamStateChanged(E_PAUSED);               break;           case STR_SETHINT:               m_Owner->CheckIfLastNMilliSecsToBeStored();               break;           case STR_REMOVE:               if( 0 == m_pStreamList->GetCount())               {                   m_bHasStreams = FALSE;                   m_Owner->Stop(this, TRUE);                   m_bInited = FALSE;                   if(HXR_OK != (rc=Setup(m_ulGranularity)))                   {                       IHXErrorMessages* pErrorMessage = NULL;                       m_pContext->QueryInterface(IID_IHXErrorMessages, (void**) &pErrorMessage);                       if (pErrorMessage)                       {                           pErrorMessage->Report(HXLOG_ERR, rc, 0, NULL, NULL);                           pErrorMessage->Release();                       }                       rc = HXR_OK;                   }                   else                   {                       rc = ResumeFakeTimeline();                   }               }               else               {                   AudioStreamStateChanged(E_STOPPED);               }               break;           default:               HX_ASSERT("bad stream action taken"==NULL );        }    }    return rc;}HX_RESULTCHXAudioPlayer::AudioStreamStateChanged(EPlayerState eState){    if(!m_Owner->GetDisableMultiPlayPauseSupport())    {	// we only concern about the state change of audio stream	// while its parent audio player is in playing mode	if (m_eState == E_PLAYING)	{	    switch (eState)	    {	    case E_PLAYING:		m_Owner->RewindSession();		m_Owner->ActualResume();		break;	    case E_PAUSED:	    case E_STOPPED:		m_Owner->RewindSession();		if (NumberOfResumedStreams() > 0 ||		    m_Owner->NumberOfResumedPlayers() > 0)		{		    m_Owner->ActualResume();		}		break;	    default:		break;	    }	}    }    return HXR_OK;}CHXAudioStream*CHXAudioPlayer::GetCHXAudioStream(UINT16 uIndex){    LISTPOSITION lp = 0;    lp = m_pStreamList->FindIndex( (int) uIndex );    if ( lp )    {	return (CHXAudioStream*)m_pStreamList->GetAt(lp);    }    else    {        return NULL;    }}BOOLCHXAudioPlayer::IsLastNMilliSecsToBeStored(){    BOOL bResult = FALSE;    if (m_bHasStreams)    {	CHXAudioStream* s = 0;	CHXSimpleList::Iterator lIter = m_pStreamList->Begin();	for (; lIter != m_pStreamList->End(); ++lIter)	{	    s = (CHXAudioStream*) (*lIter);	    if (s->IsAudioDeviceReflushHint())	    {		bResult = TRUE;		break;	    }	}    }    return bResult;}HX_RESULTCHXAudioPlayer::ActualAddPostMixHook(IHXAudioHook* pHook,	    			     const BOOL	    bDisableWrite,				     const BOOL	    bFinal){    if (!m_pPMixHookList || !pHook)    {	return HXR_FAILED;    }#if defined(HELIX_FEATURE_AUDIO_POSTMIXHOOK)    /* Check if this one already exists */    HXAudioHookInfo* h = 0;    LISTPOSITION lp = 0;    lp = m_pPMixHookList->GetHeadPosition();    while( lp )    {	h = (HXAudioHookInfo*) m_pPMixHookList->GetNext(lp);	if (pHook == h->pHook)	{	    return HXR_FAILED;	}    }    h = (HXAudioHookInfo*) new HXAudioHookInfo;    h->pHook   = pHook;    h->bDisableWrite = bDisableWrite;    h->bFinal  = bFinal;    h->bIgnoreAudioData = FALSE;    h->bMultiChannelSupport = FALSE;    IHXValues* pValues = NULL;    if (pHook && pHook->QueryInterface(IID_IHXValues, (void**) &pValues) == HXR_OK)    {	UINT32 ulValue = 0;	pValues->GetPropertyULONG32("IgnoreAudioData", ulValue);	h->bIgnoreAudioData = (ulValue == 1);	HX_RELEASE(pValues);    }    IHXAudioMultiChannel* pMultiChannel = NULL;    if (pHook && HXR_OK == pHook->QueryInterface(IID_IHXAudioMultiChannel, (void**) &pMultiChannel))    {        h->bMultiChannelSupport = pMultiChannel->GetMultiChannelSupport();    }    HX_RELEASE(pMultiChannel);    if (bDisableWrite)    {	m_bDisableWrite = bDisableWrite;    }    pHook->AddRef();    // Order list by putting all bFinal == TRUE at end of list.    if ( m_pPMixHookList->IsEmpty() || !bFinal )    {	m_pPMixHookList->AddHead((void*) h);    }    else    {	m_pPMixHookList->AddTail((void*) h);    }    m_Owner->PostMixHooksUpdated();    ProcessAudioHook(ACTION_ADD, pHook);    /* If we are already initialized, send the device format to the     * post hook     */    if (m_bInited)    {	if (h->bIgnoreAudioData ||	    HXR_OK == ProcessAudioHook(ACTION_CHECK, pHook))	{	    HXAudioFormat audioFmt;	    m_Owner->GetFormat( &audioFmt );	    pHook->OnInit( &audioFmt );	}    }#endif /* HELIX_FEATURE_AUDIO_POSTMIXHOOK */    return HXR_OK;}HX_RESULTCHXAudioPlayer::ActualRemovePostMixHook(IHXAudioHook* pHook){    if (!m_pPMixHookList || !pHook)    {	return HXR_FAILED;    }#if defined(HELIX_FEATURE_AUDIO_POSTMIXHOOK)    BOOL bCheckForDisableWrite	= FALSE;    BOOL bFound			= FALSE;    HXAudioHookInfo* h = 0;    LISTPOSITION lp, lastlp;    lp = lastlp = 0;    lp = m_pPMixHookList->GetHeadPosition();    while( lp )    {	lastlp = lp;	h = (HXAudioHookInfo*) m_pPMixHookList->GetNext(lp);	if ( pHook == h->pHook )	{	    if (h->bDisableWrite)	    {		m_bDisableWrite		= FALSE;		bCheckForDisableWrite	= TRUE;	    }	    ProcessAudioHook(ACTION_REMOVE, pHook);	    h->pHook->Release();	    delete h;	    h = 0;	    m_pPMixHookList->RemoveAt(lastlp);	    bFound = TRUE;	    break;	}    }    if (!bFound)    {	return HXR_FAILED;    }    m_Owner->PostMixHooksUpdated();    if ( m_pPMixHookList && bCheckForDisableWrite && m_pPMixHookList->GetCount() > 0)    {	HXAudioHookInfo* h = 0;	LISTPOSITION lp, lastlp;	lp = lastlp = 0;	lp = m_pPMixHookList->GetHeadPosition();   	while( lp )	{	    h = (HXAudioHookInfo*) m_pPMixHookList->GetNext(lp);	    if (h->bDisableWrite)	    {		m_bDisableWrite = TRUE;		break;	    }	}    }#endif /* HELIX_FEATURE_AUDIO_POSTMIXHOOK */    return HXR_OK;}/************************************************************************ *  Method: *      CHXAudioPlayer::SetGranularity *  Purpose: *       The HELIX player object calls this BEFORE starting audio playback *       and AFTER all audio streams are created for the renderers. */void CHXAudioPlayer::SetGranularity(    const ULONG32  ulGranularity){    m_ulGranularity = ulGranularity;    return;}/************************************************************************ *  Method: *		CHXAudioPlayer::Resume *	Purpose: *		Resume audio playback by writing data to the audio device. *		Open the audio device if it is not opened already. */HX_RESULT CHXAudioPlayer::Resume(){    HX_RESULT theErr = HXR_OK;    if (!m_bInited)	return HXR_NOT_INITIALIZED;