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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxsrc.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：68k
源码类别：

Symbian

开发平台：

C/C++

hxsrc.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "hxtypes.h"
  37. #include "hxcom.h"
  38. #ifdef _WINDOWS
  39. #include <windows.h>
  40. #endif
  42. #include "hlxclib/stdio.h"
  43. #include "hlxclib/stdlib.h"
  44. #include "prefdefs.h"
  45. #include "plprefk.h"
  46. #include "hxcomm.h"
  47. #include "ihxpckts.h"
  48. #include "hxfiles.h"
  49. #include "hxengin.h"
  50. #include "hxcore.h"
  51. #include "hxprefs.h"
  52. #include "hxpref.h"
  53. #include "hxausvc.h"
  54. #include "hxmon.h"
  55. #include "hxclreg.h"
  56. #include "hxgroup.h"
  57. #include "hxsmbw.h"
  58. #include "hxstrm.h"
  59. #include "hxwin.h"
  62. #include "hxcore.h"
  63. #include "hxhyper.h"
  64. #include "playhpnv.h"
  65. #include "hxplugn.h"
  66. #include "hxrendr.h"
  68. #include "chxeven.h"
  69. #include "chxelst.h"
  70. #include "hxmap.h"
  71. #include "hxrquest.h"
  72. #include "hxmangle.h"
  73. #include "hxtick.h"
  74. #include "dbcs.h"
  76. #include "hxstrutl.h"
  77. #include "strminfo.h"
  78. #include "timeval.h"
  79. #include "statsmgr.h"
  80. #include "hxbsrc.h"
  81. #include "hxsrc.h"
  82. #include "srcinfo.h"
  83. #include "corshare.h"
  84. #include "upgrdcol.h"
  85. #include "hxrasyn.h"
  86. #include "hxaudstr.h"
  87. #include "hxplugn.h"
  88. #include "hxrendr.h"
  89. #include "errdbg.h"
  91. // will be taken out once flags are defined in a separate file
  92. #include "rmfftype.h"
  93. #include "hxplay.h"
  94. #include "hxcleng.h"
  95. #include "hxsrc.h"
  97. #include "hxheap.h"
  98. #ifdef _DEBUG
  99. #undef HX_THIS_FILE
  100. static const char HX_THIS_FILE[] = __FILE__;
  101. #endif
  103. #if defined(HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES)
  104. // TurboPlay should never be turned on in low heap mode, but just in case ...
  105. #define TURBO_AUDIO_PUSHDOWN 100
  106. #else
  107. #define TURBO_AUDIO_PUSHDOWN 2000
  108. #endif
  110. HXSource::HXSource() :
  111.   m_pPlayer (0)
  112. , m_lRefCount(0)
  113. , m_ulStreamIndex(0)
  114. , m_bInitialized (FALSE)
  115. , m_bIsPreBufferingDone(FALSE)
  116. , m_bClipTimeAdjusted(FALSE)
  117. , mLastError (HXR_OK)
  118. , m_ulPerfectPlayTime (0)
  119. , m_ulBufferedPlayTime(0)
  120.         , m_ulStreamHeadersExpected(0)
  121. , m_bPerfectPlayEntireClip(FALSE)
  122. , m_bCannotBufferEntireClip(FALSE)
  123. , m_uNumStreams (0)
  124. , mFlags (0)
  125. , m_bPerfectPlayAllowed (FALSE)
  126. , mSaveAsAllowed (FALSE)
  127. , mLiveStream (FALSE)
  128. , m_bRestrictedLiveStream (FALSE)
  129. , m_bSourceEnd (FALSE)
  130. , m_bForcedSourceEnd(FALSE)
  131. , m_ulPreRollInMs (0)
  132. , m_ulPreRoll (0)
  133. , m_ulAvgBandwidth (0)
  134. , m_ulDuration (0)
  135. , m_bReceivedData (FALSE)
  136. , m_bReceivedHeader(FALSE)
  137. , m_bNonSeekable(FALSE)
  139. , m_nSeeking (0)
  140. , m_bPaused (FALSE)  
  141. , m_bFirstResume(TRUE)
  142. , m_bResumePending(FALSE)
  143. , m_bIsActive(FALSE)
  145. , m_uActiveStreams (0)
  147. , m_pszURL(NULL)
  148. , m_pURL(NULL)
  149. , m_bAltURL(TRUE)
  151. , m_ulStartTime (0)
  152. , m_ulEndTime (0)
  153. , m_ulDelay (0)
  154. , m_ulOriginalDelay (0)
  155. , m_ulPrefetchDelay (0)
  156. , m_llLastExpectedPacketTime(0)
  157. , m_ulRestrictedDuration(0)
  158. , m_bDelayed(FALSE)
  160. , m_ulSourceStartTime(0)
  161. , m_pPreferences (0)
  162. , m_pRegistry (0)
  163. , m_pScheduler (0)
  164. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  165. , m_pStats (0)
  166. , m_pStatsManager(NULL)
  167. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  168. , m_bLocked (FALSE)
  169. , m_pEngine (0)
  170. , m_bRebufferingRequired(FALSE)
  171. , m_bInitialBuffering(TRUE)
  172. , m_bPartOfNextGroup(FALSE)
  173. , m_bPartOfPrefetchGroup(FALSE)
  174. , m_pBufferManager(NULL)
  175. , m_pFileHeader(0)
  176. , m_bPerfectPlay(FALSE)
  177. , m_bBufferedPlay(FALSE)
  178. , m_ulLossHack(0)
  179. , m_ulNumFakeLostPackets(0)
  180. , m_ulLastBufferingCalcTime(0)
  181. , m_pSourceInfo(NULL)
  182. , m_pRequest(NULL)
  183. , m_pASMSource(NULL)
  184. , m_pBackChannel(NULL)
  185. , m_bDefaultAltURL(FALSE)
  186. , m_bCustomEndTime(FALSE)
  187. , m_bCustomDuration(FALSE)
  188. , m_bIsPreBufferingStarted(FALSE)
  189. , m_ulOriginalDuration(0)
  190. , m_bReSetup(FALSE)
  191. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  192. , m_pUpgradeCollection(NULL)
  193. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  194. , m_bRTSPRuleFlagWorkAround(FALSE)
  195.         , m_bContinueWithHeaders(FALSE)
  196. , m_bPrefetch(FALSE)
  197. , m_prefetchType(PrefetchUnknown)
  198. , m_ulPrefetchValue(0)
  199. , m_ulFirstPacketTime(0)
  200. , m_bIsMeta(FALSE)
  201. , m_bFastStart(FALSE)
  202. , m_serverTurboPlay(TURBO_PLAY_UNKNOWN)
  203. , m_ulMaxBandwidth(4000) // 4000kbps
  204. , m_pAudioStreamList(NULL)
  205.         , m_maxPossibleAccelRatio(4.0) // I donno what's a good value?
  206.         , m_ulTurboPushDown(TURBO_AUDIO_PUSHDOWN)
  207.         , m_bSureStreamClip(FALSE)
  208.         , m_ulTurboStartActiveTime(0)
  209. , m_srcEndCode(END_UNKNOWN)
  210. , m_pRecordControl(NULL)
  211. , m_bPlayFromRecordControl(FALSE)
  212.         , m_pRedirectURL(NULL)
  213.         , m_bRedirectPending(FALSE)
  214. {
  215.     mStreamInfoTable = new CHXMapLongToObj;
  216. }
  218. HXSource::~HXSource()
  219. {
  220.     // XXX moved this to the distuctor because we want to keep arround
  221.     // the request until the renderers are close at which point we should
  222.     // be released and deleted.
  223.     HX_RELEASE(m_pRequest);
  224.     HX_VECTOR_DELETE(m_pszURL);
  225.     HX_DELETE(mStreamInfoTable);
  226. }
  228. void
  229. HXSource::Stop()
  230. {
  231.     m_pSourceInfo = NULL;    
  233.     HX_DELETE (m_pURL);
  234.     HX_DELETE (m_pBufferManager);
  236.     if ( FAILED(mLastError) )
  237.     {
  238. HX_RELEASE(m_pRequest);
  239.     }
  241. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  242.     if (m_pStatsManager)
  243.     {
  244. m_pStatsManager->DoCleanup();
  245. HX_RELEASE(m_pStatsManager);
  246.     }        
  247.     HX_DELETE(m_pStats);    
  248. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  250.     DeleteAllEvents(); 
  252.     HX_RELEASE(m_pRegistry);
  253.     HX_RELEASE(m_pPreferences);
  254.     HX_RELEASE(m_pScheduler);
  255.     HX_RELEASE(m_pEngine);
  256. }    
  258. HX_RESULT HXSource::DoCleanup(EndCode endCode)
  259. {
  260.     m_ulDuration = 0;    
  261.     m_ulPreRollInMs = 0;
  262.     m_ulPreRoll = 0;
  263.     m_ulAvgBandwidth = 0;
  264.     m_ulLastBufferingCalcTime = 0;
  266.     m_ulMaxBandwidth = 0;
  267.     m_serverTurboPlay = TURBO_PLAY_UNKNOWN;
  269.     m_bAltURL = FALSE;    
  270.     m_bPaused = FALSE;
  271.     m_bFirstResume = TRUE;
  272.     m_bIsActive = FALSE;
  273.     m_bResumePending = FALSE;
  274.     m_bIsPreBufferingStarted = FALSE;
  275.     m_bIsPreBufferingDone = FALSE;    
  276.     m_bClipTimeAdjusted = FALSE;    
  277.     m_bInitialBuffering = TRUE;
  278.     m_bRebufferingRequired = FALSE;    
  279.     m_bReceivedData = FALSE;
  280.     m_bReceivedHeader = FALSE;
  282.     ReleaseAudioStreams(m_pAudioStreamList);
  283.     HX_DELETE(m_pAudioStreamList);
  285.     DeleteStreamTable();
  287.     CHXSimpleList::Iterator lIter = m_HXStreamList.Begin();
  288.     for (; lIter != m_HXStreamList.End(); ++lIter)
  289.     {
  290. HXStream* pStream = (HXStream*) (*lIter);
  291. pStream->Release();
  292.     }
  294.     m_HXStreamList.RemoveAll();    
  296.     HX_RELEASE(m_pFileHeader);    
  297.     HX_RELEASE(m_pASMSource);
  298.     HX_RELEASE(m_pBackChannel);
  299. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  300.     HX_RELEASE(m_pUpgradeCollection);
  301. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  303.     m_bForcedSourceEnd = FALSE;
  304.     m_bSourceEnd = FALSE;
  306.     HX_DELETE(m_pRedirectURL);
  307.     m_bRedirectPending  = FALSE;
  309. #if defined(HELIX_FEATURE_RECORDCONTROL)
  310.     if(m_pRecordControl)
  311.     {
  312. m_pRecordControl->Cleanup();
  313.     }
  314. #endif /* HELIX_FEATURE_RECORDCONTROL */
  315.     HX_RELEASE(m_pRecordControl);
  317.     return HXR_OK;
  318. }
  320. /////////////////////////////////////////////////////////////////////////
  321. // Method:
  322. // IUnknown::QueryInterface
  323. // Purpose:
  324. // Implement this to export the interfaces supported by your 
  325. // object.
  326. //
  327. STDMETHODIMP HXSource::QueryInterface(REFIID riid, void** ppvObj)
  328. {
  329.     QInterfaceList qiList[] =
  330.         {
  331.             { GET_IIDHANDLE(IID_IHXStreamSource), (IHXStreamSource*)this },
  332.             { GET_IIDHANDLE(IID_IHXPendingStatus), (IHXPendingStatus*)this },
  333.             { GET_IIDHANDLE(IID_IHXInfoLogger), (IHXInfoLogger*)this },
  334.             { GET_IIDHANDLE(IID_IHXPrivateStreamSource), (IHXPrivateStreamSource*)this },
  335.             { GET_IIDHANDLE(IID_IHXSourceBufferingStats), (IHXSourceBufferingStats*)this },
  336.             { GET_IIDHANDLE(IID_IHXSourceBufferingStats2), (IHXSourceBufferingStats2*)this },
  337. #if defined(HELIX_FEATURE_HYPER_NAVIGATE)
  338.             { GET_IIDHANDLE(IID_IHXHyperNavigate), (IHXHyperNavigate*)this },
  339.             { GET_IIDHANDLE(IID_IHXHyperNavigate2), (IHXHyperNavigate2*)this },
  340. #endif /* defined(HELIX_FEATURE_HYPER_NAVIGATE) */
  341.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXStreamSource*)this },
  342.         };
  343.     
  344.     HX_RESULT res = ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  345.     
  346.     // if successful, return immediately...
  347.     if (SUCCEEDED(res))
  348.     {
  349.         return res;
  350.     }
  351.     // ... otherwise proceed onward
  352.     
  353.     if (IsEqualIID(riid, IID_IHXBackChannel))
  354.     {
  355. if (m_pBackChannel)
  356. {
  357.     AddRef();
  358.     *ppvObj = (IHXBackChannel*)this;
  359.     return HXR_OK;
  360. }
  361. else
  362. {
  363.     *ppvObj = NULL;
  364.     return HXR_NOINTERFACE;
  365. }
  366.     }
  367.     else if (IsEqualIID(riid, IID_IHXASMSource))
  368.     {
  369. if (m_pASMSource)
  370. {
  371.     AddRef();
  372.     *ppvObj = (IHXASMSource*)this;
  373.     return HXR_OK;
  374. }
  375. else
  376. {
  377.     *ppvObj = NULL;
  378.     return HXR_NOINTERFACE;
  379. }
  380.     }
  382. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  383.     else if (IsEqualIID(riid, IID_IHXUpgradeCollection))
  384.     {
  385. if (!m_pUpgradeCollection)
  386. {
  387.     m_pUpgradeCollection = new HXUpgradeCollection;
  388.     m_pUpgradeCollection->AddRef();
  389. }
  391. return m_pUpgradeCollection->QueryInterface(riid, ppvObj);
  392.     }
  393. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  394.     else if (m_pRequest &&
  395. m_pRequest->QueryInterface(riid, ppvObj) == HXR_OK)
  396.     {
  397. return HXR_OK;
  398.     }
  399.     else if (m_pFileHeader &&
  400. m_pFileHeader->QueryInterface(riid, ppvObj) == HXR_OK)
  401.     {
  402. return HXR_OK;
  403.     }
  405.     *ppvObj = NULL;
  406.     return HXR_NOINTERFACE;
  407. }
  409. /////////////////////////////////////////////////////////////////////////
  410. // Method:
  411. // IUnknown::AddRef
  412. // Purpose:
  413. // Everyone usually implements this the same... feel free to use
  414. // this implementation.
  415. //
  416. STDMETHODIMP_(ULONG32) HXSource::AddRef()
  417. {
  418.     return InterlockedIncrement(&m_lRefCount);
  419. }
  421. /////////////////////////////////////////////////////////////////////////
  422. // Method:
  423. // IUnknown::Release
  424. // Purpose:
  425. // Everyone usually implements this the same... feel free to use
  426. // this implementation.
  427. //
  428. STDMETHODIMP_(ULONG32) HXSource::Release()
  429. {
  430.     if (InterlockedDecrement(&m_lRefCount) > 0)
  431.     {
  432. return m_lRefCount;
  433.     }
  435.     delete this;
  436.     return 0;
  437. }
  439. // *** IHXStreamSource methods ***
  441. /************************************************************************
  442.  * Method:
  443.  * IHXStreamSource::IsLive
  444.  * Purpose:
  445.  * Ask the source whether it is live
  446.  *
  447.  */
  448. STDMETHODIMP_ (BOOL) HXSource::IsLive(void)
  449. {
  450.     return mLiveStream;
  451. }
  453. /************************************************************************
  454.  * Method:
  455.  *     IHXStreamSource::GetPlayer
  456.  * Purpose:
  457.  *     Get the interface to the player object of which the source is
  458.  *     a part of.
  459.  *
  460.  */
  461. STDMETHODIMP HXSource::GetPlayer(IHXPlayer* &pPlayer)
  462. {
  463.     pPlayer = m_pPlayer;
  464.     if (pPlayer)
  465.     {
  466. pPlayer->AddRef();
  467.     }
  469.     return HXR_OK;
  470. }
  472. /************************************************************************
  473.  * Method:
  474.  *     IHXStreamSource::GetContext
  475.  * Purpose:
  476.  *     Get the interface to the context object of which the source is
  477.  *     a part of.
  478.  *
  479.  */
  480. STDMETHODIMP HXSource::GetContext(IUnknown* &pContext)
  481. {
  482.     pContext = ((IUnknown*)(IHXClientEngine*) m_pEngine);
  483.     if (pContext)
  484.     {
  485. pContext->AddRef();
  486.     }
  488.     return HXR_OK;
  489. }
  491. /************************************************************************
  492.  * Method:
  493.  *     IHXStreamSource::GetURL
  494.  * Purpose:
  495.  *     Get the URL for this source. NOTE: The returned string is
  496.  *     assumed to be valid for the life of the IHXStreamSource from which it
  497.  *     was returned.
  498.  *
  499.  */
  500. STDMETHODIMP_(const char*) HXSource::GetURL(void)
  501. {
  502.     const char* pURL = NULL;
  504.     /* 
  505.      * Make sure that the we have not been re-directed
  506.      * to a new URL.
  507.      */ 
  508.     if (m_pRequest && 
  509. m_pRequest->GetURL(pURL) == HXR_OK &&
  510. pURL)
  511.     {
  512. if (!m_pszURL ||
  513.     ::strcasecmp(pURL, m_pszURL) != 0)
  514. {
  515.     HX_VECTOR_DELETE(m_pszURL);
  516.     m_pszURL = new char[strlen(pURL) + 1];
  517.     strcpy(m_pszURL, pURL); /* Flawfinder: ignore */
  518. }
  519.     }
  521.     // append RAM mimeType as URL option to notify the
  522.     // caller(i.e. ViewSource)
  523.     if (m_bIsMeta)
  524.     {
  525. char* pszTemp = NULL;
  527. pszTemp = ::HXFindChar(m_pszURL, '?');
  528. if (pszTemp)
  529. {
  530. int lenTemp = strlen(m_pszURL) + strlen("&mimeType=") + strlen(RAM_MIMETYPE) + 1;
  531.     pszTemp = new char[lenTemp];
  532.     SafeSprintf(pszTemp, lenTemp, "%s%s%s", m_pszURL, "&mimeType=", RAM_MIMETYPE); /* Flawfinder: ignore */
  533. }
  534. else
  535. {
  536. int lenTemp = strlen(m_pszURL) + strlen("?mimeType=") + strlen(RAM_MIMETYPE) + 1;
  537.     pszTemp = new char[lenTemp];
  538.     SafeSprintf(pszTemp, lenTemp, "%s%s%s", m_pszURL, "?mimeType=", RAM_MIMETYPE); /* Flawfinder: ignore */
  539. }
  541. HX_VECTOR_DELETE(m_pszURL);
  542. m_pszURL = pszTemp;
  543.     }
  545.     return m_pszURL;
  546. }
  549. /************************************************************************
  550.  * Method:
  551.  *     IHXStreamSource::GetStreamCount
  552.  * Purpose:
  553.  *     Get the number of streams in this source
  554.  *
  555.  */
  556. STDMETHODIMP_(UINT16)
  557. HXSource::GetStreamCount()
  558. {
  559.     return m_HXStreamList.GetCount();
  560. }
  563. /************************************************************************
  564.  * Method:
  565.  *     IHXStreamSource::GetStream
  566.  * Purpose:
  567.  *     Get the stream with the given index.
  568.  * Note: 
  569.  *     Since stream numbers may not be zero based, stream index is not
  570.  *     equal to the stream number. Actual stream number may be determined 
  571.  *     from IHXStream::GetStreamNumber()
  572.  *
  573.  */
  574. STDMETHODIMP
  575. HXSource::GetStream
  576. (
  577.     UINT16 nIndex,
  578.     REF(IUnknown*) pUnknown
  579. )
  580. {
  581.     LISTPOSITION lPosition = m_HXStreamList.FindIndex((int) nIndex);
  582.     if (!lPosition)
  583.     {
  584. pUnknown = NULL;
  585. return HXR_INVALID_PARAMETER;
  586.     }
  588.     HXStream* pStream = (HXStream*) m_HXStreamList.GetAt(lPosition);
  589.     HX_ASSERT(pStream);
  591.     return pStream->QueryInterface(IID_IUnknown,(void**)&pUnknown);
  592. }
  595. // IHXPrivateStreamSource methods 
  596. STDMETHODIMP_(BOOL) HXSource::IsSaveAllowed()
  597. {
  598.     return mSaveAsAllowed;
  599. }
  602. /*
  603.  * IHXBackChannel method
  604.  */
  606. /************************************************************************
  607.  * Method:
  608.  *     IHXBackChannel::PacketReady
  609.  * Purpose:
  610.  *      A back channel packet sent from Renderer to FileFormat plugin.
  611.  */
  612. STDMETHODIMP
  613. HXSource::PacketReady(IHXPacket* pPacket)
  614. {
  615.     HX_ASSERT(m_pBackChannel);
  617.     if (m_pBackChannel)
  618.     {
  619. return m_pBackChannel->PacketReady(pPacket);
  620.     }
  622.     return HXR_FAIL;
  623. }
  626. /*
  627.  * IHXASMSource methods
  628.  */
  630. /************************************************************************
  631.  * Method:
  632.  *     IHXASMSource::Subscribe
  633.  * Purpose:
  634.  *      Called to inform a file format that a subscription has occurred,
  635.  *     to rule number uRuleNumber, for stream uStreamNumber.
  636.  */
  637. STDMETHODIMP
  638. HXSource::Subscribe(UINT16 uStreamNumber,
  639.      UINT16 uRuleNumber)
  640. {
  641.     HX_ASSERT(m_pASMSource);
  643.     if (m_pASMSource)
  644.     {
  645. return m_pASMSource->Subscribe(uStreamNumber, uRuleNumber);
  646.     }
  648.     return HXR_FAIL;
  649. }
  651. /************************************************************************
  652.  * Method:
  653.  *     IHXASMSource::Unsubscribe
  654.  * Purpose:
  655.  *      Called to inform a file format that a unsubscription has occurred,
  656.  *     to rule number uRuleNumber, for stream uStreamNumber.
  657.  */
  658. STDMETHODIMP
  659. HXSource::Unsubscribe(UINT16 uStreamNumber,
  660.        UINT16 uRuleNumber)
  661. {
  662.     HX_ASSERT(m_pASMSource);
  664.     if (m_pASMSource)
  665.     {
  666. return m_pASMSource->Unsubscribe(uStreamNumber, uRuleNumber);
  667.     }
  669.     return HXR_FAIL;
  670. }
  672. void
  673. HXSource::AddHXStream(HXStream* pStream)
  674. {
  675.     pStream->AddRef();
  676.     m_HXStreamList.AddTail(pStream);
  678.     UINT16 uStreamNumber = pStream->GetStreamNumber();
  679.     STREAM_INFO* pStreamInfo;
  680.     if (mStreamInfoTable->Lookup((LONG32) uStreamNumber, (void*& )pStreamInfo))
  681.     {
  682. pStreamInfo->m_pStream = pStream;
  683. pStreamInfo->m_pStream->AddRef();
  685. pStreamInfo->BufferingState().OnStream((IHXStream*)pStream);
  686.     }
  687. }
  689. HX_RESULT
  690. HXSource::CollectAudioStreams(CHXSimpleList*& pAudioStreamList)
  691. {
  692. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  693.     HX_RESULT     rc = HXR_OK;
  694.     UINT16     i = 0;
  695.     UINT16     uNumAudioStreams = 0;
  696.     CHXAudioPlayer* pAudioPlayer = NULL;
  697.     CHXAudioStream* pCHXAudioStream = NULL;
  698.     IHXValues*     pHeader = NULL;
  700.     pAudioStreamList = NULL;
  702.     if (!m_pPlayer)
  703.     {
  704. goto cleanup;
  705.     }
  707.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  708.     if (!pAudioPlayer)
  709.     {
  710. goto cleanup;
  711.     }
  713.     uNumAudioStreams = pAudioPlayer->GetAudioStreamCount();
  714.     for (i = 0; i < uNumAudioStreams; i++)
  715.     {
  716. pCHXAudioStream = pAudioPlayer->GetCHXAudioStream(i);
  717. pCHXAudioStream->AddRef();
  719. pHeader = ((IHXAudioStream*)pCHXAudioStream)->GetStreamInfo();
  721. if (pHeader &&
  722.     IsAudioStreamFromThisSource(pHeader))
  723. {
  724.     if (!pAudioStreamList)
  725.     {
  726. pAudioStreamList = new CHXSimpleList();
  727.     }
  729.     pAudioStreamList->AddTail(pCHXAudioStream);
  730. }
  731. else
  732. {
  733.     HX_RELEASE(pCHXAudioStream);
  734. }
  735. HX_RELEASE(pHeader);
  736.     }
  738. cleanup:
  740.     if (!pAudioStreamList)
  741.     {  
  742. rc = HXR_FAILED;
  743.     }
  745.     return rc;
  746. #else
  747.     return HXR_NOTIMPL;
  748. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  749. }
  751. void
  752. HXSource::RemoveAudioStreams(void)
  753. {    
  754. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  755.     CHXAudioPlayer* pAudioPlayer = NULL;
  756.     CHXSimpleList*  pAudioStreamList = NULL;
  758.     if (!m_pPlayer)
  759.     {
  760. goto cleanup;
  761.     }
  763.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  764.     if (!pAudioPlayer)
  765.     {
  766. goto cleanup;
  767.     }
  769.     pAudioPlayer->AddRef();
  771.     if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
  772.     {
  773. pAudioPlayer->ManageAudioStreams(pAudioStreamList, CHXAudioPlayer::STR_REMOVE);
  775. ReleaseAudioStreams(pAudioStreamList);
  776. HX_DELETE(pAudioStreamList);
  777.     }
  779.     HX_RELEASE(pAudioPlayer);
  781. cleanup:
  782. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  784.     return;
  785. }
  787. void
  788. HXSource::PauseAudioStreams(void)
  789. {
  790. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  791.     CHXAudioPlayer* pAudioPlayer = NULL;
  792.     CHXSimpleList*  pAudioStreamList = NULL;
  794.     if (!m_pPlayer)
  795.     {
  796. goto cleanup;
  797.     }
  799.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  800.     if (!pAudioPlayer)
  801.     {
  802. goto cleanup;
  803.     }
  805.     pAudioPlayer->AddRef();
  807.     if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
  808.     {
  809. pAudioPlayer->ManageAudioStreams(pAudioStreamList, CHXAudioPlayer::STR_PAUSE);
  811. ReleaseAudioStreams(pAudioStreamList);
  812. HX_DELETE(pAudioStreamList);
  813.     }
  815.     HX_RELEASE(pAudioPlayer);
  817. cleanup:
  818. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  820.     return;
  821. }
  823. void
  824. HXSource::ResumeAudioStreams(void)
  825. {
  826. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  827.     CHXAudioPlayer* pAudioPlayer = NULL;
  828.     CHXSimpleList*  pAudioStreamList = NULL;
  830.     if (!m_pPlayer)
  831.     {
  832. goto cleanup;
  833.     }
  835.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  836.     if (!pAudioPlayer)
  837.     {
  838. goto cleanup;
  839.     }
  841.     pAudioPlayer->AddRef();
  843.     if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
  844.     {
  845. pAudioPlayer->ManageAudioStreams(pAudioStreamList, CHXAudioPlayer::STR_RESUME);
  847. ReleaseAudioStreams(pAudioStreamList);
  848. HX_DELETE(pAudioStreamList);
  849.     }
  851.     HX_RELEASE(pAudioPlayer);
  853. cleanup:
  854. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  856.     return;
  857. }
  859. void
  860. HXSource::ReleaseAudioStreams(CHXSimpleList* pAudioStreamList)
  861. {
  862. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  863.     if (pAudioStreamList && !pAudioStreamList->IsEmpty())
  864.     {
  865. CHXSimpleList::Iterator lIter = pAudioStreamList->Begin();
  866. for (; lIter != pAudioStreamList->End(); ++lIter)
  867. {
  868.     CHXAudioStream* pAudioStream = (CHXAudioStream*) (*lIter);
  869.     HX_RELEASE(pAudioStream);
  870. }
  871.     }
  872. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  874.     return;
  875. }
  877. HX_RESULT HXSource::Init(HXPlayer * pPlayer, UINT32 unRegistryID)
  878. {
  879.     HX_RESULT theErr = HXR_OK;
  880.    
  881.     m_pPlayer = pPlayer;
  882.     if (m_pPlayer->QueryInterface(IID_IHXPreferences, (void **) &m_pPreferences) != HXR_OK)
  883.     {
  884. theErr = HXR_INVALID_PARAMETER; //HX_INVALID_INTERFACE;
  885.     }
  887.     m_pBufferManager = new CBufferManager(this);
  888.     if(!m_pBufferManager)
  889.     {
  890.         theErr = HXR_OUTOFMEMORY;
  891.     }
  893.     // create registry entries
  894.     if (HXR_OK != m_pPlayer->QueryInterface(IID_IHXRegistry, (void**)&m_pRegistry))
  895.     {
  896. m_pRegistry = NULL;
  897.     }
  898.     else
  899.     {
  900. m_ulRegistryID = unRegistryID;
  901.     }
  903.     if (!theErr &&
  904. m_pPlayer->QueryInterface(IID_IHXScheduler, (void **) &m_pScheduler) != HXR_OK)
  905.     {
  906. theErr = HXR_INVALID_PARAMETER; //HX_INVALID_INTERFACE;
  907.     }
  909.     IHXPreferences* pPref = NULL;
  911.     m_pPlayer->QueryInterface(IID_IHXPreferences, (void**)&pPref);
  912.     if (HXR_OK == ReadPrefINT32(pPref, "TurboPushdown", m_ulTurboPushDown))
  913.     {
  914. m_ulTurboPushDown = (m_ulTurboPushDown / 100) * 100;  // round to multiple of 100
  915.     }
  916.     HX_RELEASE(pPref);
  918.     m_pEngine = m_pPlayer->m_pEngine;
  919.     m_pEngine->AddRef();
  921.     return theErr;
  922. }
  924. HX_RESULT HXSource::SetupRegistry()
  925. {
  926.     HX_RESULT theErr = HXR_OK;
  927. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  928.     UINT32 ulRepeatedRegistryID = 0;
  929.     IHXBuffer* pRepeatRegName = NULL;
  930.     char        szSourceName[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  932.     HX_ASSERT(m_pSourceInfo);    
  934.     if (m_pSourceInfo->m_bLeadingSource &&
  935. !m_pSourceInfo->m_pRepeatList)
  936.     {
  937. m_pStats = new SOURCE_STATS(m_pRegistry, m_ulRegistryID);
  938.     }
  939.     else if (m_pRegistry && 
  940.     HXR_OK == m_pRegistry->GetPropName(m_pPlayer->m_ulRepeatedRegistryID, pRepeatRegName))
  941.     {
  942. SafeSprintf(szSourceName, MAX_DISPLAY_NAME, "%s.%ld%ld%ld", 
  943. pRepeatRegName->GetBuffer(),
  944. m_pSourceInfo->m_uGroupID,
  945. m_pSourceInfo->m_uTrackID,
  946. (int)m_pSourceInfo->m_bLeadingSource);
  947.     
  948. ulRepeatedRegistryID = m_pRegistry->GetId(szSourceName);
  949. if (!ulRepeatedRegistryID)
  950. {
  951.     ulRepeatedRegistryID = m_pRegistry->AddComp(szSourceName);
  952. }
  954. m_pStatsManager = new StatsManager(m_pRegistry, m_ulRegistryID, ulRepeatedRegistryID);
  955. m_pStatsManager->AddRef();
  957. m_pStats = new SOURCE_STATS(m_pRegistry, ulRepeatedRegistryID);
  958.         if( !m_pStats )
  959.         {
  960.             theErr = HXR_OUTOFMEMORY;
  961.         }
  962.     }
  963.     else
  964.     {
  965. // why stats' creation failed??
  966. HX_ASSERT(FALSE);
  967.     }
  969.     HX_RELEASE(pRepeatRegName);
  970. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  972.     return theErr;
  973. }
  975. HX_RESULT HXSource::ReadPreferences(void)
  976. {
  977.     UINT32      un16Temp = 10;
  979.     ReadPrefINT32(m_pPreferences, "PerfectPlayTime", un16Temp); 
  980.     m_ulPerfectPlayTime = un16Temp;
  982.     ReadPrefINT32(m_pPreferences, "BufferedPlayTime", un16Temp);
  983.     m_ulBufferedPlayTime = un16Temp;
  985.     ReadPrefBOOL(m_pPreferences, "PerfPlayEntireClip", m_bPerfectPlayEntireClip); 
  987.     return HXR_OK;
  988. }
  991. HX_RESULT HXSource::DeleteStreamTable(void)
  992. {
  993.     HX_RESULT theErr = HXR_OK;
  995.     STREAM_INFO * sInfo = NULL;
  997.     for (CHXMapLongToObj::Iterator i = mStreamInfoTable->Begin();
  998.          i != mStreamInfoTable->End(); ++i) 
  999.     {    
  1000. sInfo = (STREAM_INFO*) (*i);
  1002. if (sInfo)
  1003. {
  1004.     HX_DELETE (sInfo);
  1005. }
  1006.     }
  1008.     mStreamInfoTable->RemoveAll();
  1009.     m_ulStreamIndex = 0;
  1010.     m_uNumStreams = 0;
  1011.     
  1012.     return theErr;
  1013. }
  1016. IHXValues* HXSource::GetHeaderInfo(UINT16 stream_number)
  1017. {
  1018.     STREAM_INFO * pStreamInfo;
  1019.     if (mStreamInfoTable->Lookup((LONG32) stream_number, (void*& )pStreamInfo))
  1020.     {
  1021. return pStreamInfo->m_pHeader;
  1022.     }
  1023.     else
  1024.     {
  1025. return NULL;
  1026.     }
  1027. }
  1029. HX_RESULT
  1030. HXSource::GetStreamHeaderInfo(UINT16 index, IHXValues*& hdr)
  1031. {
  1032.     HX_TRACE("HXSource::GetStreamHeaderInfo");
  1033.     
  1034.     // sanity check
  1035.     if (index >= m_uNumStreams)
  1036.     {
  1037. return HXR_INVALID_PARAMETER; // HX_INVALID_INDEX;
  1038.     }
  1039.     
  1040.     CHXMapLongToObj::Iterator i = mStreamInfoTable->Begin();
  1041.     for (UINT16 j=0; j < index; j++)
  1042.     {
  1043. ++i;
  1044.     }
  1046.     STREAM_INFO* pStreamInfo = (STREAM_INFO*) *i;
  1048.     hdr = pStreamInfo->m_pHeader;
  1049.     if (hdr)
  1050.     {
  1051. hdr->AddRef();
  1052.     }
  1054.     return HXR_OK;
  1055. }
  1058. void HXSource::SetFlags(UINT16 flags)
  1059. {
  1060.     mFlags = flags;
  1062.     if (mFlags & HX_PERFECT_PLAY_ENABLED)
  1063.     {
  1064. m_bPerfectPlayAllowed = TRUE;
  1065.     }
  1066.     else
  1067.     {
  1068. m_bPerfectPlayAllowed = FALSE;
  1069.     }
  1071.     if (mFlags & HX_SAVE_ENABLED)
  1072.     {
  1073. mSaveAsAllowed = TRUE;
  1074.     }
  1075.     else
  1076.     {
  1077. mSaveAsAllowed = FALSE;
  1078.     }
  1079. }
  1081. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  1082. HX_RESULT HXSource::CopyMetaDataToRegistry(IHXValues* pHeader)
  1083. {
  1084.     // get Request Object
  1085.     char pszServerMetaData[256] = {0}; /* Flawfinder: ignore */
  1086.     char pszMetaData[256] = {0}; /* Flawfinder: ignore */
  1088.     IHXValues* pReqHeaders = NULL;
  1089.     IHXRequest* pRequest = NULL;
  1090.     IHXBuffer* pBuffer = NULL;
  1091.     char szRegKeyName[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  1092.     char buff[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  1093.     char szSMDKey[256]; /* Flawfinder: ignore */
  1094.     ULONG32 ulValue = 0;
  1095.     IHXBuffer* pParentName = NULL;
  1096.     UINT32 regid = 0;
  1097.     const char szServerMetaData[] = {"ServerMetaData"};
  1100.     if (HXR_OK == m_pRegistry->GetPropName(m_pStats->m_ulRegistryID, pParentName))
  1101.     {
  1102. SafeStrCpy(buff, (const char*) pParentName->GetBuffer(), MAX_DISPLAY_NAME);
  1103. char* pDot = strrchr(buff, '.');
  1104. if (pDot)
  1105. {
  1106.     *pDot = '';
  1107. }
  1108. SafeStrCpy(szSMDKey, buff, 256);
  1110. if (HXR_OK == GetRequest(pRequest))
  1111. {
  1112.     // get request headers
  1113.     if (HXR_OK == pRequest->GetRequestHeaders(pReqHeaders))
  1114.     {
  1115. // look for the meta data properties
  1116. if (HXR_OK == pReqHeaders->GetPropertyCString("AcceptMetaInfo", pBuffer))
  1117. {
  1118.     SafeStrCpy(pszMetaData, (char*) pBuffer->GetBuffer(), 256);
  1119.     HX_RELEASE(pBuffer);
  1121.     // look for comma delimited entries
  1122.     const char* pCharEntryStart = pszMetaData;
  1123.     const char* pCharEntryEnd = pCharEntryStart;
  1125.     while (pCharEntryEnd && *pCharEntryEnd)
  1126.     {
  1127. ++pCharEntryEnd;
  1128. if (*pCharEntryEnd == ',' || !*pCharEntryEnd)
  1129. {
  1130.     // copy next prop request into buffer 
  1131.     strncpy(buff, pCharEntryStart, (UINT32)pCharEntryEnd - (UINT32)pCharEntryStart); /* Flawfinder: ignore */
  1132.     *(buff+(UINT32)pCharEntryEnd - (UINT32)pCharEntryStart) = '';
  1134.     // see if this prop is in file header (it should be!)
  1135.     if (HXR_OK == pHeader->GetPropertyCString(buff, pBuffer))
  1136.     {
  1137. // create new registry entry
  1138. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.%s", pParentName->GetBuffer(), buff);
  1139. regid = m_pRegistry->GetId(szRegKeyName);
  1140. if (!regid)
  1141. {
  1142.     m_pRegistry->AddStr(szRegKeyName, pBuffer);
  1143. }
  1144. else
  1145. {
  1146.     // set new value
  1147.     m_pRegistry->SetStrByName(szRegKeyName, pBuffer);
  1148. }
  1150. HX_RELEASE(pBuffer);
  1151.     }
  1152.     else if (HXR_OK == pHeader->GetPropertyULONG32(buff, ulValue))
  1153.     {
  1154. // create new registry entry
  1155. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.%s", pParentName->GetBuffer(), buff);
  1157. regid = m_pRegistry->GetId(szRegKeyName);
  1158. if (!regid)
  1159. {
  1160.     m_pRegistry->AddInt(szRegKeyName, ulValue);
  1161. }
  1162. else
  1163. {
  1164.     // set new value
  1165.     m_pRegistry->SetIntByName(szRegKeyName, ulValue);
  1166. }
  1167.     }
  1169.     pCharEntryStart = pCharEntryEnd + 1;
  1170. }
  1171.     }
  1172. }
  1174. // look for the meta data properties
  1175. if (HXR_OK == pReqHeaders->GetPropertyCString("AcceptServerMetaData", pBuffer))
  1176. {
  1177.     SafeStrCpy(pszServerMetaData, (char*) pBuffer->GetBuffer(), 256);
  1178.     HX_RELEASE(pBuffer);
  1180.     // first make sure we have a composit key for "statistics.Player0.ServerMetaData"
  1181.     SafeSprintf(buff, MAX_DISPLAY_NAME, "%s.%s", szSMDKey, szServerMetaData);
  1182.     regid = m_pRegistry->GetId(buff);
  1183.     if (!regid)
  1184.     {
  1185. m_pRegistry->AddComp(buff);
  1186.     }
  1187.     SafeStrCpy(szSMDKey, buff, 256);
  1189.     // look for comma delimited entries
  1190.     const char* pCharEntryStart = pszServerMetaData;
  1191.     const char* pCharEntryEnd = pCharEntryStart;
  1193.     while (pCharEntryEnd && *pCharEntryEnd)
  1194.     {
  1195. ++pCharEntryEnd;
  1196. if (*pCharEntryEnd == ',' || !*pCharEntryEnd)
  1197. {
  1198.     // copy next prop request into buffer 
  1199.     strncpy(buff, pCharEntryStart, (UINT32)pCharEntryEnd - (UINT32)pCharEntryStart); /* Flawfinder: ignore */
  1200.     *(buff+(UINT32)pCharEntryEnd - (UINT32)pCharEntryStart) = '';
  1202.     // see if this prop is in file header (it should be!)
  1203.     if (HXR_OK == pHeader->GetPropertyCString(buff, pBuffer))
  1204.     {
  1205. // create new registry entry (if one does not exist)
  1206. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.%s", szSMDKey, buff);
  1207. regid = m_pRegistry->GetId(szRegKeyName);
  1208. if (!regid)
  1209. {
  1210.     m_pRegistry->AddStr(szRegKeyName, pBuffer);
  1211. }
  1212. else
  1213. {
  1214.     // set new value
  1215.     m_pRegistry->SetStrByName(szRegKeyName, pBuffer);
  1216. }
  1218. HX_RELEASE(pBuffer);
  1219.     }
  1220.     else if (HXR_OK == pHeader->GetPropertyULONG32(buff, ulValue))
  1221.     {
  1222. // create new registry entry
  1223. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.%s", szSMDKey, buff);
  1224. regid = m_pRegistry->GetId(szRegKeyName);
  1225. if (!regid)
  1226. {
  1227.     m_pRegistry->AddInt(szRegKeyName, ulValue);
  1228. }
  1229. else
  1230. {
  1231.     // set new value
  1232.     m_pRegistry->SetIntByName(szRegKeyName, ulValue);
  1233. }
  1234.     }
  1236.     pCharEntryStart = pCharEntryEnd + 1;
  1237. }
  1238.     }
  1239. }
  1241. HX_RELEASE(pReqHeaders);
  1242.     }
  1244.     HX_RELEASE(pRequest);
  1245. }
  1247. HX_RELEASE(pParentName);
  1248.     }
  1250.     return HXR_OK;
  1251. }
  1252. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  1254. HX_RESULT HXSource::SetPlayTimes(UINT32 ulStartTime, 
  1255.   UINT32 ulEndTime, 
  1256.   UINT32 ulDelay, 
  1257.   UINT32 ulDuration)
  1258. {
  1259.     m_ulStartTime     = ulStartTime;
  1260.     m_ulEndTime     = ulEndTime;
  1261.     /* We do not handle Delay field for now */
  1262.     m_ulDelay     = ulDelay;
  1263.     m_ulRestrictedDuration  = ulDuration;
  1265.     if (m_ulEndTime > 0)
  1266.     {
  1267. m_bCustomEndTime = TRUE;
  1268.     }
  1269.     else
  1270.     {
  1271.      m_bCustomEndTime = FALSE;
  1272.     }
  1274.     return HXR_OK;
  1275. }
  1277. HX_RESULT
  1278. HXSource::UpdatePlayTimes(IHXValues* pValues)
  1279. {
  1280.     HX_RESULT rc = HXR_OK;
  1281.     char szStart[] = "Start";
  1282.     char szEnd[] = "End";
  1283.     char szDelay[] = "Delay";
  1284.     char szDuration[] = "Duration";
  1285.     UINT32 ulStartTime = 0;
  1286.     UINT32 ulEndTime = 0;
  1287.     UINT32 ulDelay = 0;
  1288.     UINT32 ulRestrictedDuration = 0;
  1290.     pValues->GetPropertyULONG32(szStart, ulStartTime);
  1291.     pValues->GetPropertyULONG32(szEnd, ulEndTime);
  1292.     pValues->GetPropertyULONG32(szDelay, ulDelay);
  1293.     pValues->GetPropertyULONG32(szDuration, ulRestrictedDuration);
  1295.     if (ulStartTime != m_ulStartTime    ||
  1296. ulEndTime != m_ulEndTime     ||
  1297. ulDelay != m_ulDelay     ||
  1298. ulRestrictedDuration != m_ulRestrictedDuration)
  1299.     {
  1300. SetPlayTimes(ulStartTime, ulEndTime, ulDelay, ulRestrictedDuration);
  1301. rc = AdjustClipTime();
  1302.     }
  1304.     return rc;
  1305. }
  1307. ULONG32 
  1308. HXSource::GetPerfectPlayTime(void)
  1309. {
  1310.     ULONG32 ulCurrentPlayTime = m_pPlayer ? m_pPlayer->GetCurrentPlayTime() : 0;
  1311.     ULONG32 result       = m_bPerfectPlay ? m_ulPerfectPlayTime : m_ulBufferedPlayTime;
  1313.     if (m_ulDuration != 0)
  1314.     {
  1315. // mPlaybackLength is in Milliseconds, we want to calculate
  1316. // playback in seconds...
  1317. ULONG32 playbackTimeLeftInClip = 
  1318.     ((m_ulDuration > ulCurrentPlayTime ? m_ulDuration - ulCurrentPlayTime : 0) /1000)+1;
  1320. /* Perfect Play entire clip ONLY if user has chosen PerfectPlay specifically
  1321.  * If we internally go in buffered play mode, always use perfect play time
  1322.  * setting.
  1323.  */
  1324. if (m_bPerfectPlay)
  1325. {
  1326.     if (m_bPerfectPlayEntireClip)
  1327.     {
  1328. result = playbackTimeLeftInClip;
  1329.     }
  1330.     else
  1331.     {
  1332. result = min(m_ulPerfectPlayTime, playbackTimeLeftInClip);
  1333.     }
  1334. }
  1335. else // if (m_bBufferedPlay)
  1336. {
  1337.     result = min(m_ulBufferedPlayTime, playbackTimeLeftInClip);
  1338. }
  1339.     }
  1340.     
  1341.     // check if enough memory is available to handle the result
  1342.     if(result > 0)
  1343.     {
  1344. // get 50% of the available memory
  1345. ULONG32 maxMemAvail = GetAvailableMemory() / 2;
  1346. ULONG32 bytesPerSecond = m_ulAvgBandwidth/8;
  1347. ULONG32 maxTimeAvail = maxMemAvail/(bytesPerSecond > 0 ? bytesPerSecond : 1);
  1349. // if this is true then we can't buffer the entire clip
  1350. if (maxTimeAvail < result)
  1351. m_bCannotBufferEntireClip = (m_bPerfectPlayEntireClip) ? TRUE : FALSE;
  1352. else
  1353. m_bCannotBufferEntireClip = FALSE;
  1355. result = min(result,maxTimeAvail);
  1356.     }
  1358.     /* Value now returned in ms. */
  1359.     return 1000*(max(result, PERFECTPLAY_MIN_TIME));
  1360. }
  1362. STDMETHODIMP 
  1363. HXSource::ReportRebufferStatus(UINT16 uStreamNumber,
  1364.         UINT8 unNeeded, 
  1365.         UINT8 unAvailable) 
  1366. {
  1367.     STREAM_INFO* pStreamInfo = 0;
  1369. //    if (m_bDelayed ||
  1370. // (m_ulDelay > 0 && m_ulDelay > m_pPlayer->GetCurrentPlayTime()))
  1372.     if (m_bDelayed)
  1373.     {
  1374. return HXR_OK;
  1375.     }
  1377.     DEBUG_OUT(m_pPlayer, DOL_TRANSPORT, (s, "(%p)ReportRebufferStatus %lu %lu %lu", this, uStreamNumber, unNeeded, unAvailable));
  1379.     if (mStreamInfoTable->Lookup((LONG32) uStreamNumber, (void*& )pStreamInfo))
  1380.     {
  1381. pStreamInfo->m_unNeeded     = unNeeded;
  1382. pStreamInfo->m_unAvailable  = unAvailable;
  1383. if (unNeeded > unAvailable)
  1384. {
  1385. //     dfprintf("buff", "reportrebufferstatus: %lun", m_pPlayer->GetInternalCurrentPlayTime());     
  1386. //     g_bRahulLog = TRUE;
  1388.     if (m_bFastStart)
  1389.     {
  1390.                 DEBUG_OUT(m_pPlayer, DOL_TRANSPORT, (s, "(%p)ALMOST Turbo OFF ReportRebufferStatus", this));
  1391.                 //with surestream audio only clips, rarender may report buffering immediately after resume
  1392.                 if (m_bSureStreamClip)
  1393. {
  1394.     if (CALCULATE_ELAPSED_TICKS(m_ulTurboStartActiveTime, HX_GET_TICKCOUNT()) > 1000)
  1395.     {
  1396. LeaveFastStart(TP_OFF_BY_REBUFFER);
  1397. DEBUG_OUT(m_pPlayer, DOL_TRANSPORT, (s, "(%p)Turbo OFF ReportRebufferStatus", this));
  1398.     }
  1399. }
  1400. else
  1401. {
  1402.                     LeaveFastStart(TP_OFF_BY_REBUFFER);
  1403.                     DEBUG_OUT(m_pPlayer, DOL_TRANSPORT, (s, "(%p)Turbo OFF ReportRebufferStatus", this));
  1404. }
  1405.     }
  1407.     // log rebuffer action
  1408.     LogInformation("BUFBEG", NULL);
  1409.     
  1410.     DoRebuffer();
  1411.   }
  1412. else
  1413. {
  1414.     m_bRebufferingRequired = IsRebufferRequired();
  1415.     if (!m_bRebufferingRequired)
  1416.     {
  1417. // log rebuffer action
  1418. LogInformation("BUFEND", NULL);
  1419.     }
  1420. }
  1422.         return HXR_OK;
  1423.     }
  1425.     return HXR_UNEXPECTED;
  1426. }
  1428. STDMETHODIMP 
  1429. HXSource::SetGranularity
  1430. (
  1431.     UINT16 uStreamNumber,
  1432.     ULONG32 ulGranularity
  1433. ) 
  1434. {
  1435.     STREAM_INFO* pStreamInfo = 0;
  1437.     if (mStreamInfoTable->Lookup((LONG32) uStreamNumber, (void*& )pStreamInfo))
  1438.     {
  1439. m_pPlayer->SetGranularity(this, uStreamNumber, ulGranularity);
  1440. return HXR_OK;
  1441.     }
  1442.     else
  1443.     {
  1444. return HXR_OK;
  1445.     }
  1447.     return HXR_UNEXPECTED;
  1448. }
  1450. BOOL
  1451. HXSource::TryResume(void)
  1452. {
  1453.     BOOL    bResume = FALSE;
  1455.     // resume the persistent source ASAP
  1456.     if (m_pSourceInfo && m_pSourceInfo->m_bIsPersistentSource)
  1457.     {
  1458.         m_bDelayed = FALSE;
  1459.         bResume = TRUE;
  1460.     }
  1461.     else if (m_bPaused && m_bDelayed && m_pPlayer &&
  1462.              m_pPlayer->CanBeStarted(this, m_pSourceInfo, m_bPartOfNextGroup))
  1463.     {
  1464.         UINT32 ulCurrentTime = m_pPlayer->GetInternalCurrentPlayTime();
  1465.         UINT32 ulStartTime = 0;
  1467.         if (m_ulDelay > m_ulPreRollInMs + NETWORK_FUDGE_FACTOR)
  1468.         {
  1469.             ulStartTime = m_ulDelay - (m_ulPreRollInMs + NETWORK_FUDGE_FACTOR);
  1470.         }
  1472.         if (ulCurrentTime >= ulStartTime)
  1473.         {
  1474.             m_bDelayed = FALSE;
  1475.             bResume = TRUE;
  1476.         }
  1478.         if (!m_bIsPreBufferingStarted)
  1479.         {
  1480.             m_bIsPreBufferingStarted = TRUE;
  1481.             bResume = TRUE;
  1482.         }
  1483.     }
  1484.     else if (m_bPrefetch)
  1485.     {
  1486.         bResume = TRUE;
  1487.     }
  1489.     if (bResume && CanBeResumed())
  1490.     {
  1491.         if (m_pSourceInfo)
  1492.         {
  1493.             m_pSourceInfo->Register();
  1494.         }
  1496.         m_bResumePending = TRUE;
  1497.     }
  1499.     return bResume;
  1500. }
  1502. BOOL
  1503. HXSource::IsAnyAudioStream(void)
  1504. {
  1505.     IHXAudioPlayer* pAudioPlayer = NULL;
  1506.     BOOL bAtLeastOneAudioStream = FALSE;
  1508.     if (!m_pPlayer)
  1509.     {
  1510. return FALSE;
  1511.     }
  1513.     m_pPlayer->QueryInterface(IID_IHXAudioPlayer, (void **) &pAudioPlayer);
  1514.     UINT16 uNumAudioStreams = pAudioPlayer->GetAudioStreamCount();
  1515.     for (UINT16 i = 0; i < uNumAudioStreams && !bAtLeastOneAudioStream; i++)
  1516.     {
  1517. IHXAudioStream* pAudioStream = pAudioPlayer->GetAudioStream(i);
  1518. IHXValues* pHeader = pAudioStream->GetStreamInfo();
  1519. pAudioStream->Release();
  1520. if (!pHeader)
  1521. {
  1522.     continue;
  1523. }
  1525. if (IsAudioStreamFromThisSource(pHeader))
  1526. {
  1527.     bAtLeastOneAudioStream = TRUE;
  1528.     pHeader->Release();
  1529.     break;
  1530. }
  1532. pHeader->Release();
  1533.     }
  1535.     if (!bAtLeastOneAudioStream)
  1536.     {
  1537.         IHXValues* pHeader = NULL;
  1538.         int nStreamCnt = GetNumStreams();
  1539.         ULONG32     ulIsAudioStream = FALSE;
  1541.         for (int i=0; i<nStreamCnt && !bAtLeastOneAudioStream; i++)
  1542.         {
  1543.             GetStreamHeaderInfo(i, pHeader);
  1545.             pHeader->GetPropertyULONG32("IsAudioStream", ulIsAudioStream);
  1546.             if (ulIsAudioStream)
  1547.             {
  1548.                 bAtLeastOneAudioStream = TRUE;
  1549.             }
  1550.     HX_RELEASE(pHeader);
  1551.         }
  1552.     }
  1554.     pAudioPlayer->Release();
  1556.     return bAtLeastOneAudioStream;
  1557. }
  1559. void
  1560. HXSource::EventReady(CHXEvent* pEvent)
  1561. {
  1562.     if (m_pPlayer)
  1563.     {
  1564. m_pPlayer->EventReady(this, pEvent);
  1565.     }
  1566. }
  1568. BOOL 
  1569. HXSource::IsAudioStreamFromThisSource(IHXValues* pAudioHeader)
  1570. {
  1571.     BOOL bFound = FALSE;
  1573.     CHXMapLongToObj::Iterator ndxStreamIterator = mStreamInfoTable->Begin();
  1574.     for (; ndxStreamIterator != mStreamInfoTable->End(); ++ndxStreamIterator) 
  1575.     {
  1576. STREAM_INFO* pStreamInfo = (STREAM_INFO*) (*ndxStreamIterator);
  1577. if (pStreamInfo->m_pHeader == pAudioHeader)
  1578. {
  1579.     bFound = TRUE;
  1580.     break;
  1581. }
  1582.     }
  1584.     return bFound;
  1585. }
  1587. ULONG32
  1588. HXSource::GetAvailableMemory()
  1589. {
  1590.     ULONG32 memAvail = 1000000;
  1592. #if   defined (__MWERKS__)
  1593. //  XXX Hack! We can't call any of the Memory Manager calls at interrupt time so we will have 
  1594. //  to change this to ask our interrupt safe memory allocator how much memory is free
  1595.     memAvail = 1000000;
  1596. #elif defined(_WINCE) && !defined(_WIN32_WCE_EMULATION)
  1597.     STORE_INFORMATION stInfo;
  1598.     GetStoreInformation(&stInfo);
  1599.     memAvail = stInfo.dwFreeSize;
  1600. #elif (_WIN32)
  1601.     MEMORYSTATUS status;
  1602.     status.dwLength = sizeof(MEMORYSTATUS);
  1603.     GlobalMemoryStatus(&status);
  1604.     memAvail = status.dwAvailPageFile;
  1605. #elif defined( _WINDOWS)
  1606.     memAvail = GetFreeSpace(0);
  1607. #elif defined (_UNIX)
  1608.     // XXXX Need to get this to compile.
  1609.     memAvail = 1000000;
  1610. #endif
  1612.     return memAvail;
  1613. }
  1615. void
  1616. HXSource::ReportError(HX_RESULT theErr)
  1617. {
  1618.     if (m_pPlayer)
  1619.     {
  1620. m_pPlayer->ReportError(this, theErr);
  1621.     }
  1622. }
  1625. HX_RESULT
  1626. HXSource::AdjustClipTime(void)
  1627. {
  1628.     HX_RESULT theErr = HXR_OK;
  1629.     UINT32  ulOriginalDuration = m_ulDuration;        
  1630.     UINT32  ulTrackEndTime = 0;
  1631.     CHXMapLongToObj::Iterator i;
  1632.     BOOL    bCustomEndTimeSet = FALSE;
  1634.     if (m_bPartOfPrefetchGroup)
  1635.     {
  1636. if (m_ulDelay)
  1637. {
  1638.     m_ulPrefetchDelay = m_ulDelay;
  1639.     m_bDelayed = TRUE;
  1640.     AdjustClipBandwidthStats(FALSE);
  1641.     DoPause();
  1642. }
  1644. m_ulEndTime = 0;
  1645. m_bCustomEndTime = FALSE;
  1646. goto cleanup;
  1647.     }
  1649.     /* For a live stream, the only qualifiers that make sense
  1650.      * are Duration and Delay. All other qualifiers should be made 0
  1651.      */
  1652.     if (mLiveStream)
  1653.     {
  1654. m_ulStartTime = 0;
  1656. if (!m_bRestrictedLiveStream)
  1657. {
  1658.     m_ulEndTime = 0;
  1659. }
  1660.     }
  1662.     for (i = mStreamInfoTable->Begin(); i != mStreamInfoTable->End(); ++i) 
  1663.     {    
  1664. STREAM_INFO* pStreamInfo = (STREAM_INFO*) (*i);
  1666. ulTrackEndTime = 0;
  1668. HX_RESULT hrTemp = pStreamInfo->m_pHeader->GetPropertyULONG32("EndTime", ulTrackEndTime);
  1670. if (HXR_OK == hrTemp && !m_bCustomEndTime)
  1671. {
  1672.     if (m_ulEndTime < ulTrackEndTime)
  1673.     {
  1674. m_ulEndTime = ulTrackEndTime;
  1675.     }
  1676.     pStreamInfo->m_bCustomEndTime = TRUE;
  1677. }
  1678. else if (m_bCustomEndTime)
  1679. {
  1680.     ulTrackEndTime = m_ulEndTime;
  1681.     pStreamInfo->m_bCustomEndTime = TRUE;
  1682. }
  1684. if (ulTrackEndTime > 0 && !mLiveStream)
  1685. {
  1686.     pStreamInfo->m_pHeader->SetPropertyULONG32("TrackEndTime",
  1687. ulTrackEndTime);
  1688.     bCustomEndTimeSet = TRUE;
  1689. }
  1690.     }
  1691.     
  1692.     // if max. duration is set on this source
  1693.     if (m_pSourceInfo && 
  1694. m_pSourceInfo->m_ulMaxDuration)
  1695.     {
  1696. if (m_ulRestrictedDuration)
  1697. {     
  1698.     if (m_ulRestrictedDuration > m_pSourceInfo->m_ulMaxDuration)
  1699.     {
  1700. m_ulRestrictedDuration = m_pSourceInfo->m_ulMaxDuration;
  1701.     }
  1702. }
  1703. else if (m_ulDuration)
  1704. {
  1705.     if (m_ulDuration > m_pSourceInfo->m_ulMaxDuration)
  1706.     {
  1707. m_ulRestrictedDuration = m_pSourceInfo->m_ulMaxDuration;
  1708.     }
  1709. }
  1710.     }
  1712.     // By default, we always set the end time to be the duration of the clip,
  1713.     // but do not set end time if it was manually specified.
  1714.     if (!bCustomEndTimeSet && !mLiveStream)
  1715.     {
  1716. m_ulEndTime = m_ulDuration;
  1717.     }
  1719.     /* Check if there is any end time */
  1720.     if ((m_ulEndTime < m_ulDuration) || m_bRestrictedLiveStream)
  1721.     {
  1722. m_ulDuration = m_ulEndTime;
  1723.     }
  1724.     
  1725.     /* Is "Delay" specified too? */
  1726.     if (m_ulDelay > 0) 
  1727.     {
  1728. /* Increase duration of this clip */
  1729. m_ulDuration += m_ulDelay;
  1730. UINT32 ulStartTime = 0;
  1732. if (m_ulDelay > m_ulPreRollInMs + NETWORK_FUDGE_FACTOR)
  1733. {
  1734.     ulStartTime = m_ulDelay - (m_ulPreRollInMs + NETWORK_FUDGE_FACTOR);
  1735. }
  1737. // no need to pause delayed persistent component since Pause() will be called
  1738. // on actual tracks' AdjustClipTime() if necessary
  1739. if (m_pSourceInfo && !m_pSourceInfo->m_bIsPersistentSource)
  1740. {
  1741.     m_bDelayed = TRUE;
  1742.     AdjustClipBandwidthStats(FALSE);
  1743.     DoPause();
  1744. }
  1745.     }
  1747.     if (m_ulStartTime > 0) /* reduce duration by start time amount */
  1748.     {
  1749.      if (m_ulDuration > m_ulStartTime)
  1750.      {
  1751.     m_ulDuration -= m_ulStartTime;
  1752. }
  1753. else
  1754. {
  1755.     /* This is bad case. We consider it invalid */
  1756.     m_ulDuration = 0;
  1757. }
  1758.     }
  1760.     /* We now allow to increase the default duration of the clip */
  1761.     if (m_ulRestrictedDuration > 0)
  1762.     {
  1763. m_ulDuration = m_ulRestrictedDuration + m_ulDelay;
  1765. if (mLiveStream && !m_bRestrictedLiveStream)
  1766. {
  1767.     m_bRestrictedLiveStream = TRUE;
  1768.     m_ulEndTime = m_ulRestrictedDuration + m_ulStartTime;
  1769. }
  1771. if (m_ulEndTime > m_ulRestrictedDuration + m_ulStartTime)
  1772. {
  1773.     m_ulEndTime = m_ulRestrictedDuration + m_ulStartTime;
  1774. }
  1775.     }
  1777.     // orig duration is active duration for this source -- time for which
  1778.     // this source lasts.
  1779.     if (m_ulDuration > m_ulDelay)
  1780.     {
  1781. m_ulOriginalDuration = m_ulDuration - m_ulDelay;
  1782.     }
  1783.     else
  1784.     {
  1785. m_ulOriginalDuration = 0;
  1786.     }
  1788.     if (m_pURL     &&
  1789. rtspProtocol == m_pURL->GetProtocol()     &&
  1790. m_llLastExpectedPacketTime != m_ulEndTime   &&
  1791. !m_bFirstResume)
  1792.     {
  1793. m_bRTSPRuleFlagWorkAround = TRUE;
  1794.     }
  1795.     /* If we receive a packet after this stream, we consider the stream to be done */
  1796.     m_llLastExpectedPacketTime  = CAST_TO_INT64 m_ulEndTime;
  1798.     // Seek to the starting position only if the source
  1799.     // has not been resumed yet
  1800.     if (m_ulStartTime > 0 && m_bFirstResume) 
  1801.     {
  1802. /* We will add m_ulStartTime in DoSeek() call*/
  1803.      theErr = DoSeek(0);
  1804.     }
  1806.     /* Update stream durations if required */
  1807.     for (i = mStreamInfoTable->Begin(); i != mStreamInfoTable->End(); ++i) 
  1808.     {    
  1809. STREAM_INFO* pStreamInfo = (STREAM_INFO*) (*i);
  1810. if (m_ulStartTime > 0)
  1811. {
  1812.     pStreamInfo->m_pHeader->SetPropertyULONG32("TrackStartTime",
  1813.     m_ulStartTime);
  1814. }
  1817. if (m_ulEndTime > 0 && 
  1818.     !mLiveStream    &&
  1819.     HXR_OK != pStreamInfo->m_pHeader->GetPropertyULONG32("TrackEndTime",
  1820.   ulTrackEndTime))
  1821. {
  1822.     pStreamInfo->m_pHeader->SetPropertyULONG32("TrackEndTime",
  1823. m_ulEndTime);
  1824. }
  1826. if (ulOriginalDuration != m_ulDuration)
  1827. {
  1828.     pStreamInfo->m_ulDuration = m_ulDuration;
  1829.     pStreamInfo->m_pHeader->SetPropertyULONG32("Duration", 
  1830. pStreamInfo->m_ulDuration);
  1831. }
  1833. if (m_ulDelay > 0)
  1834. {
  1835.     pStreamInfo->m_pHeader->SetPropertyULONG32("Delay", m_ulDelay);
  1836. }
  1837.     }
  1839. //{FILE* f1 = ::fopen("d:\temp\url.txt", "a+"); ::fprintf(f1, "%p %s %lu %lun", this, m_pszURL, m_ulDelay, m_ulDuration);::fclose(f1);}
  1841. cleanup:
  1843.     m_bClipTimeAdjusted = TRUE;
  1845.     return theErr;
  1846. }
  1848. void
  1849. HXSource::GenerateFakeLostPacket(CHXEvent*& theEvent)
  1850. {
  1851.     IHXPacket* pPacket = theEvent->GetPacket();
  1852.     CHXPacket* pLostPacket = new CHXPacket;
  1853.     pLostPacket->AddRef();
  1854.     pLostPacket->Set(0, 0, pPacket->GetStreamNumber(), 0, 0);
  1855.     pLostPacket->SetAsLost();
  1857.     /* Create a new event with lost packet */
  1858.     CHXEvent* pEvent = new CHXEvent(pLostPacket);
  1859.     pEvent->SetTimeStartPos(theEvent->GetTimeStartPos());
  1860.     pEvent->SetTimeOffset(theEvent->GetTimeOffset());
  1861.     pEvent->SetPreSeekEvent(theEvent->IsPreSeekEvent());
  1862.     pLostPacket->Release();
  1864.     delete theEvent;
  1865.     theEvent = pEvent;
  1866. }
  1868. char*
  1869. HXSource::GetAltURL(BOOL& bDefault)
  1870. {
  1871. #if defined(HELIX_FEATURE_ALT_URL)
  1872.     char*   pAltURL = NULL;
  1874.     if (!m_pURL || m_bInitialized)
  1875.     {
  1876. goto cleanup;
  1877.     }
  1879.     pAltURL = m_pURL->GetAltURL(bDefault);
  1881. cleanup:
  1883.     return pAltURL;
  1884. #else
  1885.     return NULL;
  1886. #endif /* HELIX_FEATURE_ALT_URL */
  1887. }
  1889. HX_RESULT
  1890. HXSource::SetRequest(const CHXURL* pURL, BOOL bAltURL)
  1891. {
  1892.     HX_RESULT hr = HXR_OK;
  1893.     IHXValues* pValues = NULL;
  1894.     IHXValues* pValuesInRequest = NULL;
  1895.     IHXGroup* pGroup = NULL;
  1896.     IHXGroup2* pGroup2 = NULL;
  1897.     IHXGroupManager* pGroupManager = NULL;
  1899.     HX_RELEASE(m_pRequest);
  1901.     if (m_pPlayer)
  1902.     {
  1903. m_pPlayer->GetActiveRequest(m_pRequest);
  1905. if (m_pRequest)
  1906. {
  1907.     m_pPlayer->ResetActiveRequest();
  1908. }
  1909.     }
  1911. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  1912.     if (m_pPlayer && m_pSourceInfo)
  1913.     {
  1914. if (HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager, (void**)&pGroupManager))
  1915. {
  1916.     if (HXR_OK == pGroupManager->GetGroup(m_pSourceInfo->m_uGroupID, pGroup))
  1917.     {
  1918. if (HXR_OK == pGroup->QueryInterface(IID_IHXGroup2, (void**)&pGroup2))
  1919. {
  1920.     pGroup2->GetTrack2(m_pSourceInfo->m_uTrackID, pValues, pValuesInRequest);
  1921.     UINT32 ulValue = 0;
  1922.     char   szDuration[128] = {0}; /* Flawfinder: ignore */
  1923.     IHXBuffer* pBuffer = NULL;
  1924.     if (pValues && HXR_OK == pValues->GetPropertyULONG32("Duration", ulValue))
  1925.     {
  1926. if (!pValuesInRequest)
  1927. {
  1928.     pValuesInRequest = new CHXHeader();
  1929.     if( pValuesInRequest )
  1930.     {
  1931.         pValuesInRequest->AddRef();
  1932.     }
  1933.     else
  1934.     {
  1935.         hr = HXR_OUTOFMEMORY;
  1936.     }
  1937. }
  1938. if (pValuesInRequest)
  1939. {
  1940.     SafeSprintf (szDuration, 128, "%lu", ulValue); /* Flawfinder: ignore */
  1941.     pBuffer = new CHXBuffer();
  1942.     pBuffer->AddRef();
  1943.          pBuffer->Set((UCHAR*)szDuration, strlen(szDuration) + 1);
  1944.     pValuesInRequest->SetPropertyCString("Duration", pBuffer);
  1945.     HX_RELEASE(pBuffer);
  1946. }
  1947.     }
  1948. }
  1949. HX_RELEASE(pGroup2);
  1950.     }
  1951.     HX_RELEASE(pGroup);
  1952. }
  1953. HX_RELEASE(pGroupManager);
  1954.     }
  1955. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  1957.     IHXRegistry* pRegistry = NULL;   
  1958.     m_pEngine->QueryInterface(IID_IHXRegistry, (void**)&pRegistry);
  1960.     hr = ::SetRequest(pURL->GetEscapedURL(), bAltURL, m_pPreferences, pRegistry, pValuesInRequest, m_pRequest);
  1962.     HX_RELEASE(pValues);
  1963.     HX_RELEASE(pValuesInRequest);
  1964.     HX_RELEASE(pRegistry);
  1966. #if defined(HELIX_FEATURE_RECORDCONTROL)
  1967.     if(hr == HXR_OK && pURL->GetProtocol() != fileProtocol)
  1968.     {
  1969. if(!m_pRecordControl)
  1970. {
  1971.     m_pRecordControl = new HXRecordControl((IHXPlayer*)m_pPlayer, (IHXStreamSource*)this);
  1972.     if(m_pRecordControl)
  1973.     {
  1974. m_pRecordControl->AddRef();
  1975. if(m_pRecordControl->IsValid())
  1976.                     m_bPlayFromRecordControl = m_pRecordControl->CanGetPackets();
  1977.                 else
  1978.     HX_RELEASE(m_pRecordControl);
  1979.     }
  1980. }
  1982. if(m_pRecordControl)
  1983. {
  1984.     m_pRecordControl->SetSource((IHXStreamSource*)this);
  1985. }
  1986.     }
  1987. #endif /* HELIX_FEATURE_RECORDCONTROL */
  1989.     return hr;
  1990. }
  1992. void
  1993. HXSource::UpdateDuration(UINT32 ulDuration)
  1994. {
  1995.     CHXSimpleList* pRepeatList = m_pSourceInfo->GetRepeatList();
  1997.     // ulDuration excludes the delay time
  1998.     if (pRepeatList && 
  1999. ulDuration >= (m_ulDuration - m_ulDelay))
  2000.     {
  2001. m_pSourceInfo->m_ulTotalTrackDuration = ulDuration + m_ulDelay;
  2002. if (m_pSourceInfo->m_pPeerSourceInfo)
  2003. {
  2004.     m_pSourceInfo->m_pPeerSourceInfo->m_ulTotalTrackDuration = m_pSourceInfo->m_ulTotalTrackDuration;
  2005. }
  2006.     }
  2007.     else
  2008.     {
  2009. m_ulOriginalDuration = m_ulRestrictedDuration = ulDuration;
  2010. AdjustClipTime();
  2011. m_pSourceInfo->UpdateDuration(m_ulDuration);
  2012.     }
  2013. }
  2015. void
  2016. HXSource::UpdateDelay(UINT32 ulDelay)
  2017. {
  2018.     m_ulDelay = ulDelay;
  2019.     AdjustClipTime();
  2020.     m_pSourceInfo->UpdateDelay(m_ulDelay);
  2021. }
  2023. void
  2024. HXSource::InitialBufferingDone(void)
  2025. {
  2026.     m_bInitialBuffering = FALSE;
  2028.     // resume if we satisfy the initial preroll AND we have issued
  2029.     // rebuffer
  2030.     // note: IsRebufferRequired() should return FALSE!!
  2031.     if (m_bRebufferingRequired)
  2032.     {
  2033. m_bRebufferingRequired = IsRebufferRequired();
  2034. HX_ASSERT(!m_bRebufferingRequired);
  2035.     }
  2037.     return;
  2038. }
  2040. void
  2041. HXSource::DoRebuffer(void)
  2042. {
  2043.     m_bRebufferingRequired  = TRUE;
  2045.     if (m_pPlayer)
  2046.     {
  2047. m_pPlayer->InternalPause();     
  2048.         ReBuffer();
  2049.     }
  2051.     return;
  2052. }
  2054. BOOL
  2055. HXSource::IsRebufferRequired(void)
  2056. {
  2057.     BOOL     bResult = FALSE;
  2058.     STREAM_INFO*    pStreamInfo = NULL;
  2060.     // Check if all streams are doing OK
  2061.     for (CHXMapLongToObj::Iterator ndxStrm = mStreamInfoTable->Begin();
  2062.  ndxStrm != mStreamInfoTable->End(); ++ndxStrm) 
  2063.     {    
  2064. pStreamInfo = (STREAM_INFO*) (*ndxStrm);
  2066. if (pStreamInfo->m_unNeeded > pStreamInfo->m_unAvailable)
  2067. {
  2068.     bResult = TRUE;
  2069.     break;
  2070. }
  2071.     }
  2073.     return bResult;
  2074. }
  2076. BOOL
  2077. HXSource::IsRebufferDone(void)
  2078. {
  2079.     BOOL    bResult = TRUE;
  2081.     if (m_pSourceInfo)
  2082.     {
  2083. bResult = m_pSourceInfo->IsRebufferDone();
  2084.     }
  2086.     return bResult;
  2087. }
  2089. void
  2090. HXSource::ScheduleProcessCallback()
  2091. {
  2092.     if (m_pSourceInfo)
  2093.     {
  2094.         m_pSourceInfo->ScheduleProcessCallback();
  2095.     }
  2096. }
  2098. #if defined(HELIX_FEATURE_HYPER_NAVIGATE)
  2099. /************************************************************************
  2100.  * Method:
  2101.  *     IHXHyperNavigate::GoToURL
  2102.  * Purpose:
  2103.  *     Acts as a proxy for actual hypernavigate interface.
  2104.  *     Is used to convert any relative URLs to absolute URLs
  2105.  */
  2106. STDMETHODIMP 
  2107. HXSource::GoToURL(const char* pURL, const char* pTarget)
  2108. {
  2109.     return Execute(pURL, pTarget, NULL, NULL, NULL);
  2110. }
  2112. /************************************************************************
  2113.  * Method:
  2114.  *     IHXHyperNavigate2::Execute
  2115.  * Purpose:
  2116.  *     
  2117.  * Parameters:
  2118.  *      pURL:     URL (absolute or relative)
  2119.  *     pTargetInstance:
  2120.  *     pTargetApplication: 
  2121.  *     pTargetRegion:
  2122.  *     pParams:
  2123.  */
  2124. STDMETHODIMP 
  2125. HXSource::Execute(const char* pURL,
  2126.    const char* pTargetInstance,
  2127.    const char* pTargetApplication,
  2128.    const char* pTargetRegion,
  2129.    IHXValues* pParams)
  2130. {
  2131.     HX_RESULT theErr = HXR_OK;
  2132.     CHXString newURL = pURL;
  2134. //    pURL = "rogers.rt";
  2136. //    if (pTargetInstance && 
  2137. // stricmp(pTargetInstance, "_player") == 0 &&
  2138.     if (ShouldConvert(pTargetInstance) && 
  2139. pURL  &&
  2140. strnicmp(pURL, URL_COMMAND, sizeof(URL_COMMAND) - 1) != 0 )
  2141.     {
  2142. CHXURL urlObj(pURL);
  2143. IHXValues* pHeader = urlObj.GetProperties();
  2144. IHXBuffer* pBuffer = NULL;
  2146. if(pHeader && 
  2147.    m_pszURL &&
  2148.    HXR_OK != pHeader->GetPropertyBuffer(PROPERTY_SCHEME, pBuffer))
  2149. {
  2150.     // relative URL
  2151.     // if it starts with '/', make it relative to the root of 
  2152.     // the URL prefix
  2154.     CHXString urlPrefix, urlRoot;
  2155.     char* pURLFragment = NULL;
  2156.     theErr = CHXURL::GeneratePrefixRootFragment(m_pszURL, urlPrefix, urlRoot, pURLFragment);
  2157.     HX_VECTOR_DELETE(pURLFragment);
  2159.     if (!theErr)
  2160.     {
  2161. if(*pURL == '/')
  2162. {
  2163.     newURL = urlRoot + pURL;
  2164. }
  2165. else
  2166. {
  2167.     newURL = urlPrefix + pURL;
  2168. }
  2169.     }
  2170. }
  2171. HX_RELEASE(pBuffer);
  2172. HX_RELEASE(pHeader);
  2173.     }
  2174.     
  2175.     AddRef();
  2177.     HX_ASSERT(m_pPlayer && m_pPlayer->m_pHyperNavigate);
  2178.     if (m_pPlayer && m_pPlayer->m_pHyperNavigate)
  2179.     {
  2180. theErr = m_pPlayer->m_pHyperNavigate->ExecuteWithContext(newURL, 
  2181. pTargetInstance, pTargetApplication, pTargetRegion, 
  2182. pParams, (IUnknown*) (IHXStreamSource*) this);
  2183.     }
  2185.     Release();
  2187.     return theErr;
  2188. }
  2189. #endif /* defined(HELIX_FEATURE_HYPER_NAVIGATE) */
  2191. STDMETHODIMP
  2192. HXSource::GetTotalBuffering(UINT16  uStreamNumber,
  2193.     REF(INT64)  llLowestTimestamp, 
  2194.     REF(INT64)  llHighestTimestamp,
  2195.     REF(UINT32) ulNumBytes,
  2196.     REF(BOOL)   bDone)
  2197. {
  2198.     HX_RESULT res = HXR_NO_DATA;
  2199.     
  2200.     llLowestTimestamp = 0;
  2201.     llHighestTimestamp = 0;
  2202.     ulNumBytes = 0;
  2203.     bDone = FALSE;
  2205.     STREAM_INFO* pStreamInfo;
  2206.     if (mStreamInfoTable->Lookup((LONG32) uStreamNumber, (void*& )pStreamInfo))
  2207.     {
  2208. HXBufferingState& bufState = pStreamInfo->BufferingState();
  2209. BOOL   bUseTransportStats = FALSE;
  2211. INT64  llTransportLowTS = 0;
  2212. INT64  llTransportHighTS = 0;
  2213. UINT32 ulTransportBytes = 0;
  2214. BOOL   bTransportDone = FALSE;
  2216. if (!IsLocalSource() &&
  2217.     (HXR_OK == GetCurrentBuffering(uStreamNumber,
  2218.    llTransportLowTS,
  2219.    llTransportHighTS,
  2220.    ulTransportBytes,
  2221.    bTransportDone)))
  2222. {
  2223.     bufState.UpdateTransportStats(llTransportLowTS,
  2224.   llTransportHighTS,
  2225.   ulTransportBytes,
  2226.   bTransportDone);
  2228.     bUseTransportStats = TRUE;
  2230.     // Update bDone with what the transport says.
  2231.     bDone = bTransportDone;
  2232. }
  2234. res = bufState.GetBufferingStats(llLowestTimestamp,
  2235.  llHighestTimestamp,
  2236.  ulNumBytes,
  2237.  bUseTransportStats);
  2238.     }
  2241.     return res;
  2242. }
  2244. /* 
  2245.  * All relative URLs are converted to absolute URLs unless the 
  2246.  * original request (ram/smil) passed in OpenRequest/OpenURL()
  2247.  * is a mem: URL AND the target is not _player.
  2248.  *
  2249.  * This fixes relative URLs being hurled to the browser using events
  2250.  * come from the same location as the .ram file. (Broadcase usage case)
  2251.  * PR 31352
  2252.  *
  2253.  * This also fixes content on CD-ROMs where relative URLs being hurled 
  2254.  * to the browser using events come from the same location as 
  2255.  * the .rm file in which they are merged. 
  2256.  * PR 23489
  2257.  */
  2258. BOOL HXSource::ShouldConvert(const char* pTargetInstance)
  2259. {
  2260.     if (pTargetInstance && 
  2261. stricmp(pTargetInstance, "_player") == 0)
  2262.     {
  2263. return TRUE;
  2264.     }
  2265.     
  2266.     const char* pPlayerURL = NULL;
  2267.     IHXRequest* pPlayerRequest = NULL;
  2268.     if (m_pPlayer)
  2269.     {
  2270. m_pPlayer->GetRequest(pPlayerRequest);
  2271. if (pPlayerRequest)
  2272. {
  2273.     pPlayerRequest->GetURL(pPlayerURL);
  2274. }
  2275.     }
  2276.     HX_RELEASE(pPlayerRequest);
  2278.     if (pPlayerURL && ::strncasecmp(pPlayerURL, "mem:", 4) == 0)
  2279.     {
  2280. return FALSE;
  2281.     }
  2283.     return TRUE;
  2284. }
  2286. void
  2287. HXSource::MergeUpgradeRequest(BOOL bAddDefault /*= FALSE*/, char* pUpgradeString /* = NULL*/)
  2288. {
  2289. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  2290.     if (m_pPlayer && 
  2291. bAddDefault && 
  2292. (!m_pUpgradeCollection || m_pUpgradeCollection->GetCount() == 0))
  2293.     {
  2294. if (!m_pUpgradeCollection)
  2295. {
  2296.     m_pUpgradeCollection = new HXUpgradeCollection;
  2297. }
  2299. if (!pUpgradeString)
  2300. {
  2301.     pUpgradeString = "Missing Component";
  2302. }
  2304. IHXBuffer* pPluginID = (IHXBuffer*) new CHXBuffer;
  2305. pPluginID->AddRef();
  2306. pPluginID->Set((const UINT8*)pUpgradeString, strlen(pUpgradeString) + 1);
  2307. m_pUpgradeCollection->Add(eUT_Required, pPluginID, 0, 0);
  2308. pPluginID->Release();
  2309.     }
  2311.     if (m_pPlayer && m_pUpgradeCollection && m_pUpgradeCollection->GetCount() > 0)
  2312.     {
  2313. UINT32 ulCount = m_pUpgradeCollection->GetCount();
  2314. IHXUpgradeCollection* pPlayerUpgrade;
  2315. m_pPlayer->QueryInterface(IID_IHXUpgradeCollection, (void**) &pPlayerUpgrade);
  2316. for (UINT32 i = 0; i < ulCount; i++)
  2317. {
  2318.     HXUpgradeType upgradeType;
  2319.     IHXBuffer* pPluginId = (IHXBuffer*) new CHXBuffer;
  2320.     UINT32 majorVersion;
  2321.     UINT32 minorVersion;
  2322.     pPluginId->AddRef(); 
  2323.     // GetAt is a non-COM like API. It expects pPluginID to be allocated by the user
  2324.     // and does not perform an addref either!
  2325.     m_pUpgradeCollection->GetAt(i, upgradeType, pPluginId, majorVersion, minorVersion);
  2326.     pPlayerUpgrade->Add(upgradeType, pPluginId, majorVersion, minorVersion);
  2327.     pPluginId->Release();
  2328. }
  2330. pPlayerUpgrade->Release();
  2331. m_pUpgradeCollection->RemoveAll();
  2332.     }
  2333. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  2334. }
  2336. void
  2337. HXSource::ClearUpgradeRequest()
  2338. {
  2339. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  2340.     if (m_pUpgradeCollection)
  2341.     {
  2342. m_pUpgradeCollection->RemoveAll();
  2343.     }
  2344. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  2345. }
  2347. void
  2348. HXSource::EnterPrefetch(PrefetchType prefetchType, UINT32 ulPrefetchValue)
  2349. {
  2350.     m_bPrefetch = TRUE;
  2351.     m_prefetchType = prefetchType;
  2352.     m_ulPrefetchValue = ulPrefetchValue;
  2354.     return;
  2355. }
  2357. void
  2358. HXSource::LeavePrefetch(void)
  2359. {
  2360.     m_bPrefetch = FALSE;
  2362.     // send prefetch notification so that SMIL
  2363.     // renderer can resolve the duration on this prefetch track
  2364.     if (m_pSourceInfo)
  2365.     {
  2366. m_pPlayer->PrefetchTrackDone(m_pSourceInfo->m_uGroupID, 
  2367.           m_pSourceInfo->m_uTrackID, 
  2368.      HXR_OK);
  2369.     }
  2371.     return;
  2372. }
  2374. void
  2375. HXSource::SetSoundLevel(UINT16 uSoundLevel, BOOL bReflushAudioDevice)
  2376. {
  2377. #if defined(HELIX_FEATURE_SMIL_SOUNDLEVEL)
  2378.     CHXAudioPlayer* pAudioPlayer = NULL;
  2379.     CHXAudioStream* pCHXAudioStream = NULL;
  2380.     CHXSimpleList*  pAudioStreamList = NULL;
  2382.     if (!m_pPlayer)
  2383.     {
  2384. goto cleanup;
  2385.     }
  2387.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  2388.     if (!pAudioPlayer)
  2389.     {
  2390. goto cleanup;
  2391.     }
  2393.     pAudioPlayer->AddRef();
  2395.     if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
  2396.     {
  2397. pAudioPlayer->SetSoundLevel(pAudioStreamList, uSoundLevel, bReflushAudioDevice);
  2399. ReleaseAudioStreams(pAudioStreamList);
  2400. HX_DELETE(pAudioStreamList);
  2401.     }
  2403.     HX_RELEASE(pAudioPlayer);
  2405. cleanup:
  2406. #endif /* HELIX_FEATURE_SMIL_SOUNDLEVEL */
  2408.     return;
  2409. }
  2411. void
  2412. HXSource::SetAudioDeviceReflushHint(void)
  2413. {
  2414. #if defined(HELIX_FEATURE_SOUNDLEVEL)
  2415.     CHXAudioPlayer* pAudioPlayer = NULL;
  2416.     CHXSimpleList*  pAudioStreamList = NULL;
  2418.     if (!m_pPlayer)
  2419.     {
  2420. goto cleanup;
  2421.     }
  2423.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  2424.     if (!pAudioPlayer)
  2425.     {
  2426. goto cleanup;
  2427.     }
  2429.     pAudioPlayer->AddRef();
  2431.     if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
  2432.     {
  2433. pAudioPlayer->ManageAudioStreams(pAudioStreamList, CHXAudioPlayer::STR_SETHINT);
  2435. ReleaseAudioStreams(pAudioStreamList);
  2436. HX_DELETE(pAudioStreamList);
  2437.     }
  2439.     HX_RELEASE(pAudioPlayer);
  2441. cleanup:
  2442. #endif /* HELIX_FEATURE_SOUNDLEVEL */
  2444.     return;
  2445. }
  2447. void
  2448. HXSource::LeaveFastStart(TurboPlayOffReason leftReason)
  2449. {
  2450.     m_turboPlayStats.tpOffReason = leftReason;
  2451.     m_bFastStart = FALSE;
  2452. }
  2454. void
  2455. HXSource::DeleteAllEvents()
  2456. {
  2457.     if (m_PacketBufferList.GetCount() > 0)
  2458.     {
  2459. LISTPOSITION pos = m_PacketBufferList.GetHeadPosition();
  2460. while (pos != NULL)
  2461. {
  2462.     CHXEvent* pTempEvent  = (CHXEvent*) m_PacketBufferList.GetNext(pos);
  2463.     delete pTempEvent;
  2464. }
  2466. m_PacketBufferList.RemoveAll();
  2467.     }
  2468. }
  2470. void
  2471. HXSource::SetMinimumPreroll(ULONG32 ulMinimumAudioPreroll, ULONG32 ulMinimumStartingPreroll)
  2472. {
  2473.     UINT32 ulTotalMinimumPreroll = 0;
  2475.     if (m_pPlayer)
  2476.     {
  2477. // get the user-set minimum preroll
  2478. m_pPlayer->GetMinimumPreroll(ulTotalMinimumPreroll);
  2479.     }
  2481.     if (IsAnyAudioStream())
  2482.     {
  2483. m_ulPreRollInMs += ulMinimumAudioPreroll;
  2484.     }
  2486.     if (m_ulPreRollInMs < ulTotalMinimumPreroll)
  2487.     {
  2488. m_ulPreRollInMs = ulTotalMinimumPreroll;
  2489.     }
  2491.     DEBUG_OUT(m_pPlayer, DOL_TRANSPORT, (s, "(%p)Preroll: %lu MinPreroll %lu MinAudioPreroll %lu", this, m_ulPreRollInMs, ulTotalMinimumPreroll, ulMinimumStartingPreroll));
  2493.     m_pBufferManager->SetMinimumPreroll(IsLocalSource() | m_bPerfectPlay,
  2494. ulTotalMinimumPreroll,
  2495. ulMinimumStartingPreroll);
  2496. }
  2498. HX_RESULT
  2499. HXSource::SendHeaderToRecordControl(BOOL bFileHeader, IHXValues* pHeader)
  2500. {
  2501. #if defined(HELIX_FEATURE_RECORDCONTROL)
  2502.     HX_RESULT nResult = HXR_OK;
  2504.     if(m_pRecordControl && pHeader)
  2505.     {
  2506. if(bFileHeader)
  2507.     nResult = m_pRecordControl->OnFileHeader(pHeader);
  2508. else
  2509.     nResult = m_pRecordControl->OnStreamHeader(pHeader);
  2511. if(nResult != HXR_OK)
  2512. {
  2513.     m_bPlayFromRecordControl = FALSE;
  2514.     if(nResult != HXR_RECORD)
  2515. HX_RELEASE(m_pRecordControl);
  2516. }
  2517.     }
  2518.     return nResult;
  2519. #else
  2520.     return HXR_NOTIMPL;
  2521. #endif /* HELIX_FEATURE_RECORDCONTROL */
  2522. }
  2524. void
  2525. HXSource::ProcessFileHeader(void)
  2526. {
  2527.     UINT32      bNonSeekAble = 0;
  2528.     IHXBuffer*  pTitle = NULL;
  2529.     IHXBuffer*  pAuthor = NULL;
  2530.     IHXBuffer*  pCopyright = NULL;
  2531.     IHXBuffer*  pAbstract = NULL;
  2532.     IHXBuffer*  pDescription = NULL;
  2533.     IHXBuffer*  pKeywords = NULL;
  2534.     IHXValues*  pValues = NULL;
  2536.     if (m_pURL)
  2537.     {
  2538. pValues = m_pURL->GetOptions();
  2539.     }
  2541.     // retrieve the TAC from the URL
  2542.     if (pValues)
  2543.     {
  2544. pValues->GetPropertyBuffer("Title", pTitle);
  2545.         pValues->GetPropertyBuffer("Author", pAuthor);
  2546.         pValues->GetPropertyBuffer("Copyright", pCopyright);
  2547.         pValues->GetPropertyBuffer("Abstract", pAbstract);
  2548.         pValues->GetPropertyBuffer("Description", pDescription);
  2549.         pValues->GetPropertyBuffer("Keywords", pKeywords);
  2551. //#define LOSS_HACK
  2552. #ifdef LOSS_HACK
  2553. UINT32 ulLoss = 0;
  2554. if (HXR_OK == pValues->GetPropertyULONG32("Loss", ulLoss))
  2555. {
  2556.     m_ulLossHack = ulLoss;
  2557.     /* Initialize random number generator */
  2558.     ::srand((unsigned int) HX_GET_TICKCOUNT());
  2559. }
  2560. #endif /*LOSS_HACK*/
  2561.     }
  2563.     if (m_pFileHeader)
  2564.     {
  2565.         if (!pTitle)     m_pFileHeader->GetPropertyBuffer("Title", pTitle);
  2566.         if (!pAuthor)     m_pFileHeader->GetPropertyBuffer("Author", pAuthor);
  2567.         if (!pCopyright)    m_pFileHeader->GetPropertyBuffer("Copyright", pCopyright);
  2568.         if (!pDescription)  m_pFileHeader->GetPropertyCString("Description", pDescription);
  2569.         if (!pAbstract)     m_pFileHeader->GetPropertyCString("Abstract", pAbstract);
  2570.         if (!pKeywords)     m_pFileHeader->GetPropertyCString("Keywords", pKeywords);
  2572.         m_pFileHeader->GetPropertyULONG32("NonSeekable", bNonSeekAble);
  2573. m_bNonSeekable = bNonSeekAble ? TRUE : FALSE;
  2574.         
  2575.         m_pFileHeader->GetPropertyULONG32("StreamCount",m_ulStreamHeadersExpected);
  2576.             
  2577.         HX_ASSERT(mStreamInfoTable->IsEmpty() == TRUE);
  2578.         if (mStreamInfoTable->IsEmpty() && m_ulStreamHeadersExpected > 0 &&
  2579.             m_ulStreamHeadersExpected < mStreamInfoTable->GetHashTableSize())
  2580.         {
  2581.             mStreamInfoTable->InitHashTable(m_ulStreamHeadersExpected);
  2582.         }
  2583.     }
  2585. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  2586.     if (m_pStats)
  2587.     {
  2588.         if (pTitle && m_pStats->m_pTitle)
  2589.         {
  2590.     m_pStats->m_pTitle->SetStr((char*)(pTitle->GetBuffer()));
  2591.         }
  2593.         if (pAuthor && m_pStats->m_pAuthor)
  2594.         {
  2595.     m_pStats->m_pAuthor->SetStr((char*)(pAuthor->GetBuffer()));
  2596.         }
  2598.         if (pCopyright && m_pStats->m_pCopyright)
  2599.         {
  2600.     m_pStats->m_pCopyright->SetStr((char*)(pCopyright->GetBuffer()));
  2601.         }
  2603.         if (pAbstract && m_pStats->m_pAbstract)
  2604.         {
  2605.     m_pStats->m_pAbstract->SetStr((char*)(pAbstract->GetBuffer()));
  2606.         }
  2607.     
  2608.         if (pDescription && m_pStats->m_pDescription)
  2609.         {
  2610.             m_pStats->m_pDescription->SetStr((char*)(pDescription->GetBuffer()));
  2611.         }
  2613.         if (pKeywords && m_pStats->m_pKeywords)
  2614.         {
  2615.     m_pStats->m_pKeywords->SetStr((char*)(pKeywords->GetBuffer()));
  2616.         }
  2617.     }
  2619.     CopyMetaDataToRegistry(m_pFileHeader);
  2620. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  2622.     m_bReceivedHeader = TRUE;
  2624.     HX_RELEASE(pTitle);
  2625.     HX_RELEASE(pAuthor);
  2626.     HX_RELEASE(pCopyright);
  2627.     HX_RELEASE(pAbstract);
  2628.     HX_RELEASE(pDescription);
  2629.     HX_RELEASE(pKeywords);
  2630.     HX_RELEASE(pValues);
  2632.     return;
  2633. }
  2635. static BOOL GetHeaderBOOL(IHXValues* pHeader, const char* pKey)
  2636. {
  2637.     BOOL bRet = FALSE;
  2639.     ULONG32 ulTemp = 0;
  2640.     if ((HXR_OK == pHeader->GetPropertyULONG32(pKey, ulTemp)) && ulTemp)
  2641.     {
  2642. bRet = TRUE;
  2643.     }
  2645.     return bRet;
  2646. }
  2648. HX_RESULT
  2649. HXSource::ProcessStreamHeaders(IHXValues* pHeader, STREAM_INFO*& pStreamInfo)
  2650. {
  2651.     HX_RESULT       rc = HXR_OK;
  2652.     UINT32          ulStreamNumber = 0;
  2653.     UINT32          ulAvgBitRate = 0;
  2654.     UINT32          ulAvgPacketSize = 0;
  2655.     UINT32          ulPreroll = 0;
  2656.     ULONG32         ulPredata = 0;
  2657.     UINT32          ulDuration = 0;
  2658.     UINT32          ulTemp = 0;
  2659.     void*           lTmp = NULL;
  2661.     pStreamInfo = NULL;
  2663.     if (!pHeader)
  2664.     {
  2665.         rc = HX_INVALID_HEADER;
  2666.         goto cleanup;
  2667.     }
  2669.     // Use file header for default duration
  2670.     if (m_pFileHeader)
  2671.     {
  2672.         m_pFileHeader->GetPropertyULONG32("Duration", ulDuration);
  2673.         if (!m_ulDuration && ulDuration)
  2674.         {
  2675.             m_ulDuration = ulDuration;
  2676.             ulDuration = 0;
  2677.         }
  2678.     }
  2680.     pHeader->GetPropertyULONG32("StreamNumber",     ulStreamNumber);
  2681.     pHeader->GetPropertyULONG32("AvgBitRate",     ulAvgBitRate);
  2682.     pHeader->GetPropertyULONG32("AvgPacketSize",    ulAvgPacketSize);
  2683.     pHeader->GetPropertyULONG32("Preroll",     ulPreroll);
  2684.     pHeader->GetPropertyULONG32("Predata",          ulPredata);
  2685.     pHeader->GetPropertyULONG32("Duration",     ulDuration);
  2687.     if (mStreamInfoTable->Lookup((LONG32) ulStreamNumber, (void *&) lTmp))
  2688.     {
  2689. // a header with this stream number already exists..
  2690.         rc = HX_INVALID_HEADER;
  2691.         goto cleanup;
  2692.     }
  2694.     // max preroll
  2695.     if (m_ulPreRollInMs < ulPreroll)
  2696.     {
  2697. m_ulPreRollInMs = ulPreroll;
  2698.     }
  2700.     m_ulAvgBandwidth   += ulAvgBitRate;
  2702.     // max duration...
  2703.     if (m_ulDuration < ulDuration)
  2704.     {
  2705. m_ulDuration = ulDuration;
  2706.     }
  2708.     pStreamInfo = new STREAM_INFO;
  2709.     if (!pStreamInfo)
  2710.     {
  2711. rc = HXR_OUTOFMEMORY;
  2712.         goto cleanup;
  2713.     }
  2715.     pStreamInfo->m_pHeader                  = pHeader;
  2716.     pStreamInfo->m_pHeader->AddRef();
  2718.     pStreamInfo->m_bCustomEndTime           = FALSE;
  2719.     pStreamInfo->m_bSrcStreamDone           = FALSE;
  2720.     pStreamInfo->m_bSrcStreamFillingDone    = FALSE;
  2721.     pStreamInfo->m_bPacketRequested         = FALSE;
  2722.     
  2723.     pStreamInfo->m_uStreamNumber = (UINT16) ulStreamNumber;
  2725.     pStreamInfo->m_ulDuration = ulDuration;
  2727.     pStreamInfo->BufferingState().OnStreamHeader(
  2728. ulPreroll,
  2729. ulPredata,
  2730. GetHeaderBOOL(pHeader, "PreDataAtStart"),
  2731. GetHeaderBOOL(pHeader, "PreDataAfterSeek"),
  2732. GetHeaderBOOL(pHeader, "PrerollAtStart"),
  2733. GetHeaderBOOL(pHeader, "PrerollAfterSeek"),
  2734. ulAvgBitRate);
  2737.     mStreamInfoTable->SetAt(ulStreamNumber, (void *) pStreamInfo);
  2739. cleanup:
  2741.     return rc;
  2742. }
  2744. HX_RESULT HXSource::OnTimeSync(ULONG32 ulCurrentTime)
  2745. {
  2746.     HX_RESULT res = HXR_OK;
  2748.     for (CHXMapLongToObj::Iterator i = mStreamInfoTable->Begin();
  2749.          i != mStreamInfoTable->End(); ++i) 
  2750.     {    
  2751. STREAM_INFO* pStreamInfo = (STREAM_INFO*) (*i);
  2753. pStreamInfo->BufferingState().OnTimeSync(ulCurrentTime);
  2754.     }
  2756.     return res;
  2757. }