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

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

Symbian

开发平台：

Visual C++

hxsm2.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: hxsm2.cpp,v 1.9.8.2 2004/07/09 02:05:30 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 "hxsm2.h"
  51. #include "hxsmutil.h"
  52. #include "ihxpckts.h"
  53. #include "hxprefs.h"
  54. #include "hxpref.h"
  55. #include "hxbsrc.h" /* HXSource */
  56. #include "asmrulep.h" /* ASMRuleBook */
  57. #include "hxbuffer.h" /* CHXBuffer */
  58. #include "chxpckts.h" /* CHXHeader */
  59. #include "safestring.h" /* SafeSprintf */
  60. #include "rtspif.h"     /* RTSPSubscription */
  62. class ASMStreamInfo2;
  64. class ASMSourceInfo2
  65. {
  66. public:
  67.     ASMSourceInfo2(HXSource* pSource);
  68.     ~ASMSourceInfo2();
  70.     UINT32 StreamCount() const;
  71.     ASMStreamInfo2* GetStream(UINT32 i);
  73.     UINT32& SubscribeBw();
  74.     UINT32& LastSetDelivery();
  76.     UINT32& MasterOffer();
  78.     BOOL IsMySource(HXSource* pSource);
  79.     BOOL IsLive();
  80.     BOOL IsPerfectPlay() const;
  82.     BOOL HasMasterRuleBook() const;
  83.     void DistributeBw();
  85.     CHXSimpleList* SubsChanges();
  87.     void SubscribeToChanges();
  88.     void SetDeliveryBw(UINT32 ulMaxBw);
  90.     void Done();
  92. private:
  93.     HX_RESULT GetSubInfo(UINT32 ulBandwidth,
  94.  BOOL* pCurrentSubInfo);
  96.     UINT32 GetStreamBw(IHXValues* pProps, 
  97.        UINT32 ulStreamIndex) const;
  99.     HXSource* m_pSource;
  101.     UINT32 m_ulStreamCount;
  102.     ASMStreamInfo2** m_pStreams;
  104.     UINT32 m_ulSubscribedBw;
  105.     UINT32 m_ulLastSetDelivery;
  107.     UINT32 m_ulMasterOffer;
  109.     BOOL m_bPerfectPlay;
  110.     ASMRuleBook* m_pMasterRuleBook;
  111.     IHXValues* m_pSubsVars;
  112.     CHXSimpleList   m_subsChanges;
  113. };
  115. class ASMStreamInfo2
  116. {
  117. public:
  118.     ASMStreamInfo2(IUnknown* pStream);
  119.     ~ASMStreamInfo2();
  121.     HX_RESULT GetBiasFactor(REF(INT32) lBiasFactor);
  123.     BOOL IsFixedBw() const;
  124.     UINT32 CurrentBw() const;
  126.     UINT32 StreamID() const;
  127.     
  128.     void SetStreamOffer(UINT32 ulOffer);
  130.     void SelectBw(BOOL bPerfectPlay,
  131.   UINT32 ulAltOffer);
  132.     
  133.     UINT32 ResistanceToLower() const;
  135.     void SelectNextLowerBw();
  137.     UINT32 GetLastBw() const;
  138.     void SubscribeToNewBw(UINT32 ulBw, CHXSimpleList* pSubChanges);
  139.     void SubscribeToChanges(CHXSimpleList* pSubChanges);
  141. private:
  142.     void ComputeResistence(BOOL bPerfectPlay);
  144.     BOOL   m_bFixedBwValid;
  145.     UINT32 m_ulFixedBandwidth;
  146.     UINT32 m_ulNumThresholds;
  147.     float* m_pThresholds;
  148.     UINT32 m_ulCurThresh;
  149.     UINT32 m_ulMaxEffectiveThreshold;
  150.     IHXStreamBandwidthBias* m_pBias;
  151.     IHXStreamBandwidthNegotiator* m_pNegotiator;
  152.     IHXAtomicRuleGather* m_pRuleGather;
  154.     UINT32 m_ulStreamID;
  156.     UINT32 m_ulStreamOffer; // From master rulebook
  157.     UINT32 m_ulOffer;       // From SelectBw()
  158.     UINT32 m_ulResistanceToLower;
  160.     UINT32 m_ulLastBw;
  161. };
  163. class ASMStreamInfoItr
  164. {
  165. public:
  166.     ASMStreamInfoItr(CHXSimpleList* pSourceList);
  167.     
  168.     ASMSourceInfo2* Source();
  169.     ASMStreamInfo2* Stream();
  171.     BOOL More() const;
  172.     void Next();
  173.     void Reset();
  175. private:
  176.     void FindNextSource();
  178.     CHXSimpleList* m_pSourceList;
  179.     CHXSimpleList::Iterator m_itr;
  180.     UINT32         m_ulStream;
  181. };
  183. ASMStreamInfoItr::ASMStreamInfoItr(CHXSimpleList* pSourceList) :
  184.     m_pSourceList(pSourceList),
  185.     m_ulStream(0)
  186. {
  187.     Reset();
  188. }
  190. ASMSourceInfo2* ASMStreamInfoItr::Source()
  191. {
  192.     ASMSourceInfo2* pRet = 0;
  193.     
  194.     if (More())
  195.     {
  196. pRet = (ASMSourceInfo2*)(*m_itr);
  197.     }
  199.     return pRet;
  200. }
  202. ASMStreamInfo2* ASMStreamInfoItr::Stream()
  203. {
  204.     ASMStreamInfo2* pRet = 0;
  205.     
  206.     ASMSourceInfo2* pSrc = Source();
  208.     if (pSrc)
  209.     {
  210. pRet = pSrc->GetStream(m_ulStream);
  211.     }
  213.     return pRet;
  214. }
  216. BOOL ASMStreamInfoItr::More() const
  217. {
  218.     return  (m_pSourceList && 
  219.      (m_itr != m_pSourceList->End()));
  220. }
  222. void ASMStreamInfoItr::Next()
  223. {
  224.     if (More())
  225.     {
  226. m_ulStream++;
  228. if (m_ulStream == Source()->StreamCount())
  229. {
  230.     // We are done with this source.
  231.     // Move onto the next one
  232.     m_ulStream = 0;
  234.     ++m_itr;
  235.     FindNextSource();
  236. }
  237.     }
  238. }
  240. void ASMStreamInfoItr::Reset()
  241. {
  242.     if (m_pSourceList)
  243.     {
  244. m_ulStream = 0;
  246. m_itr = m_pSourceList->Begin(); 
  247. FindNextSource();
  248.     }
  249. }
  251. void ASMStreamInfoItr::FindNextSource()
  252. {
  253.     BOOL bDone = FALSE;
  254.     while(!bDone && m_itr != m_pSourceList->End())
  255.     {
  256. ASMSourceInfo2* pSrc = (ASMSourceInfo2*)(*m_itr);
  258. if (pSrc && pSrc->StreamCount() > 0)
  259. {
  260.     bDone = TRUE;
  261. }
  262. else
  263. {
  264.     ++m_itr;
  265. }
  266.     }
  267. }
  269. ASMSourceInfo2::ASMSourceInfo2(HXSource* pSource) :
  270.     m_pSource(pSource),
  271.     m_ulStreamCount(0),
  272.     m_pStreams(0),
  273.     m_ulSubscribedBw(0),
  274.     m_ulLastSetDelivery(0),
  275.     m_ulMasterOffer(0),
  276.     m_bPerfectPlay(FALSE),
  277.     m_pMasterRuleBook(0),
  278.     m_pSubsVars(0)
  279. {
  280.     if (m_pSource)
  281.     {
  282. m_pSource->AddRef();
  283. m_bPerfectPlay = m_pSource->IsPerfectPlay();
  286.         m_ulStreamCount = pSource->GetStreamCount();     
  287. m_pStreams = new ASMStreamInfo2*[m_ulStreamCount];
  289. if (m_pStreams)
  290. {
  291.     for (UINT32 i = 0; i < m_ulStreamCount; i++)
  292.     {
  293. IUnknown* pStream = 0;
  295. HX_VERIFY(HXR_OK == pSource->GetStream(i, pStream));
  297. m_pStreams[i] = new ASMStreamInfo2(pStream);
  298.     
  299. HX_RELEASE(pStream);
  300.     }
  301. }
  303. // Get Master Rulebook
  304. if (pSource->m_pFileHeader)
  305. {
  306.     IHXBuffer* pMasterRuleBook = NULL;
  307.     pSource->m_pFileHeader->
  308. GetPropertyCString("ASMRuleBook", pMasterRuleBook);
  309.     
  310.     if (pMasterRuleBook)
  311.     {
  312. m_pMasterRuleBook = new ASMRuleBook
  313.     ((const char *)pMasterRuleBook->GetBuffer());
  314.     }
  315.     
  316.     HX_RELEASE(pMasterRuleBook);
  317. }
  318.     }
  319. }
  321. ASMSourceInfo2::~ASMSourceInfo2()
  322. {
  323.     if (m_pStreams)
  324.     {
  325. for (UINT32 i = 0; i < m_ulStreamCount; i++)
  326. {
  327.     delete m_pStreams[i];
  328.     m_pStreams[i] = 0;
  329. }
  331. delete [] m_pStreams;
  332.     }
  334.     HX_RELEASE(m_pSource);
  335.     HX_RELEASE(m_pSubsVars);
  337.     delete m_pMasterRuleBook;
  338.     m_pMasterRuleBook = 0;
  339. }
  341. inline
  342. UINT32 ASMSourceInfo2::StreamCount() const
  343. {
  344.     return m_ulStreamCount;
  345. }
  347. ASMStreamInfo2* ASMSourceInfo2::GetStream(UINT32 i)
  348. {
  349.     ASMStreamInfo2* pRet = 0;
  351.     if (m_pStreams && (i < m_ulStreamCount))
  352.     {
  353. pRet = m_pStreams[i];
  354.     }
  356.     return pRet;
  357. }
  359. inline
  360. UINT32& ASMSourceInfo2::SubscribeBw()
  361. {
  362.     return m_ulSubscribedBw;
  363. }
  365. inline
  366. UINT32& ASMSourceInfo2::LastSetDelivery()
  367. {
  368.     return m_ulLastSetDelivery;
  369. }
  371. inline
  372. UINT32& ASMSourceInfo2::MasterOffer()
  373. {
  374.     return m_ulMasterOffer;
  375. }
  377. inline
  378. BOOL ASMSourceInfo2::IsMySource(HXSource* pSource)
  379. {
  380.     return (m_pSource == pSource);
  381. }
  383. BOOL ASMSourceInfo2::IsLive()
  384. {
  385.     BOOL bRet = FALSE;
  387.     if (m_pSource)
  388.     {
  389. bRet = m_pSource->IsLive();
  390.     }
  392.     return bRet;
  393. }
  395. inline
  396. BOOL ASMSourceInfo2::IsPerfectPlay() const
  397. {
  398.     return m_bPerfectPlay;
  399. }
  401. inline
  402. BOOL ASMSourceInfo2::HasMasterRuleBook() const
  403. {
  404.     return (m_pMasterRuleBook != NULL);
  405. }
  407. void ASMSourceInfo2::DistributeBw()
  408. {
  409.     if (m_pMasterRuleBook)
  410.     {
  411. UINT32 ulRuleCount = m_pMasterRuleBook->GetNumRules();
  412. BOOL* pCurrentSubInfo = new BOOL[ulRuleCount];
  414. GetSubInfo(m_ulMasterOffer, pCurrentSubInfo);
  416. for (UINT16 idxRule = 0; idxRule < ulRuleCount; idxRule++)
  417. {
  418.     if (pCurrentSubInfo[idxRule])
  419.     {
  420. IHXValues* pProps = 0;
  421. // Set Distribution
  422. m_pMasterRuleBook->GetProperties(idxRule, pProps);
  424. for (UINT32 j = 0; j < m_ulStreamCount; j++)
  425. {
  426.     UINT32 ulStreamBw = GetStreamBw(pProps, j);
  428.     m_pStreams[j]->SetStreamOffer(ulStreamBw);
  429. }
  431. HX_RELEASE(pProps);
  432. break;
  433.     }
  434. }
  436. delete [] pCurrentSubInfo;
  437.     }
  438. }
  440. inline
  441. CHXSimpleList* ASMSourceInfo2::SubsChanges()
  442. {
  443.     return &m_subsChanges;
  444. }
  446. void ASMSourceInfo2::SubscribeToChanges()
  447. {
  448.     if (!m_subsChanges.IsEmpty() && m_pStreams && m_pStreams[0])
  449.     {
  450. m_pStreams[0]->SubscribeToChanges(&m_subsChanges);
  452. while(!m_subsChanges.IsEmpty())
  453. {
  454.     RTSPSubscription* pSub = (RTSPSubscription*)m_subsChanges.RemoveHead();
  455.     delete pSub;
  456. }
  457.     }
  458. }
  460. void ASMSourceInfo2::SetDeliveryBw(UINT32 ulMaxBw)
  461. {
  462.     if (m_pStreams)
  463.     {
  464. UINT32 ulTotalBw = 0;
  466. // Calculate the total BW used by the streams
  467. for (UINT32 i = 0; i < m_ulStreamCount; i++)
  468. {
  469.     ulTotalBw += m_pStreams[i]->CurrentBw();
  470. }
  472. m_ulSubscribedBw = ulTotalBw;
  474. if (ulTotalBw)
  475. {
  476.     IHXThinnableSource* pThin = 0;
  477.     
  478.     if (HXR_OK == m_pSource->QueryInterface(IID_IHXThinnableSource, 
  479.     (void **)&pThin))
  480.     {
  481. /* Clamp bandwidth request */
  482. if (ulTotalBw > ulMaxBw)
  483. {
  484.     ulTotalBw = ulMaxBw;
  485. }
  487. pThin->SetDeliveryBandwidth(ulTotalBw, 0);
  489. HX_RELEASE(pThin);
  490.     }
  491. }
  492.     }
  493. }
  495. inline
  496. void ASMSourceInfo2::Done()
  497. {
  498.     HX_RELEASE(m_pSource);
  499. }
  501. HX_RESULT ASMSourceInfo2::GetSubInfo(UINT32 ulBandwidth,
  502.      BOOL* pCurrentSubInfo)
  503. {
  504.     HX_RESULT res = HXR_FAILED;
  506.     if (m_pMasterRuleBook)
  507.     {
  508. res = HXSMUpdateSubscriptionVars(m_pSubsVars, ulBandwidth, FALSE, 0);
  510. if (HXR_OK == res)
  511. {
  512.     res = m_pMasterRuleBook->GetSubscription(pCurrentSubInfo, 
  513.      m_pSubsVars);
  514. }
  515.     }
  517.     return res;
  518. }
  520. UINT32 ASMSourceInfo2::GetStreamBw(IHXValues* pProps, 
  521.    UINT32 ulStreamIndex) const
  522. {
  523.     UINT32 ulRet = 0;
  525.     UINT8       pTemp[128];
  526.     IHXBuffer* pBw = NULL;
  527.     HX_RESULT   hxResult;
  528.     
  529.     // Don't assume that streamid == index in m_pStreams[j]
  530.     sprintf((char *)pTemp, 
  531.     "Stream%ldBandwidth", 
  532.     m_pStreams[ulStreamIndex]->StreamID()); /* Flawfinder: ignore */
  533.     
  534.     /*
  535.      * if this tripps either there's a bug in here or
  536.      * the content is messed up
  537.      *
  538.      */
  539.     //If the Stream?Bandwidth property isn't found for
  540.     //all streams don't worry about it. Not all streams
  541.     //may have rule books.
  542.     hxResult = pProps->GetPropertyCString((char *)pTemp, pBw);
  543.     if(HXR_OK == hxResult && pBw)
  544.     {
  545. ulRet = atoi((char*)pBw->GetBuffer());
  547. HX_RELEASE(pBw);
  548.     }
  550.     return ulRet;
  551. }
  553. ASMStreamInfo2::ASMStreamInfo2(IUnknown* pStream) :
  554.     m_bFixedBwValid(FALSE),
  555.     m_ulFixedBandwidth(0),
  556.     m_ulNumThresholds(0),
  557.     m_pThresholds(0),
  558.     m_ulCurThresh(0),
  559.     m_ulMaxEffectiveThreshold(0),
  560.     m_pBias(0),
  561.     m_pNegotiator(0),
  562.     m_pRuleGather(0),
  563.     m_ulStreamID(0),
  564.     m_ulStreamOffer(0),
  565.     m_ulOffer(0),
  566.     m_ulResistanceToLower(0xffffffff)
  567. {
  568.     if (pStream)
  569.     {
  570. if (HXR_OK == pStream->QueryInterface
  571.     (IID_IHXStreamBandwidthNegotiator,
  572.      (void **)&m_pNegotiator))
  573. {
  574.     m_pNegotiator->GetFixedBandwidth(m_ulFixedBandwidth);
  576.     if (m_ulFixedBandwidth)
  577.     {
  578. /* We need to check to see if the fixed bandwidth value
  579.  * matches the ASMProps Bandwidth value. If it doesn't then
  580.  * that means that we are dealing with a clip that doesn't
  581.  * advertise any bandwidth information. This is a corner
  582.  * case discover by streaming some unhinted .3gp files.
  583.  */
  584. IHXASMProps* pASMProps = NULL;
  585. UINT32 ulASMBw = 0;
  587. if ((HXR_OK == pStream->QueryInterface(IID_IHXASMProps,
  588.        (void**)&pASMProps))&&
  589.     (HXR_OK == pASMProps->GetBandwidth(ulASMBw)) &&
  590.     (m_ulFixedBandwidth == ulASMBw))
  591. {
  592.     m_bFixedBwValid = TRUE;
  593. }
  595. HX_RELEASE(pASMProps);
  596.     }
  597.     else
  598.     {
  599. m_ulNumThresholds = m_pNegotiator->GetNumThresholds();
  600. m_pThresholds = new float[m_ulNumThresholds];
  602. if (m_pThresholds)
  603. {
  604.     m_pNegotiator->GetThresholdInfo(m_pThresholds, 
  605. m_ulNumThresholds);
  607.     m_ulMaxEffectiveThreshold = m_ulNumThresholds - 1;
  608. }
  609.     }
  610. }
  612. pStream->QueryInterface(IID_IHXStreamBandwidthBias,
  613. (void **)&m_pBias);
  615. pStream->QueryInterface(IID_IHXAtomicRuleGather,
  616. (void **)&m_pRuleGather);
  618. // Get StreamID
  619. IHXStream* pHXStream = 0;
  621. pStream->QueryInterface(IID_IHXStream, (void**)&pHXStream);
  622. if (pHXStream)
  623.         {
  624.             m_ulStreamID = pHXStream->GetStreamNumber();
  625.             pHXStream->Release();
  626.         }
  627.     }
  628. }
  630. ASMStreamInfo2::~ASMStreamInfo2()
  631. {
  632.     delete [] m_pThresholds;
  633.     m_pThresholds = 0;
  635.     HX_RELEASE(m_pBias);
  636.     HX_RELEASE(m_pNegotiator);
  637.     HX_RELEASE(m_pRuleGather);
  638. }
  640. HX_RESULT ASMStreamInfo2::GetBiasFactor(REF(INT32) lBiasFactor)
  641. {
  642.     HX_RESULT res = HXR_FAILED;
  643.     
  644.     if (m_pBias)
  645.     {
  646. res = m_pBias->GetBiasFactor(lBiasFactor);
  647.     }
  649.     return res;
  650. }
  652. inline
  653. BOOL ASMStreamInfo2::IsFixedBw() const
  654. {
  655.     return (m_ulFixedBandwidth != 0);
  656. }
  658. UINT32 ASMStreamInfo2::CurrentBw() const
  659. {
  660.     UINT32 ulRet = (m_bFixedBwValid) ? m_ulFixedBandwidth : 0;
  662.     if (!ulRet && m_pThresholds)
  663.     {
  664. ulRet = (UINT32)m_pThresholds[m_ulCurThresh];
  665.     }
  667.     return ulRet;
  668. }
  670. inline
  671. UINT32 ASMStreamInfo2::StreamID() const
  672. {
  673.     return m_ulStreamID;
  674. }
  676. inline
  677. void ASMStreamInfo2::SetStreamOffer(UINT32 ulOffer)
  678. {
  679.     m_ulStreamOffer = ulOffer;
  680. }
  682. void ASMStreamInfo2::SelectBw(BOOL bPerfectPlay,
  683.       UINT32 ulAltOffer)
  684. {
  685.     if (m_pThresholds)
  686.     {
  687. if (bPerfectPlay)
  688. {
  689.     /*
  690.      * If we are in perfect play mode, just select the highest bandwidth rule
  691.      * and don't negotiate any further.
  692.      */
  693.     m_ulCurThresh = m_ulMaxEffectiveThreshold;
  694.     m_ulOffer = CurrentBw();
  695. }
  696. else
  697. { 
  698.     UINT32 ulOffer = ulAltOffer;
  700.     if (m_ulStreamOffer)
  701.     {
  702. ulOffer = m_ulStreamOffer - 1;
  703.     }
  704.     
  705.     if (m_ulMaxEffectiveThreshold != 0)
  706.     {
  707. for (UINT32 i = 1; i <= m_ulMaxEffectiveThreshold; i++)
  708. {
  709.     if ((ulOffer <= m_pThresholds[i]) ||
  710. (i == m_ulMaxEffectiveThreshold))
  711.     {
  712. m_ulOffer = ulOffer;
  713. m_ulCurThresh = i;
  714. break;
  715.     }
  716. }
  717.     }
  718. }
  720. ComputeResistence(bPerfectPlay);
  721.     }
  722. }
  724. inline
  725. UINT32 ASMStreamInfo2::ResistanceToLower() const
  726. {
  727.     return m_ulResistanceToLower;
  728. }
  730. void ASMStreamInfo2::SelectNextLowerBw()
  731. {
  732.     if (m_ulCurThresh > 0)
  733.     {
  734. m_ulCurThresh--;
  736. ComputeResistence(FALSE);
  737.     }
  738. }
  740. inline
  741. UINT32 ASMStreamInfo2::GetLastBw() const
  742. {
  743.     return m_ulLastBw;
  744. }
  746. void ASMStreamInfo2::SubscribeToNewBw(UINT32 ulBw, CHXSimpleList* pSubChanges)
  747. {
  748.     BOOL bTimeStampDelivery = FALSE;
  749.     
  750.     if (m_pRuleGather && m_pNegotiator)
  751.     {
  752. m_pRuleGather->RuleGather(pSubChanges);
  754. //update the HXASMStream with our new bandwidth
  755. m_pNegotiator->SetBandwidthUsage(ulBw, bTimeStampDelivery);
  757. m_pRuleGather->RuleGather(0);
  758.     }
  760.     m_ulLastBw = ulBw;
  761. }
  763. void ASMStreamInfo2::SubscribeToChanges(CHXSimpleList* pSubChanges)
  764. {
  765.     if (m_pRuleGather)
  766.     {
  767. m_pRuleGather->RuleFlush(pSubChanges);
  768.     }
  769. }
  771. void ASMStreamInfo2::ComputeResistence(BOOL bPerfectPlay)
  772. {
  773.     /* NOTE:
  774.      * m_ulCurThresh and m_ulOffer must
  775.      * be valid when this function is called
  776.      */
  778.     if (IsFixedBw() || 
  779. bPerfectPlay ||
  780. (m_ulMaxEffectiveThreshold == 0) ||
  781. (m_ulCurThresh == 1))
  782.     {
  783. m_ulResistanceToLower = 0xffffffff;
  784.     }
  785.     else
  786.     {
  787. m_ulResistanceToLower = 
  788.     (m_ulOffer - (UINT32)m_pThresholds[m_ulCurThresh - 1]) * m_ulOffer;
  789.     }
  790. }
  792. HXSM2::HXSM2() :
  793.     m_lRefCount(0),
  794.     m_ulNumSources(0),
  795.     m_pASMSourceInfo(0),
  796.     m_ulNumStreams(0),
  797.     m_ulOfferToRecalc(0),
  798.     m_ulSelectionBitRate(0),
  799.     m_ulMaxAccelBitRate(0),
  800.     m_ulSustainableBitRate(0),
  801.     m_pSubscriptionVariables(0),
  802.     m_bCheckOnDemandBw(FALSE)
  803. {
  804.     m_pASMSourceInfo = new CHXSimpleList();
  805. }
  807. HXSM2::~HXSM2()
  808. {
  809.     if (m_pASMSourceInfo)
  810.     {
  811. while(!m_pASMSourceInfo->IsEmpty())
  812. {
  813.     ASMSourceInfo2* pSrc = 
  814. (ASMSourceInfo2*)m_pASMSourceInfo->RemoveHead();
  816.     delete pSrc;
  817. }
  819. delete m_pASMSourceInfo;
  820.     }
  821. }
  823. STDMETHODIMP HXSM2::QueryInterface(THIS_ REFIID ID, void** ppInterfaceObj)
  824. {
  825. QInterfaceList qiList[] =
  826. {
  827. { GET_IIDHANDLE(IID_IUnknown), this },
  828. { GET_IIDHANDLE(IID_IHXBandwidthManager), (IHXBandwidthManager*) this },
  829. };
  830.     return QIFind(qiList, QILISTSIZE(qiList), ID, ppInterfaceObj);
  831. }
  833. STDMETHODIMP_(UINT32) HXSM2::AddRef(THIS)
  834. {
  835.     return InterlockedIncrement(&m_lRefCount);
  836. }
  838. STDMETHODIMP_(UINT32) HXSM2::Release(THIS)
  839. {
  840.     if (InterlockedDecrement(&m_lRefCount) > 0)
  841.     {
  842. return m_lRefCount;
  843.     }
  845.     delete this;
  846.     return 0;
  847. }
  849. /*
  850.  * IHXBandwidthManager methods
  851.  */
  852. STDMETHODIMP HXSM2::RegisterSource(THIS_
  853.    HXSource* pSource,
  854.    IUnknown* pUnknown)
  855. {
  856.     HX_RESULT res = HXR_OK;
  858.     IHXSourceBandwidthInfo* pSBI;
  859.     IHXPreferences* pPreferences = NULL;
  860.     IHXBuffer* pBuffer = 0;
  861.     ASMSourceInfo2* pASMSourceInfo = NULL;
  863.     if (HXR_OK == pSource->QueryInterface(IID_IHXSourceBandwidthInfo, 
  864.             (void **)&pSBI))
  865.     {
  866.         pASMSourceInfo = new ASMSourceInfo2(pSource);
  868.         m_ulNumSources++;
  869.         m_ulNumStreams += pASMSourceInfo->StreamCount();
  871.         m_pASMSourceInfo->AddTail((void *)pASMSourceInfo);
  873.         HX_RELEASE(pSBI);
  874.     }
  875.     else
  876.     {
  877.         return HXR_OK;
  878.     }
  880.     /*
  881.      * This variable tells us the highest amount of bandwidth that we
  882.      * believe is useable.  If we stream thin, then the highest value
  883.      * that the pipe can support would be the aggregate bandwidth of
  884.      * the sources.  Barring any thinning, this would be the bandwidth
  885.      * from prefs (unless we can determine it through fast buffering or
  886.      * another transport feature).  This value is used when starting sources
  887.      * as a initial guess for bandwidth (to set subscriptions).
  888.      */
  889.     if (m_ulSelectionBitRate == 0)
  890.     {
  891.         pUnknown->QueryInterface(IID_IHXPreferences, (void **)&pPreferences);
  893.         UINT32 ulTemp = 0;
  894.         UINT32 ulConnectionBw = 10485760; /* wild guess */
  896.         /* Get initial bandwidth guess from Prefs */
  897.         if ((HXR_OK == ReadPrefINT32(pPreferences, "Bandwidth", ulTemp)) &&
  898.             (ulTemp > 0))
  899.         {
  900.             ulConnectionBw = ulTemp;
  901.         }
  903.         /*
  904.          * m_ulSustainableBitRate refers to the max bitrate that we believe is
  905.          * sustainable over the connection. The client should never ask
  906.          * the server to send bits faster than this rate because it could
  907.          * cause congestion collapse.
  908.          *
  909.          * m_ulSelectionBitRate refers to the highest bitrate stream that we'll
  910.          * ever try to play. Note that people can choose to pick values
  911.          * where m_ulSelectionBitRate > m_ulSustainableBitRate. This may
  912.  * cause rebuffers because the delivery will be capped at 
  913.  * m_ulSustainableBitRate. Why would someone do that? They may accept
  914.  * rebuffers if it means they get a higher quality presentation.
  915.          */
  916.         
  917.         /* See if we have a sustainable bandwidth factor */
  918.         if (HXR_OK == ReadPrefINT32(pPreferences, "SustainableBwFactor", 
  919.                                     ulTemp))
  920.         {
  921.             /* clamp value to 0 <= ulTemp <= 100 range */
  922.             if (ulTemp > 100)
  923.             {
  924.                 ulTemp = 100;
  925.             }
  926.             
  927.             /* Apply factor */
  928.             m_ulSustainableBitRate = 
  929.                 (((ulConnectionBw / 100) * ulTemp) + 
  930.                  (((ulConnectionBw % 100) * ulTemp) / 100));
  931.         }
  932.         else
  933.         {
  934.             m_ulSustainableBitRate = ulConnectionBw;
  935.         }
  936.         
  938.         /* See if we have a selection bandwidth factor */
  939.         if (HXR_OK == ReadPrefINT32(pPreferences, "SelectionBwFactor", 
  940.                                     ulTemp))
  941.         {
  942.             /* clamp value to 0 <= ulTemp <= 200 range */
  943.             if (ulTemp > 200)
  944.             {
  945.                 ulTemp = 200;
  946.             }
  947.             
  948.             /* Apply factor */
  949.             m_ulSelectionBitRate  = 
  950.                 (((m_ulSustainableBitRate / 100) * ulTemp) + 
  951.                  (((m_ulSustainableBitRate % 100) * ulTemp) / 100));
  952.         }
  953.         else
  954.         {
  955.             m_ulSelectionBitRate = m_ulSustainableBitRate; 
  956.         }
  958.         /* Get MaxBandwidth from Prefs */
  959.         if (HXR_OK != ReadPrefINT32(pPreferences, "MaxBandwidth", 
  960.                                     m_ulMaxAccelBitRate))
  961.         {
  962.             /* 
  963.              * Failed to get the MaxBandwidth preference. 
  964.              * Use m_ulSelectionBitRate value instead.
  965.              */
  966.             m_ulMaxAccelBitRate = m_ulSelectionBitRate;
  967.         }
  969.         /* 
  970.          * Get preference that controls whether we report
  971.          * "not enough bandwidth" conditions for on-demand clips
  972.          */
  973.         ReadPrefBOOL(pPreferences, "CheckOnDemandBw", m_bCheckOnDemandBw);
  975.         HX_RELEASE(pPreferences);
  976.     }
  978.     return res;
  979. }
  981. STDMETHODIMP HXSM2::RegisterSourcesDone(THIS)
  982. {
  983.     CHXSimpleList::Iterator     i;
  984.     ASMSourceInfo2*    pASMSourceInfo;
  986.     for (i = m_pASMSourceInfo->Begin(); i != m_pASMSourceInfo->End(); ++i)
  987.     {
  988. pASMSourceInfo = (ASMSourceInfo2*)(*i);
  989. if (pASMSourceInfo)
  990. {
  991.     pASMSourceInfo->LastSetDelivery() = 0;
  992. }
  993.     }
  994.     
  995.     m_ulOfferToRecalc = m_ulSelectionBitRate;
  997.     if (m_ulOfferToRecalc > m_ulMaxAccelBitRate)
  998.     {
  999. m_ulOfferToRecalc = m_ulMaxAccelBitRate;
  1000.     }
  1002.     Recalc();
  1004.     return HXR_OK;
  1005. }
  1006.     
  1007. STDMETHODIMP_(BOOL) HXSM2::NotEnoughBandwidth(THIS)
  1008. {
  1009.     CHXSimpleList::Iterator i;
  1010.     ASMSourceInfo2*          pASMSourceInfo;
  1011.     UINT32     ulTotal = 0;
  1012.     BOOL     bCheckTotal = m_bCheckOnDemandBw;
  1014.     for (i = m_pASMSourceInfo->Begin(); i != m_pASMSourceInfo->End(); ++i)
  1015.     {
  1016. pASMSourceInfo = (ASMSourceInfo2*)(*i);
  1018. ulTotal += pASMSourceInfo->SubscribeBw();
  1020. if (pASMSourceInfo->IsLive())
  1021. {
  1022.     bCheckTotal = TRUE;
  1023. }
  1024.     }
  1026.     if (bCheckTotal && ulTotal > m_ulSelectionBitRate)
  1027.     {
  1028. return TRUE;
  1029.     }
  1030.     else
  1031.     {
  1032. return FALSE;
  1033.     }
  1034. }
  1036. STDMETHODIMP HXSM2::UnRegisterSource(THIS_
  1037.      HXSource* pSource)
  1038. {
  1039.     LISTPOSITION lPos;
  1040.     ASMSourceInfo2*             pASMSourceInfo = 0;
  1041.     BOOL bFound = FALSE;
  1043.     lPos = m_pASMSourceInfo->GetHeadPosition();
  1045.     while (lPos)
  1046.     {
  1047. pASMSourceInfo = (ASMSourceInfo2*)m_pASMSourceInfo->GetAt(lPos);
  1048. if (pASMSourceInfo->IsMySource(pSource))
  1049. {
  1050.     m_pASMSourceInfo->RemoveAt(lPos);
  1051.     pASMSourceInfo->Done();
  1052.     bFound  = TRUE;
  1053.     break;
  1054. }
  1055. m_pASMSourceInfo->GetNext(lPos);
  1056.     }
  1057.     
  1058.     if (bFound)
  1059.     {
  1060. m_ulNumStreams -= pASMSourceInfo->StreamCount();
  1062. delete pASMSourceInfo;
  1064. m_ulNumSources--;
  1066. if (m_ulNumSources > 0)
  1067. {
  1068.     Recalc();
  1069. }
  1070.     }
  1072.     return HXR_OK;
  1073. }
  1075. STDMETHODIMP HXSM2::ChangeAccelerationStatus(THIS_
  1076. HXSource* pSource,
  1077. BOOL    bMayBeAccelerated,
  1078. BOOL    bUseAccelerationFactor,
  1079. UINT32    ulAccelerationFactor)
  1080. {
  1082.     return HXR_OK;
  1083. }
  1085.     /* Called by HXPlayer at end of each presentation */
  1086. STDMETHODIMP HXSM2::PresentationDone(THIS)
  1087. {
  1088.     return HXR_OK;
  1089. }
  1090.     
  1091. STDMETHODIMP HXSM2::ChangeBW(THIS_ 
  1092.      UINT32 newBW, HXSource* pSource)
  1093. {
  1094.     return HXR_OK;
  1095. }
  1097. void
  1098. HXSM2::Recalc()
  1099. {
  1100.     CHXSimpleList::Iterator     i;
  1101.     ASMStreamInfoItr            streamItr(m_pASMSourceInfo);
  1102.     ASMSourceInfo2*             pASMSourceInfo;
  1103.     ASMStreamInfo2*             pASMStreamInfo;
  1104.     INT32 lAggregateBandwidthUsage = 0;
  1105.     UINT32 ulSourceCount;
  1106.     UINT32 ulStreamCount;
  1107.     float fBiasMean = (float) 0.;
  1109.     ulSourceCount = m_pASMSourceInfo->GetCount();
  1110.     ulStreamCount = m_ulNumStreams;
  1112.     for (i = m_pASMSourceInfo->Begin(); i != m_pASMSourceInfo->End(); ++i)
  1113.     {
  1114. pASMSourceInfo = (ASMSourceInfo2*)(*i);
  1116.         /* Init these for later */
  1117. pASMSourceInfo->MasterOffer() = 0;
  1118.     }
  1120.     lAggregateBandwidthUsage = m_ulOfferToRecalc;
  1122.     INT32 lCorrectAggregateBandwidthUsage = lAggregateBandwidthUsage;
  1124.     /*
  1125.      * For each stream that is at a fixed bitrate, remove that bitrate
  1126.      * from our available bandwidth.
  1127.      */
  1128.     for (streamItr.Reset(); streamItr.More(); streamItr.Next())
  1129.     {
  1130.         INT32 lBias;
  1132. pASMStreamInfo = streamItr.Stream();
  1134. HX_VERIFY(HXR_OK == pASMStreamInfo->GetBiasFactor(lBias));
  1135. fBiasMean += lBias;
  1137. if (pASMStreamInfo->IsFixedBw())
  1138. {
  1139.     lAggregateBandwidthUsage -= pASMStreamInfo->CurrentBw();
  1140.     ulStreamCount--;
  1141. }
  1143. /* Init this for later */
  1144. pASMStreamInfo->SetStreamOffer(0);
  1145.     }
  1147.     if (ulStreamCount != 0)
  1148.     {
  1149.         /* At least 1 stream is not fixed bandwidth */
  1151.         fBiasMean /= ulStreamCount;
  1152.         
  1153.         /*
  1154.          * Calculate the offer for each source that has a master rulebook
  1155.          * defining it's bandwidth division.
  1156.          */
  1157.         INT32 lNewAggregateBandwidthUsage = lAggregateBandwidthUsage;
  1159.         for (streamItr.Reset(); streamItr.More(); streamItr.Next())
  1160.         {
  1161.             INT32 lBias;
  1162.             
  1163.             pASMStreamInfo = streamItr.Stream();
  1164.             pASMSourceInfo = streamItr.Source();
  1165.             
  1166.             HX_VERIFY(HXR_OK == pASMStreamInfo->GetBiasFactor(lBias));
  1167.             
  1168.             if (pASMSourceInfo->HasMasterRuleBook())
  1169.             {
  1170.                 UINT32 ulOffer = 
  1171.                     (UINT32)(lAggregateBandwidthUsage / ulStreamCount);
  1172.                 
  1173.                 ulOffer += 
  1174.                     (UINT32)(((float)lBias - fBiasMean) *
  1175.                              ((float)lAggregateBandwidthUsage / 100.0) *
  1176.                              (2.0 / ulStreamCount));
  1177.                 
  1178.                 pASMSourceInfo->MasterOffer() += ulOffer;
  1179.                 lNewAggregateBandwidthUsage -= ulOffer;
  1180.             }
  1181.         }
  1183.         lAggregateBandwidthUsage = lNewAggregateBandwidthUsage;
  1184.     }
  1186.     /*
  1187.      * For each source that has a master rule book, evaluate it to find
  1188.      * out how much to distribute to each stream.
  1189.      */
  1190.     for (i = m_pASMSourceInfo->Begin(); i != m_pASMSourceInfo->End(); ++i)
  1191.     {
  1192. pASMSourceInfo = (ASMSourceInfo2*)(*i);
  1193. if (pASMSourceInfo->HasMasterRuleBook())
  1194. {
  1195.     pASMSourceInfo->DistributeBw();
  1196. }
  1197.     }
  1199.     /*
  1200.      *  Now go through each of the streams that are not at a
  1201.      *  fixed bitrate and try to distribute the rest of the bandwidth.
  1202.      */
  1203.     UINT32 ulTakenBandwidth = 0;
  1205.     for (streamItr.Reset(); streamItr.More(); streamItr.Next())
  1206.     {
  1207. pASMStreamInfo = streamItr.Stream();
  1209. if (!pASMStreamInfo->IsFixedBw())
  1210. {
  1211.     INT32 lBias;
  1212.     
  1213.     HX_VERIFY(HXR_OK == pASMStreamInfo->GetBiasFactor(lBias));
  1214.     
  1215.     UINT32 ulAltOffer =
  1216. (UINT32)(lAggregateBandwidthUsage / (float)ulStreamCount);
  1218.     ulAltOffer += (UINT32)(((float)lBias - fBiasMean) *
  1219.    ((float)lAggregateBandwidthUsage / 100.0) *
  1220.    (2.0 / (float)ulStreamCount));
  1222.     pASMStreamInfo->SelectBw(streamItr.Source()->IsPerfectPlay(),
  1223.      ulAltOffer);
  1224. }
  1226. ulTakenBandwidth += pASMStreamInfo->CurrentBw();
  1227.     }
  1229.     lAggregateBandwidthUsage = lCorrectAggregateBandwidthUsage;
  1231.     BOOL bDone = FALSE;
  1232.     while (!bDone && (lAggregateBandwidthUsage < (INT32)ulTakenBandwidth))
  1233.     {
  1234. /* Resistance is Futile.  You will be Real(tm)lyAssimilated */
  1235. UINT32 ulLowestResistance = 0xffffffff;
  1236. ASMStreamInfo2* pLowestResistanceStream  = 0;
  1238. // Find the stream with the lowest resistence
  1239. for (streamItr.Reset(); streamItr.More(); streamItr.Next())
  1240. {
  1241.     pASMStreamInfo = streamItr.Stream();
  1243.     if (pASMStreamInfo->ResistanceToLower() < ulLowestResistance)
  1244.     {
  1245. ulLowestResistance = pASMStreamInfo->ResistanceToLower();
  1246. pLowestResistanceStream = pASMStreamInfo;
  1247.     }
  1248. }
  1250. if (ulLowestResistance == 0xffffffff)
  1251. {
  1252.     bDone = TRUE;
  1253. }
  1254. else
  1255. {
  1256.     ulTakenBandwidth -= (UINT32)
  1257. pLowestResistanceStream->CurrentBw();
  1259.     pLowestResistanceStream->SelectNextLowerBw();
  1261.     ulTakenBandwidth += (UINT32)
  1262. pLowestResistanceStream->CurrentBw();
  1263. }
  1264.     }
  1266.     UINT32 ulLeftOverForDropByN = lAggregateBandwidthUsage - ulTakenBandwidth;
  1267.     BOOL bForce = FALSE;
  1269.     for (streamItr.Reset(); streamItr.More(); streamItr.Next())
  1270.     {
  1271. pASMStreamInfo = streamItr.Stream();
  1273. UINT32 ulBw = pASMStreamInfo->CurrentBw();
  1275. if (ulBw == 1)
  1276. {
  1277.     // Hack Alert for DropByN. XXXSMP
  1278.     ulBw = ulLeftOverForDropByN;
  1279. }
  1281. if ((ulBw != pASMStreamInfo->GetLastBw()) &&
  1282.     (pASMStreamInfo->IsFixedBw()))
  1283. {
  1284.     bForce = TRUE;
  1285. }
  1287. CHXSimpleList* pSubsChanges = 
  1288.     streamItr.Source()->SubsChanges();
  1290. pASMStreamInfo->SubscribeToNewBw(ulBw, pSubsChanges);
  1291.     }
  1293.     for (i = m_pASMSourceInfo->Begin(); i != m_pASMSourceInfo->End(); ++i)
  1294.     {
  1295. pASMSourceInfo = (ASMSourceInfo2*)(*i);
  1297. pASMSourceInfo->SubscribeToChanges();
  1298. pASMSourceInfo->SetDeliveryBw(m_ulSustainableBitRate);
  1299.     }
  1300. }