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

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

Symbian

开发平台：

Visual C++

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