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

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

Symbian

开发平台：

Visual C++

hxsrc.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: hxsrc.cpp,v 1.35.2.1 2004/07/09 02:05:58 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 "hxtypes.h"
  51. #include "hxcom.h"
  52. #ifdef _WINDOWS
  53. #include <windows.h>
  54. #endif
  56. #include "hlxclib/stdio.h"
  57. #include "hlxclib/stdlib.h"
  58. #include "prefdefs.h"
  59. #include "plprefk.h"
  60. #include "hxcomm.h"
  61. #include "ihxpckts.h"
  62. #include "hxfiles.h"
  63. #include "hxengin.h"
  64. #include "hxcore.h"
  65. #include "hxprefs.h"
  66. #include "hxpref.h"
  67. #include "hxausvc.h"
  68. #include "hxmon.h"
  69. #include "hxclreg.h"
  70. #include "hxgroup.h"
  71. #include "hxsmbw.h"
  72. #include "hxstrm.h"
  73. #include "hxwin.h"
  76. #include "hxcore.h"
  77. #include "hxhyper.h"
  78. #include "playhpnv.h"
  79. #include "hxplugn.h"
  80. #include "hxrendr.h"
  82. #include "chxeven.h"
  83. #include "chxelst.h"
  84. #include "hxmap.h"
  85. #include "hxrquest.h"
  86. #include "hxmangle.h"
  87. #include "hxtick.h"
  88. #include "dbcs.h"
  90. #include "hxstrutl.h"
  91. #include "strminfo.h"
  92. #include "timeval.h"
  93. #include "statsmgr.h"
  94. #include "hxbsrc.h"
  95. #include "hxsrc.h"
  96. #include "srcinfo.h"
  97. #include "corshare.h"
  98. #include "upgrdcol.h"
  99. #include "hxrasyn.h"
  100. #include "hxaudstr.h"
  101. #include "hxplugn.h"
  102. #include "hxrendr.h"
  103. #include "errdbg.h"
  105. // will be taken out once flags are defined in a separate file
  106. #include "rmfftype.h"
  107. #include "hxplay.h"
  108. #include "hxcleng.h"
  109. #include "hxsrc.h"
  111. #include "hxheap.h"
  112. #ifdef _DEBUG
  113. #undef HX_THIS_FILE
  114. static const char HX_THIS_FILE[] = __FILE__;
  115. #endif
  117. #if defined(HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES)
  118. // TurboPlay should never be turned on in low heap mode, but just in case ...
  119. #define TURBO_AUDIO_PUSHDOWN 100
  120. #else
  121. #define TURBO_AUDIO_PUSHDOWN 2000
  122. #endif
  124. HXSource::HXSource() :
  125.   m_pPlayer (0)
  126. , m_lRefCount(0)
  127. , m_ulStreamIndex(0)
  128. , m_bInitialized (FALSE)
  129. , m_bIsPreBufferingDone(FALSE)
  130. , m_bClipTimeAdjusted(FALSE)
  131. , mLastError (HXR_OK)
  132. , m_ulPerfectPlayTime (0)
  133. , m_ulBufferedPlayTime(0)
  134.         , m_ulStreamHeadersExpected(0)
  135. , m_bPerfectPlayEntireClip(FALSE)
  136. , m_bCannotBufferEntireClip(FALSE)
  137. , m_uNumStreams (0)
  138. , mFlags (0)
  139. , m_bPerfectPlayAllowed (FALSE)
  140. , mSaveAsAllowed (FALSE)
  141. , mLiveStream (FALSE)
  142. , m_bRestrictedLiveStream (FALSE)
  143. , m_bSourceEnd (FALSE)
  144. , m_bForcedSourceEnd(FALSE)
  145. , m_ulPreRollInMs (0)
  146. , m_ulPreRoll (0)
  147. , m_ulAvgBandwidth (0)
  148. , m_ulDuration (0)
  149. , m_bReceivedData (FALSE)
  150. , m_bReceivedHeader(FALSE)
  151. , m_bNonSeekable(FALSE)
  153. , m_nSeeking (0)
  154. , m_bPaused (FALSE)  
  155. , m_bFirstResume(TRUE)
  156. , m_bResumePending(FALSE)
  157. , m_bIsActive(FALSE)
  159. , m_uActiveStreams (0)
  161. , m_pszURL(NULL)
  162. , m_pURL(NULL)
  163. , m_bAltURL(TRUE)
  165. , m_ulStartTime (0)
  166. , m_ulEndTime (0)
  167. , m_ulDelay (0)
  168. , m_ulOriginalDelay (0)
  169. , m_ulPrefetchDelay (0)
  170. , m_llLastExpectedPacketTime(0)
  171. , m_ulRestrictedDuration(0)
  172. , m_bDelayed(FALSE)
  174. , m_ulSourceStartTime(0)
  175. , m_pPreferences (0)
  176. , m_pRegistry (0)
  177. , m_pScheduler (0)
  178. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  179. , m_pStats (0)
  180. , m_pStatsManager(NULL)
  181. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  182. , m_bLocked (FALSE)
  183. , m_pEngine (0)
  184. , m_bRebufferingRequired(FALSE)
  185. , m_bInitialBuffering(TRUE)
  186. , m_bPartOfNextGroup(FALSE)
  187. , m_bPartOfPrefetchGroup(FALSE)
  188. , m_pBufferManager(NULL)
  189. , m_pFileHeader(0)
  190. , m_bPerfectPlay(FALSE)
  191. , m_bBufferedPlay(FALSE)
  192. , m_ulLossHack(0)
  193. , m_ulNumFakeLostPackets(0)
  194. , m_ulLastBufferingCalcTime(0)
  195. , m_pSourceInfo(NULL)
  196. , m_pRequest(NULL)
  197. , m_pASMSource(NULL)
  198. , m_pBackChannel(NULL)
  199. , m_bDefaultAltURL(FALSE)
  200. , m_bCustomEndTime(FALSE)
  201. , m_bCustomDuration(FALSE)
  202. , m_bIsPreBufferingStarted(FALSE)
  203. , m_ulOriginalDuration(0)
  204. , m_bReSetup(FALSE)
  205. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  206. , m_pUpgradeCollection(NULL)
  207. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  208. , m_bRTSPRuleFlagWorkAround(FALSE)
  209.         , m_bContinueWithHeaders(FALSE)
  210. , m_bPrefetch(FALSE)
  211. , m_prefetchType(PrefetchUnknown)
  212. , m_ulPrefetchValue(0)
  213. , m_ulFirstPacketTime(0)
  214. , m_bIsMeta(FALSE)
  215. , m_bFastStart(FALSE)
  216. , m_serverTurboPlay(TURBO_PLAY_UNKNOWN)
  217. , m_ulMaxBandwidth(4000) // 4000kbps
  218. , m_pAudioStreamList(NULL)
  219.         , m_maxPossibleAccelRatio(4.0) // I donno what's a good value?
  220.         , m_ulTurboPushDown(TURBO_AUDIO_PUSHDOWN)
  221.         , m_bSureStreamClip(FALSE)
  222.         , m_ulTurboStartActiveTime(0)
  223. , m_srcEndCode(END_UNKNOWN)
  224. , m_pRecordControl(NULL)
  225. , m_bPlayFromRecordControl(FALSE)
  226.         , m_pRedirectURL(NULL)
  227.         , m_bRedirectPending(FALSE)
  228. {
  229.     mStreamInfoTable = new CHXMapLongToObj;
  230. }
  232. HXSource::~HXSource()
  233. {
  234.     // XXX moved this to the distuctor because we want to keep arround
  235.     // the request until the renderers are close at which point we should
  236.     // be released and deleted.
  237.     HX_RELEASE(m_pRequest);
  238.     HX_VECTOR_DELETE(m_pszURL);
  239.     HX_DELETE(mStreamInfoTable);
  240. }
  242. void
  243. HXSource::Stop()
  244. {
  245.     m_pSourceInfo = NULL;    
  247.     HX_DELETE (m_pURL);
  248.     HX_DELETE (m_pBufferManager);
  250.     if ( FAILED(mLastError) )
  251.     {
  252. HX_RELEASE(m_pRequest);
  253.     }
  255. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  256.     if (m_pStatsManager)
  257.     {
  258. m_pStatsManager->DoCleanup();
  259. HX_RELEASE(m_pStatsManager);
  260.     }        
  261.     HX_DELETE(m_pStats);    
  262. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  264.     DeleteAllEvents(); 
  266.     HX_RELEASE(m_pRegistry);
  267.     HX_RELEASE(m_pPreferences);
  268.     HX_RELEASE(m_pScheduler);
  269.     HX_RELEASE(m_pEngine);
  270. }    
  272. HX_RESULT HXSource::DoCleanup(EndCode endCode)
  273. {
  274.     m_ulDuration = 0;    
  275.     m_ulPreRollInMs = 0;
  276.     m_ulPreRoll = 0;
  277.     m_ulAvgBandwidth = 0;
  278.     m_ulLastBufferingCalcTime = 0;
  280.     m_ulMaxBandwidth = 0;
  281.     m_serverTurboPlay = TURBO_PLAY_UNKNOWN;
  283.     m_bAltURL = FALSE;    
  284.     m_bPaused = FALSE;
  285.     m_bFirstResume = TRUE;
  286.     m_bIsActive = FALSE;
  287.     m_bResumePending = FALSE;
  288.     m_bIsPreBufferingStarted = FALSE;
  289.     m_bIsPreBufferingDone = FALSE;    
  290.     m_bClipTimeAdjusted = FALSE;    
  291.     m_bInitialBuffering = TRUE;
  292.     m_bRebufferingRequired = FALSE;    
  293.     m_bReceivedData = FALSE;
  294.     m_bReceivedHeader = FALSE;
  296.     ReleaseAudioStreams(m_pAudioStreamList);
  297.     HX_DELETE(m_pAudioStreamList);
  299.     DeleteStreamTable();
  301.     CHXSimpleList::Iterator lIter = m_HXStreamList.Begin();
  302.     for (; lIter != m_HXStreamList.End(); ++lIter)
  303.     {
  304. HXStream* pStream = (HXStream*) (*lIter);
  305. pStream->Release();
  306.     }
  308.     m_HXStreamList.RemoveAll();    
  310.     HX_RELEASE(m_pFileHeader);    
  311.     HX_RELEASE(m_pASMSource);
  312.     HX_RELEASE(m_pBackChannel);
  313. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  314.     HX_RELEASE(m_pUpgradeCollection);
  315. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  317.     m_bForcedSourceEnd = FALSE;
  318.     m_bSourceEnd = FALSE;
  320.     HX_DELETE(m_pRedirectURL);
  321.     m_bRedirectPending  = FALSE;
  323. #if defined(HELIX_FEATURE_RECORDCONTROL)
  324.     if(m_pRecordControl)
  325.     {
  326. m_pRecordControl->Cleanup();
  327.     }
  328. #endif /* HELIX_FEATURE_RECORDCONTROL */
  329.     HX_RELEASE(m_pRecordControl);
  331.     return HXR_OK;
  332. }
  334. /////////////////////////////////////////////////////////////////////////
  335. // Method:
  336. // IUnknown::QueryInterface
  337. // Purpose:
  338. // Implement this to export the interfaces supported by your 
  339. // object.
  340. //
  341. STDMETHODIMP HXSource::QueryInterface(REFIID riid, void** ppvObj)
  342. {
  343.     QInterfaceList qiList[] =
  344.         {
  345.             { GET_IIDHANDLE(IID_IHXStreamSource), (IHXStreamSource*)this },
  346.             { GET_IIDHANDLE(IID_IHXPendingStatus), (IHXPendingStatus*)this },
  347.             { GET_IIDHANDLE(IID_IHXInfoLogger), (IHXInfoLogger*)this },
  348.             { GET_IIDHANDLE(IID_IHXPrivateStreamSource), (IHXPrivateStreamSource*)this },
  349.             { GET_IIDHANDLE(IID_IHXSourceBufferingStats), (IHXSourceBufferingStats*)this },
  350.             { GET_IIDHANDLE(IID_IHXSourceBufferingStats2), (IHXSourceBufferingStats2*)this },
  351. #if defined(HELIX_FEATURE_HYPER_NAVIGATE)
  352.             { GET_IIDHANDLE(IID_IHXHyperNavigate), (IHXHyperNavigate*)this },
  353.             { GET_IIDHANDLE(IID_IHXHyperNavigate2), (IHXHyperNavigate2*)this },
  354. #endif /* defined(HELIX_FEATURE_HYPER_NAVIGATE) */
  355.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXStreamSource*)this },
  356.         };
  357.     
  358.     HX_RESULT res = ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  359.     
  360.     // if successful, return immediately...
  361.     if (SUCCEEDED(res))
  362.     {
  363.         return res;
  364.     }
  365.     // ... otherwise proceed onward
  366.     
  367.     if (IsEqualIID(riid, IID_IHXBackChannel))
  368.     {
  369. if (m_pBackChannel)
  370. {
  371.     AddRef();
  372.     *ppvObj = (IHXBackChannel*)this;
  373.     return HXR_OK;
  374. }
  375. else
  376. {
  377.     *ppvObj = NULL;
  378.     return HXR_NOINTERFACE;
  379. }
  380.     }
  381.     else if (IsEqualIID(riid, IID_IHXASMSource))
  382.     {
  383. if (m_pASMSource)
  384. {
  385.     AddRef();
  386.     *ppvObj = (IHXASMSource*)this;
  387.     return HXR_OK;
  388. }
  389. else
  390. {
  391.     *ppvObj = NULL;
  392.     return HXR_NOINTERFACE;
  393. }
  394.     }
  396. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  397.     else if (IsEqualIID(riid, IID_IHXUpgradeCollection))
  398.     {
  399. if (!m_pUpgradeCollection)
  400. {
  401.     m_pUpgradeCollection = new HXUpgradeCollection;
  402.     m_pUpgradeCollection->AddRef();
  403. }
  405. return m_pUpgradeCollection->QueryInterface(riid, ppvObj);
  406.     }
  407. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  408.     else if (m_pRequest &&
  409. m_pRequest->QueryInterface(riid, ppvObj) == HXR_OK)
  410.     {
  411. return HXR_OK;
  412.     }
  413.     else if (m_pFileHeader &&
  414. m_pFileHeader->QueryInterface(riid, ppvObj) == HXR_OK)
  415.     {
  416. return HXR_OK;
  417.     }
  419.     *ppvObj = NULL;
  420.     return HXR_NOINTERFACE;
  421. }
  423. /////////////////////////////////////////////////////////////////////////
  424. // Method:
  425. // IUnknown::AddRef
  426. // Purpose:
  427. // Everyone usually implements this the same... feel free to use
  428. // this implementation.
  429. //
  430. STDMETHODIMP_(ULONG32) HXSource::AddRef()
  431. {
  432.     return InterlockedIncrement(&m_lRefCount);
  433. }
  435. /////////////////////////////////////////////////////////////////////////
  436. // Method:
  437. // IUnknown::Release
  438. // Purpose:
  439. // Everyone usually implements this the same... feel free to use
  440. // this implementation.
  441. //
  442. STDMETHODIMP_(ULONG32) HXSource::Release()
  443. {
  444.     if (InterlockedDecrement(&m_lRefCount) > 0)
  445.     {
  446. return m_lRefCount;
  447.     }
  449.     delete this;
  450.     return 0;
  451. }
  453. // *** IHXStreamSource methods ***
  455. /************************************************************************
  456.  * Method:
  457.  * IHXStreamSource::IsLive
  458.  * Purpose:
  459.  * Ask the source whether it is live
  460.  *
  461.  */
  462. STDMETHODIMP_ (BOOL) HXSource::IsLive(void)
  463. {
  464.     return mLiveStream;
  465. }
  467. /************************************************************************
  468.  * Method:
  469.  *     IHXStreamSource::GetPlayer
  470.  * Purpose:
  471.  *     Get the interface to the player object of which the source is
  472.  *     a part of.
  473.  *
  474.  */
  475. STDMETHODIMP HXSource::GetPlayer(IHXPlayer* &pPlayer)
  476. {
  477.     pPlayer = m_pPlayer;
  478.     if (pPlayer)
  479.     {
  480. pPlayer->AddRef();
  481.     }
  483.     return HXR_OK;
  484. }
  486. /************************************************************************
  487.  * Method:
  488.  *     IHXStreamSource::GetContext
  489.  * Purpose:
  490.  *     Get the interface to the context object of which the source is
  491.  *     a part of.
  492.  *
  493.  */
  494. STDMETHODIMP HXSource::GetContext(IUnknown* &pContext)
  495. {
  496.     pContext = ((IUnknown*)(IHXClientEngine*) m_pEngine);
  497.     if (pContext)
  498.     {
  499. pContext->AddRef();
  500.     }
  502.     return HXR_OK;
  503. }
  505. /************************************************************************
  506.  * Method:
  507.  *     IHXStreamSource::GetURL
  508.  * Purpose:
  509.  *     Get the URL for this source. NOTE: The returned string is
  510.  *     assumed to be valid for the life of the IHXStreamSource from which it
  511.  *     was returned.
  512.  *
  513.  */
  514. STDMETHODIMP_(const char*) HXSource::GetURL(void)
  515. {
  516.     const char* pURL = NULL;
  518.     /* 
  519.      * Make sure that the we have not been re-directed
  520.      * to a new URL.
  521.      */ 
  522.     if (m_pRequest && 
  523. m_pRequest->GetURL(pURL) == HXR_OK &&
  524. pURL)
  525.     {
  526. if (!m_pszURL ||
  527.     ::strcasecmp(pURL, m_pszURL) != 0)
  528. {
  529.     HX_VECTOR_DELETE(m_pszURL);
  530.     m_pszURL = new char[strlen(pURL) + 1];
  531.     strcpy(m_pszURL, pURL); /* Flawfinder: ignore */
  532. }
  533.     }
  535.     // append RAM mimeType as URL option to notify the
  536.     // caller(i.e. ViewSource)
  537.     if (m_bIsMeta)
  538.     {
  539. char* pszTemp = NULL;
  541. pszTemp = ::HXFindChar(m_pszURL, '?');
  542. if (pszTemp)
  543. {
  544. int lenTemp = strlen(m_pszURL) + strlen("&mimeType=") + strlen(RAM_MIMETYPE) + 1;
  545.     pszTemp = new char[lenTemp];
  546.     SafeSprintf(pszTemp, lenTemp, "%s%s%s", m_pszURL, "&mimeType=", RAM_MIMETYPE); /* Flawfinder: ignore */
  547. }
  548. else
  549. {
  550. int lenTemp = strlen(m_pszURL) + strlen("?mimeType=") + strlen(RAM_MIMETYPE) + 1;
  551.     pszTemp = new char[lenTemp];
  552.     SafeSprintf(pszTemp, lenTemp, "%s%s%s", m_pszURL, "?mimeType=", RAM_MIMETYPE); /* Flawfinder: ignore */
  553. }
  555. HX_VECTOR_DELETE(m_pszURL);
  556. m_pszURL = pszTemp;
  557.     }
  559.     return m_pszURL;
  560. }
  563. /************************************************************************
  564.  * Method:
  565.  *     IHXStreamSource::GetStreamCount
  566.  * Purpose:
  567.  *     Get the number of streams in this source
  568.  *
  569.  */
  570. STDMETHODIMP_(UINT16)
  571. HXSource::GetStreamCount()
  572. {
  573.     return m_HXStreamList.GetCount();
  574. }
  577. /************************************************************************
  578.  * Method:
  579.  *     IHXStreamSource::GetStream
  580.  * Purpose:
  581.  *     Get the stream with the given index.
  582.  * Note: 
  583.  *     Since stream numbers may not be zero based, stream index is not
  584.  *     equal to the stream number. Actual stream number may be determined 
  585.  *     from IHXStream::GetStreamNumber()
  586.  *
  587.  */
  588. STDMETHODIMP
  589. HXSource::GetStream
  590. (
  591.     UINT16 nIndex,
  592.     REF(IUnknown*) pUnknown
  593. )
  594. {
  595.     LISTPOSITION lPosition = m_HXStreamList.FindIndex((int) nIndex);
  596.     if (!lPosition)
  597.     {
  598. pUnknown = NULL;
  599. return HXR_INVALID_PARAMETER;
  600.     }
  602.     HXStream* pStream = (HXStream*) m_HXStreamList.GetAt(lPosition);
  603.     HX_ASSERT(pStream);
  605.     return pStream->QueryInterface(IID_IUnknown,(void**)&pUnknown);
  606. }
  609. // IHXPrivateStreamSource methods 
  610. STDMETHODIMP_(BOOL) HXSource::IsSaveAllowed()
  611. {
  612.     return mSaveAsAllowed;
  613. }
  616. /*
  617.  * IHXBackChannel method
  618.  */
  620. /************************************************************************
  621.  * Method:
  622.  *     IHXBackChannel::PacketReady
  623.  * Purpose:
  624.  *      A back channel packet sent from Renderer to FileFormat plugin.
  625.  */
  626. STDMETHODIMP
  627. HXSource::PacketReady(IHXPacket* pPacket)
  628. {
  629.     HX_ASSERT(m_pBackChannel);
  631.     if (m_pBackChannel)
  632.     {
  633. return m_pBackChannel->PacketReady(pPacket);
  634.     }
  636.     return HXR_FAIL;
  637. }
  640. /*
  641.  * IHXASMSource methods
  642.  */
  644. /************************************************************************
  645.  * Method:
  646.  *     IHXASMSource::Subscribe
  647.  * Purpose:
  648.  *      Called to inform a file format that a subscription has occurred,
  649.  *     to rule number uRuleNumber, for stream uStreamNumber.
  650.  */
  651. STDMETHODIMP
  652. HXSource::Subscribe(UINT16 uStreamNumber,
  653.      UINT16 uRuleNumber)
  654. {
  655.     HX_ASSERT(m_pASMSource);
  657.     if (m_pASMSource)
  658.     {
  659. return m_pASMSource->Subscribe(uStreamNumber, uRuleNumber);
  660.     }
  662.     return HXR_FAIL;
  663. }
  665. /************************************************************************
  666.  * Method:
  667.  *     IHXASMSource::Unsubscribe
  668.  * Purpose:
  669.  *      Called to inform a file format that a unsubscription has occurred,
  670.  *     to rule number uRuleNumber, for stream uStreamNumber.
  671.  */
  672. STDMETHODIMP
  673. HXSource::Unsubscribe(UINT16 uStreamNumber,
  674.        UINT16 uRuleNumber)
  675. {
  676.     HX_ASSERT(m_pASMSource);
  678.     if (m_pASMSource)
  679.     {
  680. return m_pASMSource->Unsubscribe(uStreamNumber, uRuleNumber);
  681.     }
  683.     return HXR_FAIL;
  684. }
  686. void
  687. HXSource::AddHXStream(HXStream* pStream)
  688. {
  689.     pStream->AddRef();
  690.     m_HXStreamList.AddTail(pStream);
  692.     UINT16 uStreamNumber = pStream->GetStreamNumber();
  693.     STREAM_INFO* pStreamInfo;
  694.     if (mStreamInfoTable->Lookup((LONG32) uStreamNumber, (void*& )pStreamInfo))
  695.     {
  696. pStreamInfo->m_pStream = pStream;
  697. pStreamInfo->m_pStream->AddRef();
  699. pStreamInfo->BufferingState().OnStream((IHXStream*)pStream);
  700.     }
  701. }
  703. HX_RESULT
  704. HXSource::CollectAudioStreams(CHXSimpleList*& pAudioStreamList)
  705. {
  706. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  707.     HX_RESULT     rc = HXR_OK;
  708.     UINT16     i = 0;
  709.     UINT16     uNumAudioStreams = 0;
  710.     CHXAudioPlayer* pAudioPlayer = NULL;
  711.     CHXAudioStream* pCHXAudioStream = NULL;
  712.     IHXValues*     pHeader = NULL;
  714.     pAudioStreamList = NULL;
  716.     if (!m_pPlayer)
  717.     {
  718. goto cleanup;
  719.     }
  721.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  722.     if (!pAudioPlayer)
  723.     {
  724. goto cleanup;
  725.     }
  727.     uNumAudioStreams = pAudioPlayer->GetAudioStreamCount();
  728.     for (i = 0; i < uNumAudioStreams; i++)
  729.     {
  730. pCHXAudioStream = pAudioPlayer->GetCHXAudioStream(i);
  731. pCHXAudioStream->AddRef();
  733. pHeader = ((IHXAudioStream*)pCHXAudioStream)->GetStreamInfo();
  735. if (pHeader &&
  736.     IsAudioStreamFromThisSource(pHeader))
  737. {
  738.     if (!pAudioStreamList)
  739.     {
  740. pAudioStreamList = new CHXSimpleList();
  741.     }
  743.     pAudioStreamList->AddTail(pCHXAudioStream);
  744. }
  745. else
  746. {
  747.     HX_RELEASE(pCHXAudioStream);
  748. }
  749. HX_RELEASE(pHeader);
  750.     }
  752. cleanup:
  754.     if (!pAudioStreamList)
  755.     {  
  756. rc = HXR_FAILED;
  757.     }
  759.     return rc;
  760. #else
  761.     return HXR_NOTIMPL;
  762. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  763. }
  765. void
  766. HXSource::RemoveAudioStreams(void)
  767. {    
  768. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  769.     CHXAudioPlayer* pAudioPlayer = NULL;
  770.     CHXSimpleList*  pAudioStreamList = NULL;
  772.     if (!m_pPlayer)
  773.     {
  774. goto cleanup;
  775.     }
  777.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  778.     if (!pAudioPlayer)
  779.     {
  780. goto cleanup;
  781.     }
  783.     pAudioPlayer->AddRef();
  785.     if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
  786.     {
  787. pAudioPlayer->ManageAudioStreams(pAudioStreamList, CHXAudioPlayer::STR_REMOVE);
  789. ReleaseAudioStreams(pAudioStreamList);
  790. HX_DELETE(pAudioStreamList);
  791.     }
  793.     HX_RELEASE(pAudioPlayer);
  795. cleanup:
  796. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  798.     return;
  799. }
  801. void
  802. HXSource::PauseAudioStreams(void)
  803. {
  804. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  805.     CHXAudioPlayer* pAudioPlayer = NULL;
  806.     CHXSimpleList*  pAudioStreamList = NULL;
  808.     if (!m_pPlayer)
  809.     {
  810. goto cleanup;
  811.     }
  813.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  814.     if (!pAudioPlayer)
  815.     {
  816. goto cleanup;
  817.     }
  819.     pAudioPlayer->AddRef();
  821.     if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
  822.     {
  823. pAudioPlayer->ManageAudioStreams(pAudioStreamList, CHXAudioPlayer::STR_PAUSE);
  825. ReleaseAudioStreams(pAudioStreamList);
  826. HX_DELETE(pAudioStreamList);
  827.     }
  829.     HX_RELEASE(pAudioPlayer);
  831. cleanup:
  832. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  834.     return;
  835. }
  837. void
  838. HXSource::ResumeAudioStreams(void)
  839. {
  840. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  841.     CHXAudioPlayer* pAudioPlayer = NULL;
  842.     CHXSimpleList*  pAudioStreamList = NULL;
  844.     if (!m_pPlayer)
  845.     {
  846. goto cleanup;
  847.     }
  849.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  850.     if (!pAudioPlayer)
  851.     {
  852. goto cleanup;
  853.     }
  855.     pAudioPlayer->AddRef();
  857.     if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
  858.     {
  859. pAudioPlayer->ManageAudioStreams(pAudioStreamList, CHXAudioPlayer::STR_RESUME);
  861. ReleaseAudioStreams(pAudioStreamList);
  862. HX_DELETE(pAudioStreamList);
  863.     }
  865.     HX_RELEASE(pAudioPlayer);
  867. cleanup:
  868. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  870.     return;
  871. }
  873. void
  874. HXSource::ReleaseAudioStreams(CHXSimpleList* pAudioStreamList)
  875. {
  876. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  877.     if (pAudioStreamList && !pAudioStreamList->IsEmpty())
  878.     {
  879. CHXSimpleList::Iterator lIter = pAudioStreamList->Begin();
  880. for (; lIter != pAudioStreamList->End(); ++lIter)
  881. {
  882.     CHXAudioStream* pAudioStream = (CHXAudioStream*) (*lIter);
  883.     HX_RELEASE(pAudioStream);
  884. }
  885.     }
  886. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  888.     return;
  889. }
  891. HX_RESULT HXSource::Init(HXPlayer * pPlayer, UINT32 unRegistryID)
  892. {
  893.     HX_RESULT theErr = HXR_OK;
  894.    
  895.     m_pPlayer = pPlayer;
  896.     if (m_pPlayer->QueryInterface(IID_IHXPreferences, (void **) &m_pPreferences) != HXR_OK)
  897.     {
  898. theErr = HXR_INVALID_PARAMETER; //HX_INVALID_INTERFACE;
  899.     }
  901.     m_pBufferManager = new CBufferManager(this);
  902.     if(!m_pBufferManager)
  903.     {
  904.         theErr = HXR_OUTOFMEMORY;
  905.     }
  907.     // create registry entries
  908.     if (HXR_OK != m_pPlayer->QueryInterface(IID_IHXRegistry, (void**)&m_pRegistry))
  909.     {
  910. m_pRegistry = NULL;
  911.     }
  912.     else
  913.     {
  914. m_ulRegistryID = unRegistryID;
  915.     }
  917.     if (!theErr &&
  918. m_pPlayer->QueryInterface(IID_IHXScheduler, (void **) &m_pScheduler) != HXR_OK)
  919.     {
  920. theErr = HXR_INVALID_PARAMETER; //HX_INVALID_INTERFACE;
  921.     }
  923.     IHXPreferences* pPref = NULL;
  925.     m_pPlayer->QueryInterface(IID_IHXPreferences, (void**)&pPref);
  926.     if (HXR_OK == ReadPrefINT32(pPref, "TurboPushdown", m_ulTurboPushDown))
  927.     {
  928. m_ulTurboPushDown = (m_ulTurboPushDown / 100) * 100;  // round to multiple of 100
  929.     }
  930.     HX_RELEASE(pPref);
  932.     m_pEngine = m_pPlayer->m_pEngine;
  933.     m_pEngine->AddRef();
  935.     return theErr;
  936. }
  938. HX_RESULT HXSource::SetupRegistry()
  939. {
  940.     HX_RESULT theErr = HXR_OK;
  941. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  942.     UINT32 ulRepeatedRegistryID = 0;
  943.     IHXBuffer* pRepeatRegName = NULL;
  944.     char        szSourceName[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  946.     HX_ASSERT(m_pSourceInfo);    
  948.     if (m_pSourceInfo->m_bLeadingSource &&
  949. !m_pSourceInfo->m_pRepeatList)
  950.     {
  951. m_pStats = new SOURCE_STATS(m_pRegistry, m_ulRegistryID);
  952.     }
  953.     else if (m_pRegistry && 
  954.     HXR_OK == m_pRegistry->GetPropName(m_pPlayer->m_ulRepeatedRegistryID, pRepeatRegName))
  955.     {
  956. SafeSprintf(szSourceName, MAX_DISPLAY_NAME, "%s.%ld%ld%ld", 
  957. pRepeatRegName->GetBuffer(),
  958. m_pSourceInfo->m_uGroupID,
  959. m_pSourceInfo->m_uTrackID,
  960. (int)m_pSourceInfo->m_bLeadingSource);
  961.     
  962. ulRepeatedRegistryID = m_pRegistry->GetId(szSourceName);
  963. if (!ulRepeatedRegistryID)
  964. {
  965.     ulRepeatedRegistryID = m_pRegistry->AddComp(szSourceName);
  966. }
  968. m_pStatsManager = new StatsManager(m_pRegistry, m_ulRegistryID, ulRepeatedRegistryID);
  969. m_pStatsManager->AddRef();
  971. m_pStats = new SOURCE_STATS(m_pRegistry, ulRepeatedRegistryID);
  972.         if( !m_pStats )
  973.         {
  974.             theErr = HXR_OUTOFMEMORY;
  975.         }
  976.     }
  977.     else
  978.     {
  979. // why stats' creation failed??
  980. HX_ASSERT(FALSE);
  981.     }
  983.     HX_RELEASE(pRepeatRegName);
  984. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  986.     return theErr;
  987. }
  989. HX_RESULT HXSource::ReadPreferences(void)
  990. {
  991.     UINT32      un16Temp = 10;
  993.     ReadPrefINT32(m_pPreferences, "PerfectPlayTime", un16Temp); 
  994.     m_ulPerfectPlayTime = un16Temp;
  996.     ReadPrefINT32(m_pPreferences, "BufferedPlayTime", un16Temp);
  997.     m_ulBufferedPlayTime = un16Temp;
  999.     ReadPrefBOOL(m_pPreferences, "PerfPlayEntireClip", m_bPerfectPlayEntireClip); 
  1001.     return HXR_OK;
  1002. }
  1005. HX_RESULT HXSource::DeleteStreamTable(void)
  1006. {
  1007.     HX_RESULT theErr = HXR_OK;
  1009.     STREAM_INFO * sInfo = NULL;
  1011.     for (CHXMapLongToObj::Iterator i = mStreamInfoTable->Begin();
  1012.          i != mStreamInfoTable->End(); ++i) 
  1013.     {    
  1014. sInfo = (STREAM_INFO*) (*i);
  1016. if (sInfo)
  1017. {
  1018.     HX_DELETE (sInfo);
  1019. }
  1020.     }
  1022.     mStreamInfoTable->RemoveAll();
  1023.     m_ulStreamIndex = 0;
  1024.     m_uNumStreams = 0;
  1025.     
  1026.     return theErr;
  1027. }
  1030. IHXValues* HXSource::GetHeaderInfo(UINT16 stream_number)
  1031. {
  1032.     STREAM_INFO * pStreamInfo;
  1033.     if (mStreamInfoTable->Lookup((LONG32) stream_number, (void*& )pStreamInfo))
  1034.     {
  1035. return pStreamInfo->m_pHeader;
  1036.     }
  1037.     else
  1038.     {
  1039. return NULL;
  1040.     }
  1041. }
  1043. HX_RESULT
  1044. HXSource::GetStreamHeaderInfo(UINT16 index, IHXValues*& hdr)
  1045. {
  1046.     HX_TRACE("HXSource::GetStreamHeaderInfo");
  1047.     
  1048.     // sanity check
  1049.     if (index >= m_uNumStreams)
  1050.     {
  1051. return HXR_INVALID_PARAMETER; // HX_INVALID_INDEX;
  1052.     }
  1053.     
  1054.     CHXMapLongToObj::Iterator i = mStreamInfoTable->Begin();
  1055.     for (UINT16 j=0; j < index; j++)
  1056.     {
  1057. ++i;
  1058.     }
  1060.     STREAM_INFO* pStreamInfo = (STREAM_INFO*) *i;
  1062.     hdr = pStreamInfo->m_pHeader;
  1063.     if (hdr)
  1064.     {
  1065. hdr->AddRef();
  1066.     }
  1068.     return HXR_OK;
  1069. }
  1072. void HXSource::SetFlags(UINT16 flags)
  1073. {
  1074.     mFlags = flags;
  1076.     if (mFlags & HX_PERFECT_PLAY_ENABLED)
  1077.     {
  1078. m_bPerfectPlayAllowed = TRUE;
  1079.     }
  1080.     else
  1081.     {
  1082. m_bPerfectPlayAllowed = FALSE;
  1083.     }
  1085.     if (mFlags & HX_SAVE_ENABLED)
  1086.     {
  1087. mSaveAsAllowed = TRUE;
  1088.     }
  1089.     else
  1090.     {
  1091. mSaveAsAllowed = FALSE;
  1092.     }
  1093. }
  1095. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  1096. HX_RESULT HXSource::CopyMetaDataToRegistry(IHXValues* pHeader)
  1097. {
  1098.     // get Request Object
  1099.     char pszServerMetaData[256] = {0}; /* Flawfinder: ignore */
  1100.     char pszMetaData[256] = {0}; /* Flawfinder: ignore */
  1102.     IHXValues* pReqHeaders = NULL;
  1103.     IHXRequest* pRequest = NULL;
  1104.     IHXBuffer* pBuffer = NULL;
  1105.     char szRegKeyName[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  1106.     char buff[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  1107.     char szSMDKey[256]; /* Flawfinder: ignore */
  1108.     ULONG32 ulValue = 0;
  1109.     IHXBuffer* pParentName = NULL;
  1110.     UINT32 regid = 0;
  1111.     const char szServerMetaData[] = {"ServerMetaData"};
  1114.     if (HXR_OK == m_pRegistry->GetPropName(m_pStats->m_ulRegistryID, pParentName))
  1115.     {
  1116. SafeStrCpy(buff, (const char*) pParentName->GetBuffer(), MAX_DISPLAY_NAME);
  1117. char* pDot = strrchr(buff, '.');
  1118. if (pDot)
  1119. {
  1120.     *pDot = '';
  1121. }
  1122. SafeStrCpy(szSMDKey, buff, 256);
  1124. if (HXR_OK == GetRequest(pRequest))
  1125. {
  1126.     // get request headers
  1127.     if (HXR_OK == pRequest->GetRequestHeaders(pReqHeaders))
  1128.     {
  1129. // look for the meta data properties
  1130. if (HXR_OK == pReqHeaders->GetPropertyCString("AcceptMetaInfo", pBuffer))
  1131. {
  1132.     SafeStrCpy(pszMetaData, (char*) pBuffer->GetBuffer(), 256);
  1133.     HX_RELEASE(pBuffer);
  1135.     // look for comma delimited entries
  1136.     const char* pCharEntryStart = pszMetaData;
  1137.     const char* pCharEntryEnd = pCharEntryStart;
  1139.     while (pCharEntryEnd && *pCharEntryEnd)
  1140.     {
  1141. ++pCharEntryEnd;
  1142. if (*pCharEntryEnd == ',' || !*pCharEntryEnd)
  1143. {
  1144.     // copy next prop request into buffer 
  1145.     strncpy(buff, pCharEntryStart, (UINT32)pCharEntryEnd - (UINT32)pCharEntryStart); /* Flawfinder: ignore */
  1146.     *(buff+(UINT32)pCharEntryEnd - (UINT32)pCharEntryStart) = '';
  1148.     // see if this prop is in file header (it should be!)
  1149.     if (HXR_OK == pHeader->GetPropertyCString(buff, pBuffer))
  1150.     {
  1151. // create new registry entry
  1152. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.%s", pParentName->GetBuffer(), buff);
  1153. regid = m_pRegistry->GetId(szRegKeyName);
  1154. if (!regid)
  1155. {
  1156.     m_pRegistry->AddStr(szRegKeyName, pBuffer);
  1157. }
  1158. else
  1159. {
  1160.     // set new value
  1161.     m_pRegistry->SetStrByName(szRegKeyName, pBuffer);
  1162. }
  1164. HX_RELEASE(pBuffer);
  1165.     }
  1166.     else if (HXR_OK == pHeader->GetPropertyULONG32(buff, ulValue))
  1167.     {
  1168. // create new registry entry
  1169. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.%s", pParentName->GetBuffer(), buff);
  1171. regid = m_pRegistry->GetId(szRegKeyName);
  1172. if (!regid)
  1173. {
  1174.     m_pRegistry->AddInt(szRegKeyName, ulValue);
  1175. }
  1176. else
  1177. {
  1178.     // set new value
  1179.     m_pRegistry->SetIntByName(szRegKeyName, ulValue);
  1180. }
  1181.     }
  1183.     pCharEntryStart = pCharEntryEnd + 1;
  1184. }
  1185.     }
  1186. }
  1188. // look for the meta data properties
  1189. if (HXR_OK == pReqHeaders->GetPropertyCString("AcceptServerMetaData", pBuffer))
  1190. {
  1191.     SafeStrCpy(pszServerMetaData, (char*) pBuffer->GetBuffer(), 256);
  1192.     HX_RELEASE(pBuffer);
  1194.     // first make sure we have a composit key for "statistics.Player0.ServerMetaData"
  1195.     SafeSprintf(buff, MAX_DISPLAY_NAME, "%s.%s", szSMDKey, szServerMetaData);
  1196.     regid = m_pRegistry->GetId(buff);
  1197.     if (!regid)
  1198.     {
  1199. m_pRegistry->AddComp(buff);
  1200.     }
  1201.     SafeStrCpy(szSMDKey, buff, 256);
  1203.     // look for comma delimited entries
  1204.     const char* pCharEntryStart = pszServerMetaData;
  1205.     const char* pCharEntryEnd = pCharEntryStart;
  1207.     while (pCharEntryEnd && *pCharEntryEnd)
  1208.     {
  1209. ++pCharEntryEnd;
  1210. if (*pCharEntryEnd == ',' || !*pCharEntryEnd)
  1211. {
  1212.     // copy next prop request into buffer 
  1213.     strncpy(buff, pCharEntryStart, (UINT32)pCharEntryEnd - (UINT32)pCharEntryStart); /* Flawfinder: ignore */
  1214.     *(buff+(UINT32)pCharEntryEnd - (UINT32)pCharEntryStart) = '';
  1216.     // see if this prop is in file header (it should be!)
  1217.     if (HXR_OK == pHeader->GetPropertyCString(buff, pBuffer))
  1218.     {
  1219. // create new registry entry (if one does not exist)
  1220. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.%s", szSMDKey, buff);
  1221. regid = m_pRegistry->GetId(szRegKeyName);
  1222. if (!regid)
  1223. {
  1224.     m_pRegistry->AddStr(szRegKeyName, pBuffer);
  1225. }
  1226. else
  1227. {
  1228.     // set new value
  1229.     m_pRegistry->SetStrByName(szRegKeyName, pBuffer);
  1230. }
  1232. HX_RELEASE(pBuffer);
  1233.     }
  1234.     else if (HXR_OK == pHeader->GetPropertyULONG32(buff, ulValue))
  1235.     {
  1236. // create new registry entry
  1237. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.%s", szSMDKey, buff);
  1238. regid = m_pRegistry->GetId(szRegKeyName);
  1239. if (!regid)
  1240. {
  1241.     m_pRegistry->AddInt(szRegKeyName, ulValue);
  1242. }
  1243. else
  1244. {
  1245.     // set new value
  1246.     m_pRegistry->SetIntByName(szRegKeyName, ulValue);
  1247. }
  1248.     }
  1250.     pCharEntryStart = pCharEntryEnd + 1;
  1251. }
  1252.     }
  1253. }
  1255. HX_RELEASE(pReqHeaders);
  1256.     }
  1258.     HX_RELEASE(pRequest);
  1259. }
  1261. HX_RELEASE(pParentName);
  1262.     }
  1264.     return HXR_OK;
  1265. }
  1266. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  1268. HX_RESULT HXSource::SetPlayTimes(UINT32 ulStartTime, 
  1269.   UINT32 ulEndTime, 
  1270.   UINT32 ulDelay, 
  1271.   UINT32 ulDuration)
  1272. {
  1273.     m_ulStartTime     = ulStartTime;
  1274.     m_ulEndTime     = ulEndTime;
  1275.     /* We do not handle Delay field for now */
  1276.     m_ulDelay     = ulDelay;
  1277.     m_ulRestrictedDuration  = ulDuration;
  1279.     if (m_ulEndTime > 0)
  1280.     {
  1281. m_bCustomEndTime = TRUE;
  1282.     }
  1283.     else
  1284.     {
  1285.      m_bCustomEndTime = FALSE;
  1286.     }
  1288.     return HXR_OK;
  1289. }
  1291. HX_RESULT
  1292. HXSource::UpdatePlayTimes(IHXValues* pValues)
  1293. {
  1294.     HX_RESULT rc = HXR_OK;
  1295.     char szStart[] = "Start";
  1296.     char szEnd[] = "End";
  1297.     char szDelay[] = "Delay";
  1298.     char szDuration[] = "Duration";
  1299.     UINT32 ulStartTime = 0;
  1300.     UINT32 ulEndTime = 0;
  1301.     UINT32 ulDelay = 0;
  1302.     UINT32 ulRestrictedDuration = 0;
  1304.     pValues->GetPropertyULONG32(szStart, ulStartTime);
  1305.     pValues->GetPropertyULONG32(szEnd, ulEndTime);
  1306.     pValues->GetPropertyULONG32(szDelay, ulDelay);
  1307.     pValues->GetPropertyULONG32(szDuration, ulRestrictedDuration);
  1309.     if (ulStartTime != m_ulStartTime    ||
  1310. ulEndTime != m_ulEndTime     ||
  1311. ulDelay != m_ulDelay     ||
  1312. ulRestrictedDuration != m_ulRestrictedDuration)
  1313.     {
  1314. SetPlayTimes(ulStartTime, ulEndTime, ulDelay, ulRestrictedDuration);
  1315. rc = AdjustClipTime();
  1316.     }
  1318.     return rc;
  1319. }
  1321. ULONG32 
  1322. HXSource::GetPerfectPlayTime(void)
  1323. {
  1324.     ULONG32 ulCurrentPlayTime = m_pPlayer ? m_pPlayer->GetCurrentPlayTime() : 0;
  1325.     ULONG32 result       = m_bPerfectPlay ? m_ulPerfectPlayTime : m_ulBufferedPlayTime;
  1327.     if (m_ulDuration != 0)
  1328.     {
  1329. // mPlaybackLength is in Milliseconds, we want to calculate
  1330. // playback in seconds...
  1331. ULONG32 playbackTimeLeftInClip = 
  1332.     ((m_ulDuration > ulCurrentPlayTime ? m_ulDuration - ulCurrentPlayTime : 0) /1000)+1;
  1334. /* Perfect Play entire clip ONLY if user has chosen PerfectPlay specifically
  1335.  * If we internally go in buffered play mode, always use perfect play time
  1336.  * setting.
  1337.  */
  1338. if (m_bPerfectPlay)
  1339. {
  1340.     if (m_bPerfectPlayEntireClip)
  1341.     {
  1342. result = playbackTimeLeftInClip;
  1343.     }
  1344.     else
  1345.     {
  1346. result = min(m_ulPerfectPlayTime, playbackTimeLeftInClip);
  1347.     }
  1348. }
  1349. else // if (m_bBufferedPlay)
  1350. {
  1351.     result = min(m_ulBufferedPlayTime, playbackTimeLeftInClip);
  1352. }
  1353.     }
  1354.     
  1355.     // check if enough memory is available to handle the result
  1356.     if(result > 0)
  1357.     {
  1358. // get 50% of the available memory
  1359. ULONG32 maxMemAvail = GetAvailableMemory() / 2;
  1360. ULONG32 bytesPerSecond = m_ulAvgBandwidth/8;
  1361. ULONG32 maxTimeAvail = maxMemAvail/(bytesPerSecond > 0 ? bytesPerSecond : 1);
  1363. // if this is true then we can't buffer the entire clip
  1364. if (maxTimeAvail < result)
  1365. m_bCannotBufferEntireClip = (m_bPerfectPlayEntireClip) ? TRUE : FALSE;
  1366. else
  1367. m_bCannotBufferEntireClip = FALSE;
  1369. result = min(result,maxTimeAvail);
  1370.     }
  1372.     /* Value now returned in ms. */
  1373.     return 1000*(max(result, PERFECTPLAY_MIN_TIME));
  1374. }
  1376. STDMETHODIMP 
  1377. HXSource::ReportRebufferStatus(UINT16 uStreamNumber,
  1378.         UINT8 unNeeded, 
  1379.         UINT8 unAvailable) 
  1380. {
  1381.     STREAM_INFO* pStreamInfo = 0;
  1383. //    if (m_bDelayed ||
  1384. // (m_ulDelay > 0 && m_ulDelay > m_pPlayer->GetCurrentPlayTime()))
  1386.     if (m_bDelayed)
  1387.     {
  1388. return HXR_OK;
  1389.     }
  1391.     DEBUG_OUT(m_pPlayer, DOL_TRANSPORT, (s, "(%p)ReportRebufferStatus %lu %lu %lu", this, uStreamNumber, unNeeded, unAvailable));
  1393.     if (mStreamInfoTable->Lookup((LONG32) uStreamNumber, (void*& )pStreamInfo))
  1394.     {
  1395. pStreamInfo->m_unNeeded     = unNeeded;
  1396. pStreamInfo->m_unAvailable  = unAvailable;
  1397. if (unNeeded > unAvailable)
  1398. {
  1399. //     dfprintf("buff", "reportrebufferstatus: %lun", m_pPlayer->GetInternalCurrentPlayTime());     
  1400. //     g_bRahulLog = TRUE;
  1402.     if (m_bFastStart)
  1403.     {
  1404.                 DEBUG_OUT(m_pPlayer, DOL_TRANSPORT, (s, "(%p)ALMOST Turbo OFF ReportRebufferStatus", this));
  1405.                 //with surestream audio only clips, rarender may report buffering immediately after resume
  1406.                 if (m_bSureStreamClip)
  1407. {
  1408.     if (CALCULATE_ELAPSED_TICKS(m_ulTurboStartActiveTime, HX_GET_TICKCOUNT()) > 1000)
  1409.     {
  1410. LeaveFastStart(TP_OFF_BY_REBUFFER);
  1411. DEBUG_OUT(m_pPlayer, DOL_TRANSPORT, (s, "(%p)Turbo OFF ReportRebufferStatus", this));
  1412.     }
  1413. }
  1414. else
  1415. {
  1416.                     LeaveFastStart(TP_OFF_BY_REBUFFER);
  1417.                     DEBUG_OUT(m_pPlayer, DOL_TRANSPORT, (s, "(%p)Turbo OFF ReportRebufferStatus", this));
  1418. }
  1419.     }
  1421.     // log rebuffer action
  1422.     LogInformation("BUFBEG", NULL);
  1423.     
  1424.     DoRebuffer();
  1425.   }
  1426. else
  1427. {
  1428.     m_bRebufferingRequired = IsRebufferRequired();
  1429.     if (!m_bRebufferingRequired)
  1430.     {
  1431. // log rebuffer action
  1432. LogInformation("BUFEND", NULL);
  1433.     }
  1434. }
  1436.         return HXR_OK;
  1437.     }
  1439.     return HXR_UNEXPECTED;
  1440. }
  1442. STDMETHODIMP 
  1443. HXSource::SetGranularity
  1444. (
  1445.     UINT16 uStreamNumber,
  1446.     ULONG32 ulGranularity
  1447. ) 
  1448. {
  1449.     STREAM_INFO* pStreamInfo = 0;
  1451.     if (mStreamInfoTable->Lookup((LONG32) uStreamNumber, (void*& )pStreamInfo))
  1452.     {
  1453. m_pPlayer->SetGranularity(this, uStreamNumber, ulGranularity);
  1454. return HXR_OK;
  1455.     }
  1456.     else
  1457.     {
  1458. return HXR_OK;
  1459.     }
  1461.     return HXR_UNEXPECTED;
  1462. }
  1464. BOOL
  1465. HXSource::TryResume(void)
  1466. {
  1467.     BOOL    bResume = FALSE;
  1469.     // resume the persistent source ASAP
  1470.     if (m_pSourceInfo && m_pSourceInfo->m_bIsPersistentSource)
  1471.     {
  1472.         m_bDelayed = FALSE;
  1473.         bResume = TRUE;
  1474.     }
  1475.     else if (m_bPaused && m_bDelayed && m_pPlayer &&
  1476.              m_pPlayer->CanBeStarted(this, m_pSourceInfo, m_bPartOfNextGroup))
  1477.     {
  1478.         UINT32 ulCurrentTime = m_pPlayer->GetInternalCurrentPlayTime();
  1479.         UINT32 ulStartTime = 0;
  1481.         if (m_ulDelay > m_ulPreRollInMs + NETWORK_FUDGE_FACTOR)
  1482.         {
  1483.             ulStartTime = m_ulDelay - (m_ulPreRollInMs + NETWORK_FUDGE_FACTOR);
  1484.         }
  1486.         if (ulCurrentTime >= ulStartTime)
  1487.         {
  1488.             m_bDelayed = FALSE;
  1489.             bResume = TRUE;
  1490.         }
  1492.         if (!m_bIsPreBufferingStarted)
  1493.         {
  1494.             m_bIsPreBufferingStarted = TRUE;
  1495.             bResume = TRUE;
  1496.         }
  1497.     }
  1498.     else if (m_bPrefetch)
  1499.     {
  1500.         bResume = TRUE;
  1501.     }
  1503.     if (bResume && CanBeResumed())
  1504.     {
  1505.         if (m_pSourceInfo)
  1506.         {
  1507.             m_pSourceInfo->Register();
  1508.         }
  1510.         m_bResumePending = TRUE;
  1511.     }
  1513.     return bResume;
  1514. }
  1516. BOOL
  1517. HXSource::IsAnyAudioStream(void)
  1518. {
  1519.     IHXAudioPlayer* pAudioPlayer = NULL;
  1520.     BOOL bAtLeastOneAudioStream = FALSE;
  1522.     if (!m_pPlayer)
  1523.     {
  1524. return FALSE;
  1525.     }
  1527.     m_pPlayer->QueryInterface(IID_IHXAudioPlayer, (void **) &pAudioPlayer);
  1528.     UINT16 uNumAudioStreams = pAudioPlayer->GetAudioStreamCount();
  1529.     for (UINT16 i = 0; i < uNumAudioStreams && !bAtLeastOneAudioStream; i++)
  1530.     {
  1531. IHXAudioStream* pAudioStream = pAudioPlayer->GetAudioStream(i);
  1532. IHXValues* pHeader = pAudioStream->GetStreamInfo();
  1533. pAudioStream->Release();
  1534. if (!pHeader)
  1535. {
  1536.     continue;
  1537. }
  1539. if (IsAudioStreamFromThisSource(pHeader))
  1540. {
  1541.     bAtLeastOneAudioStream = TRUE;
  1542.     pHeader->Release();
  1543.     break;
  1544. }
  1546. pHeader->Release();
  1547.     }
  1549.     if (!bAtLeastOneAudioStream)
  1550.     {
  1551.         IHXValues* pHeader = NULL;
  1552.         int nStreamCnt = GetNumStreams();
  1553.         ULONG32     ulIsAudioStream = FALSE;
  1555.         for (int i=0; i<nStreamCnt && !bAtLeastOneAudioStream; i++)
  1556.         {
  1557.             GetStreamHeaderInfo(i, pHeader);
  1559.             pHeader->GetPropertyULONG32("IsAudioStream", ulIsAudioStream);
  1560.             if (ulIsAudioStream)
  1561.             {
  1562.                 bAtLeastOneAudioStream = TRUE;
  1563.             }
  1564.     HX_RELEASE(pHeader);
  1565.         }
  1566.     }
  1568.     pAudioPlayer->Release();
  1570.     return bAtLeastOneAudioStream;
  1571. }
  1573. void
  1574. HXSource::EventReady(CHXEvent* pEvent)
  1575. {
  1576.     if (m_pPlayer)
  1577.     {
  1578. m_pPlayer->EventReady(this, pEvent);
  1579.     }
  1580. }
  1582. BOOL 
  1583. HXSource::IsAudioStreamFromThisSource(IHXValues* pAudioHeader)
  1584. {
  1585.     BOOL bFound = FALSE;
  1587.     CHXMapLongToObj::Iterator ndxStreamIterator = mStreamInfoTable->Begin();
  1588.     for (; ndxStreamIterator != mStreamInfoTable->End(); ++ndxStreamIterator) 
  1589.     {
  1590. STREAM_INFO* pStreamInfo = (STREAM_INFO*) (*ndxStreamIterator);
  1591. if (pStreamInfo->m_pHeader == pAudioHeader)
  1592. {
  1593.     bFound = TRUE;
  1594.     break;
  1595. }
  1596.     }
  1598.     return bFound;
  1599. }
  1601. ULONG32
  1602. HXSource::GetAvailableMemory()
  1603. {
  1604.     ULONG32 memAvail = 1000000;
  1606. #if   defined (__MWERKS__)
  1607. //  XXX Hack! We can't call any of the Memory Manager calls at interrupt time so we will have 
  1608. //  to change this to ask our interrupt safe memory allocator how much memory is free
  1609.     memAvail = 1000000;
  1610. #elif defined(_WINCE) && !defined(_WIN32_WCE_EMULATION)
  1611.     STORE_INFORMATION stInfo;
  1612.     GetStoreInformation(&stInfo);
  1613.     memAvail = stInfo.dwFreeSize;
  1614. #elif (_WIN32)
  1615.     MEMORYSTATUS status;
  1616.     status.dwLength = sizeof(MEMORYSTATUS);
  1617.     GlobalMemoryStatus(&status);
  1618.     memAvail = status.dwAvailPageFile;
  1619. #elif defined( _WINDOWS)
  1620.     memAvail = GetFreeSpace(0);
  1621. #elif defined (_UNIX)
  1622.     // XXXX Need to get this to compile.
  1623.     memAvail = 1000000;
  1624. #endif
  1626.     return memAvail;
  1627. }
  1629. void
  1630. HXSource::ReportError(HX_RESULT theErr)
  1631. {
  1632.     if (m_pPlayer)
  1633.     {
  1634. m_pPlayer->ReportError(this, theErr);
  1635.     }
  1636. }
  1639. HX_RESULT
  1640. HXSource::AdjustClipTime(void)
  1641. {
  1642.     HX_RESULT theErr = HXR_OK;
  1643.     UINT32  ulOriginalDuration = m_ulDuration;        
  1644.     UINT32  ulTrackEndTime = 0;
  1645.     CHXMapLongToObj::Iterator i;
  1646.     BOOL    bCustomEndTimeSet = FALSE;
  1648.     if (m_bPartOfPrefetchGroup)
  1649.     {
  1650. if (m_ulDelay)
  1651. {
  1652.     m_ulPrefetchDelay = m_ulDelay;
  1653.     m_bDelayed = TRUE;
  1654.     AdjustClipBandwidthStats(FALSE);
  1655.     DoPause();
  1656. }
  1658. m_ulEndTime = 0;
  1659. m_bCustomEndTime = FALSE;
  1660. goto cleanup;
  1661.     }
  1663.     /* For a live stream, the only qualifiers that make sense
  1664.      * are Duration and Delay. All other qualifiers should be made 0
  1665.      */
  1666.     if (mLiveStream)
  1667.     {
  1668. m_ulStartTime = 0;
  1670. if (!m_bRestrictedLiveStream)
  1671. {
  1672.     m_ulEndTime = 0;
  1673. }
  1674.     }
  1676.     for (i = mStreamInfoTable->Begin(); i != mStreamInfoTable->End(); ++i) 
  1677.     {    
  1678. STREAM_INFO* pStreamInfo = (STREAM_INFO*) (*i);
  1680. ulTrackEndTime = 0;
  1682. HX_RESULT hrTemp = pStreamInfo->m_pHeader->GetPropertyULONG32("EndTime", ulTrackEndTime);
  1684. if (HXR_OK == hrTemp && !m_bCustomEndTime)
  1685. {
  1686.     if (m_ulEndTime < ulTrackEndTime)
  1687.     {
  1688. m_ulEndTime = ulTrackEndTime;
  1689.     }
  1690.     pStreamInfo->m_bCustomEndTime = TRUE;
  1691. }
  1692. else if (m_bCustomEndTime)
  1693. {
  1694.     ulTrackEndTime = m_ulEndTime;
  1695.     pStreamInfo->m_bCustomEndTime = TRUE;
  1696. }
  1698. if (ulTrackEndTime > 0 && !mLiveStream)
  1699. {
  1700.     pStreamInfo->m_pHeader->SetPropertyULONG32("TrackEndTime",
  1701. ulTrackEndTime);
  1702.     bCustomEndTimeSet = TRUE;
  1703. }
  1704.     }
  1705.     
  1706.     // if max. duration is set on this source
  1707.     if (m_pSourceInfo && 
  1708. m_pSourceInfo->m_ulMaxDuration)
  1709.     {
  1710. if (m_ulRestrictedDuration)
  1711. {     
  1712.     if (m_ulRestrictedDuration > m_pSourceInfo->m_ulMaxDuration)
  1713.     {
  1714. m_ulRestrictedDuration = m_pSourceInfo->m_ulMaxDuration;
  1715.     }
  1716. }
  1717. else if (m_ulDuration)
  1718. {
  1719.     if (m_ulDuration > m_pSourceInfo->m_ulMaxDuration)
  1720.     {
  1721. m_ulRestrictedDuration = m_pSourceInfo->m_ulMaxDuration;
  1722.     }
  1723. }
  1724.     }
  1726.     // By default, we always set the end time to be the duration of the clip,
  1727.     // but do not set end time if it was manually specified.
  1728.     if (!bCustomEndTimeSet && !mLiveStream)
  1729.     {
  1730. m_ulEndTime = m_ulDuration;
  1731.     }
  1733.     /* Check if there is any end time */
  1734.     if ((m_ulEndTime < m_ulDuration) || m_bRestrictedLiveStream)
  1735.     {
  1736. m_ulDuration = m_ulEndTime;
  1737.     }
  1738.     
  1739.     /* Is "Delay" specified too? */
  1740.     if (m_ulDelay > 0) 
  1741.     {
  1742. /* Increase duration of this clip */
  1743. m_ulDuration += m_ulDelay;
  1744. UINT32 ulStartTime = 0;
  1746. if (m_ulDelay > m_ulPreRollInMs + NETWORK_FUDGE_FACTOR)
  1747. {
  1748.     ulStartTime = m_ulDelay - (m_ulPreRollInMs + NETWORK_FUDGE_FACTOR);
  1749. }
  1751. // no need to pause delayed persistent component since Pause() will be called
  1752. // on actual tracks' AdjustClipTime() if necessary
  1753. if (m_pSourceInfo && !m_pSourceInfo->m_bIsPersistentSource)
  1754. {
  1755.     m_bDelayed = TRUE;
  1756.     AdjustClipBandwidthStats(FALSE);
  1757.     DoPause();
  1758. }
  1759.     }
  1761.     if (m_ulStartTime > 0) /* reduce duration by start time amount */
  1762.     {
  1763.      if (m_ulDuration > m_ulStartTime)
  1764.      {
  1765.     m_ulDuration -= m_ulStartTime;
  1766. }
  1767. else
  1768. {
  1769.     /* This is bad case. We consider it invalid */
  1770.     m_ulDuration = 0;
  1771. }
  1772.     }
  1774.     /* We now allow to increase the default duration of the clip */
  1775.     if (m_ulRestrictedDuration > 0)
  1776.     {
  1777. m_ulDuration = m_ulRestrictedDuration + m_ulDelay;
  1779. if (mLiveStream && !m_bRestrictedLiveStream)
  1780. {
  1781.     m_bRestrictedLiveStream = TRUE;
  1782.     m_ulEndTime = m_ulRestrictedDuration + m_ulStartTime;
  1783. }
  1785. if (m_ulEndTime > m_ulRestrictedDuration + m_ulStartTime)
  1786. {
  1787.     m_ulEndTime = m_ulRestrictedDuration + m_ulStartTime;
  1788. }
  1789.     }
  1791.     // orig duration is active duration for this source -- time for which
  1792.     // this source lasts.
  1793.     if (m_ulDuration > m_ulDelay)
  1794.     {
  1795. m_ulOriginalDuration = m_ulDuration - m_ulDelay;
  1796.     }
  1797.     else
  1798.     {
  1799. m_ulOriginalDuration = 0;
  1800.     }
  1802.     if (m_pURL     &&
  1803. rtspProtocol == m_pURL->GetProtocol()     &&
  1804. m_llLastExpectedPacketTime != m_ulEndTime   &&
  1805. !m_bFirstResume)
  1806.     {
  1807. m_bRTSPRuleFlagWorkAround = TRUE;
  1808.     }
  1809.     /* If we receive a packet after this stream, we consider the stream to be done */
  1810.     m_llLastExpectedPacketTime  = CAST_TO_INT64 m_ulEndTime;
  1812.     // Seek to the starting position only if the source
  1813.     // has not been resumed yet
  1814.     if (m_ulStartTime > 0 && m_bFirstResume) 
  1815.     {
  1816. /* We will add m_ulStartTime in DoSeek() call*/
  1817.      theErr = DoSeek(0);
  1818.     }
  1820.     /* Update stream durations if required */
  1821.     for (i = mStreamInfoTable->Begin(); i != mStreamInfoTable->End(); ++i) 
  1822.     {    
  1823. STREAM_INFO* pStreamInfo = (STREAM_INFO*) (*i);
  1824. if (m_ulStartTime > 0)
  1825. {
  1826.     pStreamInfo->m_pHeader->SetPropertyULONG32("TrackStartTime",
  1827.     m_ulStartTime);
  1828. }
  1831. if (m_ulEndTime > 0 && 
  1832.     !mLiveStream    &&
  1833.     HXR_OK != pStreamInfo->m_pHeader->GetPropertyULONG32("TrackEndTime",
  1834.   ulTrackEndTime))
  1835. {
  1836.     pStreamInfo->m_pHeader->SetPropertyULONG32("TrackEndTime",
  1837. m_ulEndTime);
  1838. }
  1840. if (ulOriginalDuration != m_ulDuration)
  1841. {
  1842.     pStreamInfo->m_ulDuration = m_ulDuration;
  1843.     pStreamInfo->m_pHeader->SetPropertyULONG32("Duration", 
  1844. pStreamInfo->m_ulDuration);
  1845. }
  1847. if (m_ulDelay > 0)
  1848. {
  1849.     pStreamInfo->m_pHeader->SetPropertyULONG32("Delay", m_ulDelay);
  1850. }
  1851.     }
  1853. //{FILE* f1 = ::fopen("d:\temp\url.txt", "a+"); ::fprintf(f1, "%p %s %lu %lun", this, m_pszURL, m_ulDelay, m_ulDuration);::fclose(f1);}
  1855. cleanup:
  1857.     m_bClipTimeAdjusted = TRUE;
  1859.     return theErr;
  1860. }
  1862. void
  1863. HXSource::GenerateFakeLostPacket(CHXEvent*& theEvent)
  1864. {
  1865.     IHXPacket* pPacket = theEvent->GetPacket();
  1866.     CHXPacket* pLostPacket = new CHXPacket;
  1867.     pLostPacket->AddRef();
  1868.     pLostPacket->Set(0, 0, pPacket->GetStreamNumber(), 0, 0);
  1869.     pLostPacket->SetAsLost();
  1871.     /* Create a new event with lost packet */
  1872.     CHXEvent* pEvent = new CHXEvent(pLostPacket);
  1873.     pEvent->SetTimeStartPos(theEvent->GetTimeStartPos());
  1874.     pEvent->SetTimeOffset(theEvent->GetTimeOffset());
  1875.     pEvent->SetPreSeekEvent(theEvent->IsPreSeekEvent());
  1876.     pLostPacket->Release();
  1878.     delete theEvent;
  1879.     theEvent = pEvent;
  1880. }
  1882. char*
  1883. HXSource::GetAltURL(BOOL& bDefault)
  1884. {
  1885. #if defined(HELIX_FEATURE_ALT_URL)
  1886.     char*   pAltURL = NULL;
  1888.     if (!m_pURL || m_bInitialized)
  1889.     {
  1890. goto cleanup;
  1891.     }
  1893.     pAltURL = m_pURL->GetAltURL(bDefault);
  1895. cleanup:
  1897.     return pAltURL;
  1898. #else
  1899.     return NULL;
  1900. #endif /* HELIX_FEATURE_ALT_URL */
  1901. }
  1903. HX_RESULT
  1904. HXSource::SetRequest(const CHXURL* pURL, BOOL bAltURL)
  1905. {
  1906.     HX_RESULT hr = HXR_OK;
  1907.     IHXValues* pValues = NULL;
  1908.     IHXValues* pValuesInRequest = NULL;
  1909.     IHXGroup* pGroup = NULL;
  1910.     IHXGroup2* pGroup2 = NULL;
  1911.     IHXGroupManager* pGroupManager = NULL;
  1913.     HX_RELEASE(m_pRequest);
  1915.     if (m_pPlayer)
  1916.     {
  1917. m_pPlayer->GetActiveRequest(m_pRequest);
  1919. if (m_pRequest)
  1920. {
  1921.     m_pPlayer->ResetActiveRequest();
  1922. }
  1923.     }
  1925. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  1926.     if (m_pPlayer && m_pSourceInfo)
  1927.     {
  1928. if (HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager, (void**)&pGroupManager))
  1929. {
  1930.     if (HXR_OK == pGroupManager->GetGroup(m_pSourceInfo->m_uGroupID, pGroup))
  1931.     {
  1932. if (HXR_OK == pGroup->QueryInterface(IID_IHXGroup2, (void**)&pGroup2))
  1933. {
  1934.     pGroup2->GetTrack2(m_pSourceInfo->m_uTrackID, pValues, pValuesInRequest);
  1935.     UINT32 ulValue = 0;
  1936.     char   szDuration[128] = {0}; /* Flawfinder: ignore */
  1937.     IHXBuffer* pBuffer = NULL;
  1938.     if (pValues && HXR_OK == pValues->GetPropertyULONG32("Duration", ulValue))
  1939.     {
  1940. if (!pValuesInRequest)
  1941. {
  1942.     pValuesInRequest = new CHXHeader();
  1943.     if( pValuesInRequest )
  1944.     {
  1945.         pValuesInRequest->AddRef();
  1946.     }
  1947.     else
  1948.     {
  1949.         hr = HXR_OUTOFMEMORY;
  1950.     }
  1951. }
  1952. if (pValuesInRequest)
  1953. {
  1954.     SafeSprintf (szDuration, 128, "%lu", ulValue); /* Flawfinder: ignore */
  1955.     pBuffer = new CHXBuffer();
  1956.     pBuffer->AddRef();
  1957.          pBuffer->Set((UCHAR*)szDuration, strlen(szDuration) + 1);
  1958.     pValuesInRequest->SetPropertyCString("Duration", pBuffer);
  1959.     HX_RELEASE(pBuffer);
  1960. }
  1961.     }
  1962. }
  1963. HX_RELEASE(pGroup2);
  1964.     }
  1965.     HX_RELEASE(pGroup);
  1966. }
  1967. HX_RELEASE(pGroupManager);
  1968.     }
  1969. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  1971.     IHXRegistry* pRegistry = NULL;   
  1972.     m_pEngine->QueryInterface(IID_IHXRegistry, (void**)&pRegistry);
  1974.     hr = ::SetRequest(pURL->GetEscapedURL(), bAltURL, m_pPreferences, pRegistry, pValuesInRequest, m_pRequest);
  1976.     HX_RELEASE(pValues);
  1977.     HX_RELEASE(pValuesInRequest);
  1978.     HX_RELEASE(pRegistry);
  1980. #if defined(HELIX_FEATURE_RECORDCONTROL)
  1981.     if(hr == HXR_OK && pURL->GetProtocol() != fileProtocol)
  1982.     {
  1983. if(!m_pRecordControl)
  1984. {
  1985.     m_pRecordControl = new HXRecordControl((IHXPlayer*)m_pPlayer, (IHXStreamSource*)this);
  1986.     if(m_pRecordControl)
  1987.     {
  1988. m_pRecordControl->AddRef();
  1989. if(m_pRecordControl->IsValid())
  1990.                     m_bPlayFromRecordControl = m_pRecordControl->CanGetPackets();
  1991.                 else
  1992.     HX_RELEASE(m_pRecordControl);
  1993.     }
  1994. }
  1996. if(m_pRecordControl)
  1997. {
  1998.     m_pRecordControl->SetSource((IHXStreamSource*)this);
  1999. }
  2000.     }
  2001. #endif /* HELIX_FEATURE_RECORDCONTROL */
  2003.     return hr;
  2004. }
  2006. void
  2007. HXSource::UpdateDuration(UINT32 ulDuration)
  2008. {
  2009.     CHXSimpleList* pRepeatList = m_pSourceInfo->GetRepeatList();
  2011.     // ulDuration excludes the delay time
  2012.     if (pRepeatList && 
  2013. ulDuration >= (m_ulDuration - m_ulDelay))
  2014.     {
  2015. m_pSourceInfo->m_ulTotalTrackDuration = ulDuration + m_ulDelay;
  2016. if (m_pSourceInfo->m_pPeerSourceInfo)
  2017. {
  2018.     m_pSourceInfo->m_pPeerSourceInfo->m_ulTotalTrackDuration = m_pSourceInfo->m_ulTotalTrackDuration;
  2019. }
  2020.     }
  2021.     else
  2022.     {
  2023. m_ulOriginalDuration = m_ulRestrictedDuration = ulDuration;
  2024. AdjustClipTime();
  2025. m_pSourceInfo->UpdateDuration(m_ulDuration);
  2026.     }
  2027. }
  2029. void
  2030. HXSource::UpdateDelay(UINT32 ulDelay)
  2031. {
  2032.     m_ulDelay = ulDelay;
  2033.     AdjustClipTime();
  2034.     m_pSourceInfo->UpdateDelay(m_ulDelay);
  2035. }
  2037. void
  2038. HXSource::InitialBufferingDone(void)
  2039. {
  2040.     m_bInitialBuffering = FALSE;
  2042.     // resume if we satisfy the initial preroll AND we have issued
  2043.     // rebuffer
  2044.     // note: IsRebufferRequired() should return FALSE!!
  2045.     if (m_bRebufferingRequired)
  2046.     {
  2047. m_bRebufferingRequired = IsRebufferRequired();
  2048. HX_ASSERT(!m_bRebufferingRequired);
  2049.     }
  2051.     return;
  2052. }
  2054. void
  2055. HXSource::DoRebuffer(void)
  2056. {
  2057.     m_bRebufferingRequired  = TRUE;
  2059.     if (m_pPlayer)
  2060.     {
  2061. m_pPlayer->InternalPause();     
  2062.         ReBuffer();
  2063.     }
  2065.     return;
  2066. }
  2068. BOOL
  2069. HXSource::IsRebufferRequired(void)
  2070. {
  2071.     BOOL     bResult = FALSE;
  2072.     STREAM_INFO*    pStreamInfo = NULL;
  2074.     // Check if all streams are doing OK
  2075.     for (CHXMapLongToObj::Iterator ndxStrm = mStreamInfoTable->Begin();
  2076.  ndxStrm != mStreamInfoTable->End(); ++ndxStrm) 
  2077.     {    
  2078. pStreamInfo = (STREAM_INFO*) (*ndxStrm);
  2080. if (pStreamInfo->m_unNeeded > pStreamInfo->m_unAvailable)
  2081. {
  2082.     bResult = TRUE;
  2083.     break;
  2084. }
  2085.     }
  2087.     return bResult;
  2088. }
  2090. BOOL
  2091. HXSource::IsRebufferDone(void)
  2092. {
  2093.     BOOL    bResult = TRUE;
  2095.     if (m_pSourceInfo)
  2096.     {
  2097. bResult = m_pSourceInfo->IsRebufferDone();
  2098.     }
  2100.     return bResult;
  2101. }
  2103. void
  2104. HXSource::ScheduleProcessCallback()
  2105. {
  2106.     if (m_pSourceInfo)
  2107.     {
  2108.         m_pSourceInfo->ScheduleProcessCallback();
  2109.     }
  2110. }
  2112. #if defined(HELIX_FEATURE_HYPER_NAVIGATE)
  2113. /************************************************************************
  2114.  * Method:
  2115.  *     IHXHyperNavigate::GoToURL
  2116.  * Purpose:
  2117.  *     Acts as a proxy for actual hypernavigate interface.
  2118.  *     Is used to convert any relative URLs to absolute URLs
  2119.  */
  2120. STDMETHODIMP 
  2121. HXSource::GoToURL(const char* pURL, const char* pTarget)
  2122. {
  2123.     return Execute(pURL, pTarget, NULL, NULL, NULL);
  2124. }
  2126. /************************************************************************
  2127.  * Method:
  2128.  *     IHXHyperNavigate2::Execute
  2129.  * Purpose:
  2130.  *     
  2131.  * Parameters:
  2132.  *      pURL:     URL (absolute or relative)
  2133.  *     pTargetInstance:
  2134.  *     pTargetApplication: 
  2135.  *     pTargetRegion:
  2136.  *     pParams:
  2137.  */
  2138. STDMETHODIMP 
  2139. HXSource::Execute(const char* pURL,
  2140.    const char* pTargetInstance,
  2141.    const char* pTargetApplication,
  2142.    const char* pTargetRegion,
  2143.    IHXValues* pParams)
  2144. {
  2145.     HX_RESULT theErr = HXR_OK;
  2146.     CHXString newURL = pURL;
  2148. //    pURL = "rogers.rt";
  2150. //    if (pTargetInstance && 
  2151. // stricmp(pTargetInstance, "_player") == 0 &&
  2152.     if (ShouldConvert(pTargetInstance) && 
  2153. pURL  &&
  2154. strnicmp(pURL, URL_COMMAND, sizeof(URL_COMMAND) - 1) != 0 )
  2155.     {
  2156. CHXURL urlObj(pURL);
  2157. IHXValues* pHeader = urlObj.GetProperties();
  2158. IHXBuffer* pBuffer = NULL;
  2160. if(pHeader && 
  2161.    m_pszURL &&
  2162.    HXR_OK != pHeader->GetPropertyBuffer(PROPERTY_SCHEME, pBuffer))
  2163. {
  2164.     // relative URL
  2165.     // if it starts with '/', make it relative to the root of 
  2166.     // the URL prefix
  2168.     CHXString urlPrefix, urlRoot;
  2169.     char* pURLFragment = NULL;
  2170.     theErr = CHXURL::GeneratePrefixRootFragment(m_pszURL, urlPrefix, urlRoot, pURLFragment);
  2171.     HX_VECTOR_DELETE(pURLFragment);
  2173.     if (!theErr)
  2174.     {
  2175. if(*pURL == '/')
  2176. {
  2177.     newURL = urlRoot + pURL;
  2178. }
  2179. else
  2180. {
  2181.     newURL = urlPrefix + pURL;
  2182. }
  2183.     }
  2184. }
  2185. HX_RELEASE(pBuffer);
  2186. HX_RELEASE(pHeader);
  2187.     }
  2188.     
  2189.     AddRef();
  2191.     HX_ASSERT(m_pPlayer && m_pPlayer->m_pHyperNavigate);
  2192.     if (m_pPlayer && m_pPlayer->m_pHyperNavigate)
  2193.     {
  2194. theErr = m_pPlayer->m_pHyperNavigate->ExecuteWithContext(newURL, 
  2195. pTargetInstance, pTargetApplication, pTargetRegion, 
  2196. pParams, (IUnknown*) (IHXStreamSource*) this);
  2197.     }
  2199.     Release();
  2201.     return theErr;
  2202. }
  2203. #endif /* defined(HELIX_FEATURE_HYPER_NAVIGATE) */
  2205. STDMETHODIMP
  2206. HXSource::GetTotalBuffering(UINT16  uStreamNumber,
  2207.     REF(INT64)  llLowestTimestamp, 
  2208.     REF(INT64)  llHighestTimestamp,
  2209.     REF(UINT32) ulNumBytes,
  2210.     REF(BOOL)   bDone)
  2211. {
  2212.     HX_RESULT res = HXR_NO_DATA;
  2213.     
  2214.     llLowestTimestamp = 0;
  2215.     llHighestTimestamp = 0;
  2216.     ulNumBytes = 0;
  2217.     bDone = FALSE;
  2219.     STREAM_INFO* pStreamInfo;
  2220.     if (mStreamInfoTable->Lookup((LONG32) uStreamNumber, (void*& )pStreamInfo))
  2221.     {
  2222. HXBufferingState& bufState = pStreamInfo->BufferingState();
  2223. BOOL   bUseTransportStats = FALSE;
  2225. INT64  llTransportLowTS = 0;
  2226. INT64  llTransportHighTS = 0;
  2227. UINT32 ulTransportBytes = 0;
  2228. BOOL   bTransportDone = FALSE;
  2230. if (!IsLocalSource() &&
  2231.     (HXR_OK == GetCurrentBuffering(uStreamNumber,
  2232.    llTransportLowTS,
  2233.    llTransportHighTS,
  2234.    ulTransportBytes,
  2235.    bTransportDone)))
  2236. {
  2237.     bufState.UpdateTransportStats(llTransportLowTS,
  2238.   llTransportHighTS,
  2239.   ulTransportBytes,
  2240.   bTransportDone);
  2242.     bUseTransportStats = TRUE;
  2244.     // Update bDone with what the transport says.
  2245.     bDone = bTransportDone;
  2246. }
  2248. res = bufState.GetBufferingStats(llLowestTimestamp,
  2249.  llHighestTimestamp,
  2250.  ulNumBytes,
  2251.  bUseTransportStats);
  2252.     }
  2255.     return res;
  2256. }
  2258. /* 
  2259.  * All relative URLs are converted to absolute URLs unless the 
  2260.  * original request (ram/smil) passed in OpenRequest/OpenURL()
  2261.  * is a mem: URL AND the target is not _player.
  2262.  *
  2263.  * This fixes relative URLs being hurled to the browser using events
  2264.  * come from the same location as the .ram file. (Broadcase usage case)
  2265.  * PR 31352
  2266.  *
  2267.  * This also fixes content on CD-ROMs where relative URLs being hurled 
  2268.  * to the browser using events come from the same location as 
  2269.  * the .rm file in which they are merged. 
  2270.  * PR 23489
  2271.  */
  2272. BOOL HXSource::ShouldConvert(const char* pTargetInstance)
  2273. {
  2274.     if (pTargetInstance && 
  2275. stricmp(pTargetInstance, "_player") == 0)
  2276.     {
  2277. return TRUE;
  2278.     }
  2279.     
  2280.     const char* pPlayerURL = NULL;
  2281.     IHXRequest* pPlayerRequest = NULL;
  2282.     if (m_pPlayer)
  2283.     {
  2284. m_pPlayer->GetRequest(pPlayerRequest);
  2285. if (pPlayerRequest)
  2286. {
  2287.     pPlayerRequest->GetURL(pPlayerURL);
  2288. }
  2289.     }
  2290.     HX_RELEASE(pPlayerRequest);
  2292.     if (pPlayerURL && ::strncasecmp(pPlayerURL, "mem:", 4) == 0)
  2293.     {
  2294. return FALSE;
  2295.     }
  2297.     return TRUE;
  2298. }
  2300. void
  2301. HXSource::MergeUpgradeRequest(BOOL bAddDefault /*= FALSE*/, char* pUpgradeString /* = NULL*/)
  2302. {
  2303. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  2304.     if (m_pPlayer && 
  2305. bAddDefault && 
  2306. (!m_pUpgradeCollection || m_pUpgradeCollection->GetCount() == 0))
  2307.     {
  2308. if (!m_pUpgradeCollection)
  2309. {
  2310.     m_pUpgradeCollection = new HXUpgradeCollection;
  2311. }
  2313. if (!pUpgradeString)
  2314. {
  2315.     pUpgradeString = "Missing Component";
  2316. }
  2318. IHXBuffer* pPluginID = (IHXBuffer*) new CHXBuffer;
  2319. pPluginID->AddRef();
  2320. pPluginID->Set((const UINT8*)pUpgradeString, strlen(pUpgradeString) + 1);
  2321. m_pUpgradeCollection->Add(eUT_Required, pPluginID, 0, 0);
  2322. pPluginID->Release();
  2323.     }
  2325.     if (m_pPlayer && m_pUpgradeCollection && m_pUpgradeCollection->GetCount() > 0)
  2326.     {
  2327. UINT32 ulCount = m_pUpgradeCollection->GetCount();
  2328. IHXUpgradeCollection* pPlayerUpgrade;
  2329. m_pPlayer->QueryInterface(IID_IHXUpgradeCollection, (void**) &pPlayerUpgrade);
  2330. for (UINT32 i = 0; i < ulCount; i++)
  2331. {
  2332.     HXUpgradeType upgradeType;
  2333.     IHXBuffer* pPluginId = (IHXBuffer*) new CHXBuffer;
  2334.     UINT32 majorVersion;
  2335.     UINT32 minorVersion;
  2336.     pPluginId->AddRef(); 
  2337.     // GetAt is a non-COM like API. It expects pPluginID to be allocated by the user
  2338.     // and does not perform an addref either!
  2339.     m_pUpgradeCollection->GetAt(i, upgradeType, pPluginId, majorVersion, minorVersion);
  2340.     pPlayerUpgrade->Add(upgradeType, pPluginId, majorVersion, minorVersion);
  2341.     pPluginId->Release();
  2342. }
  2344. pPlayerUpgrade->Release();
  2345. m_pUpgradeCollection->RemoveAll();
  2346.     }
  2347. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  2348. }
  2350. void
  2351. HXSource::ClearUpgradeRequest()
  2352. {
  2353. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  2354.     if (m_pUpgradeCollection)
  2355.     {
  2356. m_pUpgradeCollection->RemoveAll();
  2357.     }
  2358. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  2359. }
  2361. void
  2362. HXSource::EnterPrefetch(PrefetchType prefetchType, UINT32 ulPrefetchValue)
  2363. {
  2364.     m_bPrefetch = TRUE;
  2365.     m_prefetchType = prefetchType;
  2366.     m_ulPrefetchValue = ulPrefetchValue;
  2368.     return;
  2369. }
  2371. void
  2372. HXSource::LeavePrefetch(void)
  2373. {
  2374.     m_bPrefetch = FALSE;
  2376.     // send prefetch notification so that SMIL
  2377.     // renderer can resolve the duration on this prefetch track
  2378.     if (m_pSourceInfo)
  2379.     {
  2380. m_pPlayer->PrefetchTrackDone(m_pSourceInfo->m_uGroupID, 
  2381.           m_pSourceInfo->m_uTrackID, 
  2382.      HXR_OK);
  2383.     }
  2385.     return;
  2386. }
  2388. void
  2389. HXSource::SetSoundLevel(UINT16 uSoundLevel, BOOL bReflushAudioDevice)
  2390. {
  2391. #if defined(HELIX_FEATURE_SMIL_SOUNDLEVEL)
  2392.     CHXAudioPlayer* pAudioPlayer = NULL;
  2393.     CHXAudioStream* pCHXAudioStream = NULL;
  2394.     CHXSimpleList*  pAudioStreamList = NULL;
  2396.     if (!m_pPlayer)
  2397.     {
  2398. goto cleanup;
  2399.     }
  2401.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  2402.     if (!pAudioPlayer)
  2403.     {
  2404. goto cleanup;
  2405.     }
  2407.     pAudioPlayer->AddRef();
  2409.     if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
  2410.     {
  2411. pAudioPlayer->SetSoundLevel(pAudioStreamList, uSoundLevel, bReflushAudioDevice);
  2413. ReleaseAudioStreams(pAudioStreamList);
  2414. HX_DELETE(pAudioStreamList);
  2415.     }
  2417.     HX_RELEASE(pAudioPlayer);
  2419. cleanup:
  2420. #endif /* HELIX_FEATURE_SMIL_SOUNDLEVEL */
  2422.     return;
  2423. }
  2425. void
  2426. HXSource::SetAudioDeviceReflushHint(void)
  2427. {
  2428. #if defined(HELIX_FEATURE_SOUNDLEVEL)
  2429.     CHXAudioPlayer* pAudioPlayer = NULL;
  2430.     CHXSimpleList*  pAudioStreamList = NULL;
  2432.     if (!m_pPlayer)
  2433.     {
  2434. goto cleanup;
  2435.     }
  2437.     pAudioPlayer = m_pPlayer->GetAudioPlayer();
  2438.     if (!pAudioPlayer)
  2439.     {
  2440. goto cleanup;
  2441.     }
  2443.     pAudioPlayer->AddRef();
  2445.     if (HXR_OK == CollectAudioStreams(pAudioStreamList) && pAudioStreamList)
  2446.     {
  2447. pAudioPlayer->ManageAudioStreams(pAudioStreamList, CHXAudioPlayer::STR_SETHINT);
  2449. ReleaseAudioStreams(pAudioStreamList);
  2450. HX_DELETE(pAudioStreamList);
  2451.     }
  2453.     HX_RELEASE(pAudioPlayer);
  2455. cleanup:
  2456. #endif /* HELIX_FEATURE_SOUNDLEVEL */
  2458.     return;
  2459. }
  2461. void
  2462. HXSource::LeaveFastStart(TurboPlayOffReason leftReason)
  2463. {
  2464.     m_turboPlayStats.tpOffReason = leftReason;
  2465.     m_bFastStart = FALSE;
  2466. }
  2468. void
  2469. HXSource::DeleteAllEvents()
  2470. {
  2471.     if (m_PacketBufferList.GetCount() > 0)
  2472.     {
  2473. LISTPOSITION pos = m_PacketBufferList.GetHeadPosition();
  2474. while (pos != NULL)
  2475. {
  2476.     CHXEvent* pTempEvent  = (CHXEvent*) m_PacketBufferList.GetNext(pos);
  2477.     delete pTempEvent;
  2478. }
  2480. m_PacketBufferList.RemoveAll();
  2481.     }
  2482. }
  2484. void
  2485. HXSource::SetMinimumPreroll(ULONG32 ulMinimumAudioPreroll, ULONG32 ulMinimumStartingPreroll)
  2486. {
  2487.     UINT32 ulTotalMinimumPreroll = 0;
  2489.     if (m_pPlayer)
  2490.     {
  2491. // get the user-set minimum preroll
  2492. m_pPlayer->GetMinimumPreroll(ulTotalMinimumPreroll);
  2493.     }
  2495.     if (IsAnyAudioStream())
  2496.     {
  2497. m_ulPreRollInMs += ulMinimumAudioPreroll;
  2498.     }
  2500.     if (m_ulPreRollInMs < ulTotalMinimumPreroll)
  2501.     {
  2502. m_ulPreRollInMs = ulTotalMinimumPreroll;
  2503.     }
  2505.     DEBUG_OUT(m_pPlayer, DOL_TRANSPORT, (s, "(%p)Preroll: %lu MinPreroll %lu MinAudioPreroll %lu", this, m_ulPreRollInMs, ulTotalMinimumPreroll, ulMinimumStartingPreroll));
  2507.     m_pBufferManager->SetMinimumPreroll(IsLocalSource() | m_bPerfectPlay,
  2508. ulTotalMinimumPreroll,
  2509. ulMinimumStartingPreroll);
  2510. }
  2512. HX_RESULT
  2513. HXSource::SendHeaderToRecordControl(BOOL bFileHeader, IHXValues* pHeader)
  2514. {
  2515. #if defined(HELIX_FEATURE_RECORDCONTROL)
  2516.     HX_RESULT nResult = HXR_OK;
  2518.     if(m_pRecordControl && pHeader)
  2519.     {
  2520. if(bFileHeader)
  2521.     nResult = m_pRecordControl->OnFileHeader(pHeader);
  2522. else
  2523.     nResult = m_pRecordControl->OnStreamHeader(pHeader);
  2525. if(nResult != HXR_OK)
  2526. {
  2527.     m_bPlayFromRecordControl = FALSE;
  2528.     if(nResult != HXR_RECORD)
  2529. HX_RELEASE(m_pRecordControl);
  2530. }
  2531.     }
  2532.     return nResult;
  2533. #else
  2534.     return HXR_NOTIMPL;
  2535. #endif /* HELIX_FEATURE_RECORDCONTROL */
  2536. }
  2538. void
  2539. HXSource::ProcessFileHeader(void)
  2540. {
  2541.     UINT32      bNonSeekAble = 0;
  2542.     IHXBuffer*  pTitle = NULL;
  2543.     IHXBuffer*  pAuthor = NULL;
  2544.     IHXBuffer*  pCopyright = NULL;
  2545.     IHXBuffer*  pAbstract = NULL;
  2546.     IHXBuffer*  pDescription = NULL;
  2547.     IHXBuffer*  pKeywords = NULL;
  2548.     IHXValues*  pValues = NULL;
  2550.     if (m_pURL)
  2551.     {
  2552. pValues = m_pURL->GetOptions();
  2553.     }
  2555.     // retrieve the TAC from the URL
  2556.     if (pValues)
  2557.     {
  2558. pValues->GetPropertyBuffer("Title", pTitle);
  2559.         pValues->GetPropertyBuffer("Author", pAuthor);
  2560.         pValues->GetPropertyBuffer("Copyright", pCopyright);
  2561.         pValues->GetPropertyBuffer("Abstract", pAbstract);
  2562.         pValues->GetPropertyBuffer("Description", pDescription);
  2563.         pValues->GetPropertyBuffer("Keywords", pKeywords);
  2565. //#define LOSS_HACK
  2566. #ifdef LOSS_HACK
  2567. UINT32 ulLoss = 0;
  2568. if (HXR_OK == pValues->GetPropertyULONG32("Loss", ulLoss))
  2569. {
  2570.     m_ulLossHack = ulLoss;
  2571.     /* Initialize random number generator */
  2572.     ::srand((unsigned int) HX_GET_TICKCOUNT());
  2573. }
  2574. #endif /*LOSS_HACK*/
  2575.     }
  2577.     if (m_pFileHeader)
  2578.     {
  2579.         if (!pTitle)     m_pFileHeader->GetPropertyBuffer("Title", pTitle);
  2580.         if (!pAuthor)     m_pFileHeader->GetPropertyBuffer("Author", pAuthor);
  2581.         if (!pCopyright)    m_pFileHeader->GetPropertyBuffer("Copyright", pCopyright);
  2582.         if (!pDescription)  m_pFileHeader->GetPropertyCString("Description", pDescription);
  2583.         if (!pAbstract)     m_pFileHeader->GetPropertyCString("Abstract", pAbstract);
  2584.         if (!pKeywords)     m_pFileHeader->GetPropertyCString("Keywords", pKeywords);
  2586.         m_pFileHeader->GetPropertyULONG32("NonSeekable", bNonSeekAble);
  2587. m_bNonSeekable = bNonSeekAble ? TRUE : FALSE;
  2588.         
  2589.         m_pFileHeader->GetPropertyULONG32("StreamCount",m_ulStreamHeadersExpected);
  2590.             
  2591.         HX_ASSERT(mStreamInfoTable->IsEmpty() == TRUE);
  2592.         if (mStreamInfoTable->IsEmpty() && m_ulStreamHeadersExpected > 0 &&
  2593.             m_ulStreamHeadersExpected < mStreamInfoTable->GetHashTableSize())
  2594.         {
  2595.             mStreamInfoTable->InitHashTable(m_ulStreamHeadersExpected);
  2596.         }
  2597.     }
  2599. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  2600.     if (m_pStats)
  2601.     {
  2602.         if (pTitle && m_pStats->m_pTitle)
  2603.         {
  2604.     m_pStats->m_pTitle->SetStr((char*)(pTitle->GetBuffer()));
  2605.         }
  2607.         if (pAuthor && m_pStats->m_pAuthor)
  2608.         {
  2609.     m_pStats->m_pAuthor->SetStr((char*)(pAuthor->GetBuffer()));
  2610.         }
  2612.         if (pCopyright && m_pStats->m_pCopyright)
  2613.         {
  2614.     m_pStats->m_pCopyright->SetStr((char*)(pCopyright->GetBuffer()));
  2615.         }
  2617.         if (pAbstract && m_pStats->m_pAbstract)
  2618.         {
  2619.     m_pStats->m_pAbstract->SetStr((char*)(pAbstract->GetBuffer()));
  2620.         }
  2621.     
  2622.         if (pDescription && m_pStats->m_pDescription)
  2623.         {
  2624.             m_pStats->m_pDescription->SetStr((char*)(pDescription->GetBuffer()));
  2625.         }
  2627.         if (pKeywords && m_pStats->m_pKeywords)
  2628.         {
  2629.     m_pStats->m_pKeywords->SetStr((char*)(pKeywords->GetBuffer()));
  2630.         }
  2631.     }
  2633.     CopyMetaDataToRegistry(m_pFileHeader);
  2634. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  2636.     m_bReceivedHeader = TRUE;
  2638.     HX_RELEASE(pTitle);
  2639.     HX_RELEASE(pAuthor);
  2640.     HX_RELEASE(pCopyright);
  2641.     HX_RELEASE(pAbstract);
  2642.     HX_RELEASE(pDescription);
  2643.     HX_RELEASE(pKeywords);
  2644.     HX_RELEASE(pValues);
  2646.     return;
  2647. }
  2649. static BOOL GetHeaderBOOL(IHXValues* pHeader, const char* pKey)
  2650. {
  2651.     BOOL bRet = FALSE;
  2653.     ULONG32 ulTemp = 0;
  2654.     if ((HXR_OK == pHeader->GetPropertyULONG32(pKey, ulTemp)) && ulTemp)
  2655.     {
  2656. bRet = TRUE;
  2657.     }
  2659.     return bRet;
  2660. }
  2662. HX_RESULT
  2663. HXSource::ProcessStreamHeaders(IHXValues* pHeader, STREAM_INFO*& pStreamInfo)
  2664. {
  2665.     HX_RESULT       rc = HXR_OK;
  2666.     UINT32          ulStreamNumber = 0;
  2667.     UINT32          ulAvgBitRate = 0;
  2668.     UINT32          ulAvgPacketSize = 0;
  2669.     UINT32          ulPreroll = 0;
  2670.     ULONG32         ulPredata = 0;
  2671.     UINT32          ulDuration = 0;
  2672.     UINT32          ulTemp = 0;
  2673.     void*           lTmp = NULL;
  2675.     pStreamInfo = NULL;
  2677.     if (!pHeader)
  2678.     {
  2679.         rc = HX_INVALID_HEADER;
  2680.         goto cleanup;
  2681.     }
  2683.     // Use file header for default duration
  2684.     if (m_pFileHeader)
  2685.     {
  2686.         m_pFileHeader->GetPropertyULONG32("Duration", ulDuration);
  2687.         if (!m_ulDuration && ulDuration)
  2688.         {
  2689.             m_ulDuration = ulDuration;
  2690.             ulDuration = 0;
  2691.         }
  2692.     }
  2694.     pHeader->GetPropertyULONG32("StreamNumber",     ulStreamNumber);
  2695.     pHeader->GetPropertyULONG32("AvgBitRate",     ulAvgBitRate);
  2696.     pHeader->GetPropertyULONG32("AvgPacketSize",    ulAvgPacketSize);
  2697.     pHeader->GetPropertyULONG32("Preroll",     ulPreroll);
  2698.     pHeader->GetPropertyULONG32("Predata",          ulPredata);
  2699.     pHeader->GetPropertyULONG32("Duration",     ulDuration);
  2701.     if (mStreamInfoTable->Lookup((LONG32) ulStreamNumber, (void *&) lTmp))
  2702.     {
  2703. // a header with this stream number already exists..
  2704.         rc = HX_INVALID_HEADER;
  2705.         goto cleanup;
  2706.     }
  2708.     // max preroll
  2709.     if (m_ulPreRollInMs < ulPreroll)
  2710.     {
  2711. m_ulPreRollInMs = ulPreroll;
  2712.     }
  2714.     m_ulAvgBandwidth   += ulAvgBitRate;
  2716.     // max duration...
  2717.     if (m_ulDuration < ulDuration)
  2718.     {
  2719. m_ulDuration = ulDuration;
  2720.     }
  2722.     pStreamInfo = new STREAM_INFO;
  2723.     if (!pStreamInfo)
  2724.     {
  2725. rc = HXR_OUTOFMEMORY;
  2726.         goto cleanup;
  2727.     }
  2729.     pStreamInfo->m_pHeader                  = pHeader;
  2730.     pStreamInfo->m_pHeader->AddRef();
  2732.     pStreamInfo->m_bCustomEndTime           = FALSE;
  2733.     pStreamInfo->m_bSrcStreamDone           = FALSE;
  2734.     pStreamInfo->m_bSrcStreamFillingDone    = FALSE;
  2735.     pStreamInfo->m_bPacketRequested         = FALSE;
  2736.     
  2737.     pStreamInfo->m_uStreamNumber = (UINT16) ulStreamNumber;
  2739.     pStreamInfo->m_ulDuration = ulDuration;
  2741.     pStreamInfo->BufferingState().OnStreamHeader(
  2742. ulPreroll,
  2743. ulPredata,
  2744. GetHeaderBOOL(pHeader, "PreDataAtStart"),
  2745. GetHeaderBOOL(pHeader, "PreDataAfterSeek"),
  2746. GetHeaderBOOL(pHeader, "PrerollAtStart"),
  2747. GetHeaderBOOL(pHeader, "PrerollAfterSeek"),
  2748. ulAvgBitRate);
  2751.     mStreamInfoTable->SetAt(ulStreamNumber, (void *) pStreamInfo);
  2753. cleanup:
  2755.     return rc;
  2756. }
  2758. HX_RESULT HXSource::OnTimeSync(ULONG32 ulCurrentTime)
  2759. {
  2760.     HX_RESULT res = HXR_OK;
  2762.     for (CHXMapLongToObj::Iterator i = mStreamInfoTable->Begin();
  2763.          i != mStreamInfoTable->End(); ++i) 
  2764.     {    
  2765. STREAM_INFO* pStreamInfo = (STREAM_INFO*) (*i);
  2767. pStreamInfo->BufferingState().OnTimeSync(ulCurrentTime);
  2768.     }
  2770.     return res;
  2771. }