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

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

Symbian

开发平台：

C/C++

hxsm2.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 "hxsm2.h"
  37. #include "hxsmutil.h"
  38. #include "ihxpckts.h"
  39. #include "hxprefs.h"
  40. #include "hxpref.h"
  41. #include "hxbsrc.h" /* HXSource */
  42. #include "asmrulep.h" /* ASMRuleBook */
  43. #include "hxbuffer.h" /* CHXBuffer */
  44. #include "chxpckts.h" /* CHXHeader */
  45. #include "safestring.h" /* SafeSprintf */
  46. #include "rtspif.h"     /* RTSPSubscription */
  48. class ASMStreamInfo2;
  50. class ASMSourceInfo2
  51. {
  52. public:
  53.     ASMSourceInfo2(HXSource* pSource);
  54.     ~ASMSourceInfo2();
  56.     UINT32 StreamCount() const;
  57.     ASMStreamInfo2* GetStream(UINT32 i);
  59.     UINT32& SubscribeBw();
  60.     UINT32& LastSetDelivery();
  62.     UINT32& MasterOffer();
  64.     BOOL IsMySource(HXSource* pSource);
  65.     BOOL IsLive();
  66.     BOOL IsPerfectPlay() const;
  68.     BOOL HasMasterRuleBook() const;
  69.     void DistributeBw();
  71.     CHXSimpleList* SubsChanges();
  73.     void SubscribeToChanges();
  74.     void SetDeliveryBw(UINT32 ulMaxBw);
  76.     void Done();
  78. private:
  79.     HX_RESULT GetSubInfo(UINT32 ulBandwidth,
  80.  BOOL* pCurrentSubInfo);
  82.     UINT32 GetStreamBw(IHXValues* pProps, 
  83.        UINT32 ulStreamIndex) const;
  85.     HXSource* m_pSource;
  87.     UINT32 m_ulStreamCount;
  88.     ASMStreamInfo2** m_pStreams;
  90.     UINT32 m_ulSubscribedBw;
  91.     UINT32 m_ulLastSetDelivery;
  93.     UINT32 m_ulMasterOffer;
  95.     BOOL m_bPerfectPlay;
  96.     ASMRuleBook* m_pMasterRuleBook;
  97.     IHXValues* m_pSubsVars;
  98.     CHXSimpleList   m_subsChanges;
  99. };
  101. class ASMStreamInfo2
  102. {
  103. public:
  104.     ASMStreamInfo2(IUnknown* pStream);
  105.     ~ASMStreamInfo2();
  107.     HX_RESULT GetBiasFactor(REF(INT32) lBiasFactor);
  109.     BOOL IsFixedBw() const;
  110.     UINT32 CurrentBw() const;
  112.     UINT32 StreamID() const;
  113.     
  114.     void SetStreamOffer(UINT32 ulOffer);
  116.     void SelectBw(BOOL bPerfectPlay,
  117.   UINT32 ulAltOffer);
  118.     
  119.     UINT32 ResistanceToLower() const;
  121.     void SelectNextLowerBw();
  123.     UINT32 GetLastBw() const;
  124.     void SubscribeToNewBw(UINT32 ulBw, CHXSimpleList* pSubChanges);
  125.     void SubscribeToChanges(CHXSimpleList* pSubChanges);
  127. private:
  128.     void ComputeResistence(BOOL bPerfectPlay);
  130.     BOOL   m_bFixedBwValid;
  131.     UINT32 m_ulFixedBandwidth;
  132.     UINT32 m_ulNumThresholds;
  133.     float* m_pThresholds;
  134.     UINT32 m_ulCurThresh;
  135.     UINT32 m_ulMaxEffectiveThreshold;
  136.     IHXStreamBandwidthBias* m_pBias;
  137.     IHXStreamBandwidthNegotiator* m_pNegotiator;
  138.     IHXAtomicRuleGather* m_pRuleGather;
  140.     UINT32 m_ulStreamID;
  142.     UINT32 m_ulStreamOffer; // From master rulebook
  143.     UINT32 m_ulOffer;       // From SelectBw()
  144.     UINT32 m_ulResistanceToLower;
  146.     UINT32 m_ulLastBw;
  147. };
  149. class ASMStreamInfoItr
  150. {
  151. public:
  152.     ASMStreamInfoItr(CHXSimpleList* pSourceList);
  153.     
  154.     ASMSourceInfo2* Source();
  155.     ASMStreamInfo2* Stream();
  157.     BOOL More() const;
  158.     void Next();
  159.     void Reset();
  161. private:
  162.     void FindNextSource();
  164.     CHXSimpleList* m_pSourceList;
  165.     CHXSimpleList::Iterator m_itr;
  166.     UINT32         m_ulStream;
  167. };
  169. ASMStreamInfoItr::ASMStreamInfoItr(CHXSimpleList* pSourceList) :
  170.     m_pSourceList(pSourceList),
  171.     m_ulStream(0)
  172. {
  173.     Reset();
  174. }
  176. ASMSourceInfo2* ASMStreamInfoItr::Source()
  177. {
  178.     ASMSourceInfo2* pRet = 0;
  179.     
  180.     if (More())
  181.     {
  182. pRet = (ASMSourceInfo2*)(*m_itr);
  183.     }
  185.     return pRet;
  186. }
  188. ASMStreamInfo2* ASMStreamInfoItr::Stream()
  189. {
  190.     ASMStreamInfo2* pRet = 0;
  191.     
  192.     ASMSourceInfo2* pSrc = Source();
  194.     if (pSrc)
  195.     {
  196. pRet = pSrc->GetStream(m_ulStream);
  197.     }
  199.     return pRet;
  200. }
  202. BOOL ASMStreamInfoItr::More() const
  203. {
  204.     return  (m_pSourceList && 
  205.      (m_itr != m_pSourceList->End()));
  206. }
  208. void ASMStreamInfoItr::Next()
  209. {
  210.     if (More())
  211.     {
  212. m_ulStream++;
  214. if (m_ulStream == Source()->StreamCount())
  215. {
  216.     // We are done with this source.
  217.     // Move onto the next one
  218.     m_ulStream = 0;
  220.     ++m_itr;
  221.     FindNextSource();
  222. }
  223.     }
  224. }
  226. void ASMStreamInfoItr::Reset()
  227. {
  228.     if (m_pSourceList)
  229.     {
  230. m_ulStream = 0;
  232. m_itr = m_pSourceList->Begin(); 
  233. FindNextSource();
  234.     }
  235. }
  237. void ASMStreamInfoItr::FindNextSource()
  238. {
  239.     BOOL bDone = FALSE;
  240.     while(!bDone && m_itr != m_pSourceList->End())
  241.     {
  242. ASMSourceInfo2* pSrc = (ASMSourceInfo2*)(*m_itr);
  244. if (pSrc && pSrc->StreamCount() > 0)
  245. {
  246.     bDone = TRUE;
  247. }
  248. else
  249. {
  250.     ++m_itr;
  251. }
  252.     }
  253. }
  255. ASMSourceInfo2::ASMSourceInfo2(HXSource* pSource) :
  256.     m_pSource(pSource),
  257.     m_ulStreamCount(0),
  258.     m_pStreams(0),
  259.     m_ulSubscribedBw(0),
  260.     m_ulLastSetDelivery(0),
  261.     m_ulMasterOffer(0),
  262.     m_bPerfectPlay(FALSE),
  263.     m_pMasterRuleBook(0),
  264.     m_pSubsVars(0)
  265. {
  266.     if (m_pSource)
  267.     {
  268. m_pSource->AddRef();
  269. m_bPerfectPlay = m_pSource->IsPerfectPlay();
  272.         m_ulStreamCount = pSource->GetStreamCount();     
  273. m_pStreams = new ASMStreamInfo2*[m_ulStreamCount];
  275. if (m_pStreams)
  276. {
  277.     for (UINT32 i = 0; i < m_ulStreamCount; i++)
  278.     {
  279. IUnknown* pStream = 0;
  281. HX_VERIFY(HXR_OK == pSource->GetStream(i, pStream));
  283. m_pStreams[i] = new ASMStreamInfo2(pStream);
  284.     
  285. HX_RELEASE(pStream);
  286.     }
  287. }
  289. // Get Master Rulebook
  290. if (pSource->m_pFileHeader)
  291. {
  292.     IHXBuffer* pMasterRuleBook = NULL;
  293.     pSource->m_pFileHeader->
  294. GetPropertyCString("ASMRuleBook", pMasterRuleBook);
  295.     
  296.     if (pMasterRuleBook)
  297.     {
  298. m_pMasterRuleBook = new ASMRuleBook
  299.     ((const char *)pMasterRuleBook->GetBuffer());
  300.     }
  301.     
  302.     HX_RELEASE(pMasterRuleBook);
  303. }
  304.     }
  305. }
  307. ASMSourceInfo2::~ASMSourceInfo2()
  308. {
  309.     if (m_pStreams)
  310.     {
  311. for (UINT32 i = 0; i < m_ulStreamCount; i++)
  312. {
  313.     delete m_pStreams[i];
  314.     m_pStreams[i] = 0;
  315. }
  317. delete [] m_pStreams;
  318.     }
  320.     HX_RELEASE(m_pSource);
  321.     HX_RELEASE(m_pSubsVars);
  323.     delete m_pMasterRuleBook;
  324.     m_pMasterRuleBook = 0;
  325. }
  327. inline
  328. UINT32 ASMSourceInfo2::StreamCount() const
  329. {
  330.     return m_ulStreamCount;
  331. }
  333. ASMStreamInfo2* ASMSourceInfo2::GetStream(UINT32 i)
  334. {
  335.     ASMStreamInfo2* pRet = 0;
  337.     if (m_pStreams && (i < m_ulStreamCount))
  338.     {
  339. pRet = m_pStreams[i];
  340.     }
  342.     return pRet;
  343. }
  345. inline
  346. UINT32& ASMSourceInfo2::SubscribeBw()
  347. {
  348.     return m_ulSubscribedBw;
  349. }
  351. inline
  352. UINT32& ASMSourceInfo2::LastSetDelivery()
  353. {
  354.     return m_ulLastSetDelivery;
  355. }
  357. inline
  358. UINT32& ASMSourceInfo2::MasterOffer()
  359. {
  360.     return m_ulMasterOffer;
  361. }
  363. inline
  364. BOOL ASMSourceInfo2::IsMySource(HXSource* pSource)
  365. {
  366.     return (m_pSource == pSource);
  367. }
  369. BOOL ASMSourceInfo2::IsLive()
  370. {
  371.     BOOL bRet = FALSE;
  373.     if (m_pSource)
  374.     {
  375. bRet = m_pSource->IsLive();
  376.     }
  378.     return bRet;
  379. }
  381. inline
  382. BOOL ASMSourceInfo2::IsPerfectPlay() const
  383. {
  384.     return m_bPerfectPlay;
  385. }
  387. inline
  388. BOOL ASMSourceInfo2::HasMasterRuleBook() const
  389. {
  390.     return (m_pMasterRuleBook != NULL);
  391. }
  393. void ASMSourceInfo2::DistributeBw()
  394. {
  395.     if (m_pMasterRuleBook)
  396.     {
  397. UINT32 ulRuleCount = m_pMasterRuleBook->GetNumRules();
  398. BOOL* pCurrentSubInfo = new BOOL[ulRuleCount];
  400. GetSubInfo(m_ulMasterOffer, pCurrentSubInfo);
  402. for (UINT16 idxRule = 0; idxRule < ulRuleCount; idxRule++)
  403. {
  404.     if (pCurrentSubInfo[idxRule])
  405.     {
  406. IHXValues* pProps = 0;
  407. // Set Distribution
  408. m_pMasterRuleBook->GetProperties(idxRule, pProps);
  410. for (UINT32 j = 0; j < m_ulStreamCount; j++)
  411. {
  412.     UINT32 ulStreamBw = GetStreamBw(pProps, j);
  414.     m_pStreams[j]->SetStreamOffer(ulStreamBw);
  415. }
  417. HX_RELEASE(pProps);
  418. break;
  419.     }
  420. }
  422. delete [] pCurrentSubInfo;
  423.     }
  424. }
  426. inline
  427. CHXSimpleList* ASMSourceInfo2::SubsChanges()
  428. {
  429.     return &m_subsChanges;
  430. }
  432. void ASMSourceInfo2::SubscribeToChanges()
  433. {
  434.     if (!m_subsChanges.IsEmpty() && m_pStreams && m_pStreams[0])
  435.     {
  436. m_pStreams[0]->SubscribeToChanges(&m_subsChanges);
  438. while(!m_subsChanges.IsEmpty())
  439. {
  440.     RTSPSubscription* pSub = (RTSPSubscription*)m_subsChanges.RemoveHead();
  441.     delete pSub;
  442. }
  443.     }
  444. }
  446. void ASMSourceInfo2::SetDeliveryBw(UINT32 ulMaxBw)
  447. {
  448.     if (m_pStreams)
  449.     {
  450. UINT32 ulTotalBw = 0;
  452. // Calculate the total BW used by the streams
  453. for (UINT32 i = 0; i < m_ulStreamCount; i++)
  454. {
  455.     ulTotalBw += m_pStreams[i]->CurrentBw();
  456. }
  458. m_ulSubscribedBw = ulTotalBw;
  460. if (ulTotalBw)
  461. {
  462.     IHXThinnableSource* pThin = 0;
  463.     
  464.     if (HXR_OK == m_pSource->QueryInterface(IID_IHXThinnableSource, 
  465.     (void **)&pThin))
  466.     {
  467. /* Clamp bandwidth request */
  468. if (ulTotalBw > ulMaxBw)
  469. {
  470.     ulTotalBw = ulMaxBw;
  471. }
  473. pThin->SetDeliveryBandwidth(ulTotalBw, 0);
  475. HX_RELEASE(pThin);
  476.     }
  477. }
  478.     }
  479. }
  481. inline
  482. void ASMSourceInfo2::Done()
  483. {
  484.     HX_RELEASE(m_pSource);
  485. }
  487. HX_RESULT ASMSourceInfo2::GetSubInfo(UINT32 ulBandwidth,
  488.      BOOL* pCurrentSubInfo)
  489. {
  490.     HX_RESULT res = HXR_FAILED;
  492.     if (m_pMasterRuleBook)
  493.     {
  494. res = HXSMUpdateSubscriptionVars(m_pSubsVars, ulBandwidth, FALSE, 0);
  496. if (HXR_OK == res)
  497. {
  498.     res = m_pMasterRuleBook->GetSubscription(pCurrentSubInfo, 
  499.      m_pSubsVars);
  500. }
  501.     }
  503.     return res;
  504. }
  506. UINT32 ASMSourceInfo2::GetStreamBw(IHXValues* pProps, 
  507.    UINT32 ulStreamIndex) const
  508. {
  509.     UINT32 ulRet = 0;
  511.     UINT8       pTemp[128];
  512.     IHXBuffer* pBw = NULL;
  513.     HX_RESULT   hxResult;
  514.     
  515.     // Don't assume that streamid == index in m_pStreams[j]
  516.     sprintf((char *)pTemp, 
  517.     "Stream%ldBandwidth", 
  518.     m_pStreams[ulStreamIndex]->StreamID()); /* Flawfinder: ignore */
  519.     
  520.     /*
  521.      * if this tripps either there's a bug in here or
  522.      * the content is messed up
  523.      *
  524.      */
  525.     //If the Stream?Bandwidth property isn't found for
  526.     //all streams don't worry about it. Not all streams
  527.     //may have rule books.
  528.     hxResult = pProps->GetPropertyCString((char *)pTemp, pBw);
  529.     if(HXR_OK == hxResult && pBw)
  530.     {
  531. ulRet = atoi((char*)pBw->GetBuffer());
  533. HX_RELEASE(pBw);
  534.     }
  536.     return ulRet;
  537. }
  539. ASMStreamInfo2::ASMStreamInfo2(IUnknown* pStream) :
  540.     m_bFixedBwValid(FALSE),
  541.     m_ulFixedBandwidth(0),
  542.     m_ulNumThresholds(0),
  543.     m_pThresholds(0),
  544.     m_ulCurThresh(0),
  545.     m_ulMaxEffectiveThreshold(0),
  546.     m_pBias(0),
  547.     m_pNegotiator(0),
  548.     m_pRuleGather(0),
  549.     m_ulStreamID(0),
  550.     m_ulStreamOffer(0),
  551.     m_ulOffer(0),
  552.     m_ulResistanceToLower(0xffffffff)
  553. {
  554.     if (pStream)
  555.     {
  556. if (HXR_OK == pStream->QueryInterface
  557.     (IID_IHXStreamBandwidthNegotiator,
  558.      (void **)&m_pNegotiator))
  559. {
  560.     m_pNegotiator->GetFixedBandwidth(m_ulFixedBandwidth);
  562.     if (m_ulFixedBandwidth)
  563.     {
  564. /* We need to check to see if the fixed bandwidth value
  565.  * matches the ASMProps Bandwidth value. If it doesn't then
  566.  * that means that we are dealing with a clip that doesn't
  567.  * advertise any bandwidth information. This is a corner
  568.  * case discover by streaming some unhinted .3gp files.
  569.  */
  570. IHXASMProps* pASMProps = NULL;
  571. UINT32 ulASMBw = 0;
  573. if ((HXR_OK == pStream->QueryInterface(IID_IHXASMProps,
  574.        (void**)&pASMProps))&&
  575.     (HXR_OK == pASMProps->GetBandwidth(ulASMBw)) &&
  576.     (m_ulFixedBandwidth == ulASMBw))
  577. {
  578.     m_bFixedBwValid = TRUE;
  579. }
  581. HX_RELEASE(pASMProps);
  582.     }
  583.     else
  584.     {
  585. m_ulNumThresholds = m_pNegotiator->GetNumThresholds();
  586. m_pThresholds = new float[m_ulNumThresholds];
  588. if (m_pThresholds)
  589. {
  590.     m_pNegotiator->GetThresholdInfo(m_pThresholds, 
  591. m_ulNumThresholds);
  593.     m_ulMaxEffectiveThreshold = m_ulNumThresholds - 1;
  594. }
  595.     }
  596. }
  598. pStream->QueryInterface(IID_IHXStreamBandwidthBias,
  599. (void **)&m_pBias);
  601. pStream->QueryInterface(IID_IHXAtomicRuleGather,
  602. (void **)&m_pRuleGather);
  604. // Get StreamID
  605. IHXStream* pHXStream = 0;
  607. pStream->QueryInterface(IID_IHXStream, (void**)&pHXStream);
  608. if (pHXStream)
  609.         {
  610.             m_ulStreamID = pHXStream->GetStreamNumber();
  611.             pHXStream->Release();
  612.         }
  613.     }
  614. }
  616. ASMStreamInfo2::~ASMStreamInfo2()
  617. {
  618.     delete [] m_pThresholds;
  619.     m_pThresholds = 0;
  621.     HX_RELEASE(m_pBias);
  622.     HX_RELEASE(m_pNegotiator);
  623.     HX_RELEASE(m_pRuleGather);
  624. }
  626. HX_RESULT ASMStreamInfo2::GetBiasFactor(REF(INT32) lBiasFactor)
  627. {
  628.     HX_RESULT res = HXR_FAILED;
  629.     
  630.     if (m_pBias)
  631.     {
  632. res = m_pBias->GetBiasFactor(lBiasFactor);
  633.     }
  635.     return res;
  636. }
  638. inline
  639. BOOL ASMStreamInfo2::IsFixedBw() const
  640. {
  641.     return (m_ulFixedBandwidth != 0);
  642. }
  644. UINT32 ASMStreamInfo2::CurrentBw() const
  645. {
  646.     UINT32 ulRet = (m_bFixedBwValid) ? m_ulFixedBandwidth : 0;
  648.     if (!ulRet && m_pThresholds)
  649.     {
  650. ulRet = (UINT32)m_pThresholds[m_ulCurThresh];
  651.     }
  653.     return ulRet;
  654. }
  656. inline
  657. UINT32 ASMStreamInfo2::StreamID() const
  658. {
  659.     return m_ulStreamID;
  660. }
  662. inline
  663. void ASMStreamInfo2::SetStreamOffer(UINT32 ulOffer)
  664. {
  665.     m_ulStreamOffer = ulOffer;
  666. }
  668. void ASMStreamInfo2::SelectBw(BOOL bPerfectPlay,
  669.       UINT32 ulAltOffer)
  670. {
  671.     if (m_pThresholds)
  672.     {
  673. if (bPerfectPlay)
  674. {
  675.     /*
  676.      * If we are in perfect play mode, just select the highest bandwidth rule
  677.      * and don't negotiate any further.
  678.      */
  679.     m_ulCurThresh = m_ulMaxEffectiveThreshold;
  680.     m_ulOffer = CurrentBw();
  681. }
  682. else
  683. { 
  684.     UINT32 ulOffer = ulAltOffer;
  686.     if (m_ulStreamOffer)
  687.     {
  688. ulOffer = m_ulStreamOffer - 1;
  689.     }
  690.     
  691.     if (m_ulMaxEffectiveThreshold != 0)
  692.     {
  693. for (UINT32 i = 1; i <= m_ulMaxEffectiveThreshold; i++)
  694. {
  695.     if ((ulOffer <= m_pThresholds[i]) ||
  696. (i == m_ulMaxEffectiveThreshold))
  697.     {
  698. m_ulOffer = ulOffer;
  699. m_ulCurThresh = i;
  700. break;
  701.     }
  702. }
  703.     }
  704. }
  706. ComputeResistence(bPerfectPlay);
  707.     }
  708. }
  710. inline
  711. UINT32 ASMStreamInfo2::ResistanceToLower() const
  712. {
  713.     return m_ulResistanceToLower;
  714. }
  716. void ASMStreamInfo2::SelectNextLowerBw()
  717. {
  718.     if (m_ulCurThresh > 0)
  719.     {
  720. m_ulCurThresh--;
  722. ComputeResistence(FALSE);
  723.     }
  724. }
  726. inline
  727. UINT32 ASMStreamInfo2::GetLastBw() const
  728. {
  729.     return m_ulLastBw;
  730. }
  732. void ASMStreamInfo2::SubscribeToNewBw(UINT32 ulBw, CHXSimpleList* pSubChanges)
  733. {
  734.     BOOL bTimeStampDelivery = FALSE;
  735.     
  736.     if (m_pRuleGather && m_pNegotiator)
  737.     {
  738. m_pRuleGather->RuleGather(pSubChanges);
  740. //update the HXASMStream with our new bandwidth
  741. m_pNegotiator->SetBandwidthUsage(ulBw, bTimeStampDelivery);
  743. m_pRuleGather->RuleGather(0);
  744.     }
  746.     m_ulLastBw = ulBw;
  747. }
  749. void ASMStreamInfo2::SubscribeToChanges(CHXSimpleList* pSubChanges)
  750. {
  751.     if (m_pRuleGather)
  752.     {
  753. m_pRuleGather->RuleFlush(pSubChanges);
  754.     }
  755. }
  757. void ASMStreamInfo2::ComputeResistence(BOOL bPerfectPlay)
  758. {
  759.     /* NOTE:
  760.      * m_ulCurThresh and m_ulOffer must
  761.      * be valid when this function is called
  762.      */
  764.     if (IsFixedBw() || 
  765. bPerfectPlay ||
  766. (m_ulMaxEffectiveThreshold == 0) ||
  767. (m_ulCurThresh == 1))
  768.     {
  769. m_ulResistanceToLower = 0xffffffff;
  770.     }
  771.     else
  772.     {
  773. m_ulResistanceToLower = 
  774.     (m_ulOffer - (UINT32)m_pThresholds[m_ulCurThresh - 1]) * m_ulOffer;
  775.     }
  776. }
  778. HXSM2::HXSM2() :
  779.     m_lRefCount(0),
  780.     m_ulNumSources(0),
  781.     m_pASMSourceInfo(0),
  782.     m_ulNumStreams(0),
  783.     m_ulOfferToRecalc(0),
  784.     m_ulSelectionBitRate(0),
  785.     m_ulMaxAccelBitRate(0),
  786.     m_ulSustainableBitRate(0),
  787.     m_pSubscriptionVariables(0),
  788.     m_bCheckOnDemandBw(FALSE)
  789. {
  790.     m_pASMSourceInfo = new CHXSimpleList();
  791. }
  793. HXSM2::~HXSM2()
  794. {
  795.     if (m_pASMSourceInfo)
  796.     {
  797. while(!m_pASMSourceInfo->IsEmpty())
  798. {
  799.     ASMSourceInfo2* pSrc = 
  800. (ASMSourceInfo2*)m_pASMSourceInfo->RemoveHead();
  802.     delete pSrc;
  803. }
  805. delete m_pASMSourceInfo;
  806.     }
  807. }
  809. STDMETHODIMP HXSM2::QueryInterface(THIS_ REFIID ID, void** ppInterfaceObj)
  810. {
  811. QInterfaceList qiList[] =
  812. {
  813. { GET_IIDHANDLE(IID_IUnknown), this },
  814. { GET_IIDHANDLE(IID_IHXBandwidthManager), (IHXBandwidthManager*) this },
  815. };
  816.     return QIFind(qiList, QILISTSIZE(qiList), ID, ppInterfaceObj);
  817. }
  819. STDMETHODIMP_(UINT32) HXSM2::AddRef(THIS)
  820. {
  821.     return InterlockedIncrement(&m_lRefCount);
  822. }
  824. STDMETHODIMP_(UINT32) HXSM2::Release(THIS)
  825. {
  826.     if (InterlockedDecrement(&m_lRefCount) > 0)
  827.     {
  828. return m_lRefCount;
  829.     }
  831.     delete this;
  832.     return 0;
  833. }
  835. /*
  836.  * IHXBandwidthManager methods
  837.  */
  838. STDMETHODIMP HXSM2::RegisterSource(THIS_
  839.    HXSource* pSource,
  840.    IUnknown* pUnknown)
  841. {
  842.     HX_RESULT res = HXR_OK;
  844.     IHXSourceBandwidthInfo* pSBI;
  845.     IHXPreferences* pPreferences = NULL;
  846.     IHXBuffer* pBuffer = 0;
  847.     ASMSourceInfo2* pASMSourceInfo = NULL;
  849.     if (HXR_OK == pSource->QueryInterface(IID_IHXSourceBandwidthInfo, 
  850.             (void **)&pSBI))
  851.     {
  852.         pASMSourceInfo = new ASMSourceInfo2(pSource);
  854.         m_ulNumSources++;
  855.         m_ulNumStreams += pASMSourceInfo->StreamCount();
  857.         m_pASMSourceInfo->AddTail((void *)pASMSourceInfo);
  859.         HX_RELEASE(pSBI);
  860.     }
  861.     else
  862.     {
  863.         return HXR_OK;
  864.     }
  866.     /*
  867.      * This variable tells us the highest amount of bandwidth that we
  868.      * believe is useable.  If we stream thin, then the highest value
  869.      * that the pipe can support would be the aggregate bandwidth of
  870.      * the sources.  Barring any thinning, this would be the bandwidth
  871.      * from prefs (unless we can determine it through fast buffering or
  872.      * another transport feature).  This value is used when starting sources
  873.      * as a initial guess for bandwidth (to set subscriptions).
  874.      */
  875.     if (m_ulSelectionBitRate == 0)
  876.     {
  877.         pUnknown->QueryInterface(IID_IHXPreferences, (void **)&pPreferences);
  879.         UINT32 ulTemp = 0;
  880.         UINT32 ulConnectionBw = 10485760; /* wild guess */
  882.         /* Get initial bandwidth guess from Prefs */
  883.         if ((HXR_OK == ReadPrefINT32(pPreferences, "Bandwidth", ulTemp)) &&
  884.             (ulTemp > 0))
  885.         {
  886.             ulConnectionBw = ulTemp;
  887.         }
  889.         /*
  890.          * m_ulSustainableBitRate refers to the max bitrate that we believe is
  891.          * sustainable over the connection. The client should never ask
  892.          * the server to send bits faster than this rate because it could
  893.          * cause congestion collapse.
  894.          *
  895.          * m_ulSelectionBitRate refers to the highest bitrate stream that we'll
  896.          * ever try to play. Note that people can choose to pick values
  897.          * where m_ulSelectionBitRate > m_ulSustainableBitRate. This may
  898.  * cause rebuffers because the delivery will be capped at 
  899.  * m_ulSustainableBitRate. Why would someone do that? They may accept
  900.  * rebuffers if it means they get a higher quality presentation.
  901.          */
  902.         
  903.         /* See if we have a sustainable bandwidth factor */
  904.         if (HXR_OK == ReadPrefINT32(pPreferences, "SustainableBwFactor", 
  905.                                     ulTemp))
  906.         {
  907.             /* clamp value to 0 <= ulTemp <= 100 range */
  908.             if (ulTemp > 100)
  909.             {
  910.                 ulTemp = 100;
  911.             }
  912.             
  913.             /* Apply factor */
  914.             m_ulSustainableBitRate = 
  915.                 (((ulConnectionBw / 100) * ulTemp) + 
  916.                  (((ulConnectionBw % 100) * ulTemp) / 100));
  917.         }
  918.         else
  919.         {
  920.             m_ulSustainableBitRate = ulConnectionBw;
  921.         }
  922.         
  924.         /* See if we have a selection bandwidth factor */
  925.         if (HXR_OK == ReadPrefINT32(pPreferences, "SelectionBwFactor", 
  926.                                     ulTemp))
  927.         {
  928.             /* clamp value to 0 <= ulTemp <= 200 range */
  929.             if (ulTemp > 200)
  930.             {
  931.                 ulTemp = 200;
  932.             }
  933.             
  934.             /* Apply factor */
  935.             m_ulSelectionBitRate  = 
  936.                 (((m_ulSustainableBitRate / 100) * ulTemp) + 
  937.                  (((m_ulSustainableBitRate % 100) * ulTemp) / 100));
  938.         }
  939.         else
  940.         {
  941.             m_ulSelectionBitRate = m_ulSustainableBitRate; 
  942.         }
  944.         /* Get MaxBandwidth from Prefs */
  945.         if (HXR_OK != ReadPrefINT32(pPreferences, "MaxBandwidth", 
  946.                                     m_ulMaxAccelBitRate))
  947.         {
  948.             /* 
  949.              * Failed to get the MaxBandwidth preference. 
  950.              * Use m_ulSelectionBitRate value instead.
  951.              */
  952.             m_ulMaxAccelBitRate = m_ulSelectionBitRate;
  953.         }
  955.         /* 
  956.          * Get preference that controls whether we report
  957.          * "not enough bandwidth" conditions for on-demand clips
  958.          */
  959.         ReadPrefBOOL(pPreferences, "CheckOnDemandBw", m_bCheckOnDemandBw);
  961.         HX_RELEASE(pPreferences);
  962.     }
  964.     return res;
  965. }
  967. STDMETHODIMP HXSM2::RegisterSourcesDone(THIS)
  968. {
  969.     CHXSimpleList::Iterator     i;
  970.     ASMSourceInfo2*    pASMSourceInfo;
  972.     for (i = m_pASMSourceInfo->Begin(); i != m_pASMSourceInfo->End(); ++i)
  973.     {
  974. pASMSourceInfo = (ASMSourceInfo2*)(*i);
  975. if (pASMSourceInfo)
  976. {
  977.     pASMSourceInfo->LastSetDelivery() = 0;
  978. }
  979.     }
  980.     
  981.     m_ulOfferToRecalc = m_ulSelectionBitRate;
  983.     if (m_ulOfferToRecalc > m_ulMaxAccelBitRate)
  984.     {
  985. m_ulOfferToRecalc = m_ulMaxAccelBitRate;
  986.     }
  988.     Recalc();
  990.     return HXR_OK;
  991. }
  992.     
  993. STDMETHODIMP_(BOOL) HXSM2::NotEnoughBandwidth(THIS)
  994. {
  995.     CHXSimpleList::Iterator i;
  996.     ASMSourceInfo2*          pASMSourceInfo;
  997.     UINT32     ulTotal = 0;
  998.     BOOL     bCheckTotal = m_bCheckOnDemandBw;
  1000.     for (i = m_pASMSourceInfo->Begin(); i != m_pASMSourceInfo->End(); ++i)
  1001.     {
  1002. pASMSourceInfo = (ASMSourceInfo2*)(*i);
  1004. ulTotal += pASMSourceInfo->SubscribeBw();
  1006. if (pASMSourceInfo->IsLive())
  1007. {
  1008.     bCheckTotal = TRUE;
  1009. }
  1010.     }
  1012.     if (bCheckTotal && ulTotal > m_ulSelectionBitRate)
  1013.     {
  1014. return TRUE;
  1015.     }
  1016.     else
  1017.     {
  1018. return FALSE;
  1019.     }
  1020. }
  1022. STDMETHODIMP HXSM2::UnRegisterSource(THIS_
  1023.      HXSource* pSource)
  1024. {
  1025.     LISTPOSITION lPos;
  1026.     ASMSourceInfo2*             pASMSourceInfo = 0;
  1027.     BOOL bFound = FALSE;
  1029.     lPos = m_pASMSourceInfo->GetHeadPosition();
  1031.     while (lPos)
  1032.     {
  1033. pASMSourceInfo = (ASMSourceInfo2*)m_pASMSourceInfo->GetAt(lPos);
  1034. if (pASMSourceInfo->IsMySource(pSource))
  1035. {
  1036.     m_pASMSourceInfo->RemoveAt(lPos);
  1037.     pASMSourceInfo->Done();
  1038.     bFound  = TRUE;
  1039.     break;
  1040. }
  1041. m_pASMSourceInfo->GetNext(lPos);
  1042.     }
  1043.     
  1044.     if (bFound)
  1045.     {
  1046. m_ulNumStreams -= pASMSourceInfo->StreamCount();
  1048. delete pASMSourceInfo;
  1050. m_ulNumSources--;
  1052. if (m_ulNumSources > 0)
  1053. {
  1054.     Recalc();
  1055. }
  1056.     }
  1058.     return HXR_OK;
  1059. }
  1061. STDMETHODIMP HXSM2::ChangeAccelerationStatus(THIS_
  1062. HXSource* pSource,
  1063. BOOL    bMayBeAccelerated,
  1064. BOOL    bUseAccelerationFactor,
  1065. UINT32    ulAccelerationFactor)
  1066. {
  1068.     return HXR_OK;
  1069. }
  1071.     /* Called by HXPlayer at end of each presentation */
  1072. STDMETHODIMP HXSM2::PresentationDone(THIS)
  1073. {
  1074.     return HXR_OK;
  1075. }
  1076.     
  1077. STDMETHODIMP HXSM2::ChangeBW(THIS_ 
  1078.      UINT32 newBW, HXSource* pSource)
  1079. {
  1080.     return HXR_OK;
  1081. }
  1083. void
  1084. HXSM2::Recalc()
  1085. {
  1086.     CHXSimpleList::Iterator     i;
  1087.     ASMStreamInfoItr            streamItr(m_pASMSourceInfo);
  1088.     ASMSourceInfo2*             pASMSourceInfo;
  1089.     ASMStreamInfo2*             pASMStreamInfo;
  1090.     INT32 lAggregateBandwidthUsage = 0;
  1091.     UINT32 ulSourceCount;
  1092.     UINT32 ulStreamCount;
  1093.     float fBiasMean = (float) 0.;
  1095.     ulSourceCount = m_pASMSourceInfo->GetCount();
  1096.     ulStreamCount = m_ulNumStreams;
  1098.     for (i = m_pASMSourceInfo->Begin(); i != m_pASMSourceInfo->End(); ++i)
  1099.     {
  1100. pASMSourceInfo = (ASMSourceInfo2*)(*i);
  1102.         /* Init these for later */
  1103. pASMSourceInfo->MasterOffer() = 0;
  1104.     }
  1106.     lAggregateBandwidthUsage = m_ulOfferToRecalc;
  1108.     INT32 lCorrectAggregateBandwidthUsage = lAggregateBandwidthUsage;
  1110.     /*
  1111.      * For each stream that is at a fixed bitrate, remove that bitrate
  1112.      * from our available bandwidth.
  1113.      */
  1114.     for (streamItr.Reset(); streamItr.More(); streamItr.Next())
  1115.     {
  1116.         INT32 lBias;
  1118. pASMStreamInfo = streamItr.Stream();
  1120. HX_VERIFY(HXR_OK == pASMStreamInfo->GetBiasFactor(lBias));
  1121. fBiasMean += lBias;
  1123. if (pASMStreamInfo->IsFixedBw())
  1124. {
  1125.     lAggregateBandwidthUsage -= pASMStreamInfo->CurrentBw();
  1126.     ulStreamCount--;
  1127. }
  1129. /* Init this for later */
  1130. pASMStreamInfo->SetStreamOffer(0);
  1131.     }
  1133.     if (ulStreamCount != 0)
  1134.     {
  1135.         /* At least 1 stream is not fixed bandwidth */
  1137.         fBiasMean /= ulStreamCount;
  1138.         
  1139.         /*
  1140.          * Calculate the offer for each source that has a master rulebook
  1141.          * defining it's bandwidth division.
  1142.          */
  1143.         INT32 lNewAggregateBandwidthUsage = lAggregateBandwidthUsage;
  1145.         for (streamItr.Reset(); streamItr.More(); streamItr.Next())
  1146.         {
  1147.             INT32 lBias;
  1148.             
  1149.             pASMStreamInfo = streamItr.Stream();
  1150.             pASMSourceInfo = streamItr.Source();
  1151.             
  1152.             HX_VERIFY(HXR_OK == pASMStreamInfo->GetBiasFactor(lBias));
  1153.             
  1154.             if (pASMSourceInfo->HasMasterRuleBook())
  1155.             {
  1156.                 UINT32 ulOffer = 
  1157.                     (UINT32)(lAggregateBandwidthUsage / ulStreamCount);
  1158.                 
  1159.                 ulOffer += 
  1160.                     (UINT32)(((float)lBias - fBiasMean) *
  1161.                              ((float)lAggregateBandwidthUsage / 100.0) *
  1162.                              (2.0 / ulStreamCount));
  1163.                 
  1164.                 pASMSourceInfo->MasterOffer() += ulOffer;
  1165.                 lNewAggregateBandwidthUsage -= ulOffer;
  1166.             }
  1167.         }
  1169.         lAggregateBandwidthUsage = lNewAggregateBandwidthUsage;
  1170.     }
  1172.     /*
  1173.      * For each source that has a master rule book, evaluate it to find
  1174.      * out how much to distribute to each stream.
  1175.      */
  1176.     for (i = m_pASMSourceInfo->Begin(); i != m_pASMSourceInfo->End(); ++i)
  1177.     {
  1178. pASMSourceInfo = (ASMSourceInfo2*)(*i);
  1179. if (pASMSourceInfo->HasMasterRuleBook())
  1180. {
  1181.     pASMSourceInfo->DistributeBw();
  1182. }
  1183.     }
  1185.     /*
  1186.      *  Now go through each of the streams that are not at a
  1187.      *  fixed bitrate and try to distribute the rest of the bandwidth.
  1188.      */
  1189.     UINT32 ulTakenBandwidth = 0;
  1191.     for (streamItr.Reset(); streamItr.More(); streamItr.Next())
  1192.     {
  1193. pASMStreamInfo = streamItr.Stream();
  1195. if (!pASMStreamInfo->IsFixedBw())
  1196. {
  1197.     INT32 lBias;
  1198.     
  1199.     HX_VERIFY(HXR_OK == pASMStreamInfo->GetBiasFactor(lBias));
  1200.     
  1201.     UINT32 ulAltOffer =
  1202. (UINT32)(lAggregateBandwidthUsage / (float)ulStreamCount);
  1204.     ulAltOffer += (UINT32)(((float)lBias - fBiasMean) *
  1205.    ((float)lAggregateBandwidthUsage / 100.0) *
  1206.    (2.0 / (float)ulStreamCount));
  1208.     pASMStreamInfo->SelectBw(streamItr.Source()->IsPerfectPlay(),
  1209.      ulAltOffer);
  1210. }
  1212. ulTakenBandwidth += pASMStreamInfo->CurrentBw();
  1213.     }
  1215.     lAggregateBandwidthUsage = lCorrectAggregateBandwidthUsage;
  1217.     BOOL bDone = FALSE;
  1218.     while (!bDone && (lAggregateBandwidthUsage < (INT32)ulTakenBandwidth))
  1219.     {
  1220. /* Resistance is Futile.  You will be Real(tm)lyAssimilated */
  1221. UINT32 ulLowestResistance = 0xffffffff;
  1222. ASMStreamInfo2* pLowestResistanceStream  = 0;
  1224. // Find the stream with the lowest resistence
  1225. for (streamItr.Reset(); streamItr.More(); streamItr.Next())
  1226. {
  1227.     pASMStreamInfo = streamItr.Stream();
  1229.     if (pASMStreamInfo->ResistanceToLower() < ulLowestResistance)
  1230.     {
  1231. ulLowestResistance = pASMStreamInfo->ResistanceToLower();
  1232. pLowestResistanceStream = pASMStreamInfo;
  1233.     }
  1234. }
  1236. if (ulLowestResistance == 0xffffffff)
  1237. {
  1238.     bDone = TRUE;
  1239. }
  1240. else
  1241. {
  1242.     ulTakenBandwidth -= (UINT32)
  1243. pLowestResistanceStream->CurrentBw();
  1245.     pLowestResistanceStream->SelectNextLowerBw();
  1247.     ulTakenBandwidth += (UINT32)
  1248. pLowestResistanceStream->CurrentBw();
  1249. }
  1250.     }
  1252.     UINT32 ulLeftOverForDropByN = lAggregateBandwidthUsage - ulTakenBandwidth;
  1253.     BOOL bForce = FALSE;
  1255.     for (streamItr.Reset(); streamItr.More(); streamItr.Next())
  1256.     {
  1257. pASMStreamInfo = streamItr.Stream();
  1259. UINT32 ulBw = pASMStreamInfo->CurrentBw();
  1261. if (ulBw == 1)
  1262. {
  1263.     // Hack Alert for DropByN. XXXSMP
  1264.     ulBw = ulLeftOverForDropByN;
  1265. }
  1267. if ((ulBw != pASMStreamInfo->GetLastBw()) &&
  1268.     (pASMStreamInfo->IsFixedBw()))
  1269. {
  1270.     bForce = TRUE;
  1271. }
  1273. CHXSimpleList* pSubsChanges = 
  1274.     streamItr.Source()->SubsChanges();
  1276. pASMStreamInfo->SubscribeToNewBw(ulBw, pSubsChanges);
  1277.     }
  1279.     for (i = m_pASMSourceInfo->Begin(); i != m_pASMSourceInfo->End(); ++i)
  1280.     {
  1281. pASMSourceInfo = (ASMSourceInfo2*)(*i);
  1283. pASMSourceInfo->SubscribeToChanges();
  1284. pASMSourceInfo->SetDeliveryBw(m_ulSustainableBitRate);
  1285.     }
  1286. }