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

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

Symbian

开发平台：

C/C++

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