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

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

Symbian

开发平台：

C/C++

hxbufstate.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2003 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 ***** */ 
  35. #include "hxbufstate.h"
  37. #include "hxassert.h"
  39. class HXBufferedPktInfo
  40. {
  41. public:
  42.     HXBufferedPktInfo(INT64 llTimestamp, UINT32 ulSize);
  44.     INT64 Timestamp() const { return m_llTimestamp;}
  45.     UINT32 Size() const { return m_ulSize;}
  47. private:
  48.     INT64 m_llTimestamp;
  49.     UINT32 m_ulSize;
  50. };
  52. inline
  53. HXBufferedPktInfo::HXBufferedPktInfo(INT64 llTimestamp, 
  54.      UINT32 ulSize) :
  55.     m_llTimestamp(llTimestamp),
  56.     m_ulSize(ulSize)
  57. {}
  60. HXBufferingState::HXBufferingState() :
  61.     m_ulPreroll(0)
  62.     , m_ulPredata(0)
  63.     , m_ulMinimumPrerollInMs(0)
  64.     , m_ulMinimumPreroll(0)
  65.     , m_ulMinimumBufferingInMs(0)
  66.     , m_ulMinimumBuffering(0)
  67.     , m_ulRemainingToBufferInMs(0)
  68.     , m_ulRemainingToBuffer(0)
  69.     , m_ulCurrentBufferingInMs(0)
  70.     , m_ulCurrentBuffering(0)
  71.     , m_bIsFirstPacket(TRUE)
  72.     , m_preDataAtStart(FALSE)
  73.     , m_prerollAtStart(FALSE)
  74.     , m_preDataAfterSeek(FALSE)
  75.     , m_prerollAfterSeek(FALSE)
  76.     , m_llLowestTimeStamp(0)
  77.     , m_llHighestTimeStamp(0)
  78.     , m_llLowestTimestampAtTransport(0)
  79.     , m_llHighestTimestampAtTransport(0)
  80.     , m_ulNumBytesAtTransport(0)
  81.     , m_bDoneAtTransport(FALSE)
  82.     , m_ulTSRollOver(0)
  83.     , m_ulLastPacketTimeStamp(0)
  84.     , m_ulAvgBandwidth(0)
  85.     , m_pASMProps(NULL)
  86.     , m_llCurrentPlaybackTime(0)
  87.     , m_ulBufferedData(0)
  88.     , m_ulLastTimeSync(0)
  89.     , m_llFirstLivePacketTimestamp(0)
  90.     , m_ulTimeSyncRollOver(0)
  91. {}
  93. HXBufferingState::~HXBufferingState()
  94. {
  95.     HX_RELEASE(m_pASMProps);
  97.     ClearPktInfo();
  98. }
  100. void HXBufferingState::OnStreamHeader(UINT32 ulPreroll,
  101.       UINT32 ulPredata,
  102.       BOOL preDataAtStart,
  103.       BOOL preDataAfterSeek,
  104.       BOOL prerollAtStart,
  105.       BOOL prerollAfterSeek,
  106.       ULONG32 ulAvgBitRate)
  107. {
  108.     m_ulPreroll = ulPreroll;
  109.     m_ulPredata = ulPredata;
  110.     m_preDataAtStart = preDataAtStart;
  111.     m_preDataAfterSeek = preDataAfterSeek;
  112.     m_prerollAtStart = prerollAtStart;
  113.     m_prerollAfterSeek = prerollAfterSeek;
  114.     m_ulAvgBandwidth = ulAvgBitRate;
  115. }
  117. void HXBufferingState::OnStream(IUnknown* pStream)
  118. {
  119.     HX_RELEASE(m_pASMProps);
  121.     if (pStream)
  122.     {
  123. pStream->QueryInterface(IID_IHXASMProps, (void**) &m_pASMProps);
  124.     }
  125. }
  127. void HXBufferingState::Init(ULONG32 ulPerfectPlayTime)
  128. {
  129.     SetMinPrerollInMs(m_ulPreroll, m_ulPreroll + ulPerfectPlayTime);
  130.     SetMinPreroll();
  131. }
  134. void HXBufferingState::SetMinimumPreroll(UINT32 ulSourcePreroll, 
  135.  UINT32 ulInitialAudioPreroll,
  136.  UINT32 ulPerfectPlayTime,
  137.  BOOL   bIsRebuffering)
  138. {
  139.     UINT32 ulMinimumPreroll = m_ulPreroll;
  140.     
  141.     ulMinimumPreroll += ulInitialAudioPreroll;
  142.     
  143.     if (ulMinimumPreroll < ulSourcePreroll)
  144.     {
  145. ulMinimumPreroll = ulSourcePreroll;
  146.     }
  147.     
  148.     SetMinPrerollInMs(ulMinimumPreroll, 
  149.       ulMinimumPreroll + ulPerfectPlayTime);
  150.     m_ulCurrentBufferingInMs = 0;
  152.     /* If we have received at lest one packet for this stream,
  153.      * mark the lowest timestamp to be the
  154.      * last packet timstamp to reset buffering calculations
  155.      */
  156.     if (bIsRebuffering && !m_bIsFirstPacket)
  157.     {
  158. m_bIsFirstPacket = TRUE;
  159. m_llLowestTimeStamp = 
  160.     CAST_TO_INT64 (m_ulTSRollOver) * CAST_TO_INT64 MAX_UINT32 + CAST_TO_INT64 (m_ulLastPacketTimeStamp);
  161.     }
  162.     
  163.     UpdateMinPredata();
  164. }
  166. void HXBufferingState::Stop()
  167. {
  168.     m_ulRemainingToBufferInMs = 0;
  169.     m_ulRemainingToBuffer = 0;
  170. }
  172. void HXBufferingState::Reset(BOOL bIsSeeking, UINT32 ulSeekTime)
  173. {
  174.     m_ulRemainingToBufferInMs = m_ulMinimumBufferingInMs;
  175.     m_ulRemainingToBuffer = m_ulMinimumBuffering;
  176.     m_ulCurrentBufferingInMs = 0;
  177.     m_ulCurrentBuffering = 0;
  178.     m_ulTSRollOver = 0;
  179.     m_ulLastPacketTimeStamp = 0;
  180.     m_bIsFirstPacket = TRUE;
  182.     ClearPktInfo();
  184.     if (bIsSeeking)
  185.     {
  186. m_llLowestTimeStamp = CAST_TO_INT64 ulSeekTime;
  187. m_llHighestTimeStamp = CAST_TO_INT64 ulSeekTime;
  188.     }
  189. }
  191. void HXBufferingState::GetRemainToBuffer(REF(UINT32) ulRemainToBufferInMs,
  192.  REF(UINT32) ulRemainToBuffer)
  193. {
  194.     ulRemainToBufferInMs = m_ulRemainingToBufferInMs;
  195.     ulRemainToBuffer = m_ulRemainingToBuffer;
  196. }
  198. UINT16 HXBufferingState::GetPercentDone(BOOL bIsSeekPerformed)
  199. {
  200.     UINT16  uTotalPercentDone = 100;
  201.     UINT16  uPreDataPercentDone = 100;
  202.     UINT16  uPrerollPercentDone = 100;
  204.     BOOL bHasPreroll;
  205.     BOOL bHasPredata;
  206.     BOOL bNeedsData = FALSE;
  208.     if (!bIsSeekPerformed)
  209.     {
  210. // start/rebuffer mode
  211. bHasPreroll = m_prerollAtStart;
  212. bHasPredata = m_preDataAtStart;
  213.     }
  214.     else
  215.     {
  216. // seek mode
  217. bHasPreroll = m_prerollAfterSeek;
  218. bHasPredata = m_preDataAfterSeek;
  219.     }
  222.     // satisfy the preroll (by default + pre-set)
  223.     if (!bHasPredata || bHasPreroll)
  224.     {
  225. // percent done on preroll
  226. if (m_ulMinimumBufferingInMs)
  227. {
  228.     uPrerollPercentDone =
  229. ((m_ulMinimumBufferingInMs-m_ulRemainingToBufferInMs ) * 100) /
  230. m_ulMinimumBufferingInMs;
  231. }
  233. uTotalPercentDone = uPrerollPercentDone;
  235. bNeedsData = (m_ulRemainingToBufferInMs > 0);
  236.     }
  238.     // satisfy the predata
  239.     if (bHasPredata)
  240.     {
  241. // percent done on predata
  242. if (m_ulMinimumBuffering)
  243. {
  244.     uPreDataPercentDone = 
  245. ((m_ulMinimumBuffering - m_ulRemainingToBuffer ) * 100) /
  246. m_ulMinimumBuffering;
  247. }
  249. uTotalPercentDone = uPreDataPercentDone;
  250. bNeedsData = (m_ulRemainingToBuffer > 0);
  251.     }
  253.     if (bHasPredata && bHasPreroll)
  254.     {
  255. uTotalPercentDone = (uPrerollPercentDone + uPreDataPercentDone) / 2;
  256.     }
  257.     else if ((bIsSeekPerformed) &&
  258.      (uTotalPercentDone == 100) &&
  259.      (bNeedsData))
  260.     {
  261. uTotalPercentDone = 99;
  262.     }
  264.     return uTotalPercentDone;
  265. }
  267. void HXBufferingState::UpdatePreroll(ULONG32 ulPreroll)
  268. {
  269.     UINT32 ulExtraPrerollInMs   = m_ulMinimumPrerollInMs - m_ulPreroll;
  270.     UINT32 ulExtraBufferingInMs = m_ulMinimumBufferingInMs - m_ulPreroll;
  271.     
  272.     SetPreroll(ulPreroll);
  273.     SetMinPrerollInMs(ulPreroll + ulExtraPrerollInMs,
  274.       ulPreroll + ulExtraBufferingInMs);
  275.     SetMinPreroll();
  277.     // Notice that we don't call ClearCurrentBufferingInMs()
  278.     // or ClearCurrentBuffering(). This allows us to count
  279.     // any data we have already received as part of the
  280.     // new preroll
  282.     CalcRemainingToBufferInMs();
  283.     CalcRemainingToBuffer();
  284. }
  286. INT64 HXBufferingState::CreateINT64Timestamp(UINT32 ulTime)
  287. {
  288.     return CAST_TO_INT64 (m_ulTSRollOver) * CAST_TO_INT64 MAX_UINT32 + CAST_TO_INT64 ulTime;
  289. }
  291. INT64 HXBufferingState::CreateINT64Timesync(UINT32 ulTime)
  292. {
  293.     return CAST_TO_INT64 (m_ulTimeSyncRollOver) * CAST_TO_INT64 MAX_UINT32 + CAST_TO_INT64 ulTime;
  294. }
  296. void HXBufferingState::OnPacket(UINT32 ulTimestamp, UINT32 ulPacketSize,
  297. UINT32 ulElapsedTime,
  298. BOOL bIsLive, BOOL bIsBufferedPlayMode)
  299. {
  300.     //  0xFA .. 0xFF [roll over] (0x01)
  301.     if (m_ulLastPacketTimeStamp > ulTimestamp &&
  302. ((m_ulLastPacketTimeStamp - ulTimestamp) > MAX_TIMESTAMP_GAP))
  303.     {
  304. m_ulTSRollOver++;
  305.     }
  306.     
  307.     INT64 llActualTimeStamp = CreateINT64Timestamp(ulTimestamp);
  308.     m_ulLastPacketTimeStamp = ulTimestamp;
  310.     if (m_bIsFirstPacket)
  311.     {
  312. /* Only if we are live,  store the first packet timestemp
  313.  * as the lowest timestamp. In any other case, we consider
  314.  * the lowest ts to be 0 OR the Seek time.
  315.  * This is to fix the post-seek buffering where we should not
  316.  * account any packets < seek ts towards buffering completion.
  317.  */
  318. if (bIsLive)
  319. {
  320.     m_llLowestTimeStamp = CAST_TO_INT64 ulTimestamp;
  321.             m_llFirstLivePacketTimestamp = m_llLowestTimeStamp;
  322.         }
  324. m_llHighestTimeStamp = CAST_TO_INT64 ulTimestamp;
  325. m_bIsFirstPacket = FALSE;
  326.     }
  328.     // Add this packet to our packet info statistics
  329.     AddPktInfo(llActualTimeStamp, ulPacketSize);
  331.     // data based preroll
  332.     if (DataBasedPreroll())
  333.     {
  334. m_ulCurrentBuffering += ulPacketSize;
  335.     
  336. if (bIsBufferedPlayMode)
  337. {
  338.     /* 
  339.      * We wait to have at least 1 second worth of data
  340.      * before doing any calculations. This may need some
  341.      * tweaking.
  342.      */
  343.     if ((m_ulRemainingToBuffer != 0) &&
  344. (m_ulCurrentBuffering >= m_ulAvgBandwidth / 8))
  345.     {
  346. /* 
  347.  * Highly unlikely, but may happen from a server on the 
  348.  * local machine.
  349.  */
  350. if (ulElapsedTime == 0)
  351. {
  352.     if (m_ulCurrentBuffering >= m_ulMinimumPreroll)
  353.     {
  354. m_ulRemainingToBuffer = 0;
  355.     }
  356. }
  357. else
  358. {
  359.     UINT32 ulDenom = ulElapsedTime * m_ulAvgBandwidth / 8000;
  360.     
  361.     /* Sanity check - may be 0 only when bandwidth
  362.      * is really low 
  363.      */
  364.     ulDenom = ulDenom > 0 ? ulDenom : 1;
  365.     
  366.     CalcRemainingToBuffer(ulDenom);
  367. }
  368.     }
  369. }
  370. else
  371. {
  372.     /* bIsBufferedPlayMode == FALSE */
  373.     if (m_ulRemainingToBuffer)
  374.     {
  375. CalcRemainingToBuffer();
  376.     }
  377. }
  378.     }
  380.     if (llActualTimeStamp >= m_llHighestTimeStamp)
  381.     {
  382. m_llHighestTimeStamp = llActualTimeStamp;
  383.     } 
  384. }
  386. void HXBufferingState::UpdateBufferingInMs(INT64 llRefLowTimestamp,
  387.    INT64 llHighTimestamp, 
  388.    BOOL bIsBufferedPlayMode,
  389.    BOOL bIsTimestampDelivery,
  390.    UINT32 ulElapsedTime)
  391. {
  392.     UpdateCurrentBufferingInMs(llRefLowTimestamp, llHighTimestamp);
  394.     if (bIsBufferedPlayMode)
  395.     {
  396. /* We handle time stamp delivered streams differently
  397.  * in case of BUffered/PerfectPlay. This is because
  398.  * server sends timestamp delivered stream based
  399.  * on the timestamps on the packet and pretty
  400.  * much streams in realtime. 
  401.  * So even if we are on LAN and streaming a RealText
  402.  * file, we will get packets in realtime even though
  403.  * we have enough bandwidth available
  404.  * 
  405.  * For timestamp delivered streams, we just fulfill 
  406.  * preroll.
  407.  */
  408. if (bIsTimestampDelivery &&
  409.     m_ulCurrentBufferingInMs > m_ulMinimumPrerollInMs)
  410. {
  411.     m_ulRemainingToBufferInMs = 0;
  412. }
  413. else if ((m_ulRemainingToBufferInMs != 0) &&
  414.  (m_ulCurrentBufferingInMs >= 1000))
  415. {
  416.     /* 
  417.      * Highly unlikely, but may happen from a 
  418.      * server on the local machine.
  419.      */
  420.     if (ulElapsedTime == 0)
  421.     {
  422. if (m_ulCurrentBufferingInMs >= m_ulMinimumPrerollInMs)
  423. {
  424.     m_ulRemainingToBufferInMs = 0;
  425. }
  426.     }
  427.     else
  428.     {
  429. CalcRemainingToBufferInMs(ulElapsedTime);
  430.     }
  431. }
  432.     }
  433.     else
  434.     {
  435. /* bIsBufferedPlayMode == FALSE */
  436. if (m_ulRemainingToBufferInMs)
  437. {
  438.     CalcRemainingToBufferInMs();
  439. }
  440.     }
  441. }
  443. void HXBufferingState::UpdateTransportStats(INT64 llLowTSAtTransport,
  444.     INT64 llHighTSAtTransport,
  445.     ULONG32 ulBytesAtTransport,
  446.     BOOL bDoneAtTransport)
  447. {
  448.     m_llLowestTimestampAtTransport = llLowTSAtTransport; 
  449.     m_llHighestTimestampAtTransport = llHighTSAtTransport; 
  450.     m_ulNumBytesAtTransport = ulBytesAtTransport;
  451.     m_bDoneAtTransport = bDoneAtTransport;
  452. }
  454. HX_RESULT HXBufferingState::GetBufferingStats(REF(INT64) llLowTimestamp, 
  455.       REF(INT64) llHighTimestamp,
  456.       REF(UINT32) ulBytesBuffered,
  457.       BOOL bUseTransportStats)
  458. {
  459.     HX_RESULT res = HXR_NO_DATA;
  461.     if (!m_bIsFirstPacket)
  462.     {
  463. if (!m_pktInfo.IsEmpty())
  464. {
  465.     HXBufferedPktInfo* pPktInfo = 
  466. (HXBufferedPktInfo*)m_pktInfo.GetHead();
  468.     llLowTimestamp = pPktInfo->Timestamp();
  469. }
  470. else
  471. {
  472.     llLowTimestamp = m_llHighestTimeStamp;
  473. }
  475. llHighTimestamp = m_llHighestTimeStamp;
  476. ulBytesBuffered = GetBufferedData();
  479. if (bUseTransportStats)
  480. {
  481.     if (m_llHighestTimestampAtTransport > llHighTimestamp)
  482.     {
  483. llHighTimestamp = m_llHighestTimestampAtTransport;
  484.     }
  486.     ulBytesBuffered += m_ulNumBytesAtTransport;
  487. }
  489. res = HXR_OK;
  490.     }
  492.     return res;
  493. }
  495. void HXBufferingState::GetExcessBufferInfo(INT64 llTheLowestTS,
  496.    INT64 llTheHighestTS,
  497.    BOOL bIsSeekPerformed,
  498.    REF(UINT32) ulRemainToBufferInMs,
  499.    REF(UINT32) ulRemainToBuffer,
  500.    REF(UINT32) ulExcessBufferInMs,
  501.    REF(UINT32) ulExcessBuffer,
  502.    REF(UINT32) ulExcessForThisStreamInMs,
  503.    REF(UINT32) ulExcessForThisStream)
  504. {
  505.     UINT32 ulCurBufInMs     = 0;
  506.     UINT32 ulRemainForThisStreamInMs = 0;
  507.     UINT32 ulRemainForThisStream     = 0;
  508.     
  509.     ulExcessForThisStreamInMs = 0;
  510.     ulExcessForThisStream     = 0;
  511.     
  512.     if (m_ulNumBytesAtTransport > 0)
  513.     {
  514. HX_ASSERT((llTheHighestTS - m_llLowestTimestampAtTransport) < MAX_TIMESTAMP_GAP);
  516. ulCurBufInMs = INT64_TO_UINT32(llTheHighestTS - 
  517.        m_llLowestTimestampAtTransport);
  518.     }
  519.     else
  520.     {
  521. HX_ASSERT((llTheHighestTS - llTheLowestTS) < MAX_TIMESTAMP_GAP);
  523. ulCurBufInMs = INT64_TO_UINT32(llTheHighestTS - llTheLowestTS);
  524.     }
  526.     if (ulCurBufInMs <= m_ulMinimumBufferingInMs)
  527.     {
  528. ulRemainForThisStreamInMs = m_ulMinimumBufferingInMs - ulCurBufInMs;
  529.     }
  530.     else
  531.     {
  532. ulExcessForThisStreamInMs = ulCurBufInMs - m_ulMinimumBufferingInMs;
  533.     }
  535.     if (m_ulNumBytesAtTransport <= m_ulMinimumBuffering)
  536.     {
  537. ulRemainForThisStream = 
  538.     m_ulMinimumBuffering - m_ulNumBytesAtTransport;
  539.     }
  540.     else
  541.     {
  542. ulExcessForThisStream = m_ulNumBytesAtTransport - m_ulMinimumBuffering;
  543.     }
  545.     
  546.     BOOL bHasPreroll = HasPreroll(bIsSeekPerformed);
  547.     BOOL bHasPredata = HasPredata(bIsSeekPerformed);
  549.     // satisfy the preroll (by default + pre-set)
  550.     if (!bHasPredata || bHasPreroll)
  551.     {
  552. if (ulRemainToBufferInMs < ulRemainForThisStreamInMs)
  553. {
  554.     ulRemainToBufferInMs = ulRemainForThisStreamInMs;
  555. }
  557. if (ulExcessBufferInMs < ulExcessForThisStreamInMs)
  558. {
  559.     ulExcessBufferInMs = ulExcessForThisStreamInMs;
  560. }
  561.     }
  563.     // satisfy the predata
  564.     if (bHasPredata)
  565.     {
  566. ulRemainToBuffer += ulRemainForThisStream;
  567. ulExcessBuffer   += ulExcessForThisStream;
  568.     }
  570. }
  572. void HXBufferingState::OnTimeSync(UINT32 ulCurrentTime)
  573. {
  574.     //  0xFA .. 0xFF [roll over] (0x01)
  575.     if (m_ulLastTimeSync > ulCurrentTime &&
  576.        ((m_ulLastTimeSync - ulCurrentTime) > MAX_TIMESTAMP_GAP))
  577.     {
  578.        m_ulTimeSyncRollOver++;
  579.     }
  580.     m_ulLastTimeSync = ulCurrentTime;
  582.     m_llCurrentPlaybackTime = CreateINT64Timesync(ulCurrentTime);
  583. }
  585. void HXBufferingState::SetMinPrerollInMs(ULONG32 ulMinPrerollInMs, 
  586.  ULONG32 ulMinBufferingInMs)
  587. {
  588.     m_ulMinimumPrerollInMs    = ulMinPrerollInMs;
  589.     m_ulMinimumBufferingInMs  = ulMinBufferingInMs;
  590.     m_ulRemainingToBufferInMs = m_ulMinimumBufferingInMs;
  591. }
  593. void HXBufferingState::SetMinPreroll()
  594. {
  595.     SetMinPreroll(MsToBytes(m_ulMinimumPrerollInMs,
  596.     m_ulAvgBandwidth),
  597.   m_ulAvgBandwidth);
  598. }
  600. void HXBufferingState::SetMinPreroll(UINT32 ulMinimumPredata,
  601.      UINT32 ulBandwidth)
  602. {
  603.     HX_ASSERT(m_ulMinimumPrerollInMs >= m_ulPreroll);
  605.     UINT32 ulExtraBufferingInMs = m_ulMinimumPrerollInMs - m_ulPreroll;
  607.     /* Get current bandiwidth from asm */
  608.     m_ulMinimumPreroll = (ulMinimumPredata + 
  609.    MsToBytes(ulExtraBufferingInMs, 
  610.      ulBandwidth));
  612.     // There is no buffered or perfect play with MIN_HEAP on.
  613. #if defined(HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES)
  614.     m_ulMinimumBuffering  = m_ulMinimumPreroll;
  615. #else
  616.     ulExtraBufferingInMs = m_ulMinimumBufferingInMs - m_ulPreroll;
  618.     m_ulMinimumBuffering  = (ulMinimumPredata + 
  619.      MsToBytes(ulExtraBufferingInMs, 
  620.        ulBandwidth));
  621. #endif
  623.     m_ulRemainingToBuffer  = m_ulMinimumBuffering;
  624.     m_ulCurrentBuffering   = 0;
  625. }
  627. void HXBufferingState::UpdateMinPredata()
  628. {
  629.     UINT32     ulMinimumPredata = m_ulPredata;
  630.     UINT32     ulBandwidth      = m_ulAvgBandwidth;
  631.     
  632. #if defined(HELIX_FEATURE_ASM)
  633.     // no ASMProps in AutoConfig
  634.     HX_ASSERT(m_pASMProps);
  635.     
  636.     if (m_pASMProps)
  637.     {
  638. UINT32 ulTmp;
  639. if (HXR_OK == m_pASMProps->GetPreData(ulTmp))
  640. {
  641.     ulMinimumPredata = ulTmp;
  642. }
  644. if (HXR_OK == m_pASMProps->GetBandwidth(ulTmp))
  645. {
  646.     ulBandwidth = ulTmp;
  647. }
  648.     }
  649. #endif /* HELIX_FEATURE_ASM */
  650.     
  651.     SetMinPreroll(ulMinimumPredata, ulBandwidth);
  652. }
  654. void HXBufferingState::UpdateCurrentBufferingInMs(INT64 llLowestTimeStamp, 
  655.   INT64 llHighestTimeStamp)
  656. {
  657.     INT64 llLowTimestamp = m_llLowestTimeStamp;
  658.     
  659.     if (m_bIsFirstPacket)
  660.     {
  661. /* use the reference stream's lowest timestamp for calculation */
  662. llLowTimestamp = llLowestTimeStamp;
  663.     }
  665.     if (llHighestTimeStamp > llLowTimestamp)
  666.     {
  667. // if the stream has been continuesly playing for 49 days
  668. // we will set m_ulCurrentBufferingInMs to MAX_UINT32
  669. if (llHighestTimeStamp - llLowTimestamp > MAX_UINT32)
  670. {
  671.     m_ulCurrentBufferingInMs = MAX_UINT32;
  672. }
  673. else
  674. {
  675.     m_ulCurrentBufferingInMs = 
  676. INT64_TO_UINT32(llHighestTimeStamp - llLowTimestamp);
  677. }
  678.     }
  679. }
  681. ULONG32 HXBufferingState::MsToBytes(ULONG32 ulValueInMs, ULONG32 ulBw) const
  682. {
  683.     return (ulValueInMs * (ulBw / 8)) / 1000;
  684. }
  686. void HXBufferingState::CalcRemainingToBufferInMs()
  687. {
  688.     m_ulRemainingToBufferInMs = CalcRemaining(m_ulMinimumBufferingInMs,
  689.       m_ulCurrentBufferingInMs,
  690.       0,
  691.       0);
  692. }
  694. void HXBufferingState::CalcRemainingToBufferInMs(ULONG32 ulElapsedTime)
  695. {
  696.     m_ulRemainingToBufferInMs = CalcRemaining(m_ulMinimumBufferingInMs,
  697.       m_ulCurrentBufferingInMs,
  698.       m_ulMinimumPrerollInMs,
  699.       ulElapsedTime);
  700. }
  702. void HXBufferingState::CalcRemainingToBuffer()
  703. {
  704.     m_ulRemainingToBuffer = CalcRemaining(m_ulMinimumBuffering,
  705.   m_ulCurrentBuffering,
  706.   0,
  707.   0);
  708. }
  710. void HXBufferingState::CalcRemainingToBuffer(ULONG32 ulDenom)
  711. {
  712.     m_ulRemainingToBuffer = CalcRemaining(m_ulMinimumBuffering,
  713.   m_ulCurrentBuffering,
  714.   m_ulMinimumPreroll,
  715.   ulDenom);
  716. }
  718. UINT32 HXBufferingState::CalcRemaining(UINT32 ulMinimumBuffering,
  719.        UINT32 ulCurrentBuffering,
  720.        UINT32 ulMinimumPreroll,
  721.        UINT32 ulDenom) const
  722. {
  723.     UINT32 ulRemainingToBuffer = 0;
  725.     if (ulMinimumBuffering > ulCurrentBuffering)
  726.     {
  727. ulRemainingToBuffer = ulMinimumBuffering - ulCurrentBuffering;
  728.     }
  730.     if (ulDenom)
  731.     {
  732. UINT32 ulBufferWhilePlaying = ulRemainingToBuffer;
  734. /*
  735.  * Buffers during playback = X*X/Y + X*(X/Y)^2 + X*(X/Y)^3 + ....
  736.  *     = X*X/Y (1 + X/Y + (X/Y)^2 + ....)
  737.  *
  738.  *      = X*X/Y ( 1 / (1 - X/Y))  IFF X/Y < 1 i.e. X < Y
  739.  *
  740.  *       ELSE We have enough data... Satisfy preroll 
  741.  */
  743. /* Add a fudge factor of 10% */
  744. ulDenom = (UINT32) (ulDenom * 1.10);
  746. if (ulCurrentBuffering < ulDenom)
  747. {
  748.     double x = ulCurrentBuffering;
  749.     double y = ulDenom;
  750.     ulBufferWhilePlaying = (UINT32) (((x * x) / y) * (1. / (1. - x / y)));
  751. }
  753. if (ulBufferWhilePlaying < ulRemainingToBuffer)
  754. {
  755.     ulRemainingToBuffer -= ulBufferWhilePlaying;
  756. }
  757. else if (ulCurrentBuffering >= ulMinimumPreroll)
  758. {
  759.     ulRemainingToBuffer = 0;
  760. }
  761.     }
  763.     return ulRemainingToBuffer;
  764. }
  766. void HXBufferingState::SetAvgBWToASMBw()
  767. {
  768.     UINT32 ulBandwidth = 0;
  769.     if (m_pASMProps &&
  770. m_pASMProps->GetBandwidth(ulBandwidth) == HXR_OK)
  771.     {
  772. m_ulAvgBandwidth = ulBandwidth;
  773.     }
  774. }
  776. void HXBufferingState::ClearPktInfo()
  777. {
  778.     m_ulBufferedData = 0;
  779.     while(!m_pktInfo.IsEmpty())
  780.     {
  781. HXBufferedPktInfo* pInfo = (HXBufferedPktInfo*)m_pktInfo.RemoveHead();
  782. delete pInfo;
  783.     }
  784. }
  786. void HXBufferingState::AddPktInfo(INT64 llTimestamp, UINT32 ulPacketSize)
  787. {
  788.     // Subtract off the first live packet timestamp.
  789.     // If not live, then m_llFirstLivePacketTimeStamp is 0.
  790.     llTimestamp -= m_llFirstLivePacketTimestamp;
  791.     // Create the HXBufferedPktInfo class
  792.     HXBufferedPktInfo* pPktInfo = new HXBufferedPktInfo(llTimestamp, 
  793. ulPacketSize);
  794.     if (pPktInfo)
  795.     {
  796. m_pktInfo.AddTail(pPktInfo);
  797. m_ulBufferedData += ulPacketSize;
  798.     }
  800.     // purge the old packet info data
  801.     //  this keeps the list short and prevents the Symbian
  802.     //  allocator from freaking out
  803.     (void)GetBufferedData();
  804. }
  806. UINT32 HXBufferingState::GetBufferedData()
  807. {
  808.     BOOL bDone = m_pktInfo.IsEmpty();
  809.     
  810.     // Remove all packet info that is past due
  811.     // and subtract their sizes from our buffering total
  812.     while(!bDone)
  813.     {
  814. HXBufferedPktInfo* pPktInfo = (HXBufferedPktInfo*)m_pktInfo.GetHead();
  816. if (pPktInfo->Timestamp() <= m_llCurrentPlaybackTime)
  817. {
  818.     m_ulBufferedData -= pPktInfo->Size();
  819.     
  820.     m_pktInfo.RemoveHead();
  821.     delete pPktInfo;
  822.     
  823.     bDone = m_pktInfo.IsEmpty();
  824. }
  825. else
  826. {
  827.     bDone = TRUE;
  828. }
  829.     }
  831.     return m_ulBufferedData;
  832. }