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

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

Symbian

开发平台：

C/C++

sm1rendr.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #if defined (_AIX)
  37. #include <X11/Xlib.h>
  38. #endif
  40. #include <stdio.h>
  42. #include "sm1rendr.ver"
  43. #include "hxtypes.h"
  45. #include "hxwintyp.h"
  46. #include "chxxtype.h"
  47. #include "hxcom.h"
  48. #include "hxcomm.h"
  49. #include "ihxpckts.h"
  50. #include "hxfiles.h"
  51. #include "hxcore.h"
  52. #include "hxprefs.h"
  53. #include "hxrendr.h"
  54. #include "hxasm.h"
  55. #include "hxplugn.h"
  56. #include "hxengin.h"
  57. #include "hxwin.h"
  58. #include "hxgroup.h"
  59. #include "hxsite2.h"
  60. #include "hxclsnk.h"
  61. #include "hxerror.h"
  62. #include "hxupgrd.h"
  63. #include "hxprefs.h"
  64. #include "hxvsurf.h"
  65. #include "hxcmenu.h"
  66. #include "hxhyper.h"
  67. #include "hxmon.h" // for IHXRegistry
  68. #include "hxxres.h"
  69. #include "hxxrsmg.h"
  70. #include "hxmeta1.h"   /* renamed for SHAZAM; used to be hxmeta.h */
  71. #include "hxsm2sm.h"
  73. #include "hxxml.h"
  74. #include "hxxmlprs.h"
  75. #include "xmlreslt.h"
  77. #include "hxstack.h"
  78. #include "hxslist.h"
  79. #include "hxstring.h"
  80. #include "hxstrutl.h"
  81. #include "hxmap.h"
  82. #include "chxpckts.h"
  83. #include "hxmap.h"
  84. #include "hxurl.h"
  85. #include "asmrulep.h"
  86. #include "hxver.h"
  88. #include "smlpkt.h"
  89. #include "sm1elem.h"
  90. #include "sm1doc.h"
  91. #include "sm1error.h"
  92. #include "smilres.h"
  93. #include "xmlres.h"
  94. #include "smlrendr.h" /* for SMIL2+ renderer (CSmilRenderer) */
  95. #include "sm1rendr.h"
  96. #include "addupcol.h"
  98. /* We should really define it in a common header file */
  99. #if defined (_WINDOWS ) || defined (WIN32)
  100. #define OS_SEPARATOR_CHAR '\'
  101. #define OS_SEPARATOR_STRING "\"
  102. #elif defined (_UNIX)
  103. #define OS_SEPARATOR_CHAR '/'
  104. #define OS_SEPARATOR_STRING "/"
  105. #elif defined (_MACINTOSH)
  106. #define OS_SEPARATOR_CHAR ':'
  107. #define OS_SEPARATOR_STRING ":"
  108. #endif // defined (_WINDOWS ) || defined (WIN32)
  110. #include "hxheap.h"
  111. #ifdef _DEBUG
  112. #undef HX_THIS_FILE
  113. static const char HX_THIS_FILE[] = __FILE__;
  114. #endif
  116. #ifdef _WINDOWS
  117. extern HINSTANCE g_hInstance;
  118. #endif
  120. // /Defining the following fixes PR 62481 and seems to work fine with other
  121. // SMIL 2.0 content coming from a SMIL 1.0 File Format plug-in:
  122. #define DO_INIT_PERSISTENT_ON_NEXTGEN_SMILREND    1
  125. static const UINT32 INITIAL_GRANULARITY = 66;
  127. /****************************************************************************
  128.  * 
  129.  *  Method:
  130.  * 
  131.  * HXCreateInstance()
  132.  * 
  133.  *  Purpose:
  134.  * 
  135.  * Function implemented by all plugin DLL's to create an instance of 
  136.  * any of the objects supported by the DLL. This method is similar to 
  137.  * Window's CoCreateInstance() in its purpose, except that it only 
  138.  * creates objects from this plugin DLL.
  139.  *
  140.  * NOTE: Aggregation is never used. Therefore and outer unknown is
  141.  * not passed to this function, and you do not need to code for this
  142.  * situation.
  143.  * 
  144.  */
  145. HX_RESULT STDAPICALLTYPE CSmil1Renderer::HXCreateInstance(IUnknown** ppIUnknown)
  146. {
  147.     HX_RESULT retVal = HXR_FAIL;
  149.     if (ppIUnknown)
  150.     {
  151.         CSmil1Renderer* pObj = new CSmil1Renderer();
  152.         if (pObj)
  153.         {
  154.             retVal = pObj->QueryInterface(IID_IUnknown, (void**) ppIUnknown);
  155.             if (FAILED(retVal))
  156.             {
  157.                 HX_DELETE(pObj);
  158.             }
  159.         }
  160.     }
  162.     return retVal;
  163. }
  165. HX_RESULT STDAPICALLTYPE CSmil1Renderer::CanUnload2()
  166. {
  167.     return ((CHXBaseCountingObject::ObjectsActive() > 0) ? HXR_FAIL : HXR_OK );
  168. }
  170. const char* const CSmil1Renderer::zm_pName       = "SMIL 1.0";
  171. const char* const CSmil1Renderer::zm_pDescription    = "RealNetworks RMA Driver Renderer Plugin";
  172. const char* const CSmil1Renderer::zm_pCopyright      = HXVER_COPYRIGHT;
  173. const char* const CSmil1Renderer::zm_pMoreInfoURL    = HXVER_MOREINFO;
  174. const char* const CSmil1Renderer::zm_pStreamMimeTypes[] = { "application/vnd.rn-rmadriver", "application/rma-driver", NULL };
  177. /************************************************************************
  178.  *  Method:
  179.  *    IHXPlugin::InitPlugin
  180.  *  Purpose:
  181.  *    Initializes the plugin for use. This interface must always be
  182.  *    called before any other method is called. This is primarily needed 
  183.  *    so that the plugin can have access to the context for creation of
  184.  *    IHXBuffers and IMalloc.
  185.  */
  186. STDMETHODIMP CSmil1Renderer::InitPlugin(IUnknown* /*IN*/ pContext)
  187. {
  188. #if defined(HELIX_FEATURE_SMIL2)
  189.     HX_ASSERT(!m_bIsHigherVersionSmilStreamFromOldSMIL1FF);
  190. #endif /* defined(HELIX_FEATURE_SMIL2). */
  192.     m_pContext = pContext;
  193.     m_pContext->AddRef();
  195.     m_pContext->QueryInterface(IID_IHXCommonClassFactory,
  196.     (void**)&m_pCommonClassFactory);
  198.     return HXR_OK;
  199. }
  201. /************************************************************************
  202.  *  Method:
  203.  *    IHXPlugin::GetPluginInfo
  204.  *  Purpose:
  205.  *    Returns the basic information about this plugin. Including:
  206.  *
  207.  *    bLoadMultiple whether or not this plugin DLL can be loaded
  208.  * multiple times. All File Formats must set
  209.  * this value to TRUE.
  210.  *    pDescription which is used in about UIs (can be NULL)
  211.  *    pCopyright which is used in about UIs (can be NULL)
  212.  *    pMoreInfoURL which is used in about UIs (can be NULL)
  213.  */
  214. STDMETHODIMP CSmil1Renderer::GetPluginInfo
  215. (
  216.     REF(BOOL)        /*OUT*/ bLoadMultiple,
  217.     REF(const char*) /*OUT*/ pDescription,
  218.     REF(const char*) /*OUT*/ pCopyright,
  219.     REF(const char*) /*OUT*/ pMoreInfoURL,
  220.     REF(ULONG32)     /*OUT*/ ulVersionNumber
  221. )
  222. {
  223. #if defined(HELIX_FEATURE_SMIL2)
  224.     HX_ASSERT(!m_bIsHigherVersionSmilStreamFromOldSMIL1FF);
  225. #endif /* defined(HELIX_FEATURE_SMIL2). */
  227.     bLoadMultiple = TRUE;   // Must be true for file formats.
  229.     pDescription    = (const char*) zm_pDescription;
  230.     pCopyright     = (const char*) zm_pCopyright;
  231.     pMoreInfoURL    = (const char*) zm_pMoreInfoURL;
  232.     ulVersionNumber = TARVER_ULONG32_VERSION;
  234.     return HXR_OK;
  235. }
  237. /************************************************************************
  238.  *  Method:
  239.  *    IHXPlugin::GetRendererInfo
  240.  *  Purpose:
  241.  *    If this object is a file format object this method returns
  242.  *    information vital to the instantiation of file format plugins.
  243.  *    If this object is not a file format object, it should return
  244.  *    HXR_UNEXPECTED.
  245.  */
  246. STDMETHODIMP CSmil1Renderer::GetRendererInfo
  247. (
  248.     REF(const char**) /*OUT*/ pStreamMimeTypes,
  249.     REF(UINT32)      /*OUT*/ unInitialGranularity
  250. )
  251. {
  252. #if defined(HELIX_FEATURE_SMIL2)
  253.     HX_ASSERT(!m_bIsHigherVersionSmilStreamFromOldSMIL1FF);
  254. #endif /* defined(HELIX_FEATURE_SMIL2). */
  256.     pStreamMimeTypes = (const char**) zm_pStreamMimeTypes;
  257.     unInitialGranularity = m_ulGranularity;
  259.     return HXR_OK;
  260. }
  262. CSmil1Renderer::CSmil1Renderer()
  263. : m_lRefCount(0)
  264. , m_pContext(NULL)
  265. , m_pStream(NULL)
  266. , m_pPlayer(NULL)
  267. , m_ulLastTime(0)
  268. , m_pCommonClassFactory(0)
  269. , m_pPacketParser(0)
  270. , m_pSmilDocRenderer(0)
  271. , m_pEngine(0)
  272. , m_pClientContext(0)
  273. , m_uLayoutRule(0)
  274. , m_uSourceRule(0)
  275. , m_ulTotalSMILPackets(0)
  276. , m_ulGranularity(INITIAL_GRANULARITY)
  277. , m_pURLFragment(0)
  278. , m_lastOnPacketResult(HXR_OK)
  279. #if defined(HELIX_FEATURE_SMIL2)
  280. // /All of the following are needed for handling SMIL 2+ streams:
  281. , m_pNextGenSmilRenderer(NULL)
  282. , m_bIsHigherVersionSmilStreamFromOldSMIL1FF(FALSE)
  283. , m_pHeader(NULL)
  284. , m_pDefaultNamespace(NULL)
  285. , m_bCSmil1StartStreamHasBeenCalled(FALSE)
  286. , m_bCSmil1EndStreamHasBeenCalled(FALSE)
  287. , m_bCSmil1GetDisplayTypeHasBeenCalled(FALSE)
  288. , m_bCSmil1InitializeStatisticsHasBeenCalled(FALSE)
  290. , m_bCSmil1InitPersistenHasBeenCalled(FALSE)
  292. , m_bCSmil1GetElementPropertiesHasBeenCalled(FALSE)
  293. , m_bCSmil1RemoveLayoutSiteGroupHasBeenCalled(FALSE)
  294. , m_ulPersistentComponentID(0)
  295. , m_uPersistentGroupID(0)
  296. , m_uPersistentTrackID(0)
  297. , m_pPersistentParent(NULL)
  298. , m_ulRegistryID(0)
  299. , m_uGroupID(0)
  300. , m_uTrackID(0)
  301. // /End "...handling SMIL 2+ streams".
  302. #endif /* defined(HELIX_FEATURE_SMIL2). */
  303. , m_bUseNestedMeta(TRUE)
  304. , m_pPersistentComponentManager(NULL)    
  305. , m_ulPersistentVersion(0)
  306. , m_persistentType(PersistentSMIL)
  307. {
  308. #if defined(_DEBUG) && defined(XXXMEH_CHECK_FOR_LEAKS)
  309.     char szDbgStr[128]; /* Flawfinder: ignore */
  310.     sprintf(szDbgStr, "CON CSmil1Renderer 0x%08xn", this); /* Flawfinder: ignore */
  311.     OutputDebugString(szDbgStr);
  312. #endif
  313.     m_ulPersistentVersion = HX_ENCODE_PROD_VERSION(1, 0, 0, 0);
  314. };
  316. CSmil1Renderer::~CSmil1Renderer()
  317. {
  318. #if defined(_DEBUG) && defined(XXXMEH_CHECK_FOR_LEAKS)
  319.     char szDbgStr[128]; /* Flawfinder: ignore */
  320.     sprintf(szDbgStr, "DES CSmil1Renderer 0x%08xn", this); /* Flawfinder: ignore */
  321.     OutputDebugString(szDbgStr);
  322. #endif
  323.     if(m_pSmilDocRenderer)
  324.     {
  325. m_pSmilDocRenderer->close(this);
  326. HX_RELEASE(m_pSmilDocRenderer);
  327.     }
  329. #if defined(HELIX_FEATURE_SMIL2)
  330.     HX_RELEASE(m_pDefaultNamespace);
  331.     HX_RELEASE(m_pNextGenSmilRenderer);
  332.     HX_RELEASE(m_pHeader);
  333.     HX_RELEASE(m_pPersistentParent);
  334. #endif /* defined(HELIX_FEATURE_SMIL2). */
  336.     HX_RELEASE(m_pPersistentComponentManager);
  337.     HX_RELEASE(m_pContext);
  338.     HX_RELEASE(m_pClientContext);
  339.     HX_RELEASE(m_pStream);
  340.     HX_RELEASE(m_pEngine);
  341.     HX_RELEASE(m_pCommonClassFactory);
  343.     HX_DELETE(m_pPacketParser);
  344.     HX_RELEASE(m_pPlayer);
  345.     HX_VECTOR_DELETE(m_pURLFragment);
  346. }
  349. // *** IUnknown methods ***
  351. /////////////////////////////////////////////////////////////////////////
  352. //  Method:
  353. // IUnknown::QueryInterface
  354. //  Purpose:
  355. // Implement this to export the interfaces supported by your 
  356. // object.
  357. //
  358. STDMETHODIMP CSmil1Renderer::QueryInterface(REFIID riid, void** ppvObj)
  359. {
  360.     if (IsEqualIID(riid, IID_IUnknown))
  361.     {
  362. AddRef();
  363. *ppvObj = this;
  364. return HXR_OK;
  365.     }
  366.     else if (IsEqualIID(riid, IID_IHXPlugin))
  367.     {
  368. AddRef();
  369. *ppvObj = (IHXPlugin*)this;
  370. return HXR_OK;
  371.     }
  372.     else if (IsEqualIID(riid, IID_IHXRenderer))
  373.     {
  374. AddRef();
  375. *ppvObj = (IHXRenderer*)this;
  376. return HXR_OK;
  377.     }
  378.     else if (IsEqualIID(riid, IID_IHXSiteUser))
  379.     {
  380. AddRef();
  381. *ppvObj = (IHXSiteUser*)this;
  382. return HXR_OK;
  383.     }
  384.     else if (IsEqualIID(riid, IID_IHXStatistics))
  385.     {
  386. AddRef();
  387. *ppvObj = (IHXStatistics*)this;
  388. return HXR_OK;
  389.     }
  390.     else if (IsEqualIID(riid, IID_IHXPersistentRenderer))
  391.     {
  392. AddRef();
  393. *ppvObj = (IHXPersistentRenderer*)this;
  394. return HXR_OK;
  395.     }
  396.     else if (m_pSmilDocRenderer &&
  397.      HXR_OK == m_pSmilDocRenderer->QueryInterface(riid, ppvObj))
  398.     {
  399. return HXR_OK;
  400.     }
  401. #if defined(HELIX_FEATURE_SMIL2)
  402.     else if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  403.     {
  404. if (!m_pNextGenSmilRenderer)
  405. {
  406.     return HXR_UNEXPECTED;
  407. }
  408. if (HXR_OK ==
  409. m_pNextGenSmilRenderer->QueryInterface(riid, ppvObj))
  410. {
  411.     return HXR_OK;
  412. }
  413.     }
  414. #endif /* defined(HELIX_FEATURE_SMIL2). */
  417.     *ppvObj = NULL;
  418.     return HXR_NOINTERFACE;
  419. }
  421. /////////////////////////////////////////////////////////////////////////
  422. //  Method:
  423. // IUnknown::AddRef
  424. //  Purpose:
  425. // Everyone usually implements this the same... feel free to use
  426. // this implementation.
  427. //
  428. STDMETHODIMP_(ULONG32) CSmil1Renderer::AddRef()
  429. {
  430.     return InterlockedIncrement(&m_lRefCount);
  431. }
  433. /////////////////////////////////////////////////////////////////////////
  434. //  Method:
  435. // IUnknown::Release
  436. //  Purpose:
  437. // Everyone usually implements this the same... feel free to use
  438. // this implementation.
  439. //
  440. STDMETHODIMP_(ULONG32) CSmil1Renderer::Release()
  441. {
  442.     if (InterlockedDecrement(&m_lRefCount) > 0)
  443.     {
  444.         return m_lRefCount;
  445.     }
  447.     delete this;
  448.     return 0;
  449. }
  451. // *** IHXRenderer methods ***
  453. /////////////////////////////////////////////////////////////////////////
  454. //  Method:
  455. // IHXRenderer::StartStream
  456. //  Purpose:
  457. // Called by client engine to inform the renderer of the stream it
  458. // will be rendering. The stream interface can provide access to
  459. // its source or player. This method also provides access to the 
  460. // primary client controller interface.
  461. //
  462. STDMETHODIMP CSmil1Renderer::StartStream
  463. (
  464.     IHXStream*     pStream,
  465.     IHXPlayer*     pPlayer
  466. )
  467. {
  468. #if defined(HELIX_FEATURE_SMIL2)
  469.     m_bCSmil1StartStreamHasBeenCalled = TRUE;
  470.     HX_ASSERT(!m_bIsHigherVersionSmilStreamFromOldSMIL1FF);
  471. #endif /* defined(HELIX_FEATURE_SMIL2). */
  473.     HX_RESULT rc = HXR_OK;
  475.     // Save for later use!
  476.     m_pStream  = pStream;
  477.     m_pStream->AddRef();
  478.     m_pPlayer  = pPlayer;
  479.     m_pPlayer->AddRef();
  481.     m_pPlayer->GetClientEngine(m_pEngine);
  482.     m_pPlayer->GetClientContext(m_pClientContext);
  484.     IHXBuffer* pBuffer = NULL;
  485.     IHXPreferences* pPreferences = NULL;
  486.     IHXRendererAdviseSink* pRendererAdviseSink = NULL;
  488.     if (HXR_OK == m_pPlayer->QueryInterface(IID_IHXPreferences, (void**)&pPreferences))
  489.     {
  490. if (HXR_OK == pPreferences->ReadPref("useNestedMeta", pBuffer))
  491. {
  492.     m_bUseNestedMeta = atoi((const char*)pBuffer->GetBuffer()) ? TRUE : FALSE;
  493. }
  494. HX_RELEASE(pBuffer);
  495.     }
  496.     HX_RELEASE(pPreferences);
  498.     m_pSmilDocRenderer = new CSmil1DocumentRenderer(this, m_pContext);
  499.     m_pSmilDocRenderer->AddRef();
  501.     if (m_bUseNestedMeta)
  502.     {
  503. IHXPersistentComponent* pPersistentComponent = NULL;
  505. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXPersistentComponentManager, 
  506.        (void**)&m_pPersistentComponentManager))
  507. {
  508.     m_pPersistentComponentManager->CreatePersistentComponent(pPersistentComponent);
  510.     pPersistentComponent->Init((IHXPersistentRenderer*)this);
  511.     pPersistentComponent->AddRendererAdviseSink((IHXRendererAdviseSink*)m_pSmilDocRenderer);
  512.     pPersistentComponent->AddGroupSink((IHXGroupSink*)m_pSmilDocRenderer);
  514.     rc = m_pPersistentComponentManager->AddPersistentComponent(pPersistentComponent);
  516.     generatePreFix();
  517. }
  518.     }
  519.     else
  520.     {
  521. IHXPersistenceManager* pMgr = 0;
  522. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXPersistenceManager, 
  523.     (void**)&pMgr))
  524. {
  525.     IUnknown* pUnk = 0;
  526.     if(HXR_OK == pMgr->GetPersistentComponent(pUnk))
  527.     {
  528. rc = HXR_FAIL;
  529. CSmil1SMILSyntaxErrorHandler errHandler(m_pContext);
  530. errHandler.ReportError(SMILErrorMetaDatatype, NULL, 0);
  531. pUnk->Release();
  532.     }
  533.     else if(HXR_OK == QueryInterface(IID_IUnknown, (void**)&pUnk))
  534.     {
  535. pMgr->AddPersistentComponent(pUnk);
  536. pUnk->Release();
  537. generatePreFix();
  538.     }
  539.     pMgr->Release();
  540. }
  542. IHXDriverStreamManager* pDriverStreamMgr = 0;
  543. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXDriverStreamManager,
  544.     (void**)&pDriverStreamMgr))
  545. {
  546.     if(HXR_OK == m_pSmilDocRenderer->QueryInterface(IID_IHXRendererAdviseSink, 
  547.     (void**)&pRendererAdviseSink))
  548.     {
  549. pDriverStreamMgr->AddRendererAdviseSink(pRendererAdviseSink);
  550. pRendererAdviseSink->Release();
  551.     }
  552.     pDriverStreamMgr->Release();
  553. }
  555. IHXGroupManager* pGrpMgr = 0;
  556. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager,
  557.     (void**)&pGrpMgr))
  558. {
  559.     IHXGroupSink* pSnk = 0;
  560.     if(HXR_OK == m_pSmilDocRenderer->QueryInterface(
  561. IID_IHXGroupSink, (void**)&pSnk))
  562.     {
  563. pGrpMgr->AddSink(pSnk);
  564. pSnk->Release();
  565.     }
  566. }
  567. HX_RELEASE(pGrpMgr);
  568.     }
  570.     return rc;
  571. }
  573. /////////////////////////////////////////////////////////////////////////
  574. //  Method:
  575. // IHXRenderer::EndStream
  576. //  Purpose:
  577. // Called by client engine to inform the renderer that the stream
  578. // is was rendering is closed.
  579. //
  580. STDMETHODIMP CSmil1Renderer::EndStream()
  581. {
  582. #if defined(HELIX_FEATURE_SMIL2)
  583.     m_bCSmil1EndStreamHasBeenCalled = TRUE;
  584. #endif /* defined(HELIX_FEATURE_SMIL2). */
  586.     if(m_pPlayer)
  587.     {
  588. if (m_bUseNestedMeta)
  589. {
  590.     IHXPersistentComponent* pPersistentComponent = NULL;
  591.     IHXRendererAdviseSink* pRendererAdviseSink = 0;
  593.     if (HXR_OK == m_pPersistentComponentManager->GetPersistentComponent(m_pSmilDocRenderer->m_ulPersistentComponentID,
  594. pPersistentComponent))
  595.     {
  596. pPersistentComponent->RemoveRendererAdviseSink((IHXRendererAdviseSink*)m_pSmilDocRenderer);
  597. pPersistentComponent->RemoveGroupSink((IHXGroupSink*)m_pSmilDocRenderer);
  598.     }
  599.     HX_RELEASE(pPersistentComponent);     
  600. }
  601. else
  602. {
  603.     IHXGroupManager* pGrpMgr = 0;
  604.     if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager, 
  605. (void**)&pGrpMgr))
  606.     {
  607. IHXGroupSink* pSnk = 0;
  608. if(m_pSmilDocRenderer &&
  609.     HXR_OK == m_pSmilDocRenderer->QueryInterface(IID_IHXGroupSink, 
  610.     (void**)&pSnk))
  611. {
  612.     pGrpMgr->RemoveSink(pSnk);
  613.     pSnk->Release();
  614. }
  615. pGrpMgr->Release();
  616.     }
  618.     IHXDriverStreamManager* pStrmMgr = 0;
  619.     if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXDriverStreamManager,
  620. (void**)&pStrmMgr))
  621.     {
  622. IHXRendererAdviseSink* pSnk = 0;
  623. if(m_pSmilDocRenderer &&
  624.     HXR_OK == m_pSmilDocRenderer->QueryInterface(
  625.     IID_IHXRendererAdviseSink, (void**)&pSnk))
  626. {
  627.     pStrmMgr->RemoveRendererAdviseSink(pSnk);
  628.     pSnk->Release();
  629. }
  630. pStrmMgr->Release();
  631.     }
  632. }
  633.     }
  634.     HX_RELEASE(m_pStream);
  636. #if defined(HELIX_FEATURE_SMIL2)
  637.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  638.     {
  639. if (!m_pNextGenSmilRenderer)
  640. {
  641.     return HXR_UNEXPECTED;
  642. }
  644. return m_pNextGenSmilRenderer->EndStream();
  645.     }
  646. #endif /* defined(HELIX_FEATURE_SMIL2). */
  648.     if(m_pSmilDocRenderer)
  649.     {
  650. m_pSmilDocRenderer->endStream();
  651.     }
  654.     return HXR_OK;
  655. }
  657. /////////////////////////////////////////////////////////////////////////
  658. //  Method:
  659. // IHXRenderer::OnHeader
  660. //  Purpose:
  661. // Called by client engine when a header for this renderer is 
  662. // available. The header will arrive before any packets.
  663. //
  664. STDMETHODIMP CSmil1Renderer::OnHeader(IHXValues* pHeader)
  665. {
  666.     // check stream and content versions so an upgrade can
  667.     // be called if necessary...
  668.     HX_RESULT rc = HXR_OK;
  670.     if (!pHeader)
  671.     {
  672. return HXR_UNEXPECTED;
  673.     }
  675. #if defined(HELIX_FEATURE_SMIL2)
  676.     // /Hang onto header in case we need to send it up to a higher-version
  677.     // SMIL renderer:
  678.     m_pHeader = pHeader;
  679.     m_pHeader->AddRef();
  681.     HX_ASSERT(!m_bIsHigherVersionSmilStreamFromOldSMIL1FF);
  682. #endif /* defined(HELIX_FEATURE_SMIL2). */
  684.     BOOL bVersionOK = TRUE;
  685.     UINT16 uGroupCount = 0;
  686.     UINT16 uCurrentGroupID = 0;
  687.     UINT16 uSupportedType = 0; // G2 style by default
  688.     UINT32 ulStreamVersion = 0;
  689.     UINT32 ulContentVersion = 0;
  690.     IHXGroupManager* pGrpMgr = NULL;
  692.     if(HXR_OK == pHeader->GetPropertyULONG32("StreamVersion", 
  693. ulStreamVersion))
  694.     {
  695. UINT32 ulMajorVersion = HX_GET_MAJOR_VERSION(ulStreamVersion);
  696. UINT32 ulMinorVersion = HX_GET_MINOR_VERSION(ulStreamVersion);
  698. if((ulMajorVersion > STREAM_MAJOR_VERSION) ||
  699.    (ulMinorVersion > STREAM_MINOR_VERSION &&
  700.     ulMajorVersion == STREAM_MAJOR_VERSION))
  701. {
  702.     bVersionOK = FALSE;
  703. }
  704.     }
  706.     if(bVersionOK &&
  707.        HXR_OK == pHeader->GetPropertyULONG32("ContentVersion",
  708.            ulContentVersion))
  709.     {
  710. UINT32 ulMajorVersion = HX_GET_MAJOR_VERSION(ulContentVersion);
  711. UINT32 ulMinorVersion = HX_GET_MINOR_VERSION(ulContentVersion);
  713. if((ulMajorVersion > CONTENT_MAJOR_VERSION) ||
  714.    (ulMinorVersion > CONTENT_MINOR_VERSION &&
  715.     ulMajorVersion == CONTENT_MAJOR_VERSION))
  716. {
  717.     bVersionOK = FALSE;
  718. }
  719.     }
  721.     if(!bVersionOK)
  722.     {
  723.         AddToAutoUpgradeCollection((const char*) zm_pStreamMimeTypes[0], m_pContext);
  724. rc = HXR_FAILED;
  725. goto cleanup;
  726.     }
  728.     m_pPacketParser = new CSmilPacketParser;
  730.     m_pSmilDocRenderer->onHeader(pHeader);     
  732.     if (m_bUseNestedMeta)
  733.     {
  734. if (!m_pSmilDocRenderer->IsNestedMetaSupported(uSupportedType))
  735. {
  736.     rc = HXR_INVALID_METAFILE;
  737.     goto cleanup;
  738. }
  740. switch (uSupportedType)
  741. {
  742. case 1:
  743.     // RP8 SS3 - limited SMIL in RAM support, blow-away all the existing groups
  744.     // when it is the last SMIL in RAM.
  745.     if (HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager, (void**)&pGrpMgr))
  746.     {
  747. uGroupCount = pGrpMgr->GetGroupCount();
  748. pGrpMgr->GetCurrentGroup(uCurrentGroupID);
  750. if ((uCurrentGroupID + 1) == uGroupCount)
  751. {
  752.     m_pSmilDocRenderer->m_bLastGroupInRAM20 = TRUE;
  753.     while(pGrpMgr && pGrpMgr->GetGroupCount() > 0)
  754.     {
  755. pGrpMgr->RemoveGroup(0);
  756.     }
  757. }
  758.     }
  759.     HX_RELEASE(pGrpMgr);
  760.     break;
  761. default:
  762.     break;
  763. }
  764.     }
  765.     else
  766.     {
  767. if (HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager, (void**)&pGrpMgr))
  768. {
  769.          while(pGrpMgr && pGrpMgr->GetGroupCount() > 0)
  770.     {
  771.         pGrpMgr->RemoveGroup(0);
  772.     }     
  773. }
  774. HX_RELEASE(pGrpMgr);
  775.     }
  777. cleanup:
  779.     return rc;
  780. }
  783. /////////////////////////////////////////////////////////////////////////
  784. //  Method:
  785. // IHXRenderer::OnPacket
  786. //  Purpose:
  787. // Called by client engine when a packet for this renderer is 
  788. // due.
  789. //
  790. STDMETHODIMP CSmil1Renderer::OnPacket(IHXPacket* pPacket, 
  791.  LONG32 lTimeOffset)
  792. {
  793.     HX_RESULT rc = HXR_OK;
  794.     IHXBuffer* pBuffer = NULL;
  796. #if defined(HELIX_FEATURE_SMIL2)
  797.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  798.     {
  799. if (!m_pNextGenSmilRenderer)
  800. {
  801.     rc = HXR_UNEXPECTED;
  802.     goto cleanup;
  803. }
  804. rc = m_pNextGenSmilRenderer->OnPacket(pPacket, lTimeOffset);
  805.         goto cleanup;
  806.     }
  807. #endif /* defined(HELIX_FEATURE_SMIL2). */
  809.     HX_ASSERT(lTimeOffset <= 0);
  810.     m_pSmilDocRenderer->m_ulPersistentComponentDelay = -lTimeOffset;
  812.     //Fix for PR 23352: if we already returned a fail value from
  813.     // a prior OnPacket(), don't process this OnPacket():
  814.     if (HXR_OK != m_lastOnPacketResult)
  815.     {
  816. rc = m_lastOnPacketResult;
  817. goto cleanup;
  818.     }
  819.     pBuffer = pPacket->GetBuffer();
  820.     if(pBuffer)
  821.     {
  822. // /If parse() runs into a missing-quote situation,
  823. // we should stop and display an error.  Note that
  824. // CSmilPacketParser::parse(..)  does not keep track of
  825. // line numbers; TODO: add line-number counting to it.
  826. CSmilPacketParser::SMILPacketParseResult pktPrsRslt = CSmilPacketParser::SMILUnknown;
  827. CSmilPacket* pSmilPacket = m_pPacketParser->parse(
  828.     pBuffer, pktPrsRslt);
  829. if (CSmilPacketParser::SMILMissingQuote == pktPrsRslt)
  830. {
  831.     CSmil1SMILSyntaxErrorHandler errHandler(m_pContext);
  832.     errHandler.ReportError(SMILErrorBadAttribute,
  833.     "missing quote", 0);
  834. }
  835. else if(pSmilPacket)
  836. {
  837.     switch(pSmilPacket->m_type)
  838.     {
  839. case CSmilPacket::SMILDocument:
  840. {
  841. #if defined(HELIX_FEATURE_SMIL2)
  842.     if (!m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  843.     {
  844. // /findSmilTagAndVersion returns TRUE if it finds
  845. // the <smil> tag, regardless of the presence of
  846. // a default namespace:
  847. if (HXR_OK == findSmilTagAndVersion(pBuffer))
  848. {
  849.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  850.     {
  851. HX_RESULT pSUS2R = setUpNextGenSmilRenderer();
  852. if (HXR_OK!=pSUS2R  ||  !m_pNextGenSmilRenderer)
  853. {
  854.     rc = HXR_UNEXPECTED;
  855.     goto cleanup;
  856. }
  857.     }
  858. }
  860.     }
  862.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  863.     {
  864. rc = m_pNextGenSmilRenderer->OnPacket(pPacket,
  865. lTimeOffset);
  866.     }
  867.     else
  868. #endif /* defined(HELIX_FEATURE_SMIL2). */
  869.     {
  870. rc = handleSMILDocumentPacket(
  871.     (CSmilDocumentPacket*)pSmilPacket);
  872.     }
  873.     if (HXR_OK != rc)
  874.     {
  875. m_lastOnPacketResult = rc;
  876.     }
  877. }
  878. break;
  880. default:
  881. break;
  882.     }
  883.     delete pSmilPacket;
  884. }
  885. HX_RELEASE(pBuffer);
  886.     }
  888. cleanup:
  889.     return rc;
  890. }
  892. /////////////////////////////////////////////////////////////////////////
  893. //  Method:
  894. // IHXRenderer::OnTimeSync
  895. //  Purpose:
  896. // Called by client engine to inform the renderer of the current
  897. // time relative to the streams synchronized time-line. The 
  898. // renderer should use this time value to update its display or
  899. // render it's stream data accordingly.
  900. //
  901. STDMETHODIMP CSmil1Renderer::OnTimeSync(ULONG32 ulTime)
  902. {
  903.     HX_RESULT rc = HXR_OK;
  905. #if defined(HELIX_FEATURE_SMIL2)
  906.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  907.     {
  908. if (!m_pNextGenSmilRenderer)
  909. {
  910.     rc = HXR_UNEXPECTED;
  911.     goto cleanup;
  912. }
  913. rc = m_pNextGenSmilRenderer->OnTimeSync(ulTime);
  914.         goto cleanup;
  915.     }
  916. #endif /* defined(HELIX_FEATURE_SMIL2). */
  918.     if(m_pSmilDocRenderer)
  919.     {
  920. rc = m_pSmilDocRenderer->onTimeSync(ulTime);
  921.     }
  923. #if defined(HELIX_FEATURE_SMIL2)
  924. cleanup:
  925. #endif /* defined(HELIX_FEATURE_SMIL2). */
  926.     return rc;
  927. }
  929. /////////////////////////////////////////////////////////////////////////
  930. //  Method:
  931. // IHXRenderer::OnPreSeek
  932. //  Purpose:
  933. // Called by client engine to inform the renderer that a seek is
  934. // about to occur. The render is informed the last time for the 
  935. // stream's time line before the seek, as well as the first new
  936. // time for the stream's time line after the seek will be completed.
  937. //
  938. STDMETHODIMP CSmil1Renderer::OnPreSeek(ULONG32 ulOldTime, ULONG32 ulNewTime)
  939. {
  940.     HX_RESULT rc = HXR_OK;
  942. #if defined(HELIX_FEATURE_SMIL2)
  943.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  944.     {
  945. if (!m_pNextGenSmilRenderer)
  946. {
  947.     rc = HXR_UNEXPECTED;
  948.     goto cleanup;
  949. }
  950. rc = m_pNextGenSmilRenderer->OnPreSeek(ulOldTime, ulNewTime);
  951.         goto cleanup;
  952.     }
  953. #endif /* defined(HELIX_FEATURE_SMIL2). */
  955.     if(m_pSmilDocRenderer)
  956.     {
  957. rc = m_pSmilDocRenderer->onPreSeek(ulOldTime, ulNewTime);
  958.     }
  960. #if defined(HELIX_FEATURE_SMIL2)
  961. cleanup:
  962. #endif /* defined(HELIX_FEATURE_SMIL2). */
  963.     return rc;
  964. }
  966. /////////////////////////////////////////////////////////////////////////
  967. //  Method:
  968. // IHXRenderer::OnPostSeek
  969. //  Purpose:
  970. // Called by client engine to inform the renderer that a seek has
  971. // just occured. The render is informed the last time for the 
  972. // stream's time line before the seek, as well as the first new
  973. // time for the stream's time line after the seek.
  974. //
  975. STDMETHODIMP CSmil1Renderer::OnPostSeek(ULONG32 ulOldTime,
  976.    ULONG32 ulNewTime)
  977. {
  978.     HX_RESULT rc = HXR_OK;
  980. #if defined(HELIX_FEATURE_SMIL2)
  981.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  982.     {
  983. if (!m_pNextGenSmilRenderer)
  984. {
  985.     rc = HXR_UNEXPECTED;
  986.     goto cleanup;
  987. }
  988. rc = m_pNextGenSmilRenderer->OnPostSeek(ulOldTime, ulNewTime);
  989.         goto cleanup;
  990.     }
  991. #endif /* defined(HELIX_FEATURE_SMIL2). */
  993. #if defined(HELIX_FEATURE_SMIL2)
  994. cleanup:
  995. #endif /* defined(HELIX_FEATURE_SMIL2). */
  996.     return rc;
  997. }
  999. /////////////////////////////////////////////////////////////////////////
  1000. //  Method:
  1001. // IHXRenderer::OnPause
  1002. //  Purpose:
  1003. // Called by client engine to inform the renderer that a pause has
  1004. // just occured. The render is informed the last time for the 
  1005. // stream's time line before the pause.
  1006. //
  1007. STDMETHODIMP CSmil1Renderer::OnPause(ULONG32 ulTime)
  1008. {
  1009.     HX_RESULT rc = HXR_OK;
  1011. #if defined(HELIX_FEATURE_SMIL2)
  1012.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  1013.     {
  1014. if (!m_pNextGenSmilRenderer)
  1015. {
  1016.     rc = HXR_UNEXPECTED;
  1017.     goto cleanup;
  1018. }
  1019. rc = m_pNextGenSmilRenderer->OnPause(ulTime);
  1020.         goto cleanup;
  1021.     }
  1022. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1024. #if defined(HELIX_FEATURE_SMIL2)
  1025. cleanup:
  1026. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1027.     return rc;
  1028. }
  1030. /////////////////////////////////////////////////////////////////////////
  1031. //  Method:
  1032. // IHXRenderer::OnBegin
  1033. //  Purpose:
  1034. // Called by client engine to inform the renderer that a begin or
  1035. // resume has just occured. The render is informed the first time 
  1036. // for the stream's time line after the resume.
  1037. //
  1038. STDMETHODIMP CSmil1Renderer::OnBegin(ULONG32 ulTime)
  1039. {
  1040.     HX_RESULT rc = HXR_OK;
  1042. #if defined(HELIX_FEATURE_SMIL2)
  1043.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  1044.     {
  1045. if (!m_pNextGenSmilRenderer)
  1046. {
  1047.     rc = HXR_UNEXPECTED;
  1048.     goto cleanup;
  1049. }
  1050. rc = m_pNextGenSmilRenderer->OnBegin(ulTime);
  1051.         goto cleanup;
  1052.     }
  1053. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1055. #if defined(HELIX_FEATURE_SMIL2)
  1056. cleanup:
  1057. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1058.     return rc;
  1059. }
  1061. /////////////////////////////////////////////////////////////////////////
  1062. //  Method:
  1063. // IHXRenderer::OnBuffering
  1064. //  Purpose:
  1065. // Called by client engine to inform the renderer that buffering
  1066. // of data is occuring. The render is informed of the reason for
  1067. // the buffering (start-up of stream, seek has occured, network
  1068. // congestion, etc.), as well as percentage complete of the 
  1069. // buffering process.
  1070. //
  1071. STDMETHODIMP CSmil1Renderer::OnBuffering(ULONG32 ulFlags,
  1072. UINT16 unPercentComplete)
  1073. {
  1074.     HX_RESULT rc = HXR_OK;
  1076. #if defined(HELIX_FEATURE_SMIL2)
  1077.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  1078.     {
  1079. if (!m_pNextGenSmilRenderer)
  1080. {
  1081.     rc = HXR_UNEXPECTED;
  1082.     goto cleanup;
  1083. }
  1084. rc = m_pNextGenSmilRenderer->OnBuffering(ulFlags,
  1085. unPercentComplete);
  1086.         goto cleanup;
  1087.     }
  1088. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1090. #if defined(HELIX_FEATURE_SMIL2)
  1091. cleanup:
  1092. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1093.     return rc;
  1094. }
  1096. /////////////////////////////////////////////////////////////////////////
  1097. //  Method:
  1098. // IHXRenderer::GetDisplayType
  1099. //  Purpose:
  1100. // Called by client engine to ask the renderer for it's preferred
  1101. // display type. When layout information is not present, the 
  1102. // renderer will be asked for it's prefered display type. Depending
  1103. // on the display type a buffer of additional information may be 
  1104. // needed. This buffer could contain information about preferred
  1105. // window size.
  1106. //
  1107. STDMETHODIMP CSmil1Renderer::GetDisplayType
  1108. (
  1109.     REF(HX_DISPLAY_TYPE)   ulFlags,
  1110.     REF(IHXBuffer*)     pBuffer
  1111. )
  1112. {
  1113.     HX_RESULT rc = HXR_OK;
  1115.     ulFlags = HX_DISPLAY_NONE;
  1117. #if defined(HELIX_FEATURE_SMIL2)
  1118.     m_bCSmil1GetDisplayTypeHasBeenCalled = TRUE;
  1119.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  1120.     {
  1121. if (!m_pNextGenSmilRenderer)
  1122. {
  1123.     rc = HXR_UNEXPECTED;
  1124.     goto cleanup;
  1125. }
  1126. rc = m_pNextGenSmilRenderer->GetDisplayType(ulFlags,
  1127. pBuffer);
  1128.         goto cleanup;
  1129.     }
  1130. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1132. #if defined(HELIX_FEATURE_SMIL2)
  1133. cleanup:
  1134. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1135.     return rc;
  1136. }
  1138. /************************************************************************
  1139.  * Method:
  1140.  *     IHXRenderer::OnEndofPackets
  1141.  * Purpose:
  1142.  *     Called by client engine to inform the renderer that all the
  1143.  *     packets have been delivered. However, if the user seeks before
  1144.  *     EndStream() is called, renderer may start getting packets again
  1145.  *     and the client engine will eventually call this function again.
  1146.  */
  1147. STDMETHODIMP CSmil1Renderer::OnEndofPackets(void)
  1148. {
  1149.     HX_RESULT rc = HXR_OK;
  1151. #if defined(HELIX_FEATURE_SMIL2)
  1152.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  1153.     {
  1154. if (!m_pNextGenSmilRenderer)
  1155. {
  1156.     rc = HXR_UNEXPECTED;
  1157.     goto cleanup;
  1158. }
  1159. rc = m_pNextGenSmilRenderer->OnEndofPackets();
  1160.         goto cleanup;
  1161.     }
  1162. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1164. #if defined(HELIX_FEATURE_SMIL2)
  1165. cleanup:
  1166. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1167.     return rc;
  1168. }
  1170. /************************************************************************
  1171.  * Method:
  1172.  *     IHXStatistics::Init
  1173.  * Purpose:
  1174.  *     Pass registry ID to the caller
  1175.  *
  1176.  */
  1177. STDMETHODIMP
  1178. CSmil1Renderer::InitializeStatistics
  1179. (
  1180.     UINT32 /*IN*/ ulRegistryID
  1181. )
  1182. {
  1183.     HX_RESULT rc = HXR_OK;
  1185.     IHXRegistry* pRegistry = NULL;
  1187. #if defined(HELIX_FEATURE_SMIL2)
  1188.     m_ulRegistryID = ulRegistryID;
  1189.     m_bCSmil1InitializeStatisticsHasBeenCalled = TRUE;
  1190.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  1191.     {
  1192. if (!m_pNextGenSmilRenderer)
  1193. {
  1194.     rc = HXR_UNEXPECTED;
  1195.     goto cleanup;
  1196. }
  1197. rc = m_pNextGenSmilRenderer->InitializeStatistics(m_ulRegistryID);
  1198.         goto cleanup;
  1199.     }
  1200. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1202.     if (m_pContext &&
  1203. HXR_OK == m_pContext->QueryInterface(IID_IHXRegistry, (void**)&pRegistry))
  1204.     {
  1205. char     szRegistryEntry[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  1206. IHXBuffer*     pszRegistryName = NULL;
  1208. // Get the current registry key name
  1209. if (HXR_OK == pRegistry->GetPropName(ulRegistryID, pszRegistryName))
  1210. {
  1211.     IHXBuffer* pValue = new CHXBuffer();
  1212.     pValue->AddRef();
  1214.     SafeSprintf(szRegistryEntry, MAX_DISPLAY_NAME, "%s.name", pszRegistryName->GetBuffer());
  1216.     pValue->Set((const UCHAR*)zm_pName, strlen((const char*) zm_pName) + 1);
  1217.     pRegistry->AddStr(szRegistryEntry, pValue);
  1219.     HX_RELEASE(pValue);
  1220.     HX_RELEASE(pszRegistryName);
  1221. }
  1223. HX_RELEASE(pRegistry);
  1224.     }
  1226. #if defined(HELIX_FEATURE_SMIL2)
  1227. cleanup:
  1228. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1229.     return rc;
  1230. }
  1232. /************************************************************************
  1233.  * Method:
  1234.  *     IHXStatistics::Update
  1235.  * Purpose:
  1236.  *     Notify the client to update its statistics stored in the registry
  1237.  *
  1238.  */
  1239. STDMETHODIMP 
  1240. CSmil1Renderer::UpdateStatistics()
  1241. {
  1242.     HX_RESULT rc = HXR_OK;
  1244. #if defined(HELIX_FEATURE_SMIL2)
  1245.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  1246.     {
  1247. if (!m_pNextGenSmilRenderer)
  1248. {
  1249.     rc = HXR_UNEXPECTED;
  1250.     goto cleanup;
  1251. }
  1252. rc = m_pNextGenSmilRenderer->UpdateStatistics();
  1253.         goto cleanup;
  1254.     }
  1255. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1257. #if defined(HELIX_FEATURE_SMIL2)
  1258. cleanup:
  1259. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1260.     return rc;
  1261. }
  1263. // IHXPersistentRenderer methods
  1264. STDMETHODIMP
  1265. CSmil1Renderer::InitPersistent(UINT32 ulPersistentComponentID,
  1266.      UINT16 uPersistentGroupID,
  1267.      UINT16 uPersistentTrackID,
  1268.      IHXPersistentRenderer* pPersistentParent)
  1269. {
  1270.     HX_RESULT rc = HXR_OK;
  1272.     m_ulPersistentComponentID = ulPersistentComponentID;
  1273.     m_uPersistentGroupID = uPersistentGroupID;
  1274.     m_uPersistentTrackID = uPersistentTrackID;
  1275.     m_pPersistentParent = pPersistentParent;
  1276.     if (m_pPersistentParent)
  1277.     {
  1278. m_pPersistentParent->AddRef();
  1279.     }
  1281. #if defined(HELIX_FEATURE_SMIL2)
  1282. #if defined(DO_INIT_PERSISTENT_ON_NEXTGEN_SMILREND)
  1283.     m_bCSmil1InitPersistenHasBeenCalled = TRUE;
  1284.     HX_ASSERT (!m_bIsHigherVersionSmilStreamFromOldSMIL1FF);
  1285. #endif
  1286. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1288.     rc = m_pSmilDocRenderer->InitPersistent(ulPersistentComponentID,
  1289.       uPersistentGroupID,
  1290.       uPersistentTrackID,
  1291.       pPersistentParent);
  1293.     return rc;
  1294. }
  1296. STDMETHODIMP
  1297. CSmil1Renderer::GetPersistentID(REF(UINT32) ulPersistentComponentID)
  1298. {
  1299.     HX_RESULT rc = HXR_OK;
  1301.     ulPersistentComponentID = m_pSmilDocRenderer->m_ulPersistentComponentID;
  1303.     return rc;
  1304. }
  1306. STDMETHODIMP
  1307. CSmil1Renderer::GetPersistentProperties(REF(IHXValues*) pProperties)
  1308. {
  1309.     HX_RESULT rc = HXR_OK;
  1311.     pProperties = new CHXHeader();
  1312.     pProperties->AddRef();
  1314.     pProperties->SetPropertyULONG32("PersistentType", m_persistentType);
  1315.     pProperties->SetPropertyULONG32("PersistentVersion", m_ulPersistentVersion);
  1317.     return rc;
  1318. }
  1320. STDMETHODIMP
  1321. CSmil1Renderer::GetElementProperties(UINT16 uGroupID,
  1322.     UINT16 uTrackID,
  1323.                                     REF(IHXValues*) pProperties)
  1324. {
  1325.     HX_RESULT rc = HXR_OK;
  1327. #if defined(HELIX_FEATURE_SMIL2)
  1328.     m_bCSmil1GetElementPropertiesHasBeenCalled = TRUE;
  1329.     m_uGroupID = uGroupID;
  1330.     m_uTrackID = uTrackID;
  1331.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  1332.     {
  1333. if (!m_pNextGenSmilRenderer)
  1334. {
  1335.     rc = HXR_UNEXPECTED;
  1336.     goto cleanup;
  1337. }
  1338. rc = m_pNextGenSmilRenderer->GetElementProperties(
  1339. uGroupID, uTrackID, pProperties);
  1340. HX_ASSERT(0  &&  "XXXEH- call on both sm1 and sm2 rends?");
  1341.     }
  1342. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1344.     rc = m_pSmilDocRenderer->GetElementProperties(uGroupID,
  1345.     uTrackID,
  1346.     pProperties);
  1348. #if defined(HELIX_FEATURE_SMIL2)
  1349. cleanup:
  1350. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1351.     return rc;
  1352. }
  1354. STDMETHODIMP
  1355. CSmil1Renderer::AttachElementLayout(UINT16     uGroupID,
  1356.     UINT16     uTrackID,
  1357.     IHXRenderer*   pRenderer,
  1358.     IHXStream*     pStream,
  1359.     IHXValues*     pProps)
  1360. {
  1361.     HX_RESULT rc = HXR_OK;
  1363. #if defined(HELIX_FEATURE_SMIL2)
  1364.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  1365.     {
  1366. if (!m_pNextGenSmilRenderer)
  1367. {
  1368.     rc = HXR_UNEXPECTED;
  1369.     goto cleanup;
  1370. }
  1371. rc = m_pNextGenSmilRenderer->AttachElementLayout(uGroupID,
  1372.  uTrackID,
  1373.  pRenderer,
  1374.  pStream,
  1375.  pProps);
  1376. HX_ASSERT(0  &&  "XXXEH- call on both sm1 and sm2 rends?");
  1377.     }
  1378. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1380.     rc = m_pSmilDocRenderer->AttachElementLayout(uGroupID, 
  1381.  uTrackID,
  1382.  pRenderer,
  1383.  pStream,
  1384.  pProps);
  1386. #if defined(HELIX_FEATURE_SMIL2)
  1387. cleanup:
  1388. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1389.     return rc;
  1390. }
  1392. STDMETHODIMP
  1393. CSmil1Renderer::DetachElementLayout(IUnknown* pLSG)
  1394. {
  1395.     HX_RESULT rc = HXR_OK;
  1397. #if defined(HELIX_FEATURE_SMIL2)
  1398.     m_bCSmil1RemoveLayoutSiteGroupHasBeenCalled = TRUE;
  1399.     if (m_bIsHigherVersionSmilStreamFromOldSMIL1FF)
  1400.     {
  1401. if (!m_pNextGenSmilRenderer)
  1402. {
  1403.     rc = HXR_UNEXPECTED;
  1404.     goto cleanup;
  1405. }
  1406. rc = m_pNextGenSmilRenderer->DetachElementLayout(pLSG);
  1407. HX_ASSERT(0  &&  "XXXEH- call on both sm1 and sm2 rends?");
  1408.     }
  1409. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1411.     rc = m_pSmilDocRenderer->DetachElementLayout(pLSG);
  1413. #if defined(HELIX_FEATURE_SMIL2)
  1414. cleanup:
  1415. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1416.     return rc;
  1417. }
  1419. STDMETHODIMP
  1420. CSmil1Renderer::GetElementStatus(UINT16     uGroupID,
  1421. UINT16     uTrackID,
  1422. UINT32     ulCurrentTime,
  1423. REF(IHXValues*)    pStatus)
  1424. {
  1425.     return m_pSmilDocRenderer->GetElementStatus(uGroupID,
  1426. uTrackID,
  1427. ulCurrentTime,
  1428. pStatus);
  1429. }
  1431. HX_RESULT
  1432. CSmil1Renderer::HandleAddLayoutSiteGroup(IUnknown* pLSG)
  1433. {
  1434.     HX_RESULT     rc = HXR_OK;
  1435.     IHXValues*     pProps = NULL;
  1436.     IHXPersistentRenderer* pPersistentParentRenderer = NULL;
  1438.     pPersistentParentRenderer = m_pSmilDocRenderer->m_pPersistentParentRenderer;
  1440.     // nested meta, get layout from its parent
  1441.     if (pPersistentParentRenderer)
  1442.     {
  1443. pProps = new CHXHeader();
  1444. if (pProps)
  1445. {
  1446.     pProps->AddRef();
  1447.     pProps->SetPropertyULONG32("PersistentType", m_persistentType);
  1448. }
  1450. rc = pPersistentParentRenderer->AttachElementLayout(m_pSmilDocRenderer->m_uPersistentGroupID,
  1451.     m_pSmilDocRenderer->m_uPersistentTrackID,
  1452.     (IHXRenderer*)pLSG,
  1453.     NULL,
  1454.     pProps);
  1455.     }
  1456.     else if (m_pPlayer)
  1457.     {
  1458. IHXLayoutSiteGroupManager* pLSGMgr = 0;
  1459. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXLayoutSiteGroupManager, (void**)&pLSGMgr))
  1460. {
  1461.     rc = pLSGMgr->AddLayoutSiteGroup(pLSG);
  1462.     pLSGMgr->Release();
  1463. }
  1464.     }
  1466.     HX_RELEASE(pProps);
  1468.     return rc;
  1469. }
  1471. HX_RESULT
  1472. CSmil1Renderer::HandleRemoveLayoutSiteGroup(IUnknown* pLSG)
  1473. {
  1474.     HX_RESULT     rc = HXR_OK;
  1475.     IHXPersistentRenderer* pPersistentParentRenderer = NULL;
  1477.     pPersistentParentRenderer = m_pSmilDocRenderer->m_pPersistentParentRenderer;
  1479.     // nested meta, remove layout from its parent
  1480.     if (pPersistentParentRenderer)
  1481.     {
  1482. rc = pPersistentParentRenderer->DetachElementLayout(pLSG);
  1483.     }
  1484.     else if (m_pPlayer)
  1485.     {
  1486. IHXLayoutSiteGroupManager* pLSGMgr = 0;
  1487. if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXLayoutSiteGroupManager, (void**)&pLSGMgr))
  1488. {
  1489.     rc = pLSGMgr->RemoveLayoutSiteGroup(pLSG);
  1490.     pLSGMgr->Release();
  1491. }
  1492.     }
  1493.     return rc;
  1494. }
  1496. HX_RESULT
  1497. CSmil1Renderer::HandleAttachElementLayout(IUnknown* pLSG, IHXValues* pProps)
  1498. {
  1499.     HX_RESULT rc = HXR_OK;
  1501.     if (m_pPersistentComponentManager)
  1502.     {
  1503. rc = m_pPersistentComponentManager->AttachPersistentComponentLayout(pLSG, pProps);
  1504.     }
  1506.     return rc;
  1507. }
  1509. HX_RESULT
  1510. CSmil1Renderer::handleSMILDocumentPacket(CSmilDocumentPacket* pPacket)
  1511. {
  1512.     HX_RESULT rc = HXR_OK;
  1514.     if(pPacket->m_version == RMA_DRIVER_VERSION)
  1515.     {
  1516. CHXBuffer* pBuffer = new CHXBuffer;
  1517. pBuffer->AddRef();
  1518. BOOL bLastPacket = FALSE;
  1519. UINT32 ulDocLen = (UINT32)pPacket->m_document.GetLength();
  1520. HX_ASSERT(ulDocLen);
  1521. // /Extra safety check:
  1522. if (0 == ulDocLen)
  1523. {
  1524.     rc = HXR_UNEXPECTED;
  1525.     bLastPacket = FALSE;
  1526. }
  1527. else
  1528. {
  1529.     pBuffer->Set((const BYTE*)(const char*)pPacket->m_document,
  1530.     pPacket->m_document.GetLength());
  1531.     m_ulTotalSMILPackets++;
  1532.     bLastPacket = pPacket->m_ulTotalPackets == m_ulTotalSMILPackets;
  1533.     rc = m_pSmilDocRenderer->onPacket(pBuffer, bLastPacket);
  1534. }
  1535. HX_RELEASE(pBuffer);
  1537. if(HXR_OK != rc)
  1538. {
  1539.     // XML parsing error
  1540.     UINT32 ulLineNumber = 0;
  1541.     UINT32 ulColumnNumber = 0;
  1542.     IHXBuffer* pErrorText = NULL;
  1543.     m_pSmilDocRenderer->getErrorInfo(ulLineNumber,
  1544. ulColumnNumber, pErrorText);
  1546.     const char* pActualErrorText = NULL;
  1547.     if(pErrorText)
  1548.     {
  1549. pActualErrorText = (const char*)pErrorText->GetBuffer();
  1550.     }
  1551.     CSmil1XMLSyntaxErrorHandler errHandler(m_pContext);
  1552.     errHandler.ReportError(rc, pActualErrorText, ulLineNumber);
  1553.     HX_RELEASE(pErrorText);
  1554. }
  1555. else if(bLastPacket)
  1556. {
  1557.     //[SMIL 1.0 compliance] Handle error from setDocument()
  1558.     // otherwise it "plays" (nothing for 20 seconds) when it
  1559.     // should halt under error conditions:
  1560.     rc = m_pSmilDocRenderer->setDocument(m_pURLFragment);
  1561. }
  1562.     }
  1563.     return rc;
  1564. }
  1566. void
  1567. CSmil1Renderer::generatePreFix()
  1568. {
  1569.     // get the protocol/server for later...
  1570.     IHXStreamSource* pSource = 0;
  1571.     m_pStream->GetSource(pSource);
  1572.     HX_ASSERT(pSource);
  1573.     if (!pSource)
  1574.     {
  1575. return;
  1576.     }
  1578.     const char* pURL = pSource->GetURL();
  1579.     HX_ASSERT(pURL);
  1580.     
  1581.     if (!pURL)
  1582.     {
  1583. return;
  1584.     }
  1586.     CHXURL::GeneratePrefixRootFragment(pURL, m_urlPrefix, m_urlRoot, m_pURLFragment);
  1587.     HX_RELEASE(pSource);
  1589.     return;
  1590. }
  1593. #if defined(HELIX_FEATURE_SMIL2)
  1594. HX_RESULT 
  1595. CSmil1Renderer::findValidDefaultNamespace(IHXBuffer* pStartOfFile)
  1596. {
  1597.     HX_RESULT pnreslt = HXR_OK;
  1598.     const char* pSmilTag = NULL;
  1599.     const char* pCloseOfSmilTag = NULL;
  1600.     const char* pXmlns = NULL;
  1601.     const char* pXmlnsOpenQuotationMark = NULL;
  1602.     const char* pBuf = NULL;
  1603.     ULONG32 ulBufLen = 0;
  1604.     const char* pEqualsSign = NULL;
  1605.     const char* pTmp = NULL;
  1606.     char* pTmp2 = NULL;
  1607.     char* pszStartOfFile = NULL;
  1608.     ULONG32 ulCount = 0;
  1609.     LONG32 lNumCommentsOpen = 0;
  1611.     if (!pStartOfFile)
  1612.     {
  1613. pnreslt = HXR_BUFFERTOOSMALL;
  1614. goto cleanup;
  1615.     }
  1617.     // /Fixes PR 59282: pStartOfFile is not necessarily NULL-terminated,
  1618.     // so we have to limit our access of it to the size of the buffer:
  1619.     ulBufLen = pStartOfFile->GetSize();
  1621.     pBuf = (const char*)pStartOfFile->GetBuffer();
  1623.     if (!pBuf  ||  !ulBufLen)
  1624.     {
  1625. pnreslt = HXR_BUFFERTOOSMALL;
  1626. goto cleanup;
  1627.     }
  1629.     pszStartOfFile = new char[ulBufLen+1];
  1630.     if (!pszStartOfFile)
  1631.     {
  1632. pnreslt = HXR_OUTOFMEMORY;
  1633. goto cleanup;
  1634.     }
  1636.     // /Now, walk through and copy each character from non-NULL terminated buf:
  1637.     pTmp = pBuf; 
  1638.     pTmp2 = pszStartOfFile;
  1639.     while (*pTmp  &&  ulCount<ulBufLen)
  1640.     {
  1641. *pTmp2 = *pTmp;
  1642. pTmp++;
  1643. pTmp2++;
  1644. ulCount++;
  1645.     }
  1646.     pszStartOfFile[ulCount] = ''; // /NULL-terminate it.
  1648.     // /Now, let's walk through the start of pszStartOfFile looking for
  1649.     // namespace declaration(s) inside the <smil ...> tag, and make sure that
  1650.     // the smil tag is NOT inside of a comment:
  1651.     pTmp = pszStartOfFile;
  1652.     while (*pTmp)
  1653.     {
  1654. if (0==strncmp(pTmp, "<!--", 4) )
  1655. {
  1656.     lNumCommentsOpen++;
  1657.     pTmp+=4;
  1658. }
  1659. else if (0==strncmp(pTmp, "-->", 3) )
  1660. {
  1661.     lNumCommentsOpen--;
  1662.     pTmp+=3;
  1663. }
  1664. else if (lNumCommentsOpen<=0  &&  0==strncmp(pTmp, "<smil", 5) )
  1665. {
  1666.     pSmilTag = pTmp; // /We found the smil tag outside of a comment.
  1667.     break;
  1668. }
  1669. else
  1670. {
  1671.     pTmp++;
  1672. }
  1673.     }
  1674.     if (!pSmilTag  ||  ulBufLen-(pSmilTag-pszStartOfFile) < 6) // /6==min size: "<smil>"
  1675.     {
  1676. // /There had better be a <smil...> tag!
  1677. pnreslt = HXR_UNEXPECTED;
  1678. goto cleanup;
  1679.     }
  1681.     pCloseOfSmilTag = strchr(pSmilTag, '>');
  1682.     // /Add 6 so that we don't allow "<smilxmlns ..." (which is invalid):
  1683.     pXmlns = strstr(pSmilTag+6, "xmlns");
  1684.     if (pXmlns  &&  isspace(*(pXmlns-1)) ) // /"xmlns" must follow a space.
  1685.     {
  1686. pEqualsSign = strchr(pXmlns, '=');
  1687. if (pEqualsSign)
  1688. {
  1689.     pXmlnsOpenQuotationMark = strchr(pXmlns, '"');
  1690. }
  1691.     }
  1692.     if (pXmlns  &&   pEqualsSign  &&  pXmlnsOpenQuotationMark  &&
  1693.     (!pCloseOfSmilTag  ||  pXmlns<pCloseOfSmilTag))
  1694.     {
  1695. m_bIsHigherVersionSmilStreamFromOldSMIL1FF = TRUE;
  1697. // /First, make sure there is nothing but whitespace between
  1698. // the "xmlns" and the '=' as well as between the '=' and the
  1699. // quotation mark:
  1700. char* pTmp = (char*)(pXmlns + strlen("xmlns"));
  1701. while (pTmp<pEqualsSign)
  1702. {
  1703.     if (!isspace(*pTmp))
  1704.     {
  1705. m_bIsHigherVersionSmilStreamFromOldSMIL1FF = FALSE;
  1706. break;
  1707.     }
  1708.     pTmp++;
  1709. }
  1710. pTmp = (char*)(pEqualsSign+1);
  1711. while(pTmp<pXmlnsOpenQuotationMark)
  1712. {
  1713.     if (!isspace(*pTmp)  &&  *pTmp != '\')
  1714.     {
  1715. m_bIsHigherVersionSmilStreamFromOldSMIL1FF = FALSE;
  1716. break;
  1717.     }
  1718.     pTmp++;
  1719. }
  1721. char* pDefaultNamespace = (char*)pXmlnsOpenQuotationMark+1;
  1722. if (strlen(pDefaultNamespace) > 0)
  1723. {
  1724.     char* pXmlnsCloseQuotationMark = strstr(pDefaultNamespace, "\"");
  1725.     if (pXmlnsCloseQuotationMark)
  1726.     {
  1727. *pXmlnsCloseQuotationMark = ''; // /NULL-terminate it.
  1728.     }
  1729.     else
  1730.     {
  1731. HX_ASSERT(pXmlnsCloseQuotationMark);
  1732. pnreslt = HXR_FAIL;
  1733. goto cleanup;
  1734.     }
  1735. }
  1736. HX_RELEASE(m_pDefaultNamespace);
  1737. if (m_pCommonClassFactory  &&
  1738. HXR_OK == m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
  1739. (void**)&m_pDefaultNamespace) )
  1740. {
  1741.     LONG32 lLen = strlen(pDefaultNamespace);
  1742.     if (lLen > 0  &&  lLen < 10000) // /sanity check
  1743.     {
  1744. m_pDefaultNamespace->Set((const BYTE*)pDefaultNamespace,
  1745.         lLen + 1);
  1746.     }
  1747.     pnreslt = HXR_OK;
  1748. }
  1750.     }
  1752. cleanup:
  1753.     if (pszStartOfFile)
  1754.     {
  1755. HX_VECTOR_DELETE(pszStartOfFile);
  1756.     }
  1758.     return pnreslt;
  1759. }
  1760. #endif /* defined(HELIX_FEATURE_SMIL2). */
  1763. #if defined(HELIX_FEATURE_SMIL2)
  1764. // /The following two methods are used for looking for and handling SMIL 2+
  1765. // streams coming from SMIL 1.0 File Format plugins (that didn't have smarts
  1766. // to look for default namespace which identifies the SMIL file version):
  1767. HX_RESULT
  1768. CSmil1Renderer::findSmilTagAndVersion(IHXBuffer* pFileChunk)
  1769. {
  1770.     HX_RESULT rc = HXR_OK;
  1772.     ULONG32 ulLen = 0;
  1773.     if (!pFileChunk  ||  (ulLen=pFileChunk->GetSize()) < 6)
  1774.     {
  1775. rc = HXR_FAILED;
  1776. goto cleanup;
  1777.     }
  1779.     rc = findValidDefaultNamespace(pFileChunk);
  1781. cleanup:
  1782.     return rc;
  1783. }
  1786. HX_RESULT
  1787. CSmil1Renderer::setUpNextGenSmilRenderer()
  1788. {
  1789.     HX_RESULT rc = HXR_OK;
  1791.     rc = CSmilRenderer::HXCreateInstance((IUnknown**)(&m_pNextGenSmilRenderer));
  1793.     if (HXR_OK == rc  &&  m_pNextGenSmilRenderer)
  1794.     {
  1795. IHXSmilToSmilRendererCommunicator* pSmilToSmilComm = NULL;
  1796. if (HXR_OK == m_pNextGenSmilRenderer->
  1797. QueryInterface(IID_IHXSmilToSmilRendererCommunicator,
  1798. (void**) &pSmilToSmilComm))
  1799. {
  1800.     if (HXR_OK ==
  1801.     pSmilToSmilComm->InitSmilStreamProxiedByOtherRenderer(
  1802.     m_pDefaultNamespace))
  1803.     {
  1804. rc = m_pNextGenSmilRenderer->InitPlugin(m_pContext);
  1805.     }
  1806.     HX_RELEASE(pSmilToSmilComm);
  1807. }
  1808. if (HXR_OK == rc)
  1809. {
  1810.     // /XXXEH- note that the REF parameters in GetPluginInfo() and
  1811.     // GetRendererInfo are set by the callee, but we can't do
  1812.     // anything with the values passed back as we've already set these
  1813.     // to our own vals and there's no way to re-set them in the core:
  1814.     BOOL bLoadMultiple = FALSE;
  1815.     const char* pszDescription = NULL;
  1816.     const char* pszCopyright = NULL;
  1817.     const char* pszMoreInfoURL = NULL;
  1818.     ULONG32 ulVersionNumber = 0;
  1819.     rc = m_pNextGenSmilRenderer->GetPluginInfo(bLoadMultiple,
  1820.     pszDescription, pszCopyright, pszMoreInfoURL,
  1821.     ulVersionNumber);
  1822.     if (HXR_OK == rc)
  1823.     {
  1824. const char** ppStreamMimeTypes = NULL;
  1825. ULONG32 ulInitialGranularity = m_ulGranularity;
  1826. rc = m_pNextGenSmilRenderer->GetRendererInfo(
  1827. ppStreamMimeTypes, ulInitialGranularity);
  1828.     }
  1829.     if (HXR_OK == rc)
  1830.     {
  1831. HX_ASSERT(m_bCSmil1StartStreamHasBeenCalled);
  1832. rc = m_pNextGenSmilRenderer->StartStream(m_pStream,
  1833. m_pPlayer);
  1834.     }
  1835.     if (HXR_OK == rc  &&  m_bCSmil1EndStreamHasBeenCalled)
  1836.     {
  1837. rc = m_pNextGenSmilRenderer->EndStream();
  1838.     }
  1839.     if (HXR_OK == rc)
  1840.     {
  1841. if (!m_pHeader)
  1842. {
  1843.     HX_ASSERT(m_pHeader);
  1844.     rc = HXR_UNEXPECTED;
  1845. }
  1846. else
  1847. {
  1848.     rc = m_pNextGenSmilRenderer->OnHeader(m_pHeader);
  1849. }
  1850.     }
  1851.     if (HXR_OK == rc  &&  m_bCSmil1GetDisplayTypeHasBeenCalled)
  1852.     {
  1853. HX_DISPLAY_TYPE ulFlags = HX_DISPLAY_NONE;
  1854. IHXBuffer* pBuffer = NULL;
  1855. rc = m_pNextGenSmilRenderer->GetDisplayType(ulFlags, pBuffer);
  1856. if (pBuffer)
  1857. {
  1858.     // /XXXEH- We can't use it here, so just clean it up:
  1859.     HX_DELETE(pBuffer);
  1860. }
  1861.     }
  1862.     if (HXR_OK == rc  &&  m_bCSmil1InitializeStatisticsHasBeenCalled)
  1863.     {
  1864. rc = m_pNextGenSmilRenderer->InitializeStatistics(m_ulRegistryID);
  1865.     }
  1867. #if defined(DO_INIT_PERSISTENT_ON_NEXTGEN_SMILREND)
  1868.     if (HXR_OK == rc  &&  m_bCSmil1InitPersistenHasBeenCalled)
  1869.     {
  1870. // /NOTE: it's perfectly OK for m_pPersistentParent to be NULL
  1871. rc = m_pNextGenSmilRenderer->InitPersistent(
  1872. m_ulPersistentComponentID, m_uPersistentGroupID,
  1873. m_uPersistentTrackID, m_pPersistentParent);
  1874.     }
  1875. #endif
  1876.     if (HXR_OK == rc  &&  m_bCSmil1GetElementPropertiesHasBeenCalled)
  1877.     {
  1878. IHXValues* pProperties = NULL;
  1879. // /XXXEH- TODO: we need to notify the original caller of this
  1880. // of the next-gen renderer's setting of pProperties.
  1881. rc = m_pNextGenSmilRenderer->GetElementProperties(
  1882. m_uGroupID, m_uTrackID, pProperties);
  1883.     }
  1884.     if (HXR_OK == rc  &&  m_bCSmil1RemoveLayoutSiteGroupHasBeenCalled)
  1885.     {
  1886. // /XXXEH- Need to handle this (unexpected) case by saving the 
  1887. // removed layout site group (which could differ from the
  1888. // add site layout group,  m_pLayoutSiteGroup (or not?):
  1889. HX_ASSERT(!m_bCSmil1RemoveLayoutSiteGroupHasBeenCalled);
  1890.     }
  1891. }
  1892.     }
  1894.     return rc;
  1895. }
  1896. #endif /* defined(HELIX_FEATURE_SMIL2). */