开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxaudply.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：59k
源码类别：

Symbian

开发平台：

Visual C++

hxaudply.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: hxaudply.cpp,v 1.25.2.3 2004/07/09 02:08:08 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hlxclib/stdio.h"
  51. #include "hlxclib/stdlib.h"
  52. #include "hlxclib/string.h"
  54. #ifndef WIN32_PLATFORM_PSPC
  55. #include "hlxclib/signal.h"
  56. #endif
  58. #include "hxresult.h"
  59. #include "hxtypes.h"
  60. #include "hxslist.h"
  61. #include "hxcom.h"
  63. #include "ihxpckts.h"
  64. #include "hxengin.h"
  65. #include "hxprefs.h"
  66. #include "hxausvc.h"
  67. #include "hxrasyn.h"
  68. #include "hxerror.h"
  69. #include "hxcore.h"
  71. #include "hxmap.h"
  73. #include "hxaudply.h"
  74. #include "hxaudstr.h"
  75. #include "hxaudses.h"
  76. #include "hxaudvol.h"
  78. #include "hxaudtyp.h"
  80. #include "timeval.h"
  81. #include "hxtick.h"
  83. #ifdef _MACINTOSH
  84. #include "hxmm.h"
  86. extern  ULONG32 gTIMELINE_MUTEX;
  87. #endif
  89. #include "hxheap.h"
  90. #ifdef _DEBUG
  91. #undef HX_THIS_FILE
  92. static const char HX_THIS_FILE[] = __FILE__;
  93. #endif
  95. #if defined(HELIX_FEATURE_PREFERENCES)
  96. #include "hxprefs.h"
  97. #include "hxprefutil.h"
  98. #endif /* HELIX_FEATURE_PREFERENCES */
  100. #ifdef HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES
  101. // These values were arrived at via trial and error on a linux, xi586 (pentium)
  102. #define MINIMUM_AUDIO_GRANULARITY 50
  103. #define MAXIMUM_AUDIO_GRANULARITY 100
  104. #else
  105. #define MINIMUM_AUDIO_GRANULARITY 50
  106. #define MAXIMUM_AUDIO_GRANULARITY 100
  107. #endif
  109. #define MAX_WAIT_AT_SAME_TIME (MAXIMUM_AUDIO_GRANULARITY+50)
  111. CHXAudioPlayer::CHXAudioPlayer( CHXAudioSession* owner )
  112. : m_lRefCount(0)
  113. ,       m_ulCallbackID(0)
  114. , m_pContext(0)
  115. , m_bInited(FALSE)
  116. , m_ulGranularity(0)
  117. , m_Owner(owner)
  118. , m_pStreamList(0)
  119. , m_pRealAudioStreamList(0)
  120. , m_bAdjustForRealAudio(FALSE)
  121. , m_pPlayerResponse(0)
  122. , m_pScheduler (0)
  123. , m_pPreferences(0)
  124. , m_bHasStreams(FALSE)
  125. , m_bIsLive(FALSE)
  126. , m_ulCurrentTime(0)
  127. , m_ulLastCurrentTimeReturned(0)
  128. , m_ulLastDeviceTimeAdjusted(0)
  129. , m_bTimeReturned(FALSE)
  130. , m_pPMixHookList(0)
  131. , m_ulBytesPerGran(0)
  132. , m_pStreamRespList(0)
  133. , m_ulASstartTime(0)
  134. , m_ulAPplaybackTime(0)
  135. , m_ulAPstartTime(0)
  136. , m_ulADresumeTime(0)
  137. ,  m_eState(E_STOPPED)
  138. , m_bPrefUse11khz(FALSE)
  139. , m_uPrefBitsPerSample(16)
  140. , m_uPrefAudioQuality(4)
  141. , m_pFakeAudioCBTime(0)
  142. , m_ulLastFakeCallbackTime(0)
  143. , m_ulIncreasingTimer(0)
  144. , m_bDisableWrite(FALSE)
  145. , m_bIsResumed(FALSE)
  146. , m_ulTimeAdjustDoneAt(0)
  147. , m_bIsDonePlayback(TRUE)
  148. , m_bIsFirstResume(TRUE)
  149. , m_bCanBeRewound(FALSE)
  150. , m_uVolume(0)
  151. , m_bMute(FALSE)
  152. , m_bHasDataInAudioDevice(FALSE)
  153. , m_llLastWriteTime(0)
  154. {
  155. #ifdef HELIX_FEATURE_VOLUME
  156.     m_pPlayerVolume = NULL;
  157. #endif
  159.     m_Owner->AddRef();
  160.     m_pFakeAudioCBTime = new Timeval;
  161.     // NOTE: we should add some check on the success of this allocation.
  163.     /* Default value of Player format */
  164.     m_PlayerFmt.uChannels = 2;
  165.     m_PlayerFmt.uBitsPerSample = 16;
  166.     m_PlayerFmt.ulSamplesPerSec = 16000;
  167.     m_PlayerFmt.uMaxBlockSize = 64000;
  168. }
  170. /************************************************************************
  171.  *  Method:
  172.  * IHXAudioPlayer::~CHXAudioPlayer()
  173.  * Purpose:
  174.  * Destructor. Clean up and set free.
  175.  */
  176. CHXAudioPlayer::~CHXAudioPlayer()
  177. {
  178.     Close();
  179. }
  181. void CHXAudioPlayer::Close(void)
  182. {
  183.     ResetPlayer();
  185.     HX_DELETE(m_pStreamList);
  186.     HX_DELETE(m_pRealAudioStreamList);
  188.     HX_RELEASE(m_pContext);
  189. #if defined(HELIX_FEATURE_PREFERENCES)
  190.     HX_RELEASE(m_pPreferences);
  191. #endif /* HELIX_FEATURE_PREFERENCES */
  192.     HX_RELEASE(m_pPlayerResponse);
  194.     if ( m_pPMixHookList )
  195.     {
  196. HXAudioHookInfo* pMixHookInfo  = 0;
  197. while(!m_pPMixHookList->IsEmpty())
  198. {
  199.     pMixHookInfo = (HXAudioHookInfo*) m_pPMixHookList->RemoveHead();
  200.     pMixHookInfo->pHook->Release();
  201.     delete pMixHookInfo;
  202. }
  204. delete m_pPMixHookList;
  205. m_pPMixHookList = 0;
  206.     }
  208.     // Delete all stream response items.
  209.     if ( m_pStreamRespList )
  210.     {
  211. IHXAudioStreamInfoResponse*   pAudioStreamInfoResponse = 0;
  212. while(!m_pStreamRespList->IsEmpty())
  213. {
  214.     pAudioStreamInfoResponse =
  215.      (IHXAudioStreamInfoResponse*) m_pStreamRespList->RemoveHead();
  217.     pAudioStreamInfoResponse->Release();
  218. }
  220. delete m_pStreamRespList;
  221. m_pStreamRespList = 0;
  222.     }
  224. #ifdef HELIX_FEATURE_VOLUME
  225.     if( m_pPlayerVolume )
  226.     {
  227.         m_pPlayerVolume->RemoveAdviseSink((IHXVolumeAdviseSink*)this);
  228.         m_pPlayerVolume->Release();
  229.         m_pPlayerVolume = NULL;
  230.     }
  231. #endif
  233.     // Delete IRMA volume object.
  234.     HX_DELETE(m_pFakeAudioCBTime);
  235.     HX_RELEASE(m_Owner);
  236.     HX_RELEASE(m_pScheduler);
  237. }
  239. /////////////////////////////////////////////////////////////////////////
  240. //  Method:
  241. //      IUnknown::QueryInterface
  242. //  Purpose:
  243. //      Implement this to export the interfaces supported by your
  244. //      object.
  245. //
  246. STDMETHODIMP CHXAudioPlayer::QueryInterface(REFIID riid, void** ppvObj)
  247. {
  248.     QInterfaceList qiList[] =
  249.         {
  250.             { GET_IIDHANDLE(IID_IHXAudioPlayer), (IHXAudioPlayer*)this },
  251. #if defined(HELIX_FEATURE_CROSSFADE)
  252.             { GET_IIDHANDLE(IID_IHXAudioCrossFade), (IHXAudioCrossFade*)this },
  253. #endif /* HELIX_FEATURE_CROSSFADE */
  254. #if defined(HELIX_FEATURE_VOLUME)
  255.             { GET_IIDHANDLE(IID_IHXVolumeAdviseSink), (IHXVolumeAdviseSink*)this },
  256. #endif /* HELIX_FEATURE_VOLUME */
  257.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXAudioPlayer*)this },
  258.         };
  260.     HX_RESULT res = ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  262.     // if succeeded, return immediately...
  263.     if (SUCCEEDED(res))
  264.     {
  265.         return res;
  266.     }
  267.     // ...otherwise, proceed.
  269.     if (m_Owner &&
  270.      m_Owner->QueryInterface(riid, ppvObj) == HXR_OK)
  271.     {
  272. return HXR_OK;
  273.     }
  275.     *ppvObj = NULL;
  276.     return HXR_NOINTERFACE;
  277. }
  279. /////////////////////////////////////////////////////////////////////////
  280. //  Method:
  281. //      IUnknown::AddRef
  282. //  Purpose:
  283. //      Everyone usually implements this the same... feel free to use
  284. //      this implementation.
  285. //
  286. STDMETHODIMP_(ULONG32) CHXAudioPlayer::AddRef()
  287. {
  288.     return InterlockedIncrement(&m_lRefCount);
  289. }
  291. /////////////////////////////////////////////////////////////////////////
  292. //  Method:
  293. //      IUnknown::Release
  294. //  Purpose:
  295. //      Everyone usually implements this the same... feel free to use
  296. //      this implementation.
  297. //
  298. STDMETHODIMP_(ULONG32) CHXAudioPlayer::Release()
  299. {
  300.     if (InterlockedDecrement(&m_lRefCount) > 0)
  301.     {
  302.         return m_lRefCount;
  303.     }
  305.     delete this;
  306.     return 0;
  307. }
  309. /*
  310.  *  IHXAudioPlayer methods
  311.  */
  312. /************************************************************************
  313.  *  Method:
  314.  *              IHXAudioPlay::AddPostMixHook
  315.  *      Purpose:
  316.  *       Call this to add a post mix hook of the audio data.
  317.  */
  318. STDMETHODIMP CHXAudioPlayer::AddPostMixHook
  319. (
  320.     IHXAudioHook* pHook,
  321.     const BOOL bDisableWrite,
  322.     const BOOL          bFinal
  323. )
  324. {
  325.     /* We only allow adding Hooks before the playback has started */
  326.     if (m_bInited)
  327.     {
  328. return HXR_FAILED;
  329.     }
  331.     return ActualAddPostMixHook(pHook, bDisableWrite, bFinal);
  332. }
  334. /************************************************************************
  335.  *  Method:
  336.  *              IHXAudioPlay::RemovePostMixHook
  337.  *      Purpose:
  338.  *       Call this to remove a post mix hook.
  339.  */
  340. STDMETHODIMP CHXAudioPlayer::RemovePostMixHook
  341. (
  342.     IHXAudioHook* pHook
  343. )
  344. {
  345.     /* We only allow removing Hooks after the playback has stopped */
  346.     if (m_bInited)
  347.     {
  348. return HXR_FAILED;
  349.     }
  351.     return ActualRemovePostMixHook(pHook);
  352. }
  354. /************************************************************************
  355. *  Method:
  356. *      IHXAudioPlayer::GetAudioStreamCount
  357. *  Purpose:
  358. * Get the number of audio streams currently active in the
  359. * audio player. Since streams can be added mid-presentation
  360. * this function may return different values on different calls.
  361. * If the user needs to know about all the streams as they get
  362. * get added to the player, IHXAudioStreamInfoResponse should
  363. * be implemented and passed in SetStreamInfoResponse.
  364. */
  365. STDMETHODIMP_(UINT16) CHXAudioPlayer::GetAudioStreamCount()
  366. {
  367.     HX_ASSERT(m_pStreamList);
  368.     if (m_pStreamList)
  369.     {
  370. return (UINT16) m_pStreamList->GetCount();
  371.     }
  372.     else
  373.     {
  374. return 0;
  375.     }
  376. }
  378. /************************************************************************
  379.  *  Method:
  380.  *              IHXAudioPlayer::GetAudioStream
  381.  *      Purpose:
  382.  */
  383. STDMETHODIMP_(IHXAudioStream*) CHXAudioPlayer::GetAudioStream
  384. (
  385.     UINT16  uIndex
  386. )
  387. {
  388.     LISTPOSITION lp = 0;
  389.     lp = m_pStreamList->FindIndex( (int) uIndex );
  390.     if ( lp )
  391.     {
  392. CHXAudioStream* s = 0;
  393. s = (CHXAudioStream*) m_pStreamList->GetAt(lp);
  394. s->AddRef();
  395. return s;
  396.     }
  397.     else
  398.         return 0;
  399. }
  401. /************************************************************************
  402.  *  Method:
  403.  *              IHXAudioPlayer::GetAudioVolume
  404.  *      Purpose:
  405.  * Return this player's IRMA volume interface.
  406.  */
  407. STDMETHODIMP_(IHXVolume*) CHXAudioPlayer::GetAudioVolume()
  408. {
  409.     IHXVolume* pRet = NULL;
  410. #ifdef HELIX_FEATURE_VOLUME
  411.     if( m_pPlayerVolume )
  412.     {
  413.         m_pPlayerVolume->AddRef();
  414.         pRet = m_pPlayerVolume;
  415.     }
  416. #endif
  417.     return pRet;
  418. }
  420. /************************************************************************
  421.  *  Method:
  422.  *              IHXAudioPlayer::GetDeviceVolume
  423.  *      Purpose:
  424.  * Return this audio device volume interface.
  425.  */
  426. STDMETHODIMP_(IHXVolume*) CHXAudioPlayer::GetDeviceVolume()
  427. {
  428.     return ( m_Owner->GetDeviceVolume() );
  429. }
  431. /*
  432.  *  IHXAudioCrossFade methods
  433.  */
  435. /************************************************************************
  436.  *  Method:
  437.  *      IHXAudioCrossFade::CrossFade
  438.  *  Purpose:
  439.  * Cross-fade two audio streams.
  440.  * pStreamFrom - Stream to be cross faded from
  441.  * pStreamTo - Stream to be cross faded to
  442.  * ulFromCrossFadeStartTime- "From" Stream time when cross fade is
  443.  *   to be started
  444.  * ulToCrossFadeStartTime - "To" Stream time when cross fade is to
  445.  *   be started
  446.  * ulCrossFadeDuration - Duration over which cross-fade needs
  447.  *       to be done
  448.  *
  449.  */
  450. STDMETHODIMP
  451. CHXAudioPlayer::CrossFade(IHXAudioStream*  pStreamFrom,
  452.   IHXAudioStream*  pStreamTo,
  453.   UINT32     ulFromCrossFadeStartTime,
  454.   UINT32     ulToCrossFadeStartTime,
  455.   UINT32     ulCrossFadeDuration)
  456. {
  457. #if defined(HELIX_FEATURE_CROSSFADE)
  458.     HX_RESULT theErr = HXR_OK;
  460.     /* Make sure these two streams are available */
  461.     LISTPOSITION streamPos1 = m_pStreamList->Find(pStreamFrom);
  462.     LISTPOSITION streamPos2 = m_pStreamList->Find(pStreamTo);
  463.     if (!streamPos2 || !streamPos1)
  464.     {
  465. return HXR_INVALID_PARAMETER;
  466.     }
  468.     CHXAudioStream* pFromStream =
  469. (CHXAudioStream*) m_pStreamList->GetAt(streamPos1);
  470.     CHXAudioStream* pToStream =
  471. (CHXAudioStream*) m_pStreamList->GetAt(streamPos2);
  473.     theErr = pFromStream->StartCrossFade(pToStream, ulFromCrossFadeStartTime,
  474. ulCrossFadeDuration, FALSE);
  475.     if (!theErr)
  476.     {
  477. theErr = pToStream->StartCrossFade(pFromStream, ulToCrossFadeStartTime,
  478. ulCrossFadeDuration, TRUE);
  479.     }
  481.     /* Adjust the streams in list so that the "ToStream" List appears before
  482.      * the "FromStream"
  483.      * A lame but quick-and-dirty way to do it: Remove these two stream from
  484.      * the listand them in order at the tail!
  485.      */
  486.     if (!theErr)
  487.     {
  488. LISTPOSITION lPos = m_pStreamList->GetHeadPosition();
  489. while (lPos)
  490. {
  491.     CHXAudioStream* pStream =
  492. (CHXAudioStream* ) m_pStreamList->GetAt(lPos);
  493.     if (pStream == pFromStream ||
  494. pStream == pToStream)
  495.     {
  496. /* RemoveAt returns the next position in the list.
  497.  * DO NOT use GetNext if you remove a node.
  498.  */
  499. lPos = m_pStreamList->RemoveAt(lPos);
  500.     }
  501.     else
  502.     {
  503. m_pStreamList->GetNext(lPos);
  504.     }
  505. }
  507. m_pStreamList->AddTail((void*) pToStream);
  508. m_pStreamList->AddTail((void*) pFromStream);
  509.     }
  510. #endif /* HELIX_FEATURE_CROSSFADE */
  512.     return HXR_OK;
  513. }
  515. /************************************************************************
  516.  *  Method:
  517.  * CHXAudioPlayer::Init
  518.  * Purpose:
  519.  * Initialize the Audio Player object called by rmaplayer.
  520.  */
  521. HX_RESULT CHXAudioPlayer::Init
  522. (
  523.     IUnknown* pContext
  524. )
  525. {
  526.     if (!pContext)
  527. return HXR_INVALID_PARAMETER;
  529.     m_pContext = pContext;
  530.     m_pContext->AddRef();
  532.     if (HXR_OK != pContext->QueryInterface(IID_IHXScheduler,
  533. (void **) &m_pScheduler))
  534.     {
  535. return HXR_INVALID_PARAMETER;
  536.     }
  538.     if (HXR_OK != pContext->QueryInterface(IID_IHXAudioPlayerResponse,
  539. (void **) &m_pPlayerResponse))
  540.     {
  541. return HXR_INVALID_PARAMETER;
  542.     }
  543. #if defined( HELIX_FEATURE_PREFERENCES )
  544.     m_pContext->QueryInterface(IID_IHXPreferences, (void**) &m_pPreferences);
  545. #endif
  546.     return HXR_OK;
  547. }
  550. /************************************************************************
  551.  *  Method:
  552.  * CHXAudioPlayer::_Init
  553.  * Purpose:
  554.  * Create internal lists, etc. Called by Audio Session
  555.  * CreateAudioPlayer() method.
  556.  */
  557. HX_RESULT CHXAudioPlayer::InitializeStructures()
  558. {
  559.     HX_RESULT theErr = HXR_OK;
  561.     // Create the Stream list.
  562.     // Create the Post process hook list.
  563.     // Create the Stream response list.
  564.     m_pStreamList = new CHXSimpleList;
  565. #if defined(HELIX_FEATURE_AUDIO_POSTMIXHOOK)
  566.     m_pPMixHookList = new CHXSimpleList;
  567. #endif /* HELIX_FEATURE_AUDIO_POSTMIXHOOK */
  568.     m_pStreamRespList = new CHXSimpleList;
  570.     if ( !m_pStreamList || !m_pStreamList->IsPtrListValid())
  571. theErr = HXR_OUTOFMEMORY;
  573. #if defined(HELIX_FEATURE_AUDIO_POSTMIXHOOK)
  574.     if ( !m_pPMixHookList || !m_pPMixHookList->IsPtrListValid())
  575. theErr = HXR_OUTOFMEMORY;
  576. #endif /* HELIX_FEATURE_AUDIO_POSTMIXHOOK */
  578.     if ( !m_pStreamRespList || !m_pStreamRespList->IsPtrListValid())
  579. theErr = HXR_OUTOFMEMORY;
  581. #if defined(HELIX_FEATURE_VOLUME)
  582.     if( !theErr )
  583.     {
  584.         m_pPlayerVolume = (IHXVolume*)new CHXVolume;
  585.         if( m_pPlayerVolume )
  586.         {
  587.             m_pPlayerVolume->AddRef();
  588.             m_pPlayerVolume->AddAdviseSink(this);
  589.             //Start off with the volume at max.
  590.             m_pPlayerVolume->SetVolume(HX_MAX_VOLUME);
  591.         }
  592.         else
  593.         {
  594.             theErr = HXR_OUTOFMEMORY;
  595.         }
  596.     }
  597. #endif /* HELIX_FEATURE_VOLUME */
  599.     return ( theErr );
  600. }
  602. /************************************************************************
  603.  *  Method:
  604.  * CHXAudioPlayer::GetFormat
  605.  * Purpose:
  606.  * Return the player's device format which was determined in
  607.  * InitPlayer() and is based on all the streams.
  608.  */
  609. void CHXAudioPlayer::GetFormat
  610. (
  611. HXAudioFormat*   pAudioFormat
  612. )
  613. {
  614.     memcpy(pAudioFormat, &m_PlayerFmt, sizeof( HXAudioFormat) );
  615. }
  618. /* ***********************************************************************
  619.  *  Method:
  620.  *      CHXAudioPlayer::GetAudioPrefs
  621.  *  Purpose:
  622.  * Get audio related preferences.
  623.  */
  624. HX_RESULT CHXAudioPlayer::GetAudioPrefs()
  625. {
  626.     IHXBuffer* pBuffer = NULL;
  627.     IHXPreferences* pPreferences = 0;
  629. #if defined(HELIX_FEATURE_PREFERENCES)
  630.     /* Reason we query for Preferences here and not at Init() is because
  631.      * Preferences may have been overwritten in HXPlayer by SetupClient()
  632.      * call by upper level client and this happens AFTER CHXAudioPlayer::Init()
  633.      * is called
  634.      */
  635.     if (!m_pContext)
  636.     {
  637. return HXR_INVALID_PARAMETER;
  638.     }
  640.     m_pContext->QueryInterface(IID_IHXPreferences, (void**) &pPreferences);
  642.     //  What is the pref for this?
  643.     if( pPreferences )
  644.     {
  646.         if (pPreferences->ReadPref("SamplingRate", pBuffer) == HXR_OK)
  647.         {
  648.             m_bPrefUse11khz = (11025 == ::atol((const char*) pBuffer->GetBuffer()));
  649.             pBuffer->Release();
  650.             pBuffer = 0;
  651.         }
  653. ReadPrefINT16(pPreferences, "BitsPerSample", m_uPrefBitsPerSample);
  654. ReadPrefINT16(pPreferences, "Quality", m_uPrefAudioQuality);
  656.         /* hmmm... Looks like the client override default Preferences implementation*/
  657.         if (m_pPreferences != pPreferences)
  658.         {
  659.             if (m_pPreferences)
  660.             {
  661.                 m_pPreferences->Release();
  662.             }
  663.             m_pPreferences = pPreferences;
  664.             m_pPreferences->AddRef();
  665.         }
  667.         pPreferences->Release();
  668.     }
  669. #endif /* HELIX_FEATURE_PREFERENCES */
  671.     return HXR_OK;
  672. }
  675. /************************************************************************
  676.  *  Method:
  677.  * IHXAudioPlay::CreateAudioStream
  678.  * Purpose:
  679.  *       The renderer calls this to create a unique audio stream with its
  680.  *  unique audio format.
  681.  */
  682. STDMETHODIMP CHXAudioPlayer::CreateAudioStream
  683. (
  684.     IHXAudioStream**   pAudioStream
  685. )
  686. {
  687.    HX_RESULT theErr = HXR_OK;
  689.     // Create a new IRMA audio stream
  690.     *pAudioStream = 0;
  691.     *pAudioStream = (IHXAudioStream*) new CHXAudioStream(this, m_pContext);
  692.     if ( !*pAudioStream )
  693.     {
  694. theErr = HXR_OUTOFMEMORY;
  695.     }
  697.     // Add audio stream to my list
  698.     if (!theErr)
  699.     {
  700. theErr = _CreateAudioStream(pAudioStream);
  701.     }
  703.     return theErr;
  704. }
  706. HX_RESULT
  707. CHXAudioPlayer::_CreateAudioStream(IHXAudioStream** pAudioStream)
  708. {
  709.     (*pAudioStream)->AddRef();   // once for user
  710.     (*pAudioStream)->AddRef();   // once for me
  712.     // Add to the stream list.
  713.     m_pStreamList->AddTail((void*) *pAudioStream);
  715.     ((CHXAudioStream*)(*pAudioStream))->SetLive(m_bIsLive);
  717.     m_Owner->CheckIfLastNMilliSecsToBeStored();
  719.     /* Already initialized with no streams?*/
  720.     if (m_bInited && !m_bHasStreams)
  721.     {
  722. /* If we are already initialized and there were no audio streams before
  723.  * initialization, we must be using our fake timer to send time syncs
  724.  * This needs to change now to get time syncs from the audio device
  725.  */
  726. ((CHXAudioStream*)(*pAudioStream))->SetupToBeDone();
  728. return HXR_OK;
  729.     }
  731.     m_bHasStreams = TRUE;
  733.     /* If we are already initialized, it means CreateAudioStream was
  734.      * called in the midst of the presentation. In this case, we already know
  735.      * the granularity and the Device format and thus call Setup right away
  736.      */
  737.     if ((*pAudioStream) && m_bInited)
  738.     {
  739. ((CHXAudioStream*)(*pAudioStream))->Setup( &m_DeviceFmt, m_ulGranularity );
  740.     }
  741.     return HXR_OK;
  742. }
  744. HX_RESULT
  745. CHXAudioPlayer::SetSoundLevel(CHXSimpleList* pAudioStreamList, UINT16 uSoundLevel, BOOL bReflushAudioDevice)
  746. {
  747.     HX_RESULT rc = HXR_OK;
  748.     IHXVolume* pStreamVolume = NULL;
  750.     if (pAudioStreamList && !pAudioStreamList->IsEmpty())
  751.     {
  752. CHXSimpleList::Iterator lIter = pAudioStreamList->Begin();
  753. for (; lIter != pAudioStreamList->End(); ++lIter)
  754. {
  755.     CHXAudioStream* pAudioStream = (CHXAudioStream*) (*lIter);
  757.     pStreamVolume = pAudioStream->GetAudioVolume();
  758.     if (pStreamVolume)
  759.     {
  760. pStreamVolume->SetVolume(uSoundLevel);
  761.     }
  762.     HX_RELEASE(pStreamVolume);
  763. }
  765. if (bReflushAudioDevice)
  766. {
  767.     AudioStreamStateChanged(E_PLAYING);
  768. }
  769.     }
  771.     return rc;
  772. }
  776. HX_RESULT CHXAudioPlayer::ManageAudioStreams( CHXSimpleList* pStreamList,
  777.                                               STREAM_ACTION  what,
  778.                                               UINT32 ulTime )
  779. {
  780.     HX_RESULT    rc  = HXR_OK;
  781.     LISTPOSITION pos = 0;
  783.     if(pStreamList && !pStreamList->IsEmpty())
  784.     {
  785. CHXSimpleList::Iterator it = pStreamList->Begin();
  786. while( it != pStreamList->End() )
  787. {
  788.     CHXAudioStream* pAudioStream = (CHXAudioStream*) (*it);
  789.             switch(what)
  790.             {
  791.                case STR_STOP:
  792.                    pAudioStream->Stop();
  793.                    break;
  794.                case STR_SEEK:
  795.                    pAudioStream->Seek(ulTime);
  796.                    break;
  797.                case STR_RESUME:
  798.                    pAudioStream->Resume(FALSE);
  799.                    break;
  800.                case STR_PAUSE:
  801.                    pAudioStream->Pause(FALSE);
  802.                    break;
  803.                case STR_SETHINT:
  804.                    pAudioStream->SetAudioDeviceReflushHint(TRUE);
  805.                    break;
  806.                case STR_REMOVE:
  807.                    pos = m_pStreamList->Find(pAudioStream);
  808.                    if (pos)
  809.                        m_pStreamList->RemoveAt(pos);
  810.                    pAudioStream->Stop();
  811.                    HX_RELEASE(pAudioStream);
  812.                    break;
  813.                default:
  814.                    HX_ASSERT("bad stream action taken"==NULL);
  815.             }
  816.             ++it;
  817. }
  819.         //Post stream iteration actions.
  820.         switch(what)
  821.         {
  822.            case STR_STOP:
  823.                AudioStreamStateChanged(E_STOPPED);
  824.                break;
  825.            case STR_PAUSE:
  826.                AudioStreamStateChanged(E_PAUSED);
  827.                break;
  828.            case STR_SETHINT:
  829.                m_Owner->CheckIfLastNMilliSecsToBeStored();
  830.                break;
  831.            case STR_REMOVE:
  832.                if( 0 == m_pStreamList->GetCount())
  833.                {
  834.                    m_bHasStreams = FALSE;
  835.                    m_Owner->Stop(this, TRUE);
  836.                    m_bInited = FALSE;
  837.                    if(HXR_OK != (rc=Setup(m_ulGranularity)))
  838.                    {
  839.                        IHXErrorMessages* pErrorMessage = NULL;
  840.                        m_pContext->QueryInterface(IID_IHXErrorMessages, (void**) &pErrorMessage);
  841.                        if (pErrorMessage)
  842.                        {
  843.                            pErrorMessage->Report(HXLOG_ERR, rc, 0, NULL, NULL);
  844.                            pErrorMessage->Release();
  845.                        }
  846.                        rc = HXR_OK;
  847.                    }
  848.                    else
  849.                    {
  850.                        rc = ResumeFakeTimeline();
  851.                    }
  852.                }
  853.                else
  854.                {
  855.                    AudioStreamStateChanged(E_STOPPED);
  856.                }
  858.                break;
  859.            default:
  860.                HX_ASSERT("bad stream action taken"==NULL );
  861.         }
  863.     }
  865.     return rc;
  867. }
  871. HX_RESULT
  872. CHXAudioPlayer::AudioStreamStateChanged(EPlayerState eState)
  873. {
  874.     if(!m_Owner->GetDisableMultiPlayPauseSupport())
  875.     {
  876. // we only concern about the state change of audio stream
  877. // while its parent audio player is in playing mode
  878. if (m_eState == E_PLAYING)
  879. {
  880.     switch (eState)
  881.     {
  882.     case E_PLAYING:
  883. m_Owner->RewindSession();
  884. m_Owner->ActualResume();
  885. break;
  886.     case E_PAUSED:
  887.     case E_STOPPED:
  888. m_Owner->RewindSession();
  889. if (NumberOfResumedStreams() > 0 ||
  890.     m_Owner->NumberOfResumedPlayers() > 0)
  891. {
  892.     m_Owner->ActualResume();
  893. }
  894. break;
  895.     default:
  896. break;
  897.     }
  898. }
  899.     }
  901.     return HXR_OK;
  902. }
  904. CHXAudioStream*
  905. CHXAudioPlayer::GetCHXAudioStream(UINT16 uIndex)
  906. {
  907.     LISTPOSITION lp = 0;
  908.     lp = m_pStreamList->FindIndex( (int) uIndex );
  909.     if ( lp )
  910.     {
  911. return (CHXAudioStream*)m_pStreamList->GetAt(lp);
  912.     }
  913.     else
  914.     {
  915.         return NULL;
  916.     }
  917. }
  919. BOOL
  920. CHXAudioPlayer::IsLastNMilliSecsToBeStored()
  921. {
  922.     BOOL bResult = FALSE;
  924.     if (m_bHasStreams)
  925.     {
  926. CHXAudioStream* s = 0;
  927. CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  928. for (; lIter != m_pStreamList->End(); ++lIter)
  929. {
  930.     s = (CHXAudioStream*) (*lIter);
  931.     if (s->IsAudioDeviceReflushHint())
  932.     {
  933. bResult = TRUE;
  934. break;
  935.     }
  936. }
  937.     }
  939.     return bResult;
  940. }
  942. HX_RESULT
  943. CHXAudioPlayer::ActualAddPostMixHook(IHXAudioHook* pHook,
  944.           const BOOL     bDisableWrite,
  945.      const BOOL     bFinal)
  946. {
  947.     if (!m_pPMixHookList || !pHook)
  948.     {
  949. return HXR_FAILED;
  950.     }
  952. #if defined(HELIX_FEATURE_AUDIO_POSTMIXHOOK)
  953.     /* Check if this one already exists */
  954.     HXAudioHookInfo* h = 0;
  955.     LISTPOSITION lp = 0;
  956.     lp = m_pPMixHookList->GetHeadPosition();
  957.     while( lp )
  958.     {
  959. h = (HXAudioHookInfo*) m_pPMixHookList->GetNext(lp);
  960. if (pHook == h->pHook)
  961. {
  962.     return HXR_FAILED;
  963. }
  964.     }
  966.     h = (HXAudioHookInfo*) new HXAudioHookInfo;
  967.     h->pHook   = pHook;
  968.     h->bDisableWrite = bDisableWrite;
  969.     h->bFinal  = bFinal;
  970.     h->bIgnoreAudioData = FALSE;
  971.     h->bMultiChannelSupport = FALSE;
  973.     IHXValues* pValues = NULL;
  974.     if (pHook && pHook->QueryInterface(IID_IHXValues, (void**) &pValues) == HXR_OK)
  975.     {
  976. UINT32 ulValue = 0;
  977. pValues->GetPropertyULONG32("IgnoreAudioData", ulValue);
  978. h->bIgnoreAudioData = (ulValue == 1);
  979. HX_RELEASE(pValues);
  980.     }
  982.     IHXAudioMultiChannel* pMultiChannel = NULL;
  983.     if (pHook && HXR_OK == pHook->QueryInterface(IID_IHXAudioMultiChannel, (void**) &pMultiChannel))
  984.     {
  985.         h->bMultiChannelSupport = pMultiChannel->GetMultiChannelSupport();
  986.     }
  987.     HX_RELEASE(pMultiChannel);
  989.     if (bDisableWrite)
  990.     {
  991. m_bDisableWrite = bDisableWrite;
  992.     }
  994.     pHook->AddRef();
  996.     // Order list by putting all bFinal == TRUE at end of list.
  997.     if ( m_pPMixHookList->IsEmpty() || !bFinal )
  998.     {
  999. m_pPMixHookList->AddHead((void*) h);
  1000.     }
  1001.     else
  1002.     {
  1003. m_pPMixHookList->AddTail((void*) h);
  1004.     }
  1005.     m_Owner->PostMixHooksUpdated();
  1007.     ProcessAudioHook(ACTION_ADD, pHook);
  1009.     /* If we are already initialized, send the device format to the
  1010.      * post hook
  1011.      */
  1012.     if (m_bInited)
  1013.     {
  1014. if (h->bIgnoreAudioData ||
  1015.     HXR_OK == ProcessAudioHook(ACTION_CHECK, pHook))
  1016. {
  1017.     HXAudioFormat audioFmt;
  1018.     m_Owner->GetFormat( &audioFmt );
  1019.     pHook->OnInit( &audioFmt );
  1020. }
  1021.     }
  1022. #endif /* HELIX_FEATURE_AUDIO_POSTMIXHOOK */
  1024.     return HXR_OK;
  1025. }
  1027. HX_RESULT
  1028. CHXAudioPlayer::ActualRemovePostMixHook(IHXAudioHook* pHook)
  1029. {
  1030.     if (!m_pPMixHookList || !pHook)
  1031.     {
  1032. return HXR_FAILED;
  1033.     }
  1035. #if defined(HELIX_FEATURE_AUDIO_POSTMIXHOOK)
  1036.     BOOL bCheckForDisableWrite = FALSE;
  1037.     BOOL bFound = FALSE;
  1039.     HXAudioHookInfo* h = 0;
  1040.     LISTPOSITION lp, lastlp;
  1041.     lp = lastlp = 0;
  1042.     lp = m_pPMixHookList->GetHeadPosition();
  1043.     while( lp )
  1044.     {
  1045. lastlp = lp;
  1046. h = (HXAudioHookInfo*) m_pPMixHookList->GetNext(lp);
  1047. if ( pHook == h->pHook )
  1048. {
  1049.     if (h->bDisableWrite)
  1050.     {
  1051. m_bDisableWrite = FALSE;
  1052. bCheckForDisableWrite = TRUE;
  1053.     }
  1055.     ProcessAudioHook(ACTION_REMOVE, pHook);
  1057.     h->pHook->Release();
  1058.     delete h;
  1059.     h = 0;
  1060.     m_pPMixHookList->RemoveAt(lastlp);
  1061.     bFound = TRUE;
  1062.     break;
  1063. }
  1064.     }
  1066.     if (!bFound)
  1067.     {
  1068. return HXR_FAILED;
  1069.     }
  1070.     m_Owner->PostMixHooksUpdated();
  1072.     if ( m_pPMixHookList && bCheckForDisableWrite && m_pPMixHookList->GetCount() > 0)
  1073.     {
  1074. HXAudioHookInfo* h = 0;
  1075. LISTPOSITION lp, lastlp;
  1076. lp = lastlp = 0;
  1077. lp = m_pPMixHookList->GetHeadPosition();
  1078.     while( lp )
  1079. {
  1080.     h = (HXAudioHookInfo*) m_pPMixHookList->GetNext(lp);
  1081.     if (h->bDisableWrite)
  1082.     {
  1083. m_bDisableWrite = TRUE;
  1084. break;
  1085.     }
  1086. }
  1088.     }
  1089. #endif /* HELIX_FEATURE_AUDIO_POSTMIXHOOK */
  1091.     return HXR_OK;
  1092. }
  1094. /************************************************************************
  1095.  *  Method:
  1096.  *      CHXAudioPlayer::SetGranularity
  1097.  *  Purpose:
  1098.  *       The HELIX player object calls this BEFORE starting audio playback
  1099.  *       and AFTER all audio streams are created for the renderers.
  1100.  */
  1101. void CHXAudioPlayer::SetGranularity
  1102. (
  1103.     const ULONG32  ulGranularity
  1104. )
  1105. {
  1106.     m_ulGranularity = ulGranularity;
  1107.     return;
  1108. }
  1111. /************************************************************************
  1112.  *  Method:
  1113.  * CHXAudioPlayer::Resume
  1114.  * Purpose:
  1115.  * Resume audio playback by writing data to the audio device.
  1116.  * Open the audio device if it is not opened already.
  1117.  */
  1118. HX_RESULT CHXAudioPlayer::Resume()
  1119. {
  1120.     HX_RESULT theErr = HXR_OK;
  1122.     if (!m_bInited)
  1123. return HXR_NOT_INITIALIZED;
  1125.     if ( m_eState == E_PLAYING )
  1126.     {
  1127. return HXR_OK;
  1128.     }
  1130.     m_bIsDonePlayback = FALSE;
  1131.     m_eState          = E_PLAYING;
  1132.     m_bCanBeRewound   = TRUE;
  1135.     /* Use Audio Session Object ONLY if there are any audio streams
  1136.      * in the presentation
  1137.      */
  1138.     if (m_bHasStreams)
  1139.     {
  1140. CHXAudioStream* s = 0;
  1141. CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  1142. for (; lIter != m_pStreamList->End(); ++lIter)
  1143. {
  1144.     s = (CHXAudioStream*) (*lIter);
  1145.     if ( s )
  1146. s->Resume(TRUE);
  1147. }
  1149. // This is the audio device playback time that corresponds to
  1150. // when this audio player resumed.
  1151. m_ulADresumeTime = m_Owner->GetCurrentPlayBackTime();
  1153. // This is this player's start time within its timeline. This is
  1154. // modified when the player is seeked or resumed.
  1155. m_ulAPstartTime = m_ulAPplaybackTime;
  1157. UpdateStreamLastWriteTime();
  1159. // Resume the audio device playback
  1160. if ( !theErr )
  1161.     theErr = m_Owner->Resume(this);
  1162.     }
  1163.     else
  1164.     {
  1165. theErr = ResumeFakeTimeline();
  1167. /* Send time 0 at first Resume */
  1168. if (!theErr && m_bIsFirstResume)
  1169. {
  1170.     m_bIsFirstResume = FALSE;
  1171.     OnTimeSync(m_ulIncreasingTimer);
  1172. }
  1173.     }
  1175.     m_bIsResumed = TRUE;
  1176.     return ( !theErr ) ? HXR_OK : HXR_FAILED;
  1177. }
  1179. /************************************************************************
  1180.  *  Method:
  1181.  * CHXAudioPlayer::Pause
  1182.  * Purpose:
  1183.  * The player object calls this function to pause audio playback.
  1184.  */
  1185. HX_RESULT CHXAudioPlayer::Pause()
  1186. {
  1187.     if (m_eState == E_PAUSED)
  1188.     {
  1189. return HXR_OK;
  1190.     }
  1192.     m_eState = E_PAUSED;
  1194.     if (m_bHasStreams)
  1195.     {
  1196. CHXAudioStream* s = 0;
  1197. CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  1198. for (; lIter != m_pStreamList->End(); ++lIter)
  1199. {
  1200.     s = (CHXAudioStream*) (*lIter);
  1201.     if ( s )
  1202. s->Pause(TRUE);
  1203. }
  1205. m_Owner->Pause(this);
  1206.     }
  1207.     else
  1208.     {
  1209. StopFakeTimeline();
  1210.     }
  1212.     m_bCanBeRewound = FALSE;
  1214.     return HXR_OK;
  1215. }
  1217. /************************************************************************
  1218.  *  Method:
  1219.  * CHXAudioPlay::Stop
  1220.  * Purpose:
  1221.  *      The player object calls this function to stop audio playback.
  1222.  * If bFlush is TRUE, flush any data in the audio device.
  1223.  */
  1224. HX_RESULT CHXAudioPlayer::Stop
  1225. (
  1226.     const BOOL bFlush
  1227. )
  1228. {
  1229.     m_eState = E_STOPPED;
  1231.     m_ulAPstartTime  = 0;
  1233.     if (m_bHasStreams)
  1234.     {
  1235. CHXAudioStream* s = 0;
  1236. CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  1237. for (; lIter != m_pStreamList->End(); ++lIter)
  1238. {
  1239.     s = (CHXAudioStream*) (*lIter);
  1240.     if ( s )
  1241. s->Stop();
  1242. }
  1244. m_Owner->Stop(this, bFlush);
  1245.     }
  1246.     else
  1247.     {
  1248. StopFakeTimeline();
  1249.     }
  1251.     ResetPlayer();
  1253.     return HXR_OK;
  1254. }
  1256. /************************************************************************
  1257.  *  Method:
  1258.  * CHXAudioPlayer::Seek
  1259.  * Purpose:
  1260.  * The player object calls this function to seek audio playback to
  1261.  * the time (in milliseconds) given.
  1262.  */
  1263. HX_RESULT CHXAudioPlayer::Seek
  1264. (
  1265. const  UINT32 ulSeekTime
  1266. )
  1267. {
  1268.     /* always remember this seek time.. even though there may not be any streams
  1269.      * yet for this player. This is because the streams may be created later and
  1270.      * we need to correctly apply the seek time to get the accurate time.
  1271.      */
  1272.     m_ulAPstartTime = m_ulAPplaybackTime = ulSeekTime; // current start time for this player
  1273.     m_llLastWriteTime = (INT64) ulSeekTime;
  1275.     if (m_bHasStreams)
  1276.     {
  1277. // Make each stream seek, too, since they own the resampling buffers.
  1278. CHXAudioStream* s = 0;
  1279. CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  1280. for (; lIter != m_pStreamList->End(); ++lIter)
  1281. {
  1282.     s = (CHXAudioStream*) (*lIter);
  1283.     if ( s )
  1284. s->Seek(ulSeekTime);
  1285. }
  1287. m_Owner->Seek( this, ulSeekTime );
  1289. m_ulADresumeTime = m_Owner->GetCurrentPlayBackTime();
  1290.     }
  1291.     else
  1292.     {
  1293. StopFakeTimeline();
  1294. m_bIsFirstResume    = TRUE;
  1295.     }
  1297.     m_ulCurrentTime     = ulSeekTime;
  1299.     m_ulLastCurrentTimeReturned = m_ulCurrentTime;
  1300.     m_bTimeReturned     = FALSE;
  1301.     m_bHasDataInAudioDevice = FALSE;
  1303.     return HXR_OK;
  1304. }
  1306. void CHXAudioPlayer::ResetPlayer(void)
  1307. {
  1308.     m_bInited = FALSE;
  1309.     m_bHasStreams = FALSE;
  1310.     m_bIsFirstResume = TRUE;
  1312.     m_ulAPstartTime = 0;
  1313.     m_ulAPplaybackTime = 0;
  1314.     m_ulADresumeTime = 0;
  1316.     m_ulCurrentTime = 0;
  1317.     m_ulLastCurrentTimeReturned = 0;
  1318.     m_ulLastDeviceTimeAdjusted = 0;
  1319.     m_bTimeReturned = FALSE;
  1320.     m_bIsLive = FALSE;
  1321.     m_bIsResumed = FALSE;
  1322.     m_bIsDonePlayback = TRUE;
  1323.     m_llLastWriteTime = 0;
  1324.     m_bCanBeRewound = FALSE;
  1325.     m_bHasDataInAudioDevice = FALSE;
  1327.     // Delete all streams.  Remove all list items.
  1328.     if ( m_pStreamList )
  1329.     {
  1330. CHXAudioStream* pAudioStream = 0;
  1331. while(!m_pStreamList->IsEmpty())
  1332. {
  1333.     pAudioStream = (CHXAudioStream*) m_pStreamList->RemoveHead();
  1334.     pAudioStream->ResetStream();
  1335.     pAudioStream->Release();
  1336. }
  1337.     }
  1339.     /* We do not remove post mix hooks any more */
  1340.     /* We do not remove Stream Response Objects any more */
  1342.     /* Default value of Player format */
  1343.     m_PlayerFmt.uChannels = 2;
  1344.     m_PlayerFmt.uBitsPerSample = 16;
  1345.     m_PlayerFmt.ulSamplesPerSec = 16000;
  1346.     m_PlayerFmt.uMaxBlockSize = 64000;
  1348.     m_ulLastFakeCallbackTime = 0;
  1350.     StopFakeTimeline();
  1351. }
  1353. /************************************************************************
  1354.  *  Method:
  1355.  * CHXAudioPlayer::SetupStreams
  1356.  * Purpose:
  1357.  * Tell each stream about the audio device format so
  1358.  * they can setup their resamplers and buffer.
  1359.  */
  1360. void CHXAudioPlayer::SetupStreams(void)
  1361. {
  1362.     // Get audio device format
  1363.     m_Owner->GetFormat(&m_DeviceFmt);
  1365.     // Calculate bytes per gran
  1366.     m_ulBytesPerGran = (ULONG32)
  1367.                 (((m_DeviceFmt.uChannels * ((m_DeviceFmt.uBitsPerSample==8)?1:2) *  m_DeviceFmt.ulSamplesPerSec)
  1368.                                 / 1000.0) * m_ulGranularity);
  1370.     // Make sure that number of bytes per granularity is an even number.
  1371.     if ( (m_ulBytesPerGran % 2) != 0 )
  1372.         m_ulBytesPerGran++;
  1373.     /* Don't we have to calculate granularity again if we adjust
  1374.      * for even byte boundary - XXX Rahul 06/15/97
  1375.      */
  1377.     // Notify each stream
  1378.     CHXAudioStream* s = 0;
  1379.     CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  1380.     for (; lIter != m_pStreamList->End(); ++lIter)
  1381.     {
  1382. s = (CHXAudioStream*) (*lIter);
  1383. if ( s )
  1384. {
  1385.     s->Setup( &m_DeviceFmt, m_ulGranularity );
  1386. }
  1387.     }
  1388. }
  1390. /************************************************************************
  1391.  *  Method:
  1392.  * CHXAudioPlayer::OnTimeSync
  1393.  * Purpose:
  1394.  */
  1395. HX_RESULT CHXAudioPlayer::OnTimeSync(ULONG32 ulCurrentTime)
  1396. {
  1397.     HX_RESULT theErr = HXR_OK;
  1399. #ifdef _MACINTOSH
  1400.     if (InterlockedIncrement(&gTIMELINE_MUTEX) > 1)
  1401.     {
  1402.        InterlockedDecrement(&gTIMELINE_MUTEX);
  1403.        return;
  1404.     }
  1405.     InterlockedDecrement(&gTIMELINE_MUTEX);
  1406. #endif
  1408.     if (m_bHasStreams)
  1409.     {
  1410. ULONG32 ulADplaybackTime;
  1412. ulADplaybackTime = m_Owner->GetCurrentPlayBackTime();
  1413. m_ulAPplaybackTime = (ulADplaybackTime - m_ulADresumeTime) +
  1414.       m_ulAPstartTime;
  1415.     }
  1416.     else
  1417.     {
  1418. m_ulAPplaybackTime  = ulCurrentTime;
  1419.     }
  1421.     m_ulCurrentTime = m_ulAPplaybackTime ;
  1423.     AdjustForRealAudio();
  1425.     // Here we need to fudge the actual time for this player
  1426.     // For now we support only one player/timeline
  1427.     if (m_pPlayerResponse)
  1428.     {
  1429. // The current playback time of any player is the difference
  1430. // of the current audio device playback time minus the audio
  1431. // device time when this player started (resumed) playback
  1432. // plus the initial start time of playback within this player's
  1433. // timeline (usually 0 but can be something else esp. after a
  1434. // seek).
  1435. theErr = m_pPlayerResponse->OnTimeSync(m_ulCurrentTime);
  1436.     }
  1437.     return theErr;
  1438. }
  1440. /************************************************************************
  1441.  *  Method:
  1442.  * CHXAudioPlayer::Setup
  1443.  * Purpose:
  1444.  * This is called after AS receives format and stream info
  1445.  * from the renderers AND before packets are received from
  1446.  * the renderer.
  1447.  */
  1448. HX_RESULT CHXAudioPlayer::Setup( ULONG32 ulGranularity)
  1449. {
  1450.     HX_RESULT theErr = HXR_OK;
  1453.     if (m_bInited)
  1454. return HXR_OK;
  1456.     /* Always write 100ms audio blocks for now. */
  1457.     m_ulGranularity = MAXIMUM_AUDIO_GRANULARITY; //ulGranularity;
  1459.     /* We do not go below MINIMUM_AUDIO_GRANULARITY. This will not affect
  1460.      * sending timesyncs at this lower granularity since HXPlayer object
  1461.      * uses the scheduler to send individual timesyncs anyway
  1462.      */
  1463.     if (m_ulGranularity < MINIMUM_AUDIO_GRANULARITY)
  1464.     {
  1465. m_ulGranularity = MINIMUM_AUDIO_GRANULARITY;
  1466.     }
  1467.     else if (m_ulGranularity > MAXIMUM_AUDIO_GRANULARITY)
  1468.     {
  1469. m_ulGranularity = MAXIMUM_AUDIO_GRANULARITY;
  1470.     }
  1472.     if (!m_bHasStreams)
  1473.     {
  1474. m_bInited = TRUE;
  1475. return HXR_OK;
  1476.     }
  1478.     /* If this is the second player, session object may overide
  1479.      * the granularity value.
  1480.      */
  1481.     m_ulGranularity = m_Owner->SetGranularity(m_ulGranularity);
  1483.     // Determine this player's audio format parameters based on
  1484.     // the mixer channels attributes supplied in RegisterRenderer.
  1485.     //
  1486.     // 1. Spin thru the list of registered streams and
  1487.     //    determine the desired audio device parameters.
  1488.     // 2. Check the audio format with the audio device.
  1489.     //
  1490.     CHXAudioStream* pAudioStream = 0;
  1491.     ULONG32 maxSamplesPerSec = 8000;
  1492.     ULONG32 minSamplesPerSec = 44100;
  1493.     BOOL    bFirst = TRUE;
  1494.     UINT16  maxChannels = 1;
  1495.     UINT16  maxBlocksize = 0;
  1496.     UINT16  maxBitsPerSample = 0;
  1497.     HXAudioFormat audioFmt;
  1499.     theErr = GetAudioPrefs();
  1501.     if (!theErr && m_pStreamList->GetCount() > 0)
  1502.     {
  1503. CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  1504. for (;lIter != m_pStreamList->End(); ++lIter)
  1505. {
  1506.     pAudioStream = (CHXAudioStream*) (*lIter); //m_pStreamList->GetNext(lp);
  1508.     if (!pAudioStream->IsAudioFormatKnown())
  1509.     {
  1510. continue;
  1511.     }
  1513.     pAudioStream->GetFormat( &audioFmt );
  1515.     if (bFirst)
  1516.     {
  1517. bFirst = FALSE;
  1518. maxSamplesPerSec    = audioFmt.ulSamplesPerSec;
  1519. minSamplesPerSec    = audioFmt.ulSamplesPerSec;
  1520. maxChannels     = audioFmt.uChannels;
  1521. maxBlocksize     = audioFmt.uMaxBlockSize;
  1522. maxBitsPerSample    = audioFmt.uBitsPerSample;
  1523.     }
  1524.     else
  1525.     {
  1526. //
  1527. // NOTE: upsampling typically costs more CPU than downsampling
  1528. if ( audioFmt.ulSamplesPerSec > maxSamplesPerSec )
  1529.     maxSamplesPerSec = audioFmt.ulSamplesPerSec;
  1530. if ( audioFmt.ulSamplesPerSec < minSamplesPerSec)
  1531.     minSamplesPerSec = audioFmt.ulSamplesPerSec;
  1532. //
  1533. // NOTE: converting mono to stereo and vice versa cost about the
  1534. // same in CPU usage.
  1535. if ( audioFmt.uChannels > maxChannels)
  1536.     maxChannels = audioFmt.uChannels;
  1538. // Get max block size.
  1539. if ( audioFmt.uMaxBlockSize > maxBlocksize )
  1540.     maxBlocksize = audioFmt.uMaxBlockSize;
  1542. // Get max sample width.
  1543. if ( audioFmt.uBitsPerSample > maxBitsPerSample )
  1544.     maxBitsPerSample = audioFmt.uBitsPerSample;
  1545.     }
  1546. }
  1548. // Set the audio format for this Player.
  1549. m_PlayerFmt.uMaxBlockSize  = maxBlocksize;
  1550. m_PlayerFmt.uChannels = maxChannels;
  1551. m_PlayerFmt.uBitsPerSample  = maxBitsPerSample;
  1553. // If user wants upsampling
  1554. if ( m_uPrefAudioQuality > 2 )
  1555.     m_PlayerFmt.ulSamplesPerSec = maxSamplesPerSec;
  1556. else
  1557.     m_PlayerFmt.ulSamplesPerSec = minSamplesPerSec;
  1558.     }
  1560.     if (m_bPrefUse11khz)
  1561.     {
  1562. m_PlayerFmt.ulSamplesPerSec = 11025;
  1563.     }
  1565.     // Do audio session setup. (e.g., determine device audio
  1566.     // format, etc.
  1567.     if ( !theErr )
  1568. theErr = m_Owner->Setup( m_bHasStreams );
  1570.     // Now let all streams know the final audio format so they
  1571.     // can resample to this format.
  1572.     if ( !theErr )
  1573.     {
  1574. SetupStreams();
  1575.     }
  1576.     // if audio device is failed to initialized, we
  1577.     // will keep the video playing if this is not audio only source
  1578.     else if (!IsAudioOnlyTrue())
  1579.     {
  1580. m_bHasStreams = FALSE;
  1581. m_bInited = TRUE;
  1582. return HXR_OK;
  1583.     }
  1585.     // Let all stream response know total number of streams.
  1586.     if (!theErr && m_pStreamRespList)
  1587.     {
  1588. IHXAudioStreamInfoResponse* pAudioStreamInfoResponse = 0;
  1589. CHXSimpleList::Iterator lIter = m_pStreamRespList->Begin();
  1590. for (; lIter != m_pStreamRespList->End(); ++lIter)
  1591.   {
  1592.     pAudioStreamInfoResponse = (IHXAudioStreamInfoResponse*) (*lIter);
  1594.     CHXSimpleList::Iterator lIter2 = m_pStreamList->Begin();
  1596.     for (; lIter2 != m_pStreamList->End(); ++lIter2)
  1597.       {
  1598. CHXAudioStream* pStream = (CHXAudioStream*) (*lIter2);
  1599. /* Only if a stream is initialized, send it to
  1600.  * Response object. If not, we will send it when it
  1601.  * gets initialized (in StreamInitialized() call)
  1602.  */
  1603. if (pStream->IsInitialized())
  1604. {
  1605.     pAudioStreamInfoResponse->OnStream(pStream);
  1606. }
  1607.     }
  1608. }
  1609.     }
  1611.     // All renderers should have checked in by now!
  1612.     // Call post mix process hooks in list and provide the audio format.
  1613.     if (!theErr && m_pPMixHookList)
  1614.     {
  1615. HXAudioFormat audioFmt;
  1616. m_Owner->GetFormat( &audioFmt );
  1617. HXAudioHookInfo* pPMixHookInfo = 0;
  1618. CHXSimpleList::Iterator lIter = m_pPMixHookList->Begin();
  1619. for (; lIter != m_pPMixHookList->End(); ++lIter)
  1620. {
  1621.     pPMixHookInfo = (HXAudioHookInfo*) (*lIter);
  1622.     if (pPMixHookInfo->bIgnoreAudioData ||
  1623. HXR_OK == ProcessAudioHook(ACTION_CHECK, pPMixHookInfo->pHook))
  1624.     {
  1625. pPMixHookInfo->pHook->OnInit( &audioFmt );
  1626.     }
  1627. }
  1628.     }
  1630.     if (!theErr)
  1631.     {
  1632.      m_bInited = TRUE;
  1633. /* Only change the state to initialized if we were in a stopped
  1634.  * state earlier. It is possible to be in Playing state and be still
  1635.  * in this function. This will happen if we have started the
  1636.  * timeline as a fake timeline and later an audio stream joins the
  1637.  * presentation thereby converting fake to audio timeline
  1638.  * (delayed audio source in SMIL playback)
  1639.  */
  1640. if (m_eState == E_STOPPED)
  1641. {
  1642.     m_eState = E_INITIALIZED;
  1643. }
  1644.     }
  1646.     return theErr;
  1647. }
  1649. ULONG32 CHXAudioPlayer::GetCurrentPlayBackTime(void)
  1650. {
  1653.     if (m_eState != E_PLAYING)
  1654.     {
  1655. return m_ulCurrentTime;
  1656.     }
  1658.     // The current playback time of any player is the difference
  1659.     // of the current audio device playback time minus the audio
  1660.     // device time when this player started (resumed) playback
  1661.     // plus the initial start time of playback within this player's
  1662.     // timeline (usually 0 but can be something else esp. after a
  1663.     // seek).
  1664.     if (!m_bHasStreams)
  1665.     {
  1666. ULONG32 ulCurrentTime = HX_GET_TICKCOUNT();
  1668. m_ulIncreasingTimer     += CALCULATE_ELAPSED_TICKS(m_ulLastFakeCallbackTime, ulCurrentTime);
  1669. m_ulLastFakeCallbackTime    = ulCurrentTime;
  1671. m_ulCurrentTime     = m_ulIncreasingTimer;
  1672.     }
  1673.     else
  1674.     {
  1675. m_ulCurrentTime = (m_Owner->GetCurrentPlayBackTime() -
  1676.     m_ulADresumeTime) + m_ulAPstartTime;
  1677.     }
  1679.     m_ulAPplaybackTime = m_ulCurrentTime;
  1682.     AdjustForRealAudio();
  1684.     return m_ulCurrentTime;
  1685. }
  1687. /************************************************************************
  1688.  *  Method:
  1689.  * CHXAudioPlayer::GetStreamCount
  1690.  * Purpose:
  1691.  * Get the number of streams associated with this player.
  1692.  */
  1693. UINT16 CHXAudioPlayer::GetStreamCount()
  1694. {
  1695.     return m_pStreamList->GetCount();
  1696. }
  1698. /************************************************************************
  1699.  *  Method:
  1700.  * CHXAudioPlayer::SetStreamInfoResponse
  1701.  * Purpose:
  1702.  * Add the stream info response interface to our list.
  1703.  */
  1704. STDMETHODIMP CHXAudioPlayer::SetStreamInfoResponse
  1705. (
  1706.     IHXAudioStreamInfoResponse*    pResponse
  1707. )
  1708. {
  1709.     if (!pResponse || !m_pStreamRespList)
  1710.     {
  1711. return HXR_FAILED;
  1712.     }
  1714.     /* Add to the stream response list */
  1715.     LISTPOSITION lPos = m_pStreamRespList->Find(pResponse);
  1716.     if (lPos)
  1717.     {
  1718. return HXR_FAILED;
  1719.     }
  1721.     m_pStreamRespList->AddTail((void*) pResponse);
  1722.     pResponse->AddRef();         // Released in destructor
  1723.     return HXR_OK;
  1724. }
  1726. /************************************************************************
  1727.  *  Method:
  1728.  *  CHXAudioPlayer::RemoveStreamInfoResponse
  1729.  *  Purpose:
  1730.  *  Remove stream info response that was added earlier
  1731.  */
  1732. STDMETHODIMP CHXAudioPlayer::RemoveStreamInfoResponse
  1733. (
  1734.     IHXAudioStreamInfoResponse*    pResponse
  1735. )
  1736. {
  1737.     /* Add to the stream response list */
  1738.     if (pResponse && m_pStreamRespList)
  1739.     {
  1740. LISTPOSITION lPos = m_pStreamRespList->Find(pResponse);
  1741. if (lPos)
  1742. {
  1743.     m_pStreamRespList->RemoveAt(lPos);
  1744.     pResponse->Release();         // Released in destructor
  1745.     return HXR_OK;
  1746. }
  1747.     }
  1749.     return HXR_FAILED;
  1750. }
  1752. UINT16
  1753. CHXAudioPlayer::NumberOfResumedStreams(void)
  1754. {
  1755.     UINT16 uNumActive = 0;
  1756.     if (m_pStreamList && m_pStreamList->GetCount() > 0)
  1757.     {
  1758. CHXAudioStream* pStream = 0;
  1759. CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  1760. for (; lIter != m_pStreamList->End(); ++lIter)
  1761. {
  1762.     pStream = (CHXAudioStream*) (*lIter);
  1763.     if (pStream->GetState() == E_PLAYING)
  1764.     {
  1765. uNumActive++;
  1766.     }
  1767. }
  1768.     }
  1770.     return uNumActive;
  1771. }
  1773. void CHXAudioPlayer::StreamInitialized(CHXAudioStream* pAudioStream)
  1774. {
  1775.     /* If we are already initialized, it means this stream was added mid-
  1776.      * presentation and gogt initialized later. In this case, report arrival
  1777.      * of this stream to all StreamInfoResponse objects registered with the
  1778.      * player
  1779.      */
  1781.     if (m_pStreamRespList && m_bInited)
  1782.     {
  1783. IHXAudioStreamInfoResponse* pAudioStreamInfoResponse = 0;
  1784. CHXSimpleList::Iterator lIter = m_pStreamRespList->Begin();
  1785. for (; lIter != m_pStreamRespList->End(); ++lIter)
  1786.   {
  1787.     pAudioStreamInfoResponse = (IHXAudioStreamInfoResponse*) (*lIter);
  1788.     pAudioStreamInfoResponse->OnStream(pAudioStream);
  1789. }
  1790.     }
  1792.     m_bHasStreams = TRUE;
  1793. }
  1795. ULONG32 CHXAudioPlayer::GetInitialPushdown(BOOL bAtStart /* = FALSE*/)
  1796. {
  1797.     /* If there are any audio streams, initial pushdown is session's
  1798.      * initial pushdown
  1799.      */
  1800.     if (m_pStreamList->GetCount() > 0)
  1801.     {
  1802.         ULONG32 ulRet = 
  1803.             m_Owner->GetInitialPushdown(bAtStart) + m_ulGranularity;
  1805. #ifdef HELIX_FEATURE_MIN_HEAP
  1806.         // The MIN_HEAP code seems to need 1 extra block's worth
  1807.         // of data to avoid rebuffers during playback. This
  1808.         // is a low impact temporary solution that fixes the problem.
  1809.         ulRet += m_ulGranularity;
  1810. #endif /* HELIX_FEATURE_MIN_HEAP */
  1812.         return ulRet;
  1813.     }
  1814.     else
  1815.     {
  1816. return 0;
  1817.     }
  1818. }
  1820. /************************************************************************
  1821.  *  Method:
  1822.  *      CHXAudioPlayer::OnTimerCallback
  1823.  *  Purpose:
  1824.  *      Timer callback when implementing fake timeline.
  1825.  */
  1826. void CHXAudioPlayer::OnTimerCallback()
  1827. {
  1828.     ULONG32 ulCurrentTime = HX_GET_TICKCOUNT();
  1830.     m_ulIncreasingTimer += CALCULATE_ELAPSED_TICKS(m_ulLastFakeCallbackTime, ulCurrentTime);
  1831.     m_ulLastFakeCallbackTime    = ulCurrentTime;
  1833.     OnTimeSync(m_ulIncreasingTimer);
  1835.     /* A call to timesync may result in stopping
  1836.      * playback and we do not want to have any more
  1837.      * time syncs.
  1838.      */
  1839.     /* Put this back in the scheduler.
  1840.      */
  1841.     if (m_bInited && m_eState == E_PLAYING && !m_ulCallbackID)
  1842.     {
  1843. *m_pFakeAudioCBTime += (int) (m_ulGranularity*1000);
  1844. m_ulCallbackID = m_pScheduler->AbsoluteEnter( this,
  1845.                                                       *((HXTimeval*)m_pFakeAudioCBTime));
  1846.     }
  1847. }
  1850. void
  1851. CHXAudioPlayer::SetLive(BOOL bIsLive)
  1852. {
  1853.     m_bIsLive = bIsLive;
  1854.     CHXAudioStream* s = 0;
  1855.     CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  1856.     for (; lIter != m_pStreamList->End(); ++lIter)
  1857.     {
  1858. s = (CHXAudioStream*) (*lIter);
  1859. s->SetLive(m_bIsLive);
  1860.     }
  1861. }
  1863. void
  1864. CHXAudioPlayer::AudioFormatNowKnown(void)
  1865. {
  1866.     HX_ASSERT(m_bInited);
  1868.     /* When : More than one audio stream created after initialization
  1869.      * and one of them already called this function earlier
  1870.      */
  1871.     if (m_bHasStreams)
  1872.     {
  1873. return;
  1874.     }
  1876.     m_bHasStreams   = TRUE;
  1877.     m_bInited = FALSE;
  1878.     /* internal setup */
  1879.     HX_RESULT theErr = Setup(m_ulGranularity);
  1880.     if (theErr != HXR_OK)
  1881.     {
  1882. IHXErrorMessages* pErrorMessage = NULL;
  1883. m_pContext->QueryInterface(IID_IHXErrorMessages, (void**) &pErrorMessage);
  1884. if (pErrorMessage)
  1885. {
  1886.     pErrorMessage->Report(HXLOG_ERR, theErr, 0, NULL, NULL);
  1887.     pErrorMessage->Release();
  1888. }
  1890. return;
  1891.     }
  1893.     HX_ASSERT(m_bInited);
  1895.     /* If we have not yet resumed, it is simply setting the audio
  1896.      * player from fake timeline mode to audio timeline mode.
  1897.      * Instead if we have already been resumed and are acting as a
  1898.      * fake timeline, we need to kinda pause from being a fake timeline to
  1899.      * an audio timeline, In this process, we may have to seek the audio
  1900.      * device to generate right timesyncs.
  1901.      */
  1903.     /* If we are already resumed, we need to call resume again internally */
  1904.     if (m_bIsResumed)
  1905.     {
  1906. StopFakeTimeline();
  1907. Seek(m_ulCurrentTime);
  1908. // only resume the owner if we are in a play state...
  1909. // otherwise owner will be resumed when the player gets resumed.
  1910. if (m_eState == E_PLAYING)
  1911. {
  1912.     m_Owner->Resume();
  1913. }
  1914.     }
  1915.     else
  1916.     {
  1917. /* Cool! HXPlayer will call resume later */
  1918.     }
  1919. }
  1921. void
  1922. CHXAudioPlayer::RegisterRealAudioStream(CHXAudioStream* pAudioStream)
  1923. {
  1924.     if (!m_pRealAudioStreamList)
  1925.     {
  1926. m_pRealAudioStreamList = new CHXSimpleList;
  1927.     }
  1929.     m_pRealAudioStreamList->AddTail((void*) pAudioStream);
  1930.     m_bAdjustForRealAudio = TRUE;
  1931. }
  1933. void
  1934. CHXAudioPlayer::UnRegisterRealAudioStream(CHXAudioStream* pAudioStream)
  1935. {
  1936.     if (!m_pRealAudioStreamList)
  1937.     {
  1938. return;
  1939.     }
  1941.     LISTPOSITION posStream = m_pRealAudioStreamList->Find((void*) pAudioStream);
  1942.     if (posStream)
  1943.     {
  1944. m_pRealAudioStreamList->RemoveAt(posStream);
  1945.     }
  1947.     /* Check if there are any more RealAudio Streams registered */
  1948.     if (m_pRealAudioStreamList->GetCount() == 0)
  1949.     {
  1950. m_bAdjustForRealAudio = FALSE;
  1951.     }
  1952. }
  1954. BOOL
  1955. CHXAudioPlayer::IsAudioOnlyTrue(void)
  1956. {
  1957.     BOOL bRetValue = TRUE;
  1958.     IHXPlayer* pPlayer = NULL;
  1959.     m_pContext->QueryInterface(IID_IHXPlayer, (void**)&pPlayer);
  1961.     HX_ASSERT(pPlayer);
  1963.     UINT16 uNumSources = pPlayer->GetSourceCount();
  1965.     IUnknown* pUnknown = NULL;
  1966.     IHXStreamSource* pStreamSource = NULL;
  1967.     IHXStream* pStream = NULL;
  1968.     for (UINT16 i=0; bRetValue && i < uNumSources; i++)
  1969.     {
  1970. pPlayer->GetSource(i, pUnknown);
  1971. pUnknown->QueryInterface(IID_IHXStreamSource,
  1972.  (void**) &pStreamSource);
  1973. HX_RELEASE(pUnknown);
  1974. HX_ASSERT(pStreamSource);
  1976. UINT16 uNumStreams = pStreamSource->GetStreamCount();
  1977. for (UINT16 j=0; bRetValue && j < uNumStreams; j++)
  1978. {
  1979.     pStreamSource->GetStream(j, pUnknown);
  1980.     pUnknown->QueryInterface(IID_IHXStream,
  1981.      (void**) &pStream);
  1982.     HX_RELEASE(pUnknown);
  1983.     HX_ASSERT(pStream);
  1985.     IHXValues* pHeader = pStream->GetHeader();
  1986.     if (pHeader)
  1987.     {
  1988. if (!IsThisAudioStream(pHeader))
  1989. {
  1990.     bRetValue = FALSE;
  1991. }
  1992. pHeader->Release();
  1993.     }
  1995.     pStream->Release();
  1996. }
  1998. HX_RELEASE(pStreamSource);
  1999.     }
  2001.     HX_RELEASE(pPlayer);
  2003.     return bRetValue;
  2004. }
  2006. BOOL
  2007. CHXAudioPlayer::IsThisAudioStream(IHXValues* pHeader)
  2008. {
  2009.     CHXSimpleList::Iterator ndxStream = m_pStreamList->Begin();
  2010.     for(; ndxStream != m_pStreamList->End(); ++ndxStream)
  2011.     {
  2012. CHXAudioStream* pAudioStream = (CHXAudioStream*) (*ndxStream);
  2013. IHXValues* pAudioHeader = pAudioStream->GetStreamInfo();
  2014. if (pAudioHeader == pHeader)
  2015. {
  2016.     HX_RELEASE(pAudioHeader);
  2017.     return TRUE;
  2018. }
  2020. HX_RELEASE(pAudioHeader);
  2021.     }
  2023.     return FALSE;
  2024. }
  2026. void
  2027. CHXAudioPlayer::AdjustForRealAudio()
  2028. {
  2029.     UINT32 ulCurrentDeviceTime = m_ulCurrentTime;
  2031. #if defined(HELIX_FEATURE_AUDIO_INACCURATESAMPLING)
  2032.     if (m_bAdjustForRealAudio)
  2033.     {
  2034. CHXAudioStream* pAudioStream = NULL;
  2036.         // Only use a playing audio stream for time adjustment:
  2037.         for (CHXSimpleList::Iterator streamIterator = m_pRealAudioStreamList->Begin();
  2038.              streamIterator != m_pRealAudioStreamList->End();
  2039.              ++streamIterator)
  2040.         {
  2041.             if ( ((CHXAudioStream*) (*streamIterator))->GetState() == E_PLAYING)
  2042.             {
  2043.                 pAudioStream = (CHXAudioStream*) *streamIterator;
  2044.                 break;
  2045.             }
  2046.         }
  2048.         if (pAudioStream)
  2049.         {
  2050.             UINT32 ulAdjustedTime = 0L;
  2052.             double dBytesPlayed = m_Owner->GetNumBytesPlayed();
  2053.             if (HXR_OK == pAudioStream->ConvertCurrentTime( dBytesPlayed,
  2054.                                                             m_ulCurrentTime,
  2055.                                                             ulAdjustedTime))
  2056.             {
  2057.                 UINT32 ulTickCount = HX_GET_TICKCOUNT();
  2058.                 /* This is to avoid stall at end of the presentation */
  2059.                 /* The RA stream may have a duration of say 30 seconds
  2060.                  * but the actual data may be only for 29.9
  2061.                  * seconds. In this case, audio stream will never
  2062.                  * return time more than 29.9 seconds and we will get
  2063.                  * stalled.  To avoid this, we wait for atmost
  2064.                  * MAX_WAIT_AT_SAME_TIME (== max granularity+50 ms) at
  2065.                  * the same timestamp. If we find that we are pushing
  2066.                  * more data in the audio device but the audio stream
  2067.                  * is reporting the same time for the past
  2068.                  * MAX_WAIT_AT_SAME_TIME, we increment our timestamp
  2069.                  * by the real time elapsed since the last update.
  2070.                  * This code will only trigger when we are near the
  2071.                  * end of presentation.
  2072.                  */
  2073.                 if (m_bTimeReturned &&
  2074.                     ulAdjustedTime <= m_ulLastCurrentTimeReturned &&
  2075.                     ulCurrentDeviceTime > m_ulLastDeviceTimeAdjusted &&
  2076.                     ulCurrentDeviceTime - m_ulLastDeviceTimeAdjusted > MAX_WAIT_AT_SAME_TIME)
  2077.                 {
  2078.                     UINT32 ulElapsedTime = CALCULATE_ELAPSED_TICKS(m_ulTimeAdjustDoneAt,
  2079.                                                                    ulTickCount);
  2080.                     if (ulElapsedTime >= MAX_WAIT_AT_SAME_TIME)
  2081.                     {
  2082.                         m_ulCurrentTime = m_ulLastCurrentTimeReturned + ulElapsedTime;
  2083.                         m_ulTimeAdjustDoneAt     = ulTickCount;
  2084.                         m_ulLastDeviceTimeAdjusted  = ulCurrentDeviceTime;
  2085.                     }
  2086.                     else
  2087.                     {
  2088.                         m_ulCurrentTime = ulAdjustedTime;
  2089.                     }
  2090.                 }
  2091.                 else
  2092.                 {
  2093.                     m_ulTimeAdjustDoneAt = ulTickCount;
  2094.                     m_ulCurrentTime      = ulAdjustedTime;
  2095.                 }
  2096.             }
  2097.         }
  2098.     }
  2099. #endif /* HELIX_FEATURE_AUDIO_INACCURATESAMPLING */
  2101.     /* Never go back in time */
  2102.     if (!m_bTimeReturned)
  2103.     {
  2104. m_bTimeReturned     = TRUE;
  2105. m_ulLastCurrentTimeReturned = m_ulCurrentTime;
  2106. m_ulTimeAdjustDoneAt     = HX_GET_TICKCOUNT();
  2107. m_ulLastDeviceTimeAdjusted  = ulCurrentDeviceTime;
  2108.     }
  2109.     else if (m_ulCurrentTime <= m_ulLastCurrentTimeReturned)
  2110.     {
  2111. m_ulCurrentTime = m_ulLastCurrentTimeReturned;
  2112.     }
  2113.     else
  2114.     {
  2115. m_ulLastDeviceTimeAdjusted  = ulCurrentDeviceTime;
  2116. m_ulLastCurrentTimeReturned = m_ulCurrentTime;
  2117.     }
  2119. }
  2121. HX_RESULT
  2122. CHXAudioPlayer::ResumeFakeTimeline(void)
  2123. {
  2124.     HX_RESULT rc = HXR_OK;
  2126.     HX_ASSERT(!m_bHasStreams);
  2128.     HXTimeval lTime = m_pScheduler->GetCurrentSchedulerTime();
  2130.     m_pFakeAudioCBTime->tv_sec = lTime.tv_sec;
  2131.     m_pFakeAudioCBTime->tv_usec = lTime.tv_usec;
  2133.     m_ulIncreasingTimer = m_ulCurrentTime;
  2134.     m_ulLastFakeCallbackTime = HX_GET_TICKCOUNT();
  2136.     *m_pFakeAudioCBTime += (int) (m_ulGranularity*1000);
  2138.     m_ulCallbackID = m_pScheduler->AbsoluteEnter(this,
  2139.                                                  *((HXTimeval*) m_pFakeAudioCBTime));
  2141.     return rc;
  2142. }
  2144. HX_RESULT CHXAudioPlayer::Func()
  2145. {
  2146.     m_ulCallbackID = 0;
  2147.     OnTimerCallback();
  2148.     return HXR_OK;
  2149. }
  2152. HX_RESULT CHXAudioPlayer::StopFakeTimeline(void)
  2153. {
  2154.     HX_RESULT rc = HXR_OK;
  2156.     if(m_ulCallbackID && m_pScheduler)
  2157.     {
  2158.         m_pScheduler->Remove(m_ulCallbackID);
  2159.     }
  2161.     return rc;
  2162. }
  2164. double
  2165. CHXAudioPlayer::NumberOfBytesWritten()
  2166. {
  2167.     return m_Owner->NumberOfBytesWritten();
  2168. }
  2170. double
  2171. CHXAudioPlayer::ConvertMsToBytes(UINT32 ulTime)
  2172. {
  2173.     return m_Owner->ConvertMsToBytes(ulTime);
  2174. }
  2176. void
  2177. CHXAudioPlayer::UpdateStreamLastWriteTime()
  2178. {
  2179.     // Make each stream seek, too, since they own the resampling buffers.
  2180.     CHXAudioStream* s = 0;
  2181.     CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  2182.     for (; lIter != m_pStreamList->End(); ++lIter)
  2183.     {
  2184. s = (CHXAudioStream*) (*lIter);
  2185. s->UpdateStreamLastWriteTime();
  2186.     }
  2187. }
  2189. void
  2190. CHXAudioPlayer::SaveLastNMilliSeconds(BOOL bSave, UINT32 ulNMilliSeconds)
  2191. {
  2192.     // Make each stream seek, too, since they own the resampling buffers.
  2193.     CHXAudioStream* s = 0;
  2194.     CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  2195.     for (; lIter != m_pStreamList->End(); ++lIter)
  2196.     {
  2197. s = (CHXAudioStream*) (*lIter);
  2198. s->SaveLastNMilliSeconds(bSave, ulNMilliSeconds);
  2199.     }
  2200. }
  2202. void
  2203. CHXAudioPlayer::RewindPlayer(UINT32 ulTimeToRewind)
  2204. {
  2205.     if (m_pStreamList->GetCount() == 0 || !m_bCanBeRewound)
  2206.     {
  2207. return;
  2208.     }
  2210.     // Make each stream seek, too, since they own the resampling buffers.
  2211.     CHXAudioStream* s = 0;
  2212.     CHXSimpleList::Iterator lIter = m_pStreamList->Begin();
  2213.     for (; lIter != m_pStreamList->End(); ++lIter)
  2214.     {
  2215. s = (CHXAudioStream*) (*lIter);
  2216. s->RewindStream(ulTimeToRewind);
  2217.     }
  2219.     HX_ASSERT(m_llLastWriteTime >= ulTimeToRewind);
  2220.     if (m_llLastWriteTime >= ulTimeToRewind)
  2221.     {
  2222. m_llLastWriteTime -= ulTimeToRewind;
  2223.     }
  2224. }
  2226. HX_RESULT
  2227. CHXAudioPlayer::ProcessAudioHook(PROCESS_ACTION action,
  2228.  IHXAudioHook* pAudioHook)
  2229. {
  2230.     return HXR_OK;
  2231. }
  2233. STDMETHODIMP CHXAudioPlayer::SetError( HX_RESULT theErr )
  2234. {
  2235.     if (theErr != HXR_OK)
  2236.     {
  2237. IHXErrorMessages* pErrorMessage = NULL;
  2238. m_pContext->QueryInterface(IID_IHXErrorMessages, (void**) &pErrorMessage);
  2239. if (pErrorMessage)
  2240. {
  2241.     pErrorMessage->Report(HXLOG_ERR, theErr, 0, NULL, NULL);
  2242.     pErrorMessage->Release();
  2243. }
  2244.     }
  2245.     return HXR_OK;
  2246. }