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

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

Symbian

开发平台：

C/C++

buffmgr.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 "hlxclib/stdio.h"
  38. #include "hxcom.h"
  39. #include "hxcomm.h"
  40. #include "ihxpckts.h"
  41. #include "hxslist.h"
  42. #include "hxtick.h"
  43. #include "hxcore.h"
  44. #include "chxeven.h"
  45. #include "hxbsrc.h"
  46. #include "hxsrc.h"
  47. #include "hxntsrc.h"
  48. #include "hxstrm.h"
  49. #include "strminfo.h"
  50. #include "buffmgr.h"
  51. #include "hxsmbw.h"
  53. #include "hxgroup.h"
  54. #include "hxplay.h"
  55. #include "errdbg.h"
  57. #include "hxheap.h"
  58. #ifdef _DEBUG
  59. #undef HX_THIS_FILE
  60. static const char HX_THIS_FILE[] = __FILE__;
  61. #endif
  63. #if defined(__TCS__)
  64. #define MAX_ADDITIONAL_BUFFERING    3000
  65. #else
  66. #define MAX_ADDITIONAL_BUFFERING    10000
  67. #endif /* __TCS__ */
  69. CBufferManager::CBufferManager(HXSource* pParent)
  70. {
  71.     m_ulMaxAdditionalBufferingInMs  = MAX_ADDITIONAL_BUFFERING;
  73.     m_llHighestTimeStamp = 0;
  74.     m_ulTotalPauseTime = 0;
  75.     m_ulLastPauseTime = 0;
  76.     m_ulAdditionalBufferingInMs = 0;
  77.     m_bBufferStartTimeToBeSet = TRUE;
  79.     m_ulMinimumInitialAudioPreroll = 0;
  80.     m_ulMinimumSourcePreroll = 0;
  82.     m_bPerfectPlay = FALSE;     
  83.     m_bPaused = FALSE;
  84.     m_state = BUFFMGR_READY;
  86.     m_pParent = pParent;
  87.     m_pParent->AddRef();
  89.     m_bLocalPlayback = pParent->IsLocalSource();
  90.     m_pStreamInfoTable = pParent->GetStreamInfoTable();
  91.     m_bFirstResumeDone = FALSE;
  92.     m_bIsSeekPerformed = FALSE;
  93.     m_bBufferedPlay = FALSE;
  94.     m_bBufferCalcToBeChanged = FALSE;
  95.     m_bIsInitialized = FALSE;
  96.     m_ulSeekTime = 0;
  97. }
  99. CBufferManager::~CBufferManager()
  100. {
  101.     HX_RELEASE(m_pParent);
  102. }
  104. HX_RESULT
  105. CBufferManager::Init()
  106. {
  107.     UINT32     ulPerfectPlayTime = 0;
  108.     UINT32     ulMinimumPreroll = 0;
  109.     STREAM_INFO*    pStreamInfo = NULL;
  111.     CHXMapLongToObj::Iterator i;
  113.     // There is no buffered or perfect play with MIN_HEAP on.
  114. #if !defined(HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES)
  115.     SetPerfectPlay(m_pParent->IsPerfectPlay());
  117.     if (m_bPerfectPlay || m_bBufferedPlay)
  118.     {
  119. // caculate how much extra preroll for the perfect play
  120. ulPerfectPlayTime = m_pParent->GetPerfectPlayTime();
  121.     }
  122. #endif
  124.     // ajust buffering information of each stream
  125.     for (i = m_pStreamInfoTable->Begin(); i != m_pStreamInfoTable->End(); ++i)
  126.     {
  127. pStreamInfo = (STREAM_INFO*) (*i);
  129. pStreamInfo->BufferingState().Init(ulPerfectPlayTime);
  131. HX_ASSERT(pStreamInfo->m_EventList.GetHeadPosition() == NULL);
  132.     }
  134.     m_bIsInitialized = TRUE;
  136.     /* Was there a Seek called before Initialization... may happen for a clip
  137.      * with Start time
  138.      */
  139.     if (m_bIsSeekPerformed)
  140.     {
  141. DoSeek(m_ulSeekTime);
  142.     }
  144.     return HXR_OK;
  145. }
  147. HX_RESULT
  148. CBufferManager::SetMinimumPreroll(BOOL bPerfectPlay, UINT32 ulSourcePreroll, 
  149.   UINT32 ulInitialAudioPreroll,
  150.   BOOL  bModifyStartTime /* = TRUE */)
  151. {
  152.     m_ulMinimumInitialAudioPreroll = ulInitialAudioPreroll;
  153.     m_ulMinimumSourcePreroll    = ulSourcePreroll;
  155.     SetPerfectPlay(bPerfectPlay);
  157.     UpdateMinimumPreroll(bModifyStartTime);
  159.     return HXR_OK;
  160. }
  162. void 
  163. CBufferManager::UpdateMinimumPreroll(BOOL bModifyStartTime)
  164. {
  165.     UINT32     ulMinimumPreroll = 0;
  166.     UINT32     ulPerfectPlayTime = 0;
  167.     UINT32     ulStartTime = 0;
  168.     UINT32     ulEventStartTime = 0;
  169.     UINT32     ulPacketTime     = 0;
  170.     STREAM_INFO*    pStreamInfo = NULL;
  171.     BOOL     bPreDataToBeCalculated = FALSE;
  173.     CHXMapLongToObj::Iterator i;
  175.     // There is no buffered or perfect play with MIN_HEAP on.
  176. #if !defined(HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES)
  178.     if (m_bPerfectPlay || m_bBufferedPlay)
  179.     {
  180. m_ulMaxAdditionalBufferingInMs = 0;
  181. // caculate how much extra preroll for the perfect play
  182. ulPerfectPlayTime = m_pParent->GetPerfectPlayTime();
  183.     }
  184.     else
  185.     {
  186. m_ulMaxAdditionalBufferingInMs = MAX_ADDITIONAL_BUFFERING;
  188. if (m_ulAdditionalBufferingInMs > m_ulMaxAdditionalBufferingInMs)
  189. {
  190.     m_ulAdditionalBufferingInMs = m_ulMaxAdditionalBufferingInMs;
  191. }
  193. ulPerfectPlayTime = m_ulAdditionalBufferingInMs;
  194.     }
  195. #endif
  197.     ulStartTime = m_pParent->GetStartTime();
  199.     // adjust buffering information of each stream
  200.     for (i = m_pStreamInfoTable->Begin(); i != m_pStreamInfoTable->End(); ++i)
  201.     {
  202. pStreamInfo = (STREAM_INFO*) (*i);
  203.     
  204. pStreamInfo->BufferingState().SetMinimumPreroll(
  205.     m_ulMinimumSourcePreroll, 
  206.     m_ulMinimumInitialAudioPreroll,
  207.     ulPerfectPlayTime,
  208.     (m_state == BUFFMGR_REBUFFER));
  210. if (bModifyStartTime)
  211. {
  212.     pStreamInfo->UpdateStartTimes(ulStartTime);
  213. }
  214.     }
  216.     m_bBufferCalcToBeChanged = FALSE;
  217. }
  219. HX_RESULT
  220. CBufferManager::Stop(void)
  221. {
  222.     STREAM_INFO*    pStreamInfo = NULL;
  224.     CHXMapLongToObj::Iterator i;
  226.     // stop buffering of each stream
  227.     for (i = m_pStreamInfoTable->Begin(); i != m_pStreamInfoTable->End(); ++i)
  228.     {
  229. pStreamInfo = (STREAM_INFO*) (*i);
  230.     
  231. pStreamInfo->BufferingState().Stop();
  232. // DEBUG_OUT(m_pParent->m_pPlayer, (s,
  233. //     "BufferManager::Stop %p", pStreamInfo));
  234.     }
  236.     return HXR_OK;
  237. }
  239. HX_RESULT
  240. CBufferManager::DoSeek(UINT32 ulSeekTime, BOOL bSeekInsideRecordBuffer)
  241. {
  242.     m_state = BUFFMGR_SEEK;
  243.     m_bIsSeekPerformed = TRUE;
  244.     m_ulSeekTime = ulSeekTime;
  246.     /* We will call Reset during Init() call */
  247.     if (!m_bIsInitialized)
  248.     {
  249. return HXR_OK;
  250.     }
  252.     // reset all the preroll attributes
  253.     Reset(ulSeekTime, bSeekInsideRecordBuffer);
  255.     return HXR_OK;
  256. }
  258. HX_RESULT
  259. CBufferManager::DoPause(void)
  260. {
  261.     m_bPaused = TRUE;
  262.     m_ulLastPauseTime = HX_GET_TICKCOUNT();
  263.     return HXR_OK;
  264. }
  266. HX_RESULT
  267. CBufferManager::DoResume(void)
  268. {
  269.     if (m_bPaused && m_state != BUFFMGR_SEEK && !m_bBufferStartTimeToBeSet)
  270.     {
  271. m_ulTotalPauseTime += CALCULATE_ELAPSED_TICKS(m_ulLastPauseTime, HX_GET_TICKCOUNT());
  272.     }
  274.     m_bPaused = FALSE;
  276.     if (!m_bFirstResumeDone)
  277.     {
  278. m_bFirstResumeDone = TRUE;
  280. UpdateMinimumPreroll(FALSE);
  281.     }
  283.     return HXR_OK;
  284. }
  286. HX_RESULT
  287. CBufferManager::ReBuffer(void)
  288. {
  289.     // recaculate only if it is out of the buffering stage
  290.     // and not in perfect play mode
  291.     m_state = BUFFMGR_REBUFFER;
  292.     
  293.     /* go back in buffering mode...
  294.      * each time we come in buffering state, increase the
  295.      * number of packets we buffer by 1 second worth
  296.      * to a max of m_ulMaxAdditionalBuffering secs.
  297.      */
  298. #ifndef HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES
  299.     // increase by 1 sec
  300.     m_ulAdditionalBufferingInMs += 1000;
  302.     if (m_pParent->IsLive())
  303.     {
  304. m_bPerfectPlay = FALSE;
  305. m_bBufferedPlay = FALSE;
  306.     }
  307. #endif // HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES
  309.     UpdateMinimumPreroll(FALSE);
  311.     return HXR_OK;
  312. }
  314. HX_RESULT
  315. CBufferManager::Reset(UINT32 ulSeekTime, BOOL bSeekInsideRecordBuffer)
  316. {
  317.     STREAM_INFO*    pStreamInfo = NULL;
  319.     CHXEventList*  pEventList = NULL;
  320.     CHXEvent*     pEvent = NULL;
  322.     CHXMapLongToObj::Iterator i;
  324.     if (m_bBufferCalcToBeChanged)
  325.     {
  326. UpdateMinimumPreroll(FALSE);
  327.     }
  329.     m_ulBufferingStartTime = 0;
  331.     // reset each stream
  332.     for (i = m_pStreamInfoTable->Begin(); i != m_pStreamInfoTable->End(); ++i)
  333.     {
  334. pStreamInfo = (STREAM_INFO*) (*i);
  336. // reset
  337. if (!bSeekInsideRecordBuffer)
  338. {
  339.     pStreamInfo->m_bSrcStreamDone = FALSE;
  340.     pStreamInfo->m_bPacketRequested = FALSE;
  341. }
  343. pStreamInfo->m_bSrcStreamFillingDone = FALSE;
  345. // Reset buffering state
  346. pStreamInfo->BufferingState().Reset((m_state == BUFFMGR_SEEK),
  347.     ulSeekTime);
  351. HX_ASSERT(m_state == BUFFMGR_SEEK);
  353. if (m_state == BUFFMGR_SEEK)
  354. {
  355.     // remove all pending packets 
  356.     pEventList = &pStreamInfo->m_EventList;
  357.     while (pEventList->GetNumEvents() > 0)
  358.     {
  359. pEvent = pEventList->RemoveHead();
  361. // Mark it as a pre-seek event and send it to the player
  362. pEvent->SetPreSeekEvent();
  363. m_pParent->EventReady(pEvent);
  364.     }
  365. }
  366.     }
  368.     m_llHighestTimeStamp = 0;
  369.     m_ulTotalPauseTime = 0;
  370.     m_bBufferStartTimeToBeSet = TRUE;
  371.     return HXR_OK;
  372. }
  374. HX_RESULT
  375. CBufferManager::UpdateCounters(IHXPacket* pPacket)
  376. {
  377.     HX_RESULT     hr = HXR_OK;
  378.     UINT32     ulStreamNum = 0;
  379.     UINT32     ulBufferSize = 0;
  380.     UINT32     ulBufferTime = 0;
  381.     UINT32     ulElapsedTime = 0;
  382.     INT64     llActualTimeStamp = 0;
  383.     IHXBuffer*     pBuffer = NULL;
  384.     STREAM_INFO*    pStreamInfo = NULL;
  385.     STREAM_INFO*    pThisStreamInfo = NULL;
  386.     UINT32     ulCurrentTime   = HX_GET_TICKCOUNT();
  389.     CHXMapLongToObj::Iterator i;
  390.    
  391.     if (!pPacket)
  392.     {
  393. return HXR_INVALID_PARAMETER;
  394.     }
  396.     if (pPacket->IsLost() &&
  397. !(pPacket->GetASMFlags() & HX_ASM_DROPPED_PKT))
  398.     {
  399. // Ignore all lost packets that aren't dropped packets
  400. return hr;
  401.     }
  403.     ulStreamNum = pPacket->GetStreamNumber();
  405.     if (!m_pStreamInfoTable->Lookup(ulStreamNum, (void*&)pStreamInfo))
  406.     {
  407. return HXR_INVALID_PARAMETER;
  408.     }
  410.     pThisStreamInfo = pStreamInfo;
  412.     pBuffer = pPacket->GetBuffer();
  413.     if (pBuffer)
  414.     {
  415. ulBufferSize = pBuffer->GetSize();
  416.     }
  417.     HX_RELEASE(pBuffer);
  419.     ulBufferTime = pPacket->GetTime();
  421.     /* Set Buffering start time for all streams */
  422.     if (m_bBufferStartTimeToBeSet)
  423.     {
  424. m_bBufferStartTimeToBeSet = FALSE;
  425. m_ulBufferingStartTime = ulCurrentTime;
  426.     }
  428.     ulElapsedTime = GetElapsedTime(ulCurrentTime);
  430.     BOOL bIsBufferedPlayMode = (m_bPerfectPlay || m_bBufferedPlay || 
  431.       (m_bLocalPlayback && !m_pParent->IsLive()));
  433.     pStreamInfo->BufferingState().OnPacket(ulBufferTime, ulBufferSize,
  434.    ulElapsedTime,
  435.    m_pParent->IsLive(),
  436.    bIsBufferedPlayMode);
  438.     llActualTimeStamp = 
  439. pStreamInfo->BufferingState().CreateINT64Timestamp(ulBufferTime);
  441.     
  442.     // time based preroll by default
  443.     UpdateHighestTimestamps(llActualTimeStamp, pStreamInfo);
  445.     INT64 llLowRefTS = pThisStreamInfo->BufferingState().LowTS();
  447.     // adjust each stream preroll based on the hightest time stamp
  448.     for (i = m_pStreamInfoTable->Begin(); i != m_pStreamInfoTable->End(); ++i)
  449.     {
  450. pStreamInfo = (STREAM_INFO*) (*i);
  452. BOOL bIsTimestampDelivery = FALSE;
  454. if (pStreamInfo->m_pStream &&
  455.     pStreamInfo->m_pStream->IsTimeStampDelivery())
  456. {
  457.     bIsTimestampDelivery = TRUE;
  458. }
  459.     
  460. pStreamInfo->BufferingState().UpdateBufferingInMs(llLowRefTS,
  461.   m_llHighestTimeStamp,
  462.   bIsBufferedPlayMode,
  463.   bIsTimestampDelivery,
  464.   ulElapsedTime);
  465.     }
  467.     return hr;
  468. }
  470. HX_RESULT
  471. CBufferManager::GetStatus(REF(UINT16)     uStatusCode,
  472.   REF(IHXBuffer*)  pStatusDesc,
  473.   REF(UINT16)     uPercentDone)
  474. {
  475.     STREAM_INFO* pStreamInfo = NULL;
  477.     CHXMapLongToObj::Iterator i;
  479.     uStatusCode = HX_STATUS_READY;
  480.     pStatusDesc = NULL;
  481.     uPercentDone = 0;
  483.     // collect from each streams
  484.     for (i = m_pStreamInfoTable->Begin(); i != m_pStreamInfoTable->End(); ++i)
  485.     {
  486. pStreamInfo = (STREAM_INFO*) (*i);
  488. uPercentDone += pStreamInfo->BufferingState().GetPercentDone(m_bIsSeekPerformed);
  489.     }
  491.     // average them
  492.     uPercentDone = uPercentDone / m_pStreamInfoTable->GetCount();
  494.     if (uPercentDone >= 100)
  495.     {
  496. uPercentDone = 100;
  497. m_state = BUFFMGR_READY;
  498.     }
  499.     else
  500.     {
  501. uStatusCode = HX_STATUS_BUFFERING;
  502.     }
  504. //    DEBUG_OUT(m_pParent->m_pPlayer, DOL_GENERIC, (s,
  505. // "BuffMgr::GetStatus: %p Status: %s uPercentDone: %lu ", this, 
  506. // (uStatusCode == HX_STATUS_BUFFERING ? "HX_STATUS_BUFFERING" : "HX_STATUS_READY" ),
  507. //     uPercentDone));
  509.     return HXR_OK;
  510. }
  512. HX_RESULT
  513. CBufferManager::GetRemainToBuffer(REF(UINT32) ulRemainToBufferInMs,
  514.   REF(UINT32) ulRemainToBuffer)
  515. {
  516.     STREAM_INFO*    pStreamInfo = NULL;
  517.     
  518.     ulRemainToBufferInMs = 0;
  519.     ulRemainToBuffer = 0;
  521.     CHXMapLongToObj::Iterator i;
  523.     // caculate each stream
  524.     for (i = m_pStreamInfoTable->Begin(); i != m_pStreamInfoTable->End(); ++i)
  525.     {
  526. pStreamInfo = (STREAM_INFO*) (*i);
  528. BOOL bHasPreroll = 
  529.     pStreamInfo->BufferingState().HasPreroll(m_bIsSeekPerformed);
  530. BOOL bHasPredata =
  531.     pStreamInfo->BufferingState().HasPredata(m_bIsSeekPerformed);
  533. UINT32 ulRemainInMs;
  534. UINT32 ulRemain;
  535. pStreamInfo->BufferingState().GetRemainToBuffer(ulRemainInMs, 
  536. ulRemain);
  538. // satisfy the preroll (by default + pre-set)
  539. if ((!bHasPredata || bHasPreroll) &&
  540.     (ulRemainToBufferInMs < ulRemainInMs))
  541. {
  542.     ulRemainToBufferInMs = ulRemainInMs;
  543. }
  545. // satisfy the predata
  546. if (bHasPredata)
  547. {
  548.     ulRemainToBuffer += ulRemain;
  549. }
  550.     }
  552.     return HXR_OK;
  553. }
  555. HX_RESULT
  556. CBufferManager::GetMaximumPreroll(REF(UINT32) ulMaximumPrerollInMs)
  557. {
  558.     STREAM_INFO*    pStreamInfo = NULL;
  560.     CHXMapLongToObj::Iterator i;
  562.     ulMaximumPrerollInMs = 0;
  564.     // get max. preroll among the streams
  565.     for (i = m_pStreamInfoTable->Begin(); i != m_pStreamInfoTable->End(); ++i)
  566.     {
  567. pStreamInfo = (STREAM_INFO*) (*i);
  568.     
  569. UINT32 ulMinPrerollInMs = 
  570.     pStreamInfo->BufferingState().GetMinPrerollInMs();
  572. if (ulMaximumPrerollInMs < ulMinPrerollInMs)
  573. {
  574.     ulMaximumPrerollInMs = ulMinPrerollInMs;
  575. }
  576.     }
  577.     
  578.     return HXR_OK;
  579. }
  581. HX_RESULT
  582. CBufferManager::GetExcessBufferInfo(REF(UINT32) ulRemainToBufferInMs,
  583.   REF(UINT32) ulRemainToBuffer,
  584.   REF(UINT32) ulExcessBufferInMs,
  585.   REF(UINT32) ulExcessBuffer,
  586.   REF(BOOL) bValidInfo,
  587.   REF(UINT32) ulActualExcessBufferInMs,
  588.   REF(UINT32)   ulActualExcessBuffer)
  589. {
  590.     STREAM_INFO*    pStreamInfo = NULL;
  591.     INT64     llTheLowestTS = 0;
  592.     INT64     llTheHighestTS = 0;
  593.     BOOL     bIsFirst = TRUE;
  594.     STREAM_INFO*    pNonEmptyStreamInfo = NULL;
  595.     
  596.     ulRemainToBufferInMs    = 0;
  597.     ulRemainToBuffer     = 0;
  598.     ulExcessBufferInMs     = 0;
  599.     ulExcessBuffer     = 0;
  600.     bValidInfo     = FALSE;
  601.     ulActualExcessBufferInMs= 0;
  602.     ulActualExcessBuffer    = 0;
  604.     CHXMapLongToObj::Iterator i;
  606.     /*
  607.      * - Update transport stats for each stream.
  608.      * - Find the lowest and highest timestamps across all streams
  609.      * - Keep track of the stream with the lowest timestamp and is 
  610.      *   buffering data
  611.      */
  612.     for (i = m_pStreamInfoTable->Begin(); i != m_pStreamInfoTable->End(); ++i)
  613.     {
  614. pStreamInfo = (STREAM_INFO*) (*i);
  616. INT64 llLowestTimestampAtTransport = 0;
  617. INT64 llHighestTimestampAtTransport = 0;
  618. ULONG32 ulNumBytesAtTransport = 0;
  619. BOOL bDoneAtTransport = FALSE;
  621. m_pParent->GetCurrentBuffering(pStreamInfo->m_uStreamNumber, 
  622.        llLowestTimestampAtTransport,
  623.        llHighestTimestampAtTransport,
  624.        ulNumBytesAtTransport,
  625.        bDoneAtTransport);
  627. pStreamInfo->BufferingState().UpdateTransportStats(
  628.     llLowestTimestampAtTransport,
  629.     llHighestTimestampAtTransport,
  630.     ulNumBytesAtTransport,
  631.     bDoneAtTransport);
  633. if (ulNumBytesAtTransport > 0)
  634. {     
  635.     if (bIsFirst)
  636.     {
  637. bIsFirst     = FALSE;
  638. llTheLowestTS     = llLowestTimestampAtTransport;
  639. llTheHighestTS     = llHighestTimestampAtTransport;
  640. pNonEmptyStreamInfo = pStreamInfo;
  641.     }
  642.     else 
  643.     {
  644. if (llTheLowestTS > llLowestTimestampAtTransport)
  645. {
  646.     llTheLowestTS = llLowestTimestampAtTransport;
  648.     /* This is the stream with the lowest timestamp */
  649.     pNonEmptyStreamInfo = pStreamInfo;
  650. }
  652. if (llTheHighestTS < llHighestTimestampAtTransport)
  653. {
  654.     llTheHighestTS = llHighestTimestampAtTransport;
  655. }
  656.     }
  658. }
  659.     }
  661.     /* If none of the streams have any data buffered at the transport layer,
  662.      * return.
  663.      */
  664.     if (!pNonEmptyStreamInfo)
  665.     {
  666. return HXR_OK;
  667.     }
  669.     for (i = m_pStreamInfoTable->Begin(); i != m_pStreamInfoTable->End(); ++i)
  670.     {
  671. pStreamInfo = (STREAM_INFO*) (*i);
  673. UINT32 ulExcessForThisStreamInMs = 0;
  674. UINT32 ulExcessForThisStream     = 0;
  676. pStreamInfo->BufferingState().GetExcessBufferInfo(llTheLowestTS,
  677.   llTheHighestTS,
  678.   m_bIsSeekPerformed,
  679.   ulRemainToBufferInMs,
  680.   ulRemainToBuffer,
  681.   ulExcessBufferInMs,
  682.   ulExcessBuffer,
  683.   ulExcessForThisStreamInMs,
  684.   ulExcessForThisStream);
  686. /* Update Actual Values Regardless of Preroll / PreData */
  687. ulActualExcessBuffer += ulExcessForThisStream;
  688. if (ulActualExcessBufferInMs < ulExcessForThisStreamInMs)
  689. {
  690.     ulActualExcessBufferInMs = ulExcessForThisStreamInMs;
  691. }
  692.     }
  694.     bValidInfo = TRUE;
  696.     if (ulRemainToBufferInMs >= ulExcessBufferInMs)
  697.     {
  698. ulRemainToBufferInMs -= ulExcessBufferInMs;
  699. ulExcessBufferInMs    = 0;
  700.     }
  701.     else 
  702.     {
  703. ulExcessBufferInMs -= ulRemainToBufferInMs;
  704. ulRemainToBufferInMs  = 0;
  705.     }
  707.     if (ulRemainToBuffer > 0)
  708.     {
  709. ulExcessBuffer    = 0;
  710.     }
  712.     return HXR_OK;
  713. }
  715. void
  716. CBufferManager::EnterBufferedPlay(void)
  717. {
  718. #if !defined(HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES)
  719.     if (!m_bBufferedPlay && !m_bPerfectPlay)
  720.     {
  721. m_bBufferedPlay     = TRUE;
  723. UINT32 ulRemainToBufferInMs = 0;
  724. UINT32 ulRemainToBuffer = 0;
  726. GetRemainToBuffer(ulRemainToBufferInMs, ulRemainToBuffer);
  728. /* If we are not done with buffering yet, update the buffering 
  729.  * calc now!
  730.  */ 
  731. if (ulRemainToBufferInMs > 0 ||
  732.     ulRemainToBuffer > 0)
  733. {
  734.     UpdateMinimumPreroll(FALSE);
  735. }
  736. else
  737. {
  738.     m_bBufferCalcToBeChanged    = TRUE;
  739. }
  740.     }
  741. #endif // (HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES)
  742. }
  744. void
  745. CBufferManager::LeaveBufferedPlay(void)
  746. {
  747. #if !defined(HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES)
  748.     if (m_bBufferedPlay)
  749.     {
  750. m_bBufferCalcToBeChanged    = TRUE;
  751. m_bBufferedPlay     = FALSE;
  752.     }
  753. #endif // (HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES)
  754. }
  756. UINT32 CBufferManager::GetElapsedTime(UINT32 ulCurrentTime)
  757. {
  758.     UINT32 ulElapsedTime =
  759. CALCULATE_ELAPSED_TICKS(m_ulBufferingStartTime, ulCurrentTime);
  760.     
  761.     if (m_ulTotalPauseTime > 0)
  762.     {
  763. HX_ASSERT(ulElapsedTime >= m_ulTotalPauseTime);
  764. ulElapsedTime = ulElapsedTime > m_ulTotalPauseTime ? 
  765. ulElapsedTime - m_ulTotalPauseTime : 0;
  766.     }
  768.     return ulElapsedTime;
  769. }
  771. void CBufferManager::UpdateHighestTimestamps(INT64 llActualTimeStamp,
  772.      STREAM_INFO* pStreamInfo)
  773. {
  774.     // we apply the highest packet time-stamp to every stream
  775.     // to solve infinite buffering
  776.     if (m_llHighestTimeStamp < llActualTimeStamp)
  777.     {
  778. m_llHighestTimeStamp = llActualTimeStamp;
  779.     }
  780. }
  782. void CBufferManager::SetPerfectPlay(BOOL bPerfectPlay)
  783. {
  784.     m_bPerfectPlay = bPerfectPlay;
  786.     if (m_pParent->IsLive())
  787.     {
  788. m_bPerfectPlay = FALSE;
  789. m_bBufferedPlay = FALSE;
  790.     }
  791. }