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

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

Symbian

开发平台：

Visual C++

smlrendr.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: smlrendr.cpp,v 1.7.2.1 2004/07/09 01:58:02 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. #if defined (_AIX)
  51. #include <X11/Xlib.h>
  52. #endif
  53. // system
  54. #include <time.h>
  55. // include
  56. #include "hxtypes.h"
  57. #include "hxwintyp.h"
  58. #include "smiltype.h"
  59. #include "hxcom.h"
  60. #include "hxcomm.h"
  61. #include "ihxpckts.h"
  62. #include "hxcore.h"
  63. #include "hxrendr.h"
  64. #include "hxplugn.h"
  65. #include "hxwin.h"
  66. #include "hxgroup.h"
  67. #include "hxsite2.h"
  68. #include "hxupgrd.h"
  69. #include "hxmon.h"
  70. #include "hxver.h"
  71. #include "hxvport.h"
  72. #include "hxclsnk.h"
  73. #include "hxprefs.h"
  74. #include "hxmmrkr.h" // smldoc.h   dependency
  75. #include "hxinter.h" // smldoc.h   dependency
  76. #include "hxsm2sm.h"
  77. #include "hxerror.h"
  78. // cont
  79. #include "hxstring.h"
  80. #include "chxpckts.h"
  81. #include "smlpkt.h"
  82. // misc
  83. #include "hxurl.h"
  84. #include "hxstrutl.h" /* for SafeS---() */
  85. #include "smlelem.h"
  86. #include "smlutil.h"
  87. // smlrendr
  88. #include "evnthook.h"
  89. #include "siteuser.h"
  90. #include "passivsw.h"
  91. #include "layout.h"
  92. #include "smldoc.h"
  93. #include "smlerror.h"
  94. #include "smlrmlog.h"
  95. #include "smlrendr.h"
  96. #include "smlrendr.ver"
  97. // debug
  98. #include "debugout.h"
  99. #include "hxheap.h"
  100. #ifdef _DEBUG
  101. #undef HX_THIS_FILE
  102. static const char HX_THIS_FILE[] = __FILE__;
  103. #endif
  105. /* We should really define it in a common header file */
  106. #if defined (_WINDOWS ) || defined (WIN32)
  107. #define OS_SEPARATOR_CHAR '\'
  108. #define OS_SEPARATOR_STRING "\"
  109. #elif defined (_UNIX)
  110. #define OS_SEPARATOR_CHAR '/'
  111. #define OS_SEPARATOR_STRING "/"
  112. #elif defined (_MACINTOSH)
  113. #define OS_SEPARATOR_CHAR ':'
  114. #define OS_SEPARATOR_STRING ":"
  115. #endif // defined (_WINDOWS ) || defined (WIN32)
  118. #ifdef _WINDOWS
  119. extern HINSTANCE g_hInstance;
  120. #endif
  122. static const UINT32 INITIAL_GRANULARITY = 67; // XXXMEH - increased interval to help animation CPU
  124. #define SMIL20_AND_UP_STREAM_MIME_TYPE "application/smil"
  126. const char* const CSmilRenderer::zm_pName       = "SMIL";
  127. const char* const CSmilRenderer::zm_pDescription    = "RealNetworks RMA Driver Renderer Plugin";
  128. const char* const CSmilRenderer::zm_pCopyright      = HXVER_COPYRIGHT;
  129. const char* const CSmilRenderer::zm_pMoreInfoURL    = HXVER_MOREINFO;
  130. const char* const CSmilRenderer::zm_pStreamMimeTypes[] =
  131. {
  132. #if defined(HANDLE_BETA1_SMIL_1_0_STREAM)
  133.     "application/rma-driver",
  134. #endif
  135. #if defined(HANDLE_SMIL_1_0_STREAM)
  136.     "application/vnd.rn-rmadriver",
  137. #endif
  138. #if defined(HANDLE_SMIL_2_0_LASTCALL_STREAM)
  139.     SMIL20_AND_UP_STREAM_MIME_TYPE,
  140. #endif
  141. #if defined(HANDLE_SMIL_2_0_CANDIDATE_REC_STREAM)
  142.     SMIL20_AND_UP_STREAM_MIME_TYPE,
  143. #endif
  144. #if defined(HANDLE_SMIL_2_0_STREAM)
  145.     SMIL20_AND_UP_STREAM_MIME_TYPE,
  146. #endif
  147.     NULL
  148. };
  149. const char* const CSmilRenderer::zm_pRecognizedDefaultNamespaces[
  150. NUM_RECOGNIZED_DEFAULT_NAMESPACES+1] =
  151. {
  152.     // /This is the namespace in the <smil...> tag that declares that
  153.     // this is a SMIL 1.0 document that we should handle *correctly* (per
  154.     // spec); the SMIL file format plug-in would have sent any "old"
  155.     // SMIL 1.0 document to the old SMIL 1.0 renderer via the old stream
  156.     // mime type; this is the case for all files that do not contain
  157.     // a default namespace (which is xmlns= as opposed to xmlns:):
  158.     "http://www.w3.org/TR/REC-smil",
  159.     // /This is the SMIL 2.0 Last Call namespace:
  160.     "http://www.w3.org/TR/REC-smil/2000/SMIL20/LC/",
  161.     // /This is the SMIL 2.0 Language Profile Candidate Rec namespace:
  162.     "http://www.w3.org/2000/SMIL20/CR/Language",
  163.     // /This is the SMIL 2.0 Language Profile Proposed Rec namespace
  164.     // created June 2001:  (Fixes PR 55749):
  165.     "http://www.w3.org/2001/SMIL20/PR/Language",
  166.     // /This is the SMIL 2.0 Rec namespace (it became a W3C Rec on 8/7/2001):
  167. #if defined(HANDLE_SMIL_2_0_STREAM)
  168.     // /Adding "/Language" to this string fixes PR 62208:
  169.     "http://www.w3.org/2001/SMIL20/Language",
  170. #endif
  171.     NULL
  172. };
  176. /************************************************************************
  177.  *  Method:
  178.  *    IHXPlugin::InitPlugin
  179.  *  Purpose:
  180.  *    Initializes the plugin for use. This interface must always be
  181.  *    called before any other method is called. This is primarily needed 
  182.  *    so that the plugin can have access to the context for creation of
  183.  *    IHXBuffers and IMalloc.
  184.  */
  185. STDMETHODIMP CSmilRenderer::InitPlugin(IUnknown* /*IN*/ pContext)
  186. {
  187.     m_pContext = pContext;
  188.     m_pContext->AddRef();
  190.     m_pContext->QueryInterface(IID_IHXCommonClassFactory,
  191.     (void**)&m_pCommonClassFactory);
  192.     HX_RELEASE(m_pErrorMessages);
  193.     m_pContext->QueryInterface(IID_IHXErrorMessages,
  194.                                (void**) &m_pErrorMessages);
  196.     return HXR_OK;
  197. }
  199. /************************************************************************
  200.  *  Method:
  201.  *    IHXPlugin::GetPluginInfo
  202.  *  Purpose:
  203.  *    Returns the basic information about this plugin. Including:
  204.  *
  205.  *    bLoadMultiple whether or not this plugin DLL can be loaded
  206.  * multiple times. All File Formats must set
  207.  * this value to TRUE.
  208.  *    pDescription which is used in about UIs (can be NULL)
  209.  *    pCopyright which is used in about UIs (can be NULL)
  210.  *    pMoreInfoURL which is used in about UIs (can be NULL)
  211.  */
  212. STDMETHODIMP CSmilRenderer::GetPluginInfo
  213. (
  214.     REF(BOOL)        /*OUT*/ bLoadMultiple,
  215.     REF(const char*) /*OUT*/ pDescription,
  216.     REF(const char*) /*OUT*/ pCopyright,
  217.     REF(const char*) /*OUT*/ pMoreInfoURL,
  218.     REF(ULONG32)     /*OUT*/ ulVersionNumber
  219. )
  220. {
  221.     bLoadMultiple = TRUE;   // Must be true for file formats.
  223.     pDescription    = (const char*) zm_pDescription;
  224.     pCopyright     = (const char*) zm_pCopyright;
  225.     pMoreInfoURL    = (const char*) zm_pMoreInfoURL;
  226.     ulVersionNumber = TARVER_ULONG32_VERSION;
  228.     return HXR_OK;
  229. }
  231. /************************************************************************
  232.  *  Method:
  233.  *    IHXPlugin::GetRendererInfo
  234.  *  Purpose:
  235.  *    If this object is a file format object this method returns
  236.  *    information vital to the instantiation of file format plugins.
  237.  *    If this object is not a file format object, it should return
  238.  *    HXR_UNEXPECTED.
  239.  */
  240. STDMETHODIMP CSmilRenderer::GetRendererInfo
  241. (
  242.     REF(const char**) /*OUT*/ pStreamMimeTypes,
  243.     REF(UINT32)      /*OUT*/ unInitialGranularity
  244. )
  245. {
  246.     pStreamMimeTypes = (const char**) zm_pStreamMimeTypes;
  247.     unInitialGranularity = m_ulGranularity;
  249.     return HXR_OK;
  250. }
  252. CSmilRenderer::CSmilRenderer()
  253. : m_lRefCount(0)
  254. , m_pContext(NULL)
  255. , m_pStream(NULL)
  256. , m_pPlayer(NULL)
  257. , m_pHeader(NULL)
  258. , m_ulLastTime(0)
  259. , m_pCommonClassFactory(0)
  260. , m_pPacketParser(0)
  261. , m_pSmilDocRenderer(0)
  262. , m_pEngine(0)
  263.         , m_pErrorMessages(NULL)
  264. , m_pClientContext(0)
  265. , m_uLayoutRule(0)
  266. , m_uSourceRule(0)
  267. , m_ulTotalSMILPackets(0)
  268. , m_ulGranularity(INITIAL_GRANULARITY)
  269. , m_pURLFragment(0)
  270. , m_lastOnPacketResult(HXR_OK)
  271. , m_bInMetadata(FALSE)
  272. , m_bUseNestedMeta(TRUE)
  273. , m_pPersistentComponentManager(NULL)    
  274. , m_ulPersistentVersion(0)
  275. , m_persistentType(PersistentSMIL)
  276. , m_bStreamProxiedByOtherRenderer(FALSE)
  277. , m_pVersionNamespaceFromProxyRenderer(NULL)
  278. {
  279.     m_ulPersistentVersion = HX_ENCODE_PROD_VERSION(2, 0, 0, 0);
  280. };
  282. CSmilRenderer::~CSmilRenderer()
  283. {
  284.     if(m_pSmilDocRenderer)
  285.     {
  286. m_pSmilDocRenderer->close(this);
  287. HX_RELEASE(m_pSmilDocRenderer);
  288.     }
  290.     // /First, see if this player has children who need to be cleaned up:
  291.     if (m_pPlayer)
  292.     {
  293. IHXPlayerNavigator* pPlayerNavRoot = NULL;
  294. HX_RESULT pnrslt = m_pPlayer->QueryInterface(IID_IHXPlayerNavigator,
  295. (void**)&pPlayerNavRoot);
  296. if (HXR_OK == pnrslt)
  297. {
  298.     UINT16 uiNumChildren = pPlayerNavRoot->GetNumChildPlayer();
  300.     while (uiNumChildren > 0)
  301.     {
  302. IHXPlayer* pChildPlayer = NULL;
  303. // /GetChildPlayer addrefs pChildPlayer:
  304. pPlayerNavRoot->GetChildPlayer(uiNumChildren-1,pChildPlayer);
  305. HX_ASSERT(NULL != pChildPlayer);
  306. if (pChildPlayer)
  307. {
  308.     IHXPlayerNavigator* pPlayerNavChild = NULL;
  310.     // /RemoveChildPlayer decrefs it:
  311.     pPlayerNavRoot->RemoveChildPlayer(pChildPlayer);
  312.     IHXPlayer* pParentPlayer = NULL;
  314.     pnrslt= pChildPlayer->QueryInterface(
  315.     IID_IHXPlayerNavigator,
  316.     (void**)&pPlayerNavChild);
  317.     if (HXR_OK == pnrslt)
  318.     {
  319. // /GetParentPlayer addrefs pParentPlayer...
  320. pPlayerNavChild->GetParentPlayer(pParentPlayer);
  321. if (pParentPlayer)
  322. {
  323.     // /RemoveParentPlayer decrefs it...
  324.     pPlayerNavChild->RemoveParentPlayer(
  325.     pParentPlayer);
  326.     // /And we need one more to kill our use of it:
  327.     HX_RELEASE(pParentPlayer);
  328. }
  329. // /Now, remove it from client engine's list:
  330. if (m_pEngine)
  331. {
  332.     pnrslt= m_pEngine->ClosePlayer(pChildPlayer);
  333. }
  334. // /And we need one more to kill our use of it:
  335. HX_RELEASE(pChildPlayer);
  336.     }
  337.     HX_RELEASE(pPlayerNavChild);
  338. }
  339. uiNumChildren--;
  340.     }
  341.     HX_RELEASE(pPlayerNavRoot);
  342. }
  343.     }
  345.     HX_RELEASE(m_pContext);
  346.     HX_RELEASE(m_pClientContext);
  347.     HX_RELEASE(m_pStream);
  348.     HX_RELEASE(m_pEngine);
  349.     HX_RELEASE(m_pErrorMessages);
  350.     HX_RELEASE(m_pCommonClassFactory);
  351.     HX_RELEASE(m_pPersistentComponentManager);
  353.     HX_RELEASE(m_pVersionNamespaceFromProxyRenderer);
  355.     HX_DELETE(m_pPacketParser);
  356.     HX_RELEASE(m_pPlayer);
  357.     HX_VECTOR_DELETE(m_pURLFragment);
  358. }
  361. // *** IUnknown methods ***
  363. /////////////////////////////////////////////////////////////////////////
  364. //  Method:
  365. // IUnknown::QueryInterface
  366. //  Purpose:
  367. // Implement this to export the interfaces supported by your 
  368. // object.
  369. //
  370. STDMETHODIMP CSmilRenderer::QueryInterface(REFIID riid, void** ppvObj)
  371. {
  372.     if (IsEqualIID(riid, IID_IUnknown))
  373.     {
  374. AddRef();
  375. *ppvObj = this;
  376. return HXR_OK;
  377.     }
  378.     else if (IsEqualIID(riid, IID_IHXPlugin))
  379.     {
  380. AddRef();
  381. *ppvObj = (IHXPlugin*)this;
  382. return HXR_OK;
  383.     }
  384.     else if (IsEqualIID(riid, IID_IHXRenderer))
  385.     {
  386. AddRef();
  387. *ppvObj = (IHXRenderer*)this;
  388. return HXR_OK;
  389.     }
  390.     else if (IsEqualIID(riid, IID_IHXSiteUser))
  391.     {
  392. HX_ASSERT(0  &&  "Huh?!  CSmilRenderer doesn't implement IHXSiteUser");
  393. AddRef();
  394. *ppvObj = (IHXSiteUser*)this;
  395. return HXR_OK;
  396.     }
  397. /*
  398.     else if (IsEqualIID(riid, IID_IHXValues))
  399.     {
  400. AddRef();
  401. *ppvObj = (IHXValues*)this;
  402. return HXR_OK;
  403.     }
  404. */
  405.     else if (IsEqualIID(riid, IID_IHXStatistics))
  406.     {
  407. AddRef();
  408. *ppvObj = (IHXStatistics*)this;
  409. return HXR_OK;
  410.     }
  411.     else if (IsEqualIID(riid, IID_IHXPersistentRenderer))
  412.     {
  413. AddRef();
  414. *ppvObj = (IHXPersistentRenderer*)this;
  415. return HXR_OK;
  416.     }
  417.     else if (IsEqualIID(riid, IID_IHXSmilToSmilRendererCommunicator))
  418.     {
  419. AddRef();
  420. *ppvObj = (IHXSmilToSmilRendererCommunicator*)this;
  421. return HXR_OK;
  422.     }
  423.     else if (m_pSmilDocRenderer &&
  424.      HXR_OK == m_pSmilDocRenderer->QueryInterface(riid, ppvObj))
  425.     {
  426. return HXR_OK;
  427.     }
  429.     *ppvObj = NULL;
  430.     return HXR_NOINTERFACE;
  431. }
  433. /////////////////////////////////////////////////////////////////////////
  434. //  Method:
  435. // IUnknown::AddRef
  436. //  Purpose:
  437. // Everyone usually implements this the same... feel free to use
  438. // this implementation.
  439. //
  440. STDMETHODIMP_(ULONG32) CSmilRenderer::AddRef()
  441. {
  442.     return InterlockedIncrement(&m_lRefCount);
  443. }
  445. /////////////////////////////////////////////////////////////////////////
  446. //  Method:
  447. // IUnknown::Release
  448. //  Purpose:
  449. // Everyone usually implements this the same... feel free to use
  450. // this implementation.
  451. //
  452. STDMETHODIMP_(ULONG32) CSmilRenderer::Release()
  453. {
  454.     if (InterlockedDecrement(&m_lRefCount) > 0)
  455.     {
  456.         return m_lRefCount;
  457.     }
  459.     delete this;
  460.     return 0;
  461. }
  463. // *** IHXRenderer methods ***
  465. /////////////////////////////////////////////////////////////////////////
  466. //  Method:
  467. // IHXRenderer::StartStream
  468. //  Purpose:
  469. // Called by client engine to inform the renderer of the stream it
  470. // will be rendering. The stream interface can provide access to
  471. // its source or player. This method also provides access to the 
  472. // primary client controller interface.
  473. //
  474. STDMETHODIMP CSmilRenderer::StartStream
  475. (
  476.     IHXStream*     pStream,
  477.     IHXPlayer*     pPlayer
  478. )
  479. {
  480.     MLOG_FLOW(m_pErrorMessages, "CSmilRenderer::StartStream(0x%08x,0x%08x) this=0x%08xn",
  481.               pStream, pPlayer, this);
  482.     HX_RESULT rc = HXR_OK;
  484.     // Save for later use!
  485.     m_pStream  = pStream;
  486.     m_pStream->AddRef();
  487.     m_pPlayer  = pPlayer;
  488.     m_pPlayer->AddRef();
  490.     m_pPlayer->GetClientEngine(m_pEngine);
  491.     m_pPlayer->GetClientContext(m_pClientContext);
  493.     IHXBuffer* pBuffer = NULL;
  494.     IHXRendererAdviseSink* pRendererAdviseSink = NULL;
  496.     IUnknown* pUnknown = NULL;
  497.     m_pPlayer->QueryInterface(IID_IUnknown, (void**) &pUnknown);
  498.     if (pUnknown)
  499.     {
  500.         ::getBooleanPreference(pUnknown, "useNestedMeta", m_bUseNestedMeta);
  501.     }
  502.     HX_RELEASE(pUnknown);
  504.     m_pSmilDocRenderer = new CSmilDocumentRenderer(this, m_pContext);
  505.     m_pSmilDocRenderer->AddRef();
  507.     if (m_bUseNestedMeta  &&
  508.     // /For handling case where SMIL 1.0 renderer is passing this higher-
  509.     // than-1.0-version stream  to this renderer, we don't want to do what
  510.     // the SMIL 1.0 renderer has already set up with the core:
  511.     !m_bStreamProxiedByOtherRenderer)
  512.     {
  514. IHXPersistentComponent* pPersistentComponent = NULL;
  516. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXPersistentComponentManager, 
  517.        (void**)&m_pPersistentComponentManager))
  518. {
  519.     m_pPersistentComponentManager->CreatePersistentComponent(pPersistentComponent);
  521.     pPersistentComponent->Init((IHXPersistentRenderer*)this);
  522.     pPersistentComponent->AddRendererAdviseSink((IHXRendererAdviseSink*)m_pSmilDocRenderer);
  523.     pPersistentComponent->AddGroupSink((IHXGroupSink*)m_pSmilDocRenderer);
  525.     rc = m_pPersistentComponentManager->AddPersistentComponent(pPersistentComponent);
  527. }
  528.     }
  529.     else if (!m_bStreamProxiedByOtherRenderer)
  530.     {
  531. IHXPersistenceManager* pMgr = 0;
  533. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXPersistenceManager, 
  534.     (void**)&pMgr))
  535. {
  536.     IUnknown* pUnk = 0;
  537.     if(HXR_OK == pMgr->GetPersistentComponent(pUnk))
  538.     {
  539. rc = HXR_FAIL;
  540. CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  541. errHandler.ReportError(SMILErrorMetaDatatype, NULL, 0);
  542. pUnk->Release();
  543.     }
  544.     else if(HXR_OK == QueryInterface(IID_IUnknown, (void**)&pUnk))
  545.     {
  546. pMgr->AddPersistentComponent(pUnk);
  547. pUnk->Release();
  548.     }
  549.     pMgr->Release();
  550. }
  552. IHXDriverStreamManager* pDriverStreamMgr = 0;
  553. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXDriverStreamManager,
  554.     (void**)&pDriverStreamMgr))
  555. {
  556.     if(!m_bStreamProxiedByOtherRenderer  &&
  557.     HXR_OK == m_pSmilDocRenderer->QueryInterface(IID_IHXRendererAdviseSink, 
  558.     (void**)&pRendererAdviseSink))
  559.     {
  560. pDriverStreamMgr->AddRendererAdviseSink(pRendererAdviseSink);
  561. pRendererAdviseSink->Release();
  562.     }
  563.     pDriverStreamMgr->Release();
  564. }
  566. IHXGroupManager* pGrpMgr = 0;
  567. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager,
  568.     (void**)&pGrpMgr))
  569. {
  570.     IHXGroupSink* pSnk = 0;
  571.     if(!m_bStreamProxiedByOtherRenderer  &&
  572.     HXR_OK == m_pSmilDocRenderer->QueryInterface(
  573.     IID_IHXGroupSink, (void**)&pSnk))
  574.     {
  575. pGrpMgr->AddSink(pSnk);
  576. pSnk->Release();
  577.     }
  578. }
  579. HX_RELEASE(pGrpMgr);
  580.     }
  582.     generatePreFix();
  584.     return rc;
  585. }
  587. /////////////////////////////////////////////////////////////////////////
  588. //  Method:
  589. // IHXRenderer::EndStream
  590. //  Purpose:
  591. // Called by client engine to inform the renderer that the stream
  592. // is was rendering is closed.
  593. //
  594. STDMETHODIMP CSmilRenderer::EndStream()
  595. {
  596.     MLOG_FLOW(m_pErrorMessages,
  597.               "CSmilRenderer::EndStream() this=0x%08xn", this);
  598.     if(m_pSmilDocRenderer)
  599.     {
  600. m_pSmilDocRenderer->endStream();
  601.     }
  603.     if(m_pPlayer)
  604.     {
  605. if (m_bUseNestedMeta  &&  !m_bStreamProxiedByOtherRenderer)
  606. {
  607.     IHXPersistentComponent* pPersistentComponent = NULL;
  608.     IHXRendererAdviseSink* pRendererAdviseSink = 0;
  610.     if(m_pPersistentComponentManager && HXR_OK == m_pPersistentComponentManager->GetPersistentComponent( m_pSmilDocRenderer->m_ulPersistentComponentID,
  611.                                                                                  pPersistentComponent))
  612.     {
  613. pPersistentComponent->RemoveRendererAdviseSink((IHXRendererAdviseSink*)m_pSmilDocRenderer);
  614. pPersistentComponent->RemoveGroupSink((IHXGroupSink*)m_pSmilDocRenderer);
  615.     }
  616.     HX_RELEASE(pPersistentComponent);     
  617. }
  618. else if (!m_bStreamProxiedByOtherRenderer)
  619. {
  620.     IHXGroupManager* pGrpMgr = 0;
  621.     if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager, 
  622. (void**)&pGrpMgr))
  623.     {
  624. IHXGroupSink* pSnk = 0;
  625. if(m_pSmilDocRenderer &&
  626.     HXR_OK == m_pSmilDocRenderer->QueryInterface(IID_IHXGroupSink, 
  627.     (void**)&pSnk))
  628. {
  629.     pGrpMgr->RemoveSink(pSnk);
  630.     pSnk->Release();
  631. }
  632. pGrpMgr->Release();
  633.     }
  635.     IHXDriverStreamManager* pStrmMgr = 0;
  636.     if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXDriverStreamManager,
  637. (void**)&pStrmMgr))
  638.     {
  639. IHXRendererAdviseSink* pSnk = 0;
  640. if(m_pSmilDocRenderer &&
  641.     HXR_OK == m_pSmilDocRenderer->QueryInterface(
  642.     IID_IHXRendererAdviseSink, (void**)&pSnk))
  643. {
  644.     pStrmMgr->RemoveRendererAdviseSink(pSnk);
  645.     pSnk->Release();
  646. }
  647. pStrmMgr->Release();
  648.     }
  649. }
  651. IHXClientAdviseSink* pSnk = NULL;
  652. if(!m_bStreamProxiedByOtherRenderer  &&
  653. m_pSmilDocRenderer  &&
  654. HXR_OK == m_pSmilDocRenderer->QueryInterface(
  655. IID_IHXClientAdviseSink, (void**)&pSnk))
  656. {
  657.     m_pPlayer->RemoveAdviseSink(pSnk);
  658.     HX_RELEASE(pSnk);
  659. }
  660.     }
  662.     HX_RELEASE(m_pStream);
  665.     // /See if the player has child players who need to be stopped:
  666.     if (m_pPlayer)
  667.     {
  668. IHXPlayerNavigator* pPlayerNavRoot = NULL;
  669. HX_RESULT pnrslt = m_pPlayer->QueryInterface(IID_IHXPlayerNavigator,
  670. (void**)&pPlayerNavRoot);
  671. if (HXR_OK == pnrslt)
  672. {
  673.     UINT16 uiChild = pPlayerNavRoot->GetNumChildPlayer();
  675.     while (uiChild > 0)
  676.     {
  677. IHXPlayer* pChildPlayer = NULL;
  678. // /GetChildPlayer addrefs pChildPlayer:
  679. pPlayerNavRoot->GetChildPlayer(uiChild-1, pChildPlayer);
  680. HX_ASSERT(pChildPlayer);
  681. if (pChildPlayer)
  682. {
  683.     pChildPlayer->Stop();
  684.     HX_RELEASE(pChildPlayer);
  685. }
  686. uiChild--;
  687.     }
  688.     HX_RELEASE(pPlayerNavRoot);
  689. }
  690.     }
  692.     
  693.     return HXR_OK;
  694. }
  696. /////////////////////////////////////////////////////////////////////////
  697. //  Method:
  698. // IHXRenderer::OnHeader
  699. //  Purpose:
  700. // Called by client engine when a header for this renderer is 
  701. // available. The header will arrive before any packets.
  702. //
  703. STDMETHODIMP CSmilRenderer::OnHeader(IHXValues* pHeader)
  704. {
  705.     MLOG_FLOW(m_pErrorMessages,
  706.               "CSmilRenderer::OnHeader(0x%08x) this=0x%08xn", pHeader, this);
  707.     // check stream and content versions so an upgrade can
  708.     // be called if necessary...
  710.     BOOL bVersionOK = TRUE;
  712.     UINT32 ulStreamVersion = 0;
  713.     UINT32 ulContentVersion = 0;
  714.     
  715.     if (HXR_OK == pHeader->GetPropertyULONG32("StreamVersion", ulStreamVersion))
  716.     {
  717. UINT32 ulMajorVersion = HX_GET_MAJOR_VERSION(ulStreamVersion);
  718. UINT32 ulMinorVersion = HX_GET_MINOR_VERSION(ulStreamVersion);
  720. if((ulMajorVersion > STREAM_MAJOR_VERSION) ||
  721.    (ulMinorVersion > STREAM_MINOR_VERSION &&
  722.     ulMajorVersion == STREAM_MAJOR_VERSION))
  723. {
  724.     bVersionOK = FALSE;
  725. }
  726.     }
  728.     if(bVersionOK &&
  729.        HXR_OK == pHeader->GetPropertyULONG32("ContentVersion", ulContentVersion))
  730.     {
  731. UINT32 ulMajorVersion = HX_GET_MAJOR_VERSION(ulContentVersion);
  732. UINT32 ulMinorVersion = HX_GET_MINOR_VERSION(ulContentVersion);
  734. if((ulMajorVersion > CONTENT_MAJOR_VERSION) ||
  735.    (ulMinorVersion > CONTENT_MINOR_VERSION &&
  736.     ulMajorVersion == CONTENT_MAJOR_VERSION))
  737. {
  738.     bVersionOK = FALSE;
  739. }
  740.     }
  742.     if(!bVersionOK)
  743.     {
  744. IHXUpgradeCollection* pUpColl = NULL;
  745. if(m_pPlayer &&
  746.    (HXR_OK == m_pPlayer->QueryInterface(IID_IHXUpgradeCollection,
  747. (void**)&pUpColl)))
  748. {
  749.     CHXBuffer* pBuffer = new CHXBuffer;
  750.     pBuffer->AddRef();
  751.     pBuffer->Set((BYTE*)SMIL20_AND_UP_STREAM_MIME_TYPE, 
  752. strlen(SMIL20_AND_UP_STREAM_MIME_TYPE)+1);
  753.     pUpColl->Add(eUT_Required, pBuffer, 0, 0);
  754.     HX_RELEASE(pBuffer);
  755.     HX_RELEASE(pUpColl);
  756. }
  757. return HXR_FAIL;
  758.     }
  760.     m_pPacketParser = new CSmilPacketParser;
  762.     m_pSmilDocRenderer->onHeader(pHeader);
  764.     if (!m_pSmilDocRenderer->IsNestedMetaSupported())
  765.     {
  766. return HXR_INVALID_METAFILE;
  767.     }
  769.     IHXClientAdviseSink* pSnk = 0;
  770.     if(!m_bStreamProxiedByOtherRenderer  &&
  771.     HXR_OK == m_pSmilDocRenderer->QueryInterface(
  772.     IID_IHXClientAdviseSink, (void**)&pSnk))
  773.     {
  774. m_pPlayer->AddAdviseSink(pSnk);
  775. HX_RELEASE(pSnk);
  776.     }
  778.     if (!m_bUseNestedMeta)
  779.     {
  780. /* SMIL renderer currently removes previously added
  781.  * groups, if any. This is to solve the case where we have 
  782.  * SMIL file within a RAM file. We will do something more
  783.  * sensible later.
  784.  */
  785. IHXGroupManager* pGrpMgr = 0;
  786. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager,
  787.     (void**)&pGrpMgr))
  788. {
  789.     while(pGrpMgr && pGrpMgr->GetGroupCount() > 0)
  790.     {
  791. pGrpMgr->RemoveGroup(0);
  792.     }
  793. }
  794. HX_RELEASE(pGrpMgr);
  795.     }
  797.     return HXR_OK;
  798. }
  801. /////////////////////////////////////////////////////////////////////////
  802. //  Method:
  803. // IHXRenderer::OnPacket
  804. //  Purpose:
  805. // Called by client engine when a packet for this renderer is 
  806. // due.
  807. //
  808. STDMETHODIMP CSmilRenderer::OnPacket(IHXPacket* pPacket, 
  809.  LONG32 lTimeOffset)
  810. {
  811.     MLOG_FLOW(m_pErrorMessages,
  812.               "CSmilRenderer::OnPacket(0x%08x,%ld) this=0x%08xn",
  813.               pPacket, lTimeOffset, this);
  814.     HX_RESULT rc = HXR_OK;
  816.     HX_ASSERT(lTimeOffset <= 0);
  818.     //Fix for PR 23352: if we already returned a fail value from
  819.     // a prior OnPacket(), don't process this OnPacket():
  820.     if (HXR_OK != m_lastOnPacketResult)
  821.     {
  822. return m_lastOnPacketResult;
  823.     }
  824.     IHXBuffer* pBuffer = pPacket->GetBuffer();
  825.     if(pBuffer)
  826.     {
  827. // /If parse() runs into a missing-quote situation,
  828. // we should stop and display an error.  Note that
  829. // CSmilPacketParser::parse(..)  does not keep track of
  830. // line numbers; TODO: add line-number counting to it.
  831. CSmilPacketParser::SMILPacketParseResult pktPrsRslt
  832. = CSmilPacketParser::SMILUnknown;
  833. CSmilPacket* pSmilPacket = m_pPacketParser->parse(
  834.     pBuffer, pktPrsRslt);
  835. if (CSmilPacketParser::SMILMissingQuote
  836. == pktPrsRslt)
  837. {
  838.     CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  839.     errHandler.ReportError(SMILErrorBadAttribute,
  840.     "missing quote", 0);
  841. }
  842. else if(pSmilPacket)
  843. {
  844.     switch(pSmilPacket->m_type)
  845.     {
  846. case CSmilPacket::SMILDocument:
  847. {
  848.     rc = handleSMILDocumentPacket(
  849. (CSmilDocumentPacket*)pSmilPacket);
  850.     if (HXR_OK != rc)
  851.     {
  852. m_lastOnPacketResult = rc;
  853.     }
  854. }
  855. break;
  857. default:
  858. break;
  859.     }
  860.     delete pSmilPacket;
  861. }
  862. HX_RELEASE(pBuffer);
  863.     }
  864.     return rc;
  865. }
  867. /////////////////////////////////////////////////////////////////////////
  868. //  Method:
  869. // IHXRenderer::OnTimeSync
  870. //  Purpose:
  871. // Called by client engine to inform the renderer of the current
  872. // time relative to the streams synchronized time-line. The 
  873. // renderer should use this time value to update its display or
  874. // render it's stream data accordingly.
  875. //
  876. STDMETHODIMP CSmilRenderer::OnTimeSync(ULONG32 ulTime)
  877. {
  878.     MLOG_FLOW(m_pErrorMessages,
  879.               "CSmilRenderer::OnTimeSync(%lu) this=0x%08xn", ulTime, this);
  880.     HX_RESULT rc = HXR_OK;
  881.     if(m_pSmilDocRenderer)
  882.     {
  883. rc = m_pSmilDocRenderer->onTimeSync(ulTime);
  884.     }
  885.     if (rc != HXR_OUTOFMEMORY)
  886.     {
  887.         rc = HXR_OK;
  888.     }
  889.     return rc;
  890. }
  892. /////////////////////////////////////////////////////////////////////////
  893. //  Method:
  894. // IHXRenderer::OnPreSeek
  895. //  Purpose:
  896. // Called by client engine to inform the renderer that a seek is
  897. // about to occur. The render is informed the last time for the 
  898. // stream's time line before the seek, as well as the first new
  899. // time for the stream's time line after the seek will be completed.
  900. //
  901. STDMETHODIMP CSmilRenderer::OnPreSeek(ULONG32 ulOldTime, ULONG32 ulNewTime)
  902. {
  903.     MLOG_FLOW(m_pErrorMessages,
  904.               "CSmilRenderer::OnPreSeek(%lu,%lu) this=0x%08xn",
  905.               ulOldTime, ulNewTime, this);
  906.     HX_RESULT rc = HXR_OK;
  907.     if(m_pSmilDocRenderer)
  908.     {
  909. rc = m_pSmilDocRenderer->onPreSeek(ulOldTime, ulNewTime);
  910.     }
  911.     return rc;
  912. }
  914. /////////////////////////////////////////////////////////////////////////
  915. //  Method:
  916. // IHXRenderer::OnPostSeek
  917. //  Purpose:
  918. // Called by client engine to inform the renderer that a seek has
  919. // just occured. The render is informed the last time for the 
  920. // stream's time line before the seek, as well as the first new
  921. // time for the stream's time line after the seek.
  922. //
  923. STDMETHODIMP CSmilRenderer::OnPostSeek(ULONG32 ulOldTime,
  924.    ULONG32 ulNewTime)
  925. {
  926.     MLOG_FLOW(m_pErrorMessages,
  927.               "CSmilRenderer::OnPostSeek(%lu,%lu) this=0x%08xn",
  928.               ulOldTime, ulNewTime, this);
  929.     return HXR_OK;
  930. }
  932. /////////////////////////////////////////////////////////////////////////
  933. //  Method:
  934. // IHXRenderer::OnPause
  935. //  Purpose:
  936. // Called by client engine to inform the renderer that a pause has
  937. // just occured. The render is informed the last time for the 
  938. // stream's time line before the pause.
  939. //
  940. STDMETHODIMP CSmilRenderer::OnPause(ULONG32 ulTime)
  941. {
  942.     MLOG_FLOW(m_pErrorMessages,
  943.               "CSmilRenderer::OnPause(%lu) this=0x%08xn", ulTime, this);
  944.     if( m_pSmilDocRenderer )
  945.     {
  946.         m_pSmilDocRenderer->unlockSiteComposition();
  947.     }
  948.     
  949.     return HXR_OK;
  950. }
  952. /////////////////////////////////////////////////////////////////////////
  953. //  Method:
  954. // IHXRenderer::OnBegin
  955. //  Purpose:
  956. // Called by client engine to inform the renderer that a begin or
  957. // resume has just occured. The render is informed the first time 
  958. // for the stream's time line after the resume.
  959. //
  960. STDMETHODIMP CSmilRenderer::OnBegin(ULONG32 ulTime)
  961. {
  962.     MLOG_FLOW(m_pErrorMessages,
  963.               "CSmilRenderer::OnBegin(%lu) this=0x%08xn", ulTime, this);
  964.     if( m_pSmilDocRenderer )
  965.     {
  966.         m_pSmilDocRenderer->lockSiteComposition();
  967.     }
  969.     return HXR_OK;
  970. }
  972. /////////////////////////////////////////////////////////////////////////
  973. //  Method:
  974. // IHXRenderer::OnBuffering
  975. //  Purpose:
  976. // Called by client engine to inform the renderer that buffering
  977. // of data is occuring. The render is informed of the reason for
  978. // the buffering (start-up of stream, seek has occured, network
  979. // congestion, etc.), as well as percentage complete of the 
  980. // buffering process.
  981. //
  982. STDMETHODIMP CSmilRenderer::OnBuffering(ULONG32 ulFlags,
  983. UINT16 unPercentComplete)
  984. {
  985.     MLOG_FLOW(m_pErrorMessages,
  986.               "CSmilRenderer::OnBuffering(%lu,%u) this=0x%08xn",
  987.               ulFlags, unPercentComplete, this);
  988.     return HXR_OK;
  989. }
  991. /////////////////////////////////////////////////////////////////////////
  992. //  Method:
  993. // IHXRenderer::GetDisplayType
  994. //  Purpose:
  995. // Called by client engine to ask the renderer for it's preferred
  996. // display type. When layout information is not present, the 
  997. // renderer will be asked for it's prefered display type. Depending
  998. // on the display type a buffer of additional information may be 
  999. // needed. This buffer could contain information about preferred
  1000. // window size.
  1001. //
  1002. STDMETHODIMP CSmilRenderer::GetDisplayType
  1003. (
  1004.     REF(HX_DISPLAY_TYPE)   ulFlags,
  1005.     REF(IHXBuffer*)     pBuffer
  1006. )
  1007. {
  1008.     ulFlags = HX_DISPLAY_NONE;
  1010.     return HXR_OK;
  1011. }
  1013. /************************************************************************
  1014.  * Method:
  1015.  *     IHXRenderer::OnEndofPackets
  1016.  * Purpose:
  1017.  *     Called by client engine to inform the renderer that all the
  1018.  *     packets have been delivered. However, if the user seeks before
  1019.  *     EndStream() is called, renderer may start getting packets again
  1020.  *     and the client engine will eventually call this function again.
  1021.  */
  1022. STDMETHODIMP CSmilRenderer::OnEndofPackets(void)
  1023. {
  1024.     MLOG_FLOW(m_pErrorMessages,
  1025.               "CSmilRenderer::OnEndofPackets() this=0x%08xn", this);
  1026.     return HXR_OK;
  1027. }
  1029. /************************************************************************
  1030.  * Method:
  1031.  *     IHXStatistics::Init
  1032.  * Purpose:
  1033.  *     Pass registry ID to the caller
  1034.  *
  1035.  */
  1036. STDMETHODIMP
  1037. CSmilRenderer::InitializeStatistics
  1038. (
  1039.     UINT32 /*IN*/ ulRegistryID
  1040. )
  1041. {
  1042.     IHXRegistry* pRegistry = NULL;
  1043.     if (m_pContext &&
  1044. HXR_OK == m_pContext->QueryInterface(IID_IHXRegistry, (void**)&pRegistry))
  1045.     {
  1046. char     szRegistryEntry[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  1047. IHXBuffer*     pszRegistryName = NULL;
  1049. // Get the current registry key name
  1050. if (HXR_OK == pRegistry->GetPropName(ulRegistryID, pszRegistryName))
  1051. {
  1052.     IHXBuffer* pValue = new CHXBuffer();
  1053.     pValue->AddRef();
  1055.     SafeSprintf(szRegistryEntry, MAX_DISPLAY_NAME, "%s.name", pszRegistryName->GetBuffer());
  1057.     pValue->Set((const UCHAR*)zm_pName, strlen(zm_pName) + 1);
  1058.     pRegistry->AddStr(szRegistryEntry, pValue);
  1060.     HX_RELEASE(pValue);
  1061.     HX_RELEASE(pszRegistryName);
  1062. }
  1064. HX_RELEASE(pRegistry);
  1065.     }
  1067.     return HXR_OK;
  1068. }
  1070. /************************************************************************
  1071.  * Method:
  1072.  *     IHXStatistics::Update
  1073.  * Purpose:
  1074.  *     Notify the client to update its statistics stored in the registry
  1075.  *
  1076.  */
  1077. STDMETHODIMP 
  1078. CSmilRenderer::UpdateStatistics()
  1079. {
  1080.     return HXR_OK;
  1081. }
  1083. // IHXPersistentRenderer methods
  1084. STDMETHODIMP
  1085. CSmilRenderer::InitPersistent(UINT32 ulPersistentComponentID,
  1086.      UINT16 uPersistentGroupID,
  1087.      UINT16 uPersistentTrackID,
  1088.      IHXPersistentRenderer* pPersistentParent)
  1089. {
  1090.     return m_pSmilDocRenderer->InitPersistent(ulPersistentComponentID,
  1091.       uPersistentGroupID,
  1092.       uPersistentTrackID,
  1093.       pPersistentParent);
  1094. }
  1096. STDMETHODIMP
  1097. CSmilRenderer::GetPersistentID(REF(UINT32) ulPersistentComponentID)
  1098. {
  1099.     ulPersistentComponentID = m_pSmilDocRenderer->m_ulPersistentComponentID;
  1101.     return HXR_OK;
  1102. }
  1104. STDMETHODIMP
  1105. CSmilRenderer::GetPersistentProperties(REF(IHXValues*) pProperties)
  1106. {
  1107.     HX_RESULT rc = HXR_OK;
  1109.     pProperties = new CHXHeader();
  1110.     pProperties->AddRef();
  1112.     pProperties->SetPropertyULONG32("PersistentType", m_persistentType);
  1113.     pProperties->SetPropertyULONG32("PersistentVersion", m_ulPersistentVersion);
  1115.     return rc;
  1116. }
  1118. STDMETHODIMP
  1119. CSmilRenderer::GetElementProperties(UINT16 uGroupID,
  1120.     UINT16 uTrackID,
  1121.                                     REF(IHXValues*) pProperties)
  1122. {
  1123.     return m_pSmilDocRenderer->GetElementProperties(uGroupID,
  1124.     uTrackID,
  1125.     pProperties);
  1126. }
  1128. STDMETHODIMP
  1129. CSmilRenderer::AttachElementLayout(UINT16     uGroupID,
  1130.    UINT16     uTrackID,
  1131.    IHXRenderer*    pRenderer,
  1132.    IHXStream*     pStream,
  1133.    IHXValues*     pProps)
  1134. {
  1135.     return m_pSmilDocRenderer->AttachElementLayout(uGroupID,
  1136.    uTrackID,
  1137.    pRenderer,
  1138.    pStream,
  1139.    pProps);
  1140. }
  1142. STDMETHODIMP
  1143. CSmilRenderer::DetachElementLayout(IUnknown* pLSG)
  1144. {
  1145.     return m_pSmilDocRenderer->DetachElementLayout(pLSG);
  1146. }
  1151. /************************************************************************
  1152.  * Method:
  1153.  *     IHXSmilToSmilRendererCommunicator::InitSmilStreamProxiedByOtherRenderer
  1154.  * Purpose:
  1155.  *     Notify the client to update its statistics stored in the registry
  1156.  *
  1157.  */
  1159. // IHXSmilToSmilRendererCommunicator methods
  1160. STDMETHODIMP
  1161. CSmilRenderer::InitSmilStreamProxiedByOtherRenderer(IHXBuffer* pDefaultNamespace)
  1162. {
  1163.     HX_RESULT rc = HXR_FAIL;
  1165.     m_bStreamProxiedByOtherRenderer = TRUE;
  1166.     if (pDefaultNamespace  &&  pDefaultNamespace->GetSize() > 0)
  1167.     {
  1168. HX_RELEASE(m_pVersionNamespaceFromProxyRenderer);
  1169. m_pVersionNamespaceFromProxyRenderer = pDefaultNamespace;
  1170. m_pVersionNamespaceFromProxyRenderer->AddRef();
  1171. rc = HXR_OK;
  1172.     }
  1173.     return rc;
  1174. }
  1181. STDMETHODIMP
  1182. CSmilRenderer::GetElementStatus(UINT16     uGroupID,
  1183. UINT16     uTrackID,
  1184. UINT32     ulCurrentTime,
  1185. REF(IHXValues*)    pStatus)
  1186. {
  1187.     return m_pSmilDocRenderer->GetElementStatus(uGroupID,
  1188. uTrackID,
  1189. ulCurrentTime,
  1190. pStatus);
  1191. }
  1194. HX_RESULT STDAPICALLTYPE CSmilRenderer::HXCreateInstance(IUnknown** ppIUnknown)
  1195. {
  1196.     HX_RESULT retVal = HXR_FAIL;
  1198.     if (ppIUnknown)
  1199.     {
  1200.         CSmilRenderer* pObj = new CSmilRenderer();
  1201.         if (pObj)
  1202.         {
  1203.             retVal = pObj->QueryInterface(IID_IUnknown, (void**) ppIUnknown);
  1204.             if (FAILED(retVal))
  1205.             {
  1206.                 HX_DELETE(pObj);
  1207.             }
  1208.         }
  1209.     }
  1211.     return retVal;
  1212. }
  1214. HX_RESULT STDAPICALLTYPE CSmilRenderer::CanUnload2(void)
  1215. {
  1216.     return ((CHXBaseCountingObject::ObjectsActive() > 0) ? HXR_FAIL : HXR_OK);
  1217. }
  1219. HX_RESULT
  1220. CSmilRenderer::HandleAddLayoutSiteGroup(IUnknown* pLSG)
  1221. {
  1222.     HX_RESULT     rc = HXR_OK;
  1223.     IHXValues*     pProps = NULL;
  1224.     IHXPersistentRenderer* pPersistentParentRenderer = NULL;
  1226.     pPersistentParentRenderer = m_pSmilDocRenderer->m_pPersistentParentRenderer;
  1228.     // nested meta, get layout from its parent
  1229.     if (pPersistentParentRenderer)
  1230.     {
  1231. pProps = new CHXHeader();
  1232. if (pProps)
  1233. {
  1234.     pProps->AddRef();
  1235.     pProps->SetPropertyULONG32("PersistentType", m_persistentType);
  1236. }
  1238. rc = pPersistentParentRenderer->AttachElementLayout(m_pSmilDocRenderer->m_uPersistentGroupID,
  1239.     m_pSmilDocRenderer->m_uPersistentTrackID,
  1240.     (IHXRenderer*)pLSG,
  1241.     NULL,
  1242.     pProps);
  1243.     }
  1244.     else if (m_pPlayer)
  1245.     {
  1246. IHXLayoutSiteGroupManager* pLSGMgr = 0;
  1247. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXLayoutSiteGroupManager, (void**)&pLSGMgr))
  1248. {
  1249.     rc = pLSGMgr->AddLayoutSiteGroup(pLSG);
  1250.     pLSGMgr->Release();
  1251. }
  1252.     }
  1254.     HX_RELEASE(pProps);
  1256.     return rc;
  1257. }
  1259. HX_RESULT
  1260. CSmilRenderer::HandleRemoveLayoutSiteGroup(IUnknown* pLSG)
  1261. {
  1262.     HX_RESULT     rc = HXR_OK;
  1263.     IHXPersistentRenderer* pPersistentParentRenderer = NULL;
  1265.     pPersistentParentRenderer = m_pSmilDocRenderer->m_pPersistentParentRenderer;
  1267.     // nested meta, remove layout from its parent
  1268.     if (pPersistentParentRenderer)
  1269.     {
  1270. rc = pPersistentParentRenderer->DetachElementLayout(pLSG);
  1271.     }
  1272.     else if (m_pPlayer)
  1273.     {
  1274. IHXLayoutSiteGroupManager* pLSGMgr = 0;
  1275. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXLayoutSiteGroupManager, (void**)&pLSGMgr))
  1276. {
  1277.     rc = pLSGMgr->RemoveLayoutSiteGroup(pLSG);
  1278.     pLSGMgr->Release();
  1279. }
  1280.     }
  1281.     return rc;
  1282. }
  1284. HX_RESULT
  1285. CSmilRenderer::HandleAttachElementLayout(IUnknown* pLSG, IHXValues* pProps)
  1286. {
  1287.     HX_RESULT rc = HXR_OK;
  1289.     if (m_pPersistentComponentManager)
  1290.     {
  1291. rc = m_pPersistentComponentManager->AttachPersistentComponentLayout(pLSG, pProps);
  1292.     }
  1294.     return rc;
  1295. }
  1297. HX_RESULT
  1298. CSmilRenderer::handleSMILDocumentPacket(CSmilDocumentPacket* pPacket)
  1299. {
  1300.     HX_RESULT rc = HXR_OK;
  1302.     if(pPacket->m_version == RMA_DRIVER_VERSION)
  1303.     {
  1304. CHXBuffer* pBuffer = new CHXBuffer;
  1305. pBuffer->AddRef();
  1306. BOOL bLastPacket = FALSE;
  1307. UINT32 ulDocLen = (UINT32)pPacket->m_document.GetLength();
  1308. HX_ASSERT(ulDocLen);
  1309. // /Extra safety check:
  1310. if (0 == ulDocLen)
  1311. {
  1312.     rc = HXR_UNEXPECTED;
  1313.     bLastPacket = FALSE;
  1314. }
  1315. else
  1316. {
  1317.     pBuffer->Set((const BYTE*)(const char*)pPacket->m_document,
  1318.     pPacket->m_document.GetLength());
  1319.     m_ulTotalSMILPackets++;
  1320.     bLastPacket = pPacket->m_ulTotalPackets == m_ulTotalSMILPackets;
  1321.     rc = m_pSmilDocRenderer->onPacket(pBuffer, bLastPacket);
  1323.     const char* pPktContents = (const char*)pPacket->m_document;
  1324.     while (pPktContents)
  1325.     {
  1326. // /See if there is a <metadata> tag; if so, add it and all
  1327. // the rest of the text up to </metadata> to m_metadata:
  1328. // /XXXEH- TODO: make sure we're not inside a <!--comment-->!:
  1329. // Note, however, that comments are being stripped by the
  1330. // file format, so we need only do this if the ff changes
  1331. // in this respect.
  1332. char* pMetadataTag =
  1333. (char*)strstr(pPktContents, "<metadata");
  1334. char* pMetadataEndTag =
  1335. (char*)strstr(pPktContents, "</metadata");
  1336. char* pVeryEndOfTag = pMetadataEndTag != NULL ?
  1337.     (char*)strchr(pMetadataEndTag, '>') : NULL;
  1338. if (m_bInMetadata)
  1339. {
  1340.     m_bInMetadata = (NULL == pMetadataEndTag);
  1341.     // /Concatinate all the stuff up to the end tag; if there's
  1342.     // no end tag, then concatinate the whole packet:
  1343.     if (NULL != pMetadataEndTag)
  1344.     {
  1345. if (strlen(pVeryEndOfTag) > 1)
  1346. {
  1347.     char savedChar = pVeryEndOfTag[1];
  1348.     pVeryEndOfTag[1] = NULL;
  1349.     m_pSmilDocRenderer->m_metadata += pPktContents;
  1350.     pVeryEndOfTag[1] = savedChar;
  1351. }
  1352.     }
  1353.     else
  1354.     {
  1355. m_pSmilDocRenderer->m_metadata += pPktContents;
  1356.     }
  1357. }
  1358. if (pMetadataTag)
  1359. {
  1360.     HX_ASSERT(!m_bInMetadata);
  1361.     // /In case there is another end tag (multiple metadata tags):
  1362.     if (pMetadataTag > pMetadataEndTag  &&  NULL != pMetadataEndTag)
  1363.     {
  1364. pMetadataEndTag = pVeryEndOfTag != NULL?
  1365. strstr(pVeryEndOfTag, "</metadata") : NULL;
  1366. pVeryEndOfTag = pMetadataEndTag!=NULL?
  1367. strchr(pMetadataEndTag, '>') : NULL;
  1368.     }
  1369.     // /Concatinate all the stuff up to the end tag; if there's
  1370.     // no end tag, then concatinate the whole packet:
  1371.     if (NULL != pMetadataEndTag)
  1372.     {
  1373. char* pVeryEndOfTag = strchr(pMetadataEndTag, '>');
  1374. if (strlen(pVeryEndOfTag) > 1)
  1375. {
  1376.     char savedChar = pVeryEndOfTag[1];
  1377.     pVeryEndOfTag[1] = NULL;
  1378.     m_pSmilDocRenderer->m_metadata += pMetadataTag;
  1379.     pVeryEndOfTag[1] = savedChar;
  1380. }
  1381.     }
  1382.     else
  1383.     {
  1384. m_bInMetadata = TRUE;
  1385. m_pSmilDocRenderer->m_metadata += pMetadataTag;
  1386.     }
  1387. }
  1388. pPktContents = (const char*)pVeryEndOfTag;
  1389.     }
  1391.     // /See if the <smil ...> tag had a default namespace declared
  1392.     // in it; if so, see if we recognize it.  If there is none or
  1393.     // if we don't recognize it, try an auto upgrade:
  1394.     BOOL bDefaultNamespaceRecognized = FALSE;
  1395.     const char* pDefaultNamespace =
  1396.     m_pSmilDocRenderer->getDefaultNamespace();
  1397.     if (pDefaultNamespace  &&  strlen(pDefaultNamespace)>0)
  1398.     {
  1399. UINT32 ui=0;
  1400. for (ui = 0; ui < NUM_RECOGNIZED_DEFAULT_NAMESPACES; ui++)
  1401. {
  1402.     if (0 == strcmp(
  1403.     (const char*) zm_pRecognizedDefaultNamespaces[ui],
  1404.     pDefaultNamespace) )
  1405.     {
  1406. bDefaultNamespaceRecognized = TRUE;
  1407. break;
  1408.     }
  1409. }
  1410.     }
  1411.     else
  1412.     {
  1413. #if defined(HANDLE_BETA1_SMIL_1_0_STREAM)  || defined(HANDLE_SMIL_1_0_STREAM)
  1414. bDefaultNamespaceRecognized = TRUE;
  1415. #else
  1416. // /No-default-namespace files go to the old renderer so we should
  1417. // never encounter this condition:
  1418. HX_ASSERT(m_pSmilDocRenderer->m_pSmilParser->m_pDefaultNamespace);
  1419. #endif
  1420.     }
  1421.     if (!bDefaultNamespaceRecognized)
  1422.     {
  1423. // /We need to auto upgrade if we don't recognize the default
  1424. // namespace.  This can occur under the following conditions
  1425. // (but can not occur if there is no default namespace because
  1426. // those files will all go to the old SMIL 1.0 renderer); note
  1427. // that each of these conditions is a good basis for an AU request
  1428. // except that (3) would best serve our customers if they were
  1429. // notified of the exact reason for the AU request before it
  1430. // happened.
  1431. // /XXXEH- talk to Consumer Group about AU request dialog boxes
  1432. // showing more info.
  1433. // (1) SMIL 3.0 or higher namespace is specified (or whatever
  1434. //     version of SMIL was undefined at the time this renderer was
  1435. //     compiled).
  1436. // (2) Some proprietary namespace that might be handled by some
  1437. //     non-RealNetworks plug-in (or by another RN SMIL renderer).
  1438. // (3) if someone misspells the default namespace that this renderer
  1439. //     otherwise would recognize.
  1440. HX_ASSERT(1);
  1441. IHXUpgradeCollection* pUpColl = NULL;
  1443. if(m_pPlayer &&
  1444.    (HXR_OK == m_pPlayer->QueryInterface(IID_IHXUpgradeCollection,
  1445. (void**)&pUpColl)))
  1446. {
  1447.     CHXBuffer* pBuffer = new CHXBuffer;
  1448.     pBuffer->AddRef();
  1449.     pBuffer->SetSize(strlen(SMIL20_AND_UP_STREAM_MIME_TYPE) +
  1450.     strlen(pDefaultNamespace) + 1 + 1);
  1451.     char* pBuf = (char*)pBuffer->GetBuffer();
  1452.     strcpy(pBuf, SMIL20_AND_UP_STREAM_MIME_TYPE); /* Flawfinder: ignore */
  1453.     strcat(pBuf, "."); /* Flawfinder: ignore */
  1454.     strcat(pBuf, pDefaultNamespace); /* Flawfinder: ignore */
  1455.     pUpColl->Add(eUT_Required, pBuffer, 0, 0);
  1456.     HX_RELEASE(pBuffer);
  1457.     HX_RELEASE(pUpColl);
  1458. }
  1460. return HXR_FAIL;
  1461.     }
  1462. }
  1463. HX_RELEASE(pBuffer);
  1465. if(HXR_OK != rc)
  1466. {
  1467.     // XML parsing error
  1468.     UINT32 ulLineNumber = 0;
  1469.     UINT32 ulColumnNumber = 0;
  1470.     IHXBuffer* pErrorText = NULL;
  1471.     m_pSmilDocRenderer->getErrorInfo(ulLineNumber,
  1472. ulColumnNumber, pErrorText);
  1474.     const char* pActualErrorText = NULL;
  1475.     if(pErrorText)
  1476.     {
  1477. pActualErrorText = (const char*)pErrorText->GetBuffer();
  1478.     }
  1479.     CSmilXMLSyntaxErrorHandler errHandler(m_pContext);
  1480.     errHandler.ReportError(rc, pActualErrorText, ulLineNumber);
  1481.     HX_RELEASE(pErrorText);
  1482. }
  1483. else if(bLastPacket)
  1484. {
  1485.     HX_ASSERT(!m_bInMetadata);
  1486.     m_bInMetadata = FALSE;
  1487.     //[SMIL 1.0 compliance] Handle error from setDocument()
  1488.     // otherwise it "plays" (nothing for 20 seconds) when it
  1489.     // should halt under error conditions:
  1490.     rc = m_pSmilDocRenderer->setDocument(m_pURLFragment);
  1491. }
  1492.     }
  1493.     return rc;
  1494. }
  1496. void
  1497. CSmilRenderer::generatePreFix()
  1498. {
  1499.     // get the protocol/server for later...
  1500.     IHXStreamSource* pSource = 0;
  1501.     m_pStream->GetSource(pSource);
  1502.     HX_ASSERT(pSource);
  1503.     if (!pSource)
  1504.     {
  1505. return;
  1506.     }
  1508.     const char* pURL = pSource->GetURL();
  1509.     HX_ASSERT(pURL);
  1510.     
  1511.     if (!pURL)
  1512.     {
  1513. return;
  1514.     }
  1516.     CHXURL::GeneratePrefixRootFragment(pURL, m_urlPrefix, m_urlRoot, m_pURLFragment);
  1517.     HX_RELEASE(pSource);
  1519.     return;
  1520. }
  1522. HX_RESULT
  1523. CSmilRenderer::SmilDocTrackDurationSet(UINT32 ulGroupIndex,
  1524. UINT32 ulTrackIndex, UINT32 ulDuration, UINT32 ulDelay, BOOL bIsLive)
  1525. {
  1526.     HX_RESULT rc = HXR_FAIL;
  1527.     if (m_pSmilDocRenderer)
  1528.     {
  1529. rc = m_pSmilDocRenderer->TrackDurationSet(ulGroupIndex, ulTrackIndex,
  1530. ulDuration, ulDelay, bIsLive);
  1531.     }
  1532.     return rc;
  1533. }
  1535. HX_RESULT
  1536. CSmilRenderer::SmilDocRepeatedTrackDurationSet(const char* pID,
  1537. UINT32 ulDuration, BOOL bIsLive)
  1538. {
  1539.     HX_RESULT rc = HXR_FAIL;
  1540.     if (m_pSmilDocRenderer)
  1541.     {
  1542. rc = m_pSmilDocRenderer->RepeatedTrackDurationSet(pID, ulDuration,
  1543. bIsLive);
  1544.     }
  1545.     return rc;
  1546. }
  1548. HX_RESULT
  1549. CSmilRenderer::SmilDocTrackUpdated(UINT32 ulGroupIndex, UINT32 ulTrackIndex,
  1550. IHXValues* pValues)
  1551. {
  1552.     HX_RESULT rc = HXR_FAIL;
  1553.     if (m_pSmilDocRenderer)
  1554.     {
  1555. rc = m_pSmilDocRenderer->TrackUpdated(ulGroupIndex, ulTrackIndex, pValues);
  1556.     }
  1557.     return rc;
  1558. }
  1560. HX_RESULT
  1561. CSmilRenderer::SmilDocRendererInitialized(IHXRenderer* pRend,
  1562. IUnknown* pStream, IHXValues* pInfo)
  1563. {
  1564.     HX_RESULT rc = HXR_FAIL;
  1565.     if (m_pSmilDocRenderer)
  1566.     {
  1567. rc = m_pSmilDocRenderer->RendererInitialized(pRend, pStream, pInfo);
  1568.     }
  1569.     return rc;
  1570. }
  1572. HX_RESULT
  1573. CSmilRenderer::SmilDocRendererClosed(IHXRenderer* pRend, IHXValues* pInfo)
  1574. {
  1575.     HX_RESULT rc = HXR_FAIL;
  1576.     if (m_pSmilDocRenderer)
  1577.     {
  1578. rc = m_pSmilDocRenderer->RendererClosed(pRend, pInfo);
  1579.     }
  1580.     return rc;
  1581. }
  1583. HX_RESULT
  1584. CSmilRenderer::SmilDocGroupAdded(UINT16 uGroupIndex, IHXGroup* pGroup)
  1585. {
  1586.     HX_RESULT rc = HXR_FAIL;
  1587.     if (m_pSmilDocRenderer)
  1588.     {
  1589. rc = m_pSmilDocRenderer->GroupAdded(uGroupIndex, pGroup);
  1590.     }
  1591.     return rc;
  1592. }
  1594. HX_RESULT
  1595. CSmilRenderer::SmilDocGroupRemoved(UINT16 uGroupIndex, IHXGroup* pGroup)
  1596. {
  1597.     HX_RESULT rc = HXR_FAIL;
  1598.     if (m_pSmilDocRenderer)
  1599.     {
  1600. rc = m_pSmilDocRenderer->GroupRemoved(uGroupIndex, pGroup);
  1601.     }
  1602.     return rc;
  1603. }
  1605. HX_RESULT
  1606. CSmilRenderer::SmilDocAllGroupsRemoved()
  1607. {
  1608.     HX_RESULT rc = HXR_FAIL;
  1609.     if (m_pSmilDocRenderer)
  1610.     {
  1611. rc = m_pSmilDocRenderer->AllGroupsRemoved();
  1612.     }
  1613.     return rc;
  1614. }
  1616. HX_RESULT
  1617. CSmilRenderer::SmilDocTrackAdded(UINT16 uGroupIndex, UINT16 uTrackIndex,
  1618. IHXValues* pTrack)
  1619. {
  1620.     HX_RESULT rc = HXR_FAIL;
  1621.     if (m_pSmilDocRenderer)
  1622.     {
  1623. rc = m_pSmilDocRenderer->TrackAdded(uGroupIndex, uTrackIndex, pTrack);
  1624.     }
  1625.     return rc;
  1626. }
  1628. HX_RESULT
  1629. CSmilRenderer::SmilDocTrackRemoved(UINT16 uGroupIndex, UINT16 uTrackIndex,
  1630. IHXValues* pTrack)
  1631. {
  1632.     HX_RESULT rc = HXR_FAIL;
  1633.     if (m_pSmilDocRenderer)
  1634.     {
  1635. rc = m_pSmilDocRenderer->TrackRemoved(uGroupIndex, uTrackIndex, pTrack);
  1636.     }
  1637.     return rc;
  1638. }
  1640. HX_RESULT
  1641. CSmilRenderer::SmilDocTrackStarted(UINT16 uGroupIndex, UINT16 uTrackIndex,
  1642.     IHXValues* pTrack)
  1643. {
  1644.     HX_RESULT rc = HXR_FAIL;
  1645.     if (m_pSmilDocRenderer)
  1646.     {
  1647. rc = m_pSmilDocRenderer->TrackStarted(uGroupIndex, uTrackIndex, pTrack);
  1648.     }
  1649.     return rc;
  1650. }
  1652. HX_RESULT
  1653. CSmilRenderer::SmilDocTrackStopped(UINT16 uGroupIndex, UINT16 uTrackIndex,
  1654. IHXValues* pTrack)
  1655. {
  1656.     HX_RESULT rc = HXR_FAIL;
  1657.     if (m_pSmilDocRenderer)
  1658.     {
  1659. rc = m_pSmilDocRenderer->TrackStopped(uGroupIndex, uTrackIndex, pTrack);
  1660.     }
  1661.     return rc;
  1662. }
  1664. HX_RESULT
  1665. CSmilRenderer::SmilDocCurrentGroupSet(UINT16 uGroupIndex, IHXGroup* pGroup)
  1666. {
  1667.     HX_RESULT rc = HXR_FAIL;
  1668.     if (m_pSmilDocRenderer)
  1669.     {
  1670. rc = m_pSmilDocRenderer->CurrentGroupSet(uGroupIndex, pGroup);
  1671.     }
  1672.     return rc;
  1673. }