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

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

Symbian

开发平台：

C/C++

smlffpln.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. #define INITGUID
  38. #include <string.h>
  39. #include <ctype.h>
  40. #include <time.h>
  42. #include "smlffpln.ver"
  44. #include "hxtypes.h"
  45. #include "hxcom.h"
  46. #include "hxcomm.h"
  47. #include "ihxpckts.h"
  48. #include "hxfiles.h"
  49. #include "hxformt.h"
  50. #include "hxengin.h"
  51. #include "hxplugn.h"
  52. #include "hxpends.h"
  53. #include "hxasm.h"
  54. #include "hxprefs.h"
  55. #include "hxvsrc.h"  /*IHXFileViewSource*/
  56. #include "chxfgbuf.h" /*CHXFragmentedBuffer */
  57. #include "hxmon.h"
  58. #include "hxerror.h"
  60. #include "hxstack.h"
  61. #include "hxslist.h"
  62. #include "hxstring.h"
  63. #include "chxpckts.h"
  64. #include "hxurl.h"
  65. #include "hxver.h"
  66. #include "verutil.h"
  67. #include "perplex.h"
  69. #include "xmlreslt.h"
  70. #include "smlpkt.h"
  71. #include "smlffpln.h"
  72. #if defined(HELIX_FEATURE_VIEWSOURCE)
  73. #include "escsmil.h" /* CEscapeSMIL */
  74. #include "shadvsrc.h" /* CShadowViewSource */
  75. #endif /* #if defined(HELIX_FEATURE_VIEWSOURCE) */
  77. #include "hxheap.h"
  78. #ifdef _DEBUG
  79. #undef HX_THIS_FILE
  80. static const char HX_THIS_FILE[] = __FILE__;
  81. #endif
  83. #ifdef _AIX
  84. #include "dllpath.h"
  85. ENABLE_MULTILOAD_DLLACCESS_PATHS(Smlffplin);
  86. #endif
  88. //#define DUMPFILEFORMATOUTPUT 1
  90. static const UINT32 FileChunkSize = 10000; //XXXBAB adjust
  91. static const UINT32 MaxPacketSize = 1000;
  93. #define XML_BAD_ATTRIBUTE_NAME "SMIL Parse Error: Error in attribute name"
  94. #define XML_BAD_TAG_NAME "SMIL Parse Error: Bad Tag Name"
  95. #define XML_MISSING_ATTRIBUTE_VALUE "SMIL Parse Error: Attribute value is missing"
  96. #define XML_NO_CLOSE_QUOTE "SMIL Parse Error: No closing quote"
  97. #define XML_MISSING_SPACE "SMIL Parse Error: Missing space"
  100. /****************************************************************************
  101.  * 
  102.  *  Function:
  103.  * 
  104.  * HXCreateInstance()
  105.  * 
  106.  *  Purpose:
  107.  * 
  108.  * Function implemented by all plugin DLL's to create an instance of 
  109.  * any of the objects supported by the DLL. This method is similar to 
  110.  * Window's CoCreateInstance() in its purpose, except that it only 
  111.  * creates objects from this plugin DLL.
  112.  *
  113.  * NOTE: Aggregation is never used. Therefore and outer unknown is
  114.  * not passed to this function, and you do not need to code for this
  115.  * situation.
  116.  * 
  117.  */
  118. STDAPI ENTRYPOINT(HXCreateInstance)
  119. (
  120.     IUnknown**  /*OUT*/ ppIUnknown
  121. )
  122. {
  123.     *ppIUnknown = (IUnknown*)(IHXPlugin*)new CSmilFileFormat();
  124.     if (*ppIUnknown)
  125.     {
  126. (*ppIUnknown)->AddRef();
  127. return HXR_OK;
  128.     }
  129.     return HXR_OUTOFMEMORY;
  130. }
  132. /****************************************************************************
  133.  * 
  134.  *  Function:
  135.  * 
  136.  * CanUnload2()
  137.  * 
  138.  *  Purpose:
  139.  * 
  140.  * Function implemented by all plugin DLL's if it returns HXR_OK 
  141.  * then the pluginhandler can unload the DLL
  142.  *
  143.  */
  144. STDAPI ENTRYPOINT(CanUnload2)(void)
  145. {
  146.     return (CHXBaseCountingObject::ObjectsActive() > 0 ? HXR_FAIL : HXR_OK );
  147. }
  150. const char* const CSmilFileFormat::zm_pDescription    = "RealNetworks SMIL File Format Plugin";
  151. const char* const CSmilFileFormat::zm_pCopyright      = HXVER_COPYRIGHT;
  152. const char* const CSmilFileFormat::zm_pMoreInfoURL    = HXVER_MOREINFO;
  154. const char* const CSmilFileFormat::zm_pFileMimeTypes[]  = {"application/smil", NULL};
  155. // /NOTE: here's what's sent as stream mime types; if there is no default
  156. // namespace, then the file is treated as a SMIL 1.0 document and sent to
  157. // our old renderer.   If the default namespace is unrecognized, then we
  158. // send "application/smil" and let the 2.0 or later SMIL renderer parse the
  159. // namespace in the smil file data and, if it recognizes it (e.g., the SMIL
  160. // renderer is a SMIL 3.0 renderer and the namespace is SMIL 3.0 but this
  161. // file format is of the SMIL 2.0 timeframe), then it plays it.  If the
  162. // renderer doesn't recognize the namespace, it tries to auto upgrade with
  163. // the following as the AU mime-type request: "application/smil.[namespace]"
  164. // and the AU server then looks for a component (maybe not even an RN one)
  165. // that can handle this type of SMIL file.
  166. const char* const CSmilFileFormat::zm_pStreamMimeTypes[]  =  {
  167. // /The following are SMIL 1.0 stream mime types that will be handled
  168. // by SMIL 1.0-exclusive players (e.g., RealPlayer 8):
  169. "application/rma-driver", // /Beta-1, SMIL 1.0 stream
  170. "application/vnd.rn-rmadriver", // /SMIL 1.0 strm (no dflt namespace)
  171. // /The following is SMIL 1.0 Rec default namespace:
  172. // "http://www.w3.org/TR/REC-smil"
  173. "application/smil",
  174. // /The following is SMIL 2.0 Candidate Rec (i.e., pre SMIL 2.0 W3C Rec
  175. // status) default namespace:
  176. // "http://www.w3.org/2000/SMIL20/CR/Language"
  177. // The following is SMIL 2.0 Proposed Rec default namespace:
  178. // "http://www.w3.org/2001/SMIL20/PR/Language"
  179. // Both CR and PR use this stream mime type:
  180. "application/smil",
  181. // /The following is the SMIL 2.0 Recommendation namespace
  182. // "http://www.w3.org/2001/SMIL20/Language",
  183. "application/smil",
  184. // /We'll use this for any unrecognized SMIL file version (and note:
  185. // this is probably going to always be the same as the SMIL20 mime
  186. // type; the renderer will do all the work of deciding whether or not
  187. // to auto upgrade if it doesn't recognize the default namespace):
  188. "application/smil",
  189. NULL};
  190. const char* const CSmilFileFormat::zm_pFileExtensions[] = {"smi", "smil", NULL};
  191. const char* const CSmilFileFormat::zm_pFileOpenNames[]  = {"SMIL File Format (*.smi,*.smil)", NULL};
  193. CSmilFileFormat::CSmilFileFormat()
  194.     : m_lRefCount(0)
  195.     , m_pContext(0)
  196.     , m_pFileObject(0)
  197.     , m_pFFResponse(0)
  198.     , m_bHeaderSent(FALSE)
  199.     , m_bChannelInit(FALSE)
  200.     , m_bSentFirstChannel(FALSE)
  201.     , m_bSourceInit(FALSE)
  202.     , m_ulCurrentTime(0)
  203.     , m_state(Ready)
  204.     , m_pRequest(0)
  205.     , m_pCommonClassFactory(0)
  206.     , m_ulPacketCount(0)
  207.     , m_ulCurrentPacket(0)
  208.     , m_ulStreamVersion(0)
  209.     , m_ulContentVersion(0)
  210.     , m_pCurrentPacketData(NULL)
  211.     , m_fileState(InContent)
  212.     , m_smilFileVersion(SMILFileVersionSmil10)
  213.     , m_pArrayOfPackets(0)
  214.     , m_bLogErrors(FALSE)
  215.     , m_pStartOfFile(NULL)
  216. {
  217. };
  219. CSmilFileFormat::~CSmilFileFormat()
  220. {
  221.     Close();
  222. }
  225. /************************************************************************
  226.  *  Method:
  227.  *    IHXPlugin::InitPlugin
  228.  *  Purpose:
  229.  *    Initializes the plugin for use. This interface must always be
  230.  *    called before any other method is called. This is primarily needed 
  231.  *    so that the plugin can have access to the context for creation of
  232.  *    IHXBuffers and IMalloc.
  233.  */
  234. STDMETHODIMP CSmilFileFormat::InitPlugin(IUnknown* /*IN*/ pContext)
  235. {
  236.     m_pContext = pContext;
  237.     m_pContext->AddRef();
  238.     m_pContext->QueryInterface(IID_IHXCommonClassFactory,
  239.      (void**)&m_pCommonClassFactory);
  240.     return HXR_OK;
  241. }
  243. /************************************************************************
  244.  *  Method:
  245.  *    IHXPlugin::GetPluginInfo
  246.  *  Purpose:
  247.  *    Returns the basic information about this plugin. Including:
  248.  *
  249.  *    bLoadMultiple whether or not this plugin DLL can be loaded
  250.  * multiple times. All File Formats must set
  251.  * this value to TRUE.
  252.  *    pDescription which is used in about UIs (can be NULL)
  253.  *    pCopyright which is used in about UIs (can be NULL)
  254.  *    pMoreInfoURL which is used in about UIs (can be NULL)
  255.  */
  256. STDMETHODIMP CSmilFileFormat::GetPluginInfo
  257. (
  258.     REF(BOOL)     /*OUT*/ bLoadMultiple,
  259.     REF(const char*)/*OUT*/ pDescription,
  260.     REF(const char*)/*OUT*/ pCopyright,
  261.     REF(const char*)/*OUT*/ pMoreInfoURL,
  262.     REF(ULONG32)    /*OUT*/ ulVersionNumber
  263. )
  264. {
  265.     bLoadMultiple = TRUE;   // Must be true for file formats.
  267.     pDescription    = (const char*) zm_pDescription;
  268.     pCopyright     = (const char*) zm_pCopyright;
  269.     pMoreInfoURL    = (const char*) zm_pMoreInfoURL;
  270.     ulVersionNumber = TARVER_ULONG32_VERSION;
  272.     return HXR_OK;
  273. }
  275. /************************************************************************
  276.  *  Method:
  277.  *    IHXPlugin::GetObjFileFormatInfo
  278.  *  Purpose:
  279.  *    If this object is a file format object this method returns
  280.  *    information vital to the instantiation of file format plugins.
  281.  *    If this object is not a file format object, it should return
  282.  *    HXR_UNEXPECTED.
  283.  */
  284. STDMETHODIMP CSmilFileFormat::GetFileFormatInfo
  285. (
  286.     REF(const char**) /*OUT*/ pFileMimeTypes,
  287.     REF(const char**) /*OUT*/ pFileExtensions,
  288.     REF(const char**) /*OUT*/ pFileOpenNames
  289. )
  290. {
  291.     pFileMimeTypes  = (const char**) zm_pFileMimeTypes;
  292.     pFileExtensions = (const char**) zm_pFileExtensions;
  293.     pFileOpenNames  = (const char**) zm_pFileOpenNames;
  295.     return HXR_OK;
  296. }
  298. // *** IUnknown methods ***
  300. /////////////////////////////////////////////////////////////////////////
  301. //  Method:
  302. // IUnknown::QueryInterface
  303. //  Purpose:
  304. // Implement this to export the interfaces supported by your 
  305. // object.
  306. //
  307. STDMETHODIMP CSmilFileFormat::QueryInterface(REFIID riid, void** ppvObj)
  308. {
  309.     if (IsEqualIID(riid, IID_IUnknown))
  310.     {
  311. AddRef();
  312. *ppvObj = this;
  313. return HXR_OK;
  314.     }
  315.     else if (IsEqualIID(riid, IID_IHXPlugin))
  316.     {
  317. AddRef();
  318. *ppvObj = (IHXPlugin*)this;
  319. return HXR_OK;
  320.     }
  321.     else if (IsEqualIID(riid, IID_IHXFileFormatObject))
  322.     {
  323. AddRef();
  324. *ppvObj = (IHXFileFormatObject*)this;
  325. return HXR_OK;
  326.     }
  327.     else if (IsEqualIID(riid, IID_IHXFileResponse))
  328.     {
  329. AddRef();
  330. *ppvObj = (IHXFileResponse*)this;
  331. return HXR_OK;
  332.     }
  333.     else if (IsEqualIID(riid, IID_IHXPendingStatus))
  334.     {
  335. AddRef();
  336. *ppvObj = (IHXPendingStatus*)this;
  337. return HXR_OK;
  338.     }
  339.     else if (IsEqualIID(riid, IID_IHXInterruptSafe))
  340.     {
  341. AddRef();
  342. *ppvObj = (IHXInterruptSafe*)this;
  343. return HXR_OK;
  344.     }
  345.     else if (IsEqualIID(riid, IID_IHXThreadSafeMethods))
  346.     {
  347. AddRef();
  348. *ppvObj = (IHXThreadSafeMethods*)this;
  349. return HXR_OK;
  350.     }
  351. #if defined(HELIX_FEATURE_VIEWSOURCE)
  352.     else if ( IsEqualIID(riid, IID_IHXFileViewSource) )
  353.     {
  354. CShadowViewSource* pVsrc = new CShadowViewSource(m_pContext, 
  355.     (IUnknown*)(IHXPlugin*)this);
  356. if ( pVsrc == NULL )
  357. {
  358.     return HXR_FAIL;
  359. }
  360. return pVsrc->QueryInterface(riid, ppvObj);
  361.     }
  362. #endif /* #if defined(HELIX_FEATURE_VIEWSOURCE) */
  364.     *ppvObj = NULL;
  365.     return HXR_NOINTERFACE;
  366. }
  368. /////////////////////////////////////////////////////////////////////////
  369. //  Method:
  370. // IUnknown::AddRef
  371. //  Purpose:
  372. // Everyone usually implements this the same... feel free to use
  373. // this implementation.
  374. //
  375. STDMETHODIMP_(ULONG32) CSmilFileFormat::AddRef()
  376. {
  377.     return InterlockedIncrement(&m_lRefCount);
  378. }
  380. /////////////////////////////////////////////////////////////////////////
  381. //  Method:
  382. // IUnknown::Release
  383. //  Purpose:
  384. // Everyone usually implements this the same... feel free to use
  385. // this implementation.
  386. //
  387. STDMETHODIMP_(ULONG32) CSmilFileFormat::Release()
  388. {
  389.     if (InterlockedDecrement(&m_lRefCount) > 0)
  390.     {
  391.         return m_lRefCount;
  392.     }
  394.     delete this;
  395.     return 0;
  396. }
  398. // *** IHXFileFormatObject methods ***
  400. STDMETHODIMP CSmilFileFormat::InitFileFormat
  401. (
  402.     IHXRequest* /*IN*/ pRequest, 
  403.     IHXFormatResponse* /*IN*/ pFormatResponse,
  404.     IHXFileObject* /*IN*/  pFileObject
  405. )
  406. {
  407.     HX_RESULT ret = HXR_OK;
  409.     m_pRequest    = pRequest;
  410.     m_pFFResponse = pFormatResponse;
  411.     m_pFileObject = pFileObject;
  413.     m_pRequest->AddRef();
  414.     m_pFFResponse->AddRef();
  415.     m_pFileObject->AddRef();
  417.     // set stream and content versions
  418.     m_ulStreamVersion = HX_ENCODE_PROD_VERSION(STREAM_MAJOR_VER,
  419.        STREAM_MINOR_VER,
  420.        STREAM_RELEASE,
  421.        STREAM_BUILD);
  422.     m_ulContentVersion = HX_ENCODE_PROD_VERSION(CONTENT_MAJOR_VER,
  423. CONTENT_MINOR_VER,
  424. CONTENT_RELEASE,
  425. CONTENT_BUILD);
  426.     
  427.     if ( m_pArrayOfPackets )
  428.     {
  429. int s = m_pArrayOfPackets->GetSize();
  430. for ( int i = s; i > 0; --i )
  431. {
  432.     PacketData* pckt = (PacketData*)(*m_pArrayOfPackets)[i-1];
  433.     HX_RELEASE(pckt->pBuffer);
  434.     HX_DELETE(pckt);
  435.     (*m_pArrayOfPackets)[i-1] = NULL;
  436. }
  437. HX_DELETE(m_pArrayOfPackets);
  438.     }
  439.     m_pArrayOfPackets = new CHXPtrArray;
  441.     if ( m_pCurrentPacketData )
  442.     {
  443. HX_RELEASE(m_pCurrentPacketData->pBuffer);
  444. HX_DELETE(m_pCurrentPacketData);
  445.     }
  447.     m_ulCurrentBufferPos = 0;
  448.     m_ulCurrentPacket = 0;
  450.     // This file format is not a container type, so it only supports one
  451.     // stream and therefore one header, but before we do that, we want to
  452.     // make sure the file object is initialized; we can't actually return
  453.     // the header count until the file init is done... (See InitDone).
  454.     m_state = InitPending;
  456.     // Note, we need to pass ourself to the FileObject, because this is its
  457.     // first opportunity to know that we implement the IHXFileResponse
  458.     // interface it will call for completed pending operations
  459.     return m_pFileObject->Init( HX_FILE_READ, this);
  460. }
  463. STDMETHODIMP CSmilFileFormat::Close()
  464. {
  465.     HX_RELEASE(m_pContext);
  466.     if (m_pFileObject)
  467.     {
  468. m_pFileObject->Close();
  469. HX_RELEASE(m_pFileObject);
  470.     }
  471.     if ( m_pArrayOfPackets )
  472.     {
  473. int s = m_pArrayOfPackets->GetSize();
  474. for ( int i = s; i > 0; --i )
  475. {
  476.     PacketData* pckt = (PacketData*)(*m_pArrayOfPackets)[i-1];
  477.     HX_RELEASE(pckt->pBuffer);
  478.     HX_DELETE(pckt);
  479.     (*m_pArrayOfPackets)[i-1] = NULL;
  480.     m_pArrayOfPackets->RemoveAt(i-1);
  481. }
  482. HX_DELETE(m_pArrayOfPackets);
  483.     }
  484.     if ( m_pCurrentPacketData )
  485.     {
  486. HX_RELEASE(m_pCurrentPacketData->pBuffer);
  487. m_pCurrentPacketData->pNumPos = NULL;
  488. HX_DELETE(m_pCurrentPacketData);
  489.     }
  490.     HX_RELEASE(m_pFFResponse);
  491.     HX_RELEASE(m_pRequest);
  492.     HX_RELEASE(m_pCommonClassFactory);
  493.     HX_RELEASE(m_pStartOfFile);
  494.     return HXR_OK;
  495. }
  497. /////////////////////////////////////////////////////////////////////////
  498. //  Method:
  499. // IHXFileFormatObject::GetFileHeader
  500. //  Purpose:
  501. // Called by controller to ask the file format for the number of
  502. // headers in the file. The file format should call the 
  503. // IHXFileFormatSession::HeaderCountReady() for the IHXFileFormat-
  504. // Session object that was passed in during initialization, when the
  505. // header count is available.
  506. //
  507. STDMETHODIMP CSmilFileFormat::GetFileHeader()
  508. {
  509.     // If we are not ready then something has gone wrong
  510.     if (m_state != Ready) return HXR_UNEXPECTED;
  512.     IHXValues* pHeader = 0;
  513.     if (HXR_OK != m_pCommonClassFactory->CreateInstance(CLSID_IHXValues,
  514.     (void**)&pHeader))
  515.     {
  516. return HXR_UNEXPECTED;
  517.     }
  519.     pHeader->SetPropertyULONG32("StreamCount", 1);
  521.     m_pFFResponse->FileHeaderReady(HXR_OK, pHeader);
  523.     HX_RELEASE(pHeader);
  525.     return HXR_OK;
  526. }
  528. /////////////////////////////////////////////////////////////////////////
  529. //  Method:
  530. // IHXFileFormatObject::GetStreamHeader
  531. //  Purpose:
  532. // Called by controller to ask the file format for the header for
  533. // a particular stream in the file. The file format should call 
  534. // IHXFileFormatSession::StreamHeaderReady() for IHXFileFormatSession
  535. // object that was passed in during initialization, when the header
  536. // is available.
  537. //
  538. STDMETHODIMP CSmilFileFormat::GetStreamHeader(UINT16 unStreamNumber)
  539. {
  540.     // If we are not ready then something has gone wrong
  541.     if (m_state != Ready) return HXR_UNEXPECTED;
  543.     IHXBuffer* pASM = 0;
  544.     char pBook[256]; /* Flawfinder: ignore */
  546.     IHXValues* pHeader = 0;
  547.     IHXBuffer* pBuffer = 0;
  548.     if (HXR_OK != m_pCommonClassFactory->CreateInstance(CLSID_IHXValues,
  549.     (void**)&pHeader))
  550.     {
  551. return HXR_UNEXPECTED;
  552.     }
  554.     if (HXR_OK != m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
  555.     (void**)&pBuffer))
  556.     {
  557. return HXR_UNEXPECTED;
  558.     }
  560.     BOOL bBeta1Player = ::IsBeta1Player(m_pRequest);
  562.     HX_RESULT pnrver = GetSMILFileVersion();
  564.     if (HXR_OK != pnrver  ||
  565. SMILFileVersionSmil10 == m_smilFileVersion)
  566.     {
  567. if(bBeta1Player)
  568. {
  569.     pBuffer->Set((const BYTE*)
  570.    zm_pStreamMimeTypes[SMILFileVersionSmilBeta10],
  571.    strlen(zm_pStreamMimeTypes[SMILFileVersionSmilBeta10])+1);
  572. }
  573. else
  574. {
  575.     pBuffer->Set(
  576.    (const BYTE*)zm_pStreamMimeTypes[SMILFileVersionSmil10],
  577.    strlen(zm_pStreamMimeTypes[SMILFileVersionSmil10])+1);
  578. }
  579.     }
  580.     else if (SMILFileVersionSmil10Strict == m_smilFileVersion)
  581.     {
  582. // /Send strictly-declared SMIL 1.0 streams to the SMIL 2.0 renderer
  583. pBuffer->Set((const BYTE*)
  584.        zm_pStreamMimeTypes[SMILFileVersionSmil10Strict],
  585.        strlen(zm_pStreamMimeTypes[SMILFileVersionSmil10Strict])+1);
  586.     }
  587.     else if (SMILFileVersionSmil20PreRec == m_smilFileVersion)
  588.     {
  589. pBuffer->Set((const BYTE*)
  590.        zm_pStreamMimeTypes[SMILFileVersionSmil20PreRec],
  591.        strlen(zm_pStreamMimeTypes[SMILFileVersionSmil20PreRec])+1);
  592.     }
  593.     else if (SMILFileVersionSmil20 == m_smilFileVersion)
  594.     {
  595. pBuffer->Set((const BYTE*)
  596. zm_pStreamMimeTypes[SMILFileVersionSmil20],
  597. strlen(zm_pStreamMimeTypes[SMILFileVersionSmil20])+1);
  598.     }
  599.     else // /Too high a version number as far as this ff is concerned:
  600.     // /XXXEH: should we use the namespace (if there is one) to determine
  601.     // the mime type and, if there is one, send it and let the player deal
  602.     // with the auto update (if needed)?  Or, should we encourage server
  603.     // (hence smil ff) updating by just not serving the stream?  That's
  604.     // what I'm doing here:
  605.     {
  606. pBuffer->Set((const BYTE*)
  607. zm_pStreamMimeTypes[SMILFileVersionUnknown],
  608. strlen(zm_pStreamMimeTypes[SMILFileVersionUnknown])+1);
  609.     }
  611.     pHeader->SetPropertyCString("MimeType", pBuffer);
  612.     HX_RELEASE(pBuffer);
  614.     pHeader->SetPropertyULONG32("StreamNumber", unStreamNumber);
  615.     //XXXEH- removed 20000 (20sec) duration that BAB put in "to avoid problem
  616.     // in core" in 1998(?).  0 milliseconds seems to work fine now (3/2000):
  617.     pHeader->SetPropertyULONG32("Duration", 0);
  618.     pHeader->SetPropertyULONG32("PreRoll", 1000);   //XXXBAB 'cause Rahul told me to
  619.     pHeader->SetPropertyULONG32("AvgBitRate", 1000);
  621.     pHeader->SetPropertyULONG32("StreamVersion", m_ulStreamVersion);
  622.     pHeader->SetPropertyULONG32("ContentVersion", m_ulContentVersion);
  624.     //
  625.     // set ASM rule book
  626.     //
  627.     sprintf(pBook, "TimestampDelivery=TRUE,priority=10;"); /* Flawfinder: ignore */
  628.     if(HXR_OK == m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
  629.     (void**)&pASM))
  630.     {
  631. pASM->Set((BYTE*)pBook, strlen(pBook)+1);
  632. pHeader->SetPropertyCString("ASMRuleBook", pASM);
  633. HX_RELEASE(pASM);
  634.     }
  636.     m_bHeaderSent = TRUE;
  638.     m_pFFResponse->StreamHeaderReady(HXR_OK, pHeader);
  640.     HX_RELEASE(pHeader);
  642.     return HXR_OK;
  643. }
  645. /////////////////////////////////////////////////////////////////////////
  646. //  Method:
  647. // IHXFileFormatObject::GetPacket
  648. //  Purpose:
  649. // Called by controller to ask the file format for the next packet
  650. // for a particular stream in the file. The file format should call 
  651. // IHXFileFormatSession::PacketReady() for the IHXFileFormatSession
  652. // object that was passed in during initialization, when the packet
  653. // is available.
  654. //
  655. STDMETHODIMP CSmilFileFormat::GetPacket(UINT16 unStreamNumber)
  656. {
  657.     HX_RESULT result = HXR_OK;
  659.     // If we are not ready then something has gone wrong
  660.     if (m_state != Ready) return HXR_UNEXPECTED;
  662.     if (!m_bHeaderSent)
  663.     {
  664.         return HXR_UNEXPECTED;
  665.     }
  667.     IHXPacket* pPacket = NULL;
  669.     result = m_pCommonClassFactory->CreateInstance(CLSID_IHXPacket,
  670. (void**)&pPacket);
  671.     if( SUCCEEDED(result) )
  672.     {
  673. if(m_ulCurrentPacket >= m_ulPacketCount)
  674. {
  675.     m_pFFResponse->StreamDone(unStreamNumber);
  676. }
  677. else
  678. {
  679.     PacketData* pckt = (PacketData*)(*m_pArrayOfPackets)[m_ulCurrentPacket++];
  680.     
  681.     if ( pckt->pNumPos )
  682.     {
  683. char buf[10]; /* Flawfinder: ignore */
  684. sprintf(buf, "%u", m_ulPacketCount); /* Flawfinder: ignore */
  685. HX_ASSERT(strlen(buf) < 7);
  686. strncpy(pckt->pNumPos, buf, strlen(buf)); /* Flawfinder: ignore */
  687. pckt->pNumPos = NULL;
  688.     }
  689. #ifdef DUMPFILEFORMATOUTPUT
  690.     FILE* stream = fopen( "C:\PacketData.smil", "a" );
  691.     fprintf( stream, "%sn", (const char*)pckt->pBuffer->GetBuffer());
  692.     fclose( stream );
  693. #endif
  694.     pPacket->Set(pckt->pBuffer, 0, unStreamNumber, HX_ASM_SWITCH_ON, 0);
  695.     m_pFFResponse->PacketReady(HXR_OK, pPacket);
  696. }
  697.     }
  698.     HX_RELEASE(pPacket);
  699.     return result;
  700. }
  703. /////////////////////////////////////////////////////////////////////////
  704. //  Method:
  705. // IHXFileFormatObject::Seek
  706. //  Purpose:
  707. // Called by controller to tell the file format to seek to the 
  708. // nearest packet to the requested offset. The file format should 
  709. // call IHXFileFormatSession::SeekDone() for the IHXFileFormat-
  710. // Session object that was passed in during initialization, when 
  711. // the seek has completed.
  712. //
  713. STDMETHODIMP CSmilFileFormat::Seek(ULONG32 ulOffset)
  714. {
  715.     m_pFFResponse->SeekDone(HXR_OK);
  716.     return HXR_OK;
  717. }
  719. /////////////////////////////////////////////////////////////////////////
  720. //  Method:
  721. //    IHXFileResponse::InitDone
  722. //  Purpose:
  723. //    Notification interface provided by users of the IHXFileObject
  724. //    interface. This method is called by the IHXFileObject when the
  725. //    initialization of the file is complete, and the Mime type is
  726. //    available for the request file. If the URL is not valid for the
  727. //    file system, the status HXR_FAILED should be returned,
  728. //    with a mime type of NULL. If the URL is valid but the mime type
  729. //    is unknown, then the status HXR_OK should be returned with
  730. //    a mime type of NULL.
  731. //
  732. STDMETHODIMP CSmilFileFormat::InitDone
  733. (
  734.     HX_RESULT status
  735. )
  736. {
  737.     HX_RESULT rc = HXR_OK;
  739.     // If we are not ready then something has gone wrong
  740.     if (m_state != InitPending) return HXR_UNEXPECTED;
  742.     // Now it's time to read the file
  743.     m_state = ReadPending;
  745.     if (status != HXR_OK)
  746.     {
  747. rc = m_pFFResponse->InitDone(status);
  748.     }
  749.     else
  750.     {
  751. // check to see if we have logged an error for this file
  752. // in the last hour.  If we have we will not log an error.
  754. UpdateErrorCaching();
  756. rc = m_pFileObject->Read(FileChunkSize);
  757.     }
  758.     return rc;
  759. }
  761. HX_RESULT CSmilFileFormat::UpdateErrorCaching()
  762. {
  763.     IHXValues* pRequestHeaders = NULL;
  764.     UINT32 ulID = 0, ulSes = 0;
  765.  
  766.     IHXRegistry* pReg = NULL;
  767.     m_pContext->QueryInterface(IID_IHXRegistry, (void**)&pReg);
  768.     
  769.     HX_RESULT ret = m_pRequest->GetRequestHeaders(pRequestHeaders);
  770.     if (!pRequestHeaders)
  771.     {
  772. // succeeds even when there are no request headers.
  773. ret = HXR_FAIL;
  774.     }
  775.  
  776.     if (SUCCEEDED(ret))
  777.     {
  778. IHXBuffer* pID = NULL;
  779. ret = pRequestHeaders->GetPropertyCString("ConnID", pID);
  780. if (SUCCEEDED(ret) && pID) 
  781. {
  782.     ulID = atoi((char*)pID->GetBuffer());
  783. }
  784. HX_RELEASE(pID);
  785.     }
  786.     
  787.     if (SUCCEEDED(ret))
  788.     {
  789. IHXBuffer* pSes = NULL;
  790. if (SUCCEEDED(pRequestHeaders->GetPropertyCString("SessionNumber", pSes)))
  791. {
  792.     ulSes = atoi((char*)pSes->GetBuffer());
  793. }
  794. else
  795. {
  796.     // assume 0
  797.     ulSes = 0;
  798. }
  799. HX_RELEASE(pSes);
  800.     }
  802.     IHXBuffer* pURL = NULL;
  803.     if (SUCCEEDED(ret))
  804.     {
  805. const char form[] = "client.%u.session.%u.URL";
  806. char pRegkey[sizeof(form) + 20]; /* Flawfinder: ignore */
  807. sprintf(pRegkey, form, ulID, ulSes); /* Flawfinder: ignore */
  808. ret = pReg->GetStrByName(pRegkey, pURL);
  809.     }
  812.     char* buf = NULL;
  813.     const char regtemp[] = "server.smilerrorlog.";
  814.     if ( SUCCEEDED(ret) )
  815.     {
  816.        buf = new char[sizeof(regtemp) + pURL->GetSize()];
  817.        if (!buf)
  818.        {
  819.    ret = HXR_OUTOFMEMORY;
  820.        }
  821.     }
  823.     if (SUCCEEDED(ret))
  824.     {
  825. strcpy(buf, regtemp); /* Flawfinder: ignore */
  826. char* pos = buf + sizeof(regtemp) - 1;
  827. const char* url = (const char*)pURL->GetBuffer();
  828. // escape the '.'s
  829. while (*url && pos < buf + sizeof(regtemp) + pURL->GetSize())
  830. {
  831.     if (*url == '.' || *url == '/')
  832.     {
  833. *pos++ = '%';
  834. ++url;
  835.     }
  836.     else
  837.     {
  838. *pos++ = *url++;
  839.     }
  840. }
  841. *pos = '';
  842.     }
  844.     if (SUCCEEDED(ret))
  845.     {
  846. INT32 lTime = 0;
  847. INT32 lNow = time(NULL);
  848. if (SUCCEEDED(pReg->GetIntByName(buf, lTime)))
  849. {
  850.     if ((lNow - lTime) > 3600)
  851.     {
  852. m_bLogErrors = TRUE;
  853. ret = pReg->SetIntByName(buf, lNow);
  854.     }
  855.     else
  856.     {
  857. m_bLogErrors = FALSE;
  858.     }
  859. }
  860. else
  861. {
  862.     m_bLogErrors = TRUE;
  863.     pReg->AddInt(buf, lNow);
  864. }
  865.     }
  866.     HX_RELEASE(pReg);
  867.     HX_RELEASE(pRequestHeaders);
  868.     HX_VECTOR_DELETE(buf);
  869.     HX_RELEASE(pURL);
  870.     return ret;
  871. }
  873. /////////////////////////////////////////////////////////////////////////
  874. //  Method:
  875. // IHXFileResponse::CloseDone
  876. //  Purpose:
  877. // Notification interface provided by users of the IHXFileObject
  878. // interface. This method is called by the IHXFileObject when the
  879. // close of the file is complete.
  880. //
  881. STDMETHODIMP CSmilFileFormat::CloseDone(HX_RESULT status)
  882. {
  883.     return HXR_OK;
  884. }
  886. /////////////////////////////////////////////////////////////////////////
  887. //  Method:
  888. // IHXFileResponse::ReadDone
  889. //  Purpose:
  890. // Notification interface provided by users of the IHXFileObject
  891. // interface. This method is called by the IHXFileObject when the
  892. // last read from the file is complete and a buffer is available.
  893. //
  894. STDMETHODIMP CSmilFileFormat::ReadDone
  895. (
  896.     HX_RESULT status,
  897.     IHXBuffer* pBuffer
  898. )
  899. {
  900.     HX_RESULT result = HXR_OK;
  902.     if ( SUCCEEDED(status) )
  903.     {
  904. HX_ASSERT(pBuffer);
  906. // /For determining what type file this is (via namespace URI), we'll
  907. // hold onto the first pBuffer for later when we handle stream header:
  908. if (!m_pStartOfFile)
  909. {
  910.     pBuffer->AddRef();
  911.     m_pStartOfFile = pBuffer;
  912. }
  914. BreakUpBuffer(pBuffer);
  915. // recurse...
  916. m_pFileObject->Read(FileChunkSize);
  917.     }
  918.     else
  919.     {
  920. // check see if we have a packet that needs added to the array.
  921. if ( m_pCurrentPacketData )
  922. {
  923.     UCHAR* pCb = m_pCurrentPacketData->pBuffer->GetBuffer();
  924.     pCb[m_ulCurrentBufferPos++] = '"';
  925.     pCb[m_ulCurrentBufferPos++] = ')';
  926.     pCb[m_ulCurrentBufferPos++] = '';
  927.     m_pCurrentPacketData->pBuffer->SetSize(m_ulCurrentBufferPos);
  928.     m_pArrayOfPackets->Add((void*)m_pCurrentPacketData);
  929.     m_pCurrentPacketData = NULL;
  930.     m_ulCurrentBufferPos = 0;
  931. }
  932. // finished reading, calculate the number of packets to send:
  933. m_ulPacketCount = m_ulCurrentPacket;
  934. m_ulCurrentPacket = 0;
  935. m_state = Ready;
  936. m_pFFResponse->InitDone(result);
  937.     }
  938.     return result;
  939. }
  942. /////////////////////////////////////////////////////////////////////////
  943. //  Method:
  944. // GetSMILFileVersion
  945. //  Purpose:
  946. // This Function will break the buffer into packets.
  947. //
  948. // This function maintains a state, such that multiple buffers should
  949. // Be able to be passed into it at any point...
  950. //
  951. HX_RESULT 
  952. CSmilFileFormat::GetSMILFileVersion()
  953. {
  954.     HX_RESULT pnreslt = HXR_OK;
  955.     const char* pSmilTag = NULL;
  956.     const char* pCloseOfSmilTag = NULL;
  957.     const char* pXmlns = NULL;
  958.     const char* pXmlnsOpenQuotationMark = NULL;
  959.     const char* pBuf = NULL;
  960.     ULONG32 ulBufLen = 0;
  961.     const char* pEqualsSign = NULL;
  962.     const char* pTmp = NULL;
  963.     char* pTmp2 = NULL;
  964.     char* pszStartOfFile = NULL;
  965.     ULONG32 ulCount = 0;
  966.     LONG32 lNumCommentsOpen = 0;
  968.     if (!m_pStartOfFile)
  969.     {
  970. pnreslt = HXR_BUFFERTOOSMALL;
  971. goto cleanup;
  972.     }
  974.     // /Fixes PR 59282: m_pStartOfFile is not necessarily NULL-terminated,
  975.     // so we have to limit our access of it to the size of the buffer (duh!):
  976.     ulBufLen = m_pStartOfFile->GetSize();
  978.     pBuf = (const char*)m_pStartOfFile->GetBuffer();
  980.     if (!pBuf  ||  !ulBufLen)
  981.     {
  982. pnreslt = HXR_BUFFERTOOSMALL;
  983. goto cleanup;
  984.     }
  986.     pszStartOfFile = new char[ulBufLen+1];
  987.     if (!pszStartOfFile)
  988.     {
  989. pnreslt = HXR_OUTOFMEMORY;
  990. goto cleanup;
  991.     }
  993.     // /Now, walk through and copy each character from non-NULL terminated buf:
  994.     pTmp = pBuf; 
  995.     pTmp2 = pszStartOfFile;
  996.     while (*pTmp  &&  ulCount<ulBufLen)
  997.     {
  998. *pTmp2 = *pTmp;
  999. pTmp++;
  1000. pTmp2++;
  1001. ulCount++;
  1002.     }
  1003.     pszStartOfFile[ulCount] = ''; // /NULL-terminate it.
  1005.     // /Now, let's walk through the start of pszStartOfFile looking for
  1006.     // namespace declaration(s) inside the <smil ...> tag, and make sure that
  1007.     // the smil tag is NOT inside of a comment:
  1008.     pTmp = pszStartOfFile;
  1009.     while (*pTmp)
  1010.     {
  1011. if (0==strncmp(pTmp, "<!--", 4) )
  1012. {
  1013.     lNumCommentsOpen++;
  1014.     pTmp+=4;
  1015. }
  1016. else if (0==strncmp(pTmp, "-->", 3) )
  1017. {
  1018.     lNumCommentsOpen--;
  1019.     pTmp+=3;
  1020. }
  1021. else if (lNumCommentsOpen<=0  &&  0==strncmp(pTmp, "<smil", 5) )
  1022. {
  1023.     pSmilTag = pTmp; // /We found the smil tag outside of a comment.
  1024.     break;
  1025. }
  1026. else
  1027. {
  1028.     pTmp++;
  1029. }
  1030.     }
  1031.     if (!pSmilTag  ||  ulBufLen-(pSmilTag-pszStartOfFile) < 6) // /6==min size: "<smil>"
  1032.     {
  1033. // /There had better be a <smil...> tag!
  1034. pnreslt = HXR_UNEXPECTED;
  1035. goto cleanup;
  1036.     }
  1038.     pCloseOfSmilTag = strchr(pSmilTag, '>');
  1039.     // /Add 6 so that we don't allow "<smilxmlns ..." (which is invalid):
  1040.     pXmlns = strstr(pSmilTag+6, "xmlns");
  1041.     if (pXmlns  &&  isspace(*(pXmlns-1)) ) // /"xmlns" must follow a space.
  1042.     {
  1043. pEqualsSign = strchr(pXmlns, '=');
  1044. if (pEqualsSign)
  1045. {
  1046.     pXmlnsOpenQuotationMark = strchr(pXmlns, '"');
  1047. }
  1048.     }
  1049.     if (pXmlns  &&   pEqualsSign  &&  pXmlnsOpenQuotationMark  &&
  1050.     (!pCloseOfSmilTag  ||  pXmlns<pCloseOfSmilTag))
  1051.     {
  1052. BOOL bIsValidNamespaceDeclaration = TRUE;
  1054. // /First, make sure there is nothing but whitespace between
  1055. // the "xmlns" and the '=' as well as between the '=' and the
  1056. // quotation mark:
  1057. char* pTmp = (char*)(pXmlns + strlen("xmlns"));
  1058. while (pTmp<pEqualsSign)
  1059. {
  1060.     if (!isspace(*pTmp))
  1061.     {
  1062. bIsValidNamespaceDeclaration = FALSE;
  1063. break;
  1064.     }
  1065.     pTmp++;
  1066. }
  1067. pTmp = (char*)(pEqualsSign+1);
  1068. while(pTmp<pXmlnsOpenQuotationMark)
  1069. {
  1070.     if (!isspace(*pTmp))
  1071.     {
  1072. bIsValidNamespaceDeclaration = FALSE;
  1073. break;
  1074.     }
  1075.     pTmp++;
  1076. }
  1078. if (bIsValidNamespaceDeclaration)
  1079. {
  1080.     // /Note: SMIL 1.0 namespace is default and is:
  1081.     // "http://www.w3.org/TR/REC-smil".  Note that if this is
  1082.     // tagged (first) with a SMIL 1.0 namespace followed by
  1083.     // another namespace, then this is a 1.0 file and we'll let
  1084.     // the 1.0 renderer get it and do what it can with the 2.0
  1085.     // stuff (namely ignore it):
  1086.     const char* pSMIL10Namespace = strstr(pXmlnsOpenQuotationMark,
  1087.     "http://www.w3.org/TR/REC-smil"");
  1089.     // /This in the final SMIL 2.0 rec:
  1090.     const char* pSMIL20Namespace = strstr(pXmlnsOpenQuotationMark,
  1091.     "http://www.w3.org/2001/SMIL20/Language"");
  1093.     const char* pSMIL20NamespaceCandidateRec = strstr(
  1094.     pXmlnsOpenQuotationMark,
  1095.     "http://www.w3.org/2000/SMIL20/CR/Language"");
  1097.     // /Fixes PR 55749: allow new PR namespace:
  1098.     const char* pSMIL20NamespaceProposedRec = strstr(
  1099.     pXmlnsOpenQuotationMark,
  1100.     "http://www.w3.org/2001/SMIL20/PR/Language"");
  1102.     const char* pSMIL20NamespaceLastCall = strstr(
  1103.     pXmlnsOpenQuotationMark,
  1104.     "http://www.w3.org/TR/REC-smil/2000/SMIL20/LC/"");
  1106.     // /If the SMIL 1.0 namespace is declared prior to any other
  1107.     // version of SMIL's namespace, then this is a SMIL 1.0 doc:
  1108.     if (pSMIL10Namespace  &&  (!pSMIL20Namespace  ||
  1109.     pSMIL10Namespace < pSMIL20Namespace)  &&
  1110.     (!pSMIL20NamespaceCandidateRec  ||
  1111.     pSMIL10Namespace < pSMIL20NamespaceCandidateRec)  &&
  1112.     (!pSMIL20NamespaceProposedRec  ||
  1113.     pSMIL10Namespace < pSMIL20NamespaceProposedRec)  &&
  1114.     (!pSMIL20NamespaceLastCall  ||
  1115.     pSMIL10Namespace < pSMIL20NamespaceLastCall) )
  1116.     {
  1117. m_smilFileVersion = SMILFileVersionSmil10Strict;
  1118.     }
  1119.     else if (pSMIL20NamespaceCandidateRec  &&  (!pSMIL20Namespace  ||
  1120.     pSMIL20NamespaceCandidateRec < pSMIL20Namespace))
  1121.     {
  1122. m_smilFileVersion = SMILFileVersionSmil20PreRec;
  1123.     }
  1124.     else if (pSMIL20NamespaceProposedRec  &&  (!pSMIL20Namespace ||
  1125.     pSMIL20NamespaceProposedRec < pSMIL20Namespace))
  1126.     {
  1127. m_smilFileVersion = SMILFileVersionSmil20PreRec;
  1128.     }
  1129.     // /Treat both LC (Last Call) and CR (Candidate Rec) as "PreRec":
  1130.     else if (pSMIL20NamespaceLastCall  &&  (!pSMIL20Namespace  ||
  1131.     pSMIL20NamespaceLastCall < pSMIL20Namespace))
  1132.     {
  1133. m_smilFileVersion = SMILFileVersionSmil20PreRec;
  1134.     }
  1135.     else if (pSMIL20Namespace)
  1136.     {
  1137. m_smilFileVersion = SMILFileVersionSmil20;
  1138.     }
  1139.     else
  1140.     {
  1141. m_smilFileVersion = SMILFileVersionUnknown;
  1142.     }
  1143. }
  1144.     }
  1146. cleanup:
  1147.     if (pszStartOfFile)
  1148.     {
  1149. HX_VECTOR_DELETE(pszStartOfFile);
  1150.     }
  1152.     return pnreslt;
  1153. }
  1156. /////////////////////////////////////////////////////////////////////////
  1157. //  Method:
  1158. // BreakUpBuffer
  1159. //  Purpose:
  1160. // This Function will break the buffer into packets.
  1161. //
  1162. // This function maintains a state, such that multiple buffers should
  1163. // Be able to be passed into it at any point...
  1164. //
  1166. // XXX  jhug
  1167. // This doesn't allow text between tags... Future versions of SMIL might
  1168. // support this... this will need a bit of a modification.
  1169. HX_RESULT 
  1170. CSmilFileFormat::BreakUpBuffer(IHXBuffer* pBuffer)
  1171. {
  1172.     // walk through the buffer and escape all "s
  1173.     // also forget about all white space and comments...
  1174.     // also break the buffer up into packets for easy access.
  1176.     HX_RESULT result = HXR_OK;
  1178.     UCHAR* pCb = NULL;
  1179.     if ( m_pCurrentPacketData )
  1180.     {
  1181. pCb = m_pCurrentPacketData->pBuffer->GetBuffer();
  1182.     }
  1184.     const UCHAR* pData = pBuffer->GetBuffer();
  1185.     UINT32 ulSize = pBuffer->GetSize();
  1186.     for ( UINT32 ulPos = 0; ulPos < ulSize && pData[ulPos]; ++ulPos )
  1187.     {
  1188. // three for the end of the packet structure, and 1 in case we have 
  1189. // to escape a char...
  1190. if ( m_ulCurrentBufferPos >= MaxPacketSize - 4 ) 
  1191. {
  1192.     pCb[m_ulCurrentBufferPos++] = '"';
  1193.     pCb[m_ulCurrentBufferPos++] = ')';
  1194.     pCb[m_ulCurrentBufferPos++] = '';
  1195.     m_pCurrentPacketData->pBuffer->SetSize(m_ulCurrentBufferPos);
  1196.     m_pArrayOfPackets->Add((void*)m_pCurrentPacketData);
  1197.     m_pCurrentPacketData = NULL;
  1198.     m_ulCurrentBufferPos = 0;
  1199.     pCb = NULL;
  1200. }
  1202. if ( !m_pCurrentPacketData )
  1203. {
  1204.     m_pCurrentPacketData = new PacketData;
  1205.     if ( m_pCurrentPacketData == NULL )
  1206.     {
  1207. result = HXR_OUTOFMEMORY;
  1208.     }
  1209.     else
  1210.     {
  1211. m_pCurrentPacketData->pBuffer = NULL;
  1212. m_pCurrentPacketData->pNumPos = NULL;
  1213. result = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer, 
  1214. (void**)&m_pCurrentPacketData->pBuffer);
  1215.     }
  1216.     if ( SUCCEEDED(result) )
  1217.     {
  1218. result = m_pCurrentPacketData->pBuffer->SetSize(MaxPacketSize);
  1219.     }
  1220.     if ( SUCCEEDED(result) )
  1221.     {
  1222. pCb = m_pCurrentPacketData->pBuffer->GetBuffer();
  1223. //memset(pCb, 0xef, MaxPacketSize);
  1224. sprintf((char*)pCb, "(smil-document (ver %s)(npkt %ld)"
  1225.     "(ttlpkt 0     )(doc "", 
  1226.     RMA_DRIVER_VERSION, ++m_ulCurrentPacket);
  1227. m_ulCurrentBufferPos = strlen((char*)pCb);
  1228. // back up to the begining of the total number position.
  1229. // 13 is position back in header...
  1230. m_pCurrentPacketData->pNumPos = (char*)pCb + 
  1231.     m_ulCurrentBufferPos - 13; 
  1232.     }
  1233. }
  1235. if ( FAILED(result) )
  1236. {
  1237.     break;
  1238. }
  1239. switch ( m_fileState )
  1240. {
  1241. case InContent:
  1242.     {
  1243. if ( pData[ulPos] == '"' )
  1244. {
  1245.     pCb[m_ulCurrentBufferPos++] = '\';
  1246.     pCb[m_ulCurrentBufferPos++] = '"';
  1247. }
  1248. else if ( pData[ulPos] == '\' )
  1249. {
  1250.     pCb[m_ulCurrentBufferPos++] = '\';
  1251.     pCb[m_ulCurrentBufferPos++] = '"';
  1252. }
  1253. else if ( pData[ulPos] == '<' )
  1254. {
  1255.     if ( pData[ulPos+1] == '!' )
  1256.     {
  1257. if ( pData[ulPos+2] == '-'
  1258.     && pData[ulPos+3] == '-' )
  1259. {
  1260.     ulPos += 3;
  1261.     m_fileState = InComment;
  1262. }
  1263. else if ( pData[ulPos+2] == '[' && 
  1264.   pData[ulPos+3] == 'C' &&
  1265.   pData[ulPos+4] == 'D' &&
  1266.   pData[ulPos+5] == 'A' &&
  1267.   pData[ulPos+6] == 'T' &&
  1268.   pData[ulPos+7] == 'A' &&
  1269.   pData[ulPos+8] == '[' )
  1270. {
  1271.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1272.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1273.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1274.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1275.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1276.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1277.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1278.     m_fileState = InCDATA;
  1279. }
  1280. else if ( pData[ulPos+2] == 'D' && 
  1281.   pData[ulPos+3] == 'O' &&
  1282.   pData[ulPos+4] == 'C' &&
  1283.   pData[ulPos+5] == 'T' &&
  1284.   pData[ulPos+6] == 'Y' &&
  1285.   pData[ulPos+7] == 'P' &&
  1286.   pData[ulPos+8] == 'E' )
  1287. {
  1288.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1289.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1290.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1291.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1292.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1293.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1294.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1295.     m_fileState = InDTD;
  1296. }
  1297.     }
  1298.     else
  1299.     {
  1300. pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1301. m_fileState = InTagName;
  1302.     }
  1303. }
  1304. // preserve all lines so line number error reporting is
  1305. // accurate
  1306. else if ( isspace(pData[ulPos]) && pData[ulPos] != 'n'  &&
  1307. pData[ulPos] != 'r')
  1308. {
  1309.     //continue...
  1310. }
  1311. //If we find rx where x is not n, then keep it else let
  1312. // the next char (n) be kept in the next iteration of
  1313. // this loop.  This accomodates Mac-authored 'r'-only
  1314. // text.  Think Different (pain is "different").
  1315. else if (isspace(pData[ulPos])  &&  ('r' == pData[ulPos]  &&
  1316. (ulPos+1 < ulSize  &&  pData[ulPos+1])  &&
  1317. 'n' == pData[ulPos+1]) )
  1318. {
  1319.     //continue...
  1320. }
  1321. else
  1322. {
  1323.     if ('r' == pData[ulPos])
  1324.     {
  1325. pCb[m_ulCurrentBufferPos++] = 'n';
  1326.     }
  1327.     else
  1328.     {
  1329. pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1330.     }
  1331. }
  1332.     }
  1333.     break;
  1334. case InDTD:
  1335.     {
  1336. if ( pData[ulPos] == '[' )
  1337. {
  1338.     m_fileState = InDTDMarkup;
  1339. }
  1340. else if ( pData[ulPos] == '>' )
  1341. {
  1342.     m_fileState = InContent;
  1343. }
  1344. else if ( pData[ulPos] == '"' )
  1345. {
  1346.     pCb[m_ulCurrentBufferPos++] = '\';
  1347. }
  1348. else if ( pData[ulPos] == '\' )
  1349. {
  1350.     pCb[m_ulCurrentBufferPos++] = '\';
  1351. }
  1352. pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1353.     }
  1354.     break;
  1355. case InDTDMarkup:
  1356.     {
  1357. if ( pData[ulPos] == ']' )
  1358. {
  1359.     m_fileState = InDTD;
  1360. }
  1361. else if ( pData[ulPos] == '"' )
  1362. {
  1363.     pCb[m_ulCurrentBufferPos++] = '\';
  1364. }
  1365. else if ( pData[ulPos] == '\' )
  1366. {
  1367.     pCb[m_ulCurrentBufferPos++] = '\';
  1368. }
  1369. pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1370.     }
  1371.     break;
  1372. case InCDATA:
  1373.     {
  1374. if ( pData[ulPos] == ']' && pData[ulPos+1] == ']' && pData[ulPos+2] == '>' )
  1375. {
  1376.     pCb[m_ulCurrentBufferPos++] = pData[ulPos++];
  1378.     m_fileState = InContent;
  1379. }
  1380. else if ( pData[ulPos] == '"' )
  1381. {
  1382.     pCb[m_ulCurrentBufferPos++] = '\';
  1383. }
  1384. else if ( pData[ulPos] == '\' )
  1385. {
  1386.     pCb[m_ulCurrentBufferPos++] = '\';
  1387. }
  1388. pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1389.     }
  1390.     break;
  1391. case InTagName:
  1392.     {
  1393. // go to first white space
  1394. // let's escape " and  even though they are ilegal.
  1395. if ( isspace(pData[ulPos]) )
  1396. {
  1397.     m_fileState = InBeginAttributeName;
  1398. }
  1399. else if ( pData[ulPos] == '>' )
  1400. {
  1401.     m_fileState = InContent;
  1402. }
  1403. else if ( pData[ulPos] == '"' )
  1404. {
  1405.     ReportError(HXR_XML_GENERALERROR, XML_BAD_TAG_NAME);
  1406.     pCb[m_ulCurrentBufferPos++] = '\';
  1407. }
  1408. else if ( pData[ulPos] == '\' )
  1409. {
  1410.     ReportError(HXR_XML_GENERALERROR, XML_BAD_TAG_NAME);
  1411.     pCb[m_ulCurrentBufferPos++] = '\';
  1412. }
  1413. pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1414.     }
  1415.     break;
  1416. case InTag:
  1417.     {
  1418. if ( pData[ulPos] == '>' || (pData[ulPos] == '/' && 
  1419.     pData[ulPos+1] == '>'))
  1420. {
  1421.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1422.     m_fileState = InContent;
  1423. }
  1424. else
  1425. {
  1426.     // grab the first char... keep it and switch states.
  1427.     // it should be a space... but if it isn't we will
  1428.     // not complain because the renderer accepts no 
  1429.     // space.
  1430.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1431.     m_fileState = InBeginAttributeName;
  1432.     if (!isspace(pData[ulPos]))
  1433.     {
  1434. ReportError(HXR_XML_GENERALERROR,
  1435. XML_MISSING_SPACE);
  1436.     }
  1437. }
  1438.     }
  1439.     break;
  1440. case InBeginAttributeName:
  1441.     {
  1442. if ( isspace(pData[ulPos]) )
  1443. {
  1444.     // preserve all lines so line numbers in error messages
  1445.     // are accurate
  1446.     if (pData[ulPos] == 'n'  ||  ('r' == pData[ulPos]  &&
  1447.     ulPos+1 < ulSize  &&  'n' != pData[ulPos+1]) )
  1448.     {
  1449. if ('r' == pData[ulPos])
  1450. {
  1451.     pCb[m_ulCurrentBufferPos++] = 'n';
  1452. }
  1453. else
  1454. {
  1455.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1456. }
  1457.     }
  1458.     // continue...
  1459. }
  1460. else if ( pData[ulPos] == '=' )
  1461. {
  1462.     ReportError(HXR_XML_GENERALERROR, 
  1463.      XML_BAD_ATTRIBUTE_NAME);
  1465.     m_fileState = InBeginAttributeValue;
  1466.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1467. }
  1468. else if ( pData[ulPos] == '>' || (pData[ulPos] == '/' 
  1469.     && pData[ulPos+1] == '>'))
  1470. {
  1471.     m_fileState = InContent;
  1472.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1473. }
  1474. else
  1475. {
  1476.     m_fileState = InAttributeName;
  1477.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1478. }
  1479.     }
  1480.     break;
  1481. case InAttributeName:
  1482.     {
  1483. if ( isspace(pData[ulPos]) )
  1484. {
  1485.     m_fileState = InEndAttributeName;
  1486.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1487. }
  1488. else if ( pData[ulPos] == '=' )
  1489. {
  1490.     m_fileState = InBeginAttributeValue;
  1491.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1492. }
  1493. else if ( pData[ulPos] == '>' )
  1494. {
  1495.     ReportError(HXR_XML_GENERALERROR, 
  1496.      XML_MISSING_ATTRIBUTE_VALUE);
  1497.     m_fileState = InContent;
  1498.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1499. }
  1500. else if (pData[ulPos] == ''' || pData[ulPos] == '"')
  1501. {
  1502.     ReportError(HXR_XML_GENERALERROR, 
  1503.      XML_BAD_ATTRIBUTE_NAME);
  1504.     m_cQuote = pData[ulPos];
  1505.     if (m_cQuote == '"')
  1506.     {
  1507. pCb[m_ulCurrentBufferPos++] = '\';
  1508.     }
  1509.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1510.     m_fileState = InAttributeValue;
  1511. }
  1512. else
  1513. {
  1514.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1515. }
  1516.     }
  1517.     break;
  1518. case InEndAttributeName:
  1519.     {
  1520. if ( isspace(pData[ulPos]) )
  1521. {
  1522.     // preserve all lines so line numbers in error messages
  1523.     // are accurate
  1524.     if (pData[ulPos] == 'n'  ||  ('r' == pData[ulPos]  &&
  1525.     ulPos+1 < ulSize  &&  'n' != pData[ulPos+1]) )
  1526.     {
  1527. if ('r' == pData[ulPos])
  1528. {
  1529.     pCb[m_ulCurrentBufferPos++] = 'n';
  1530. }
  1531. else
  1532. {
  1533.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1534. }
  1535.     }
  1536.     // continue..
  1537. }
  1538. else if ( pData[ulPos] == '=' )
  1539. {
  1540.     m_fileState = InBeginAttributeValue;
  1541.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1542. }
  1543. else if ( pData[ulPos] == '>' )
  1544. {
  1545.     ReportError(HXR_XML_GENERALERROR, 
  1546.      XML_MISSING_ATTRIBUTE_VALUE);
  1547.     // illegal.
  1548.     m_fileState = InContent;
  1549.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1550. }
  1551. else
  1552. {
  1553.     // hmm. we got a non whitespace before the =
  1555.     // push a ' ' on so the render will get this error.
  1556.     pCb[m_ulCurrentBufferPos++] = ' ';
  1558.     //First, let's see if we have a ["] or a [']
  1559.     // (i.e., an attribute value start) in which
  1560.     // case the author must have forgotten to
  1561.     // put an '=' between the name/value pair.
  1562.     // In this case, we need to keep the renderers
  1563.     // from firing off an error with old bad content,
  1564.     // so we pretend we're in the "InAttributeValue"
  1565.     // state:
  1566.     if ( pData[ulPos] == ''' )
  1567.     {
  1568. ReportError(HXR_XML_GENERALERROR, 
  1569. XML_BAD_ATTRIBUTE_NAME);
  1571. m_cQuote = pData[ulPos];
  1572. m_fileState = InAttributeValue;
  1573.     }
  1574.     else if ( pData[ulPos] == '"' )
  1575.     {
  1576. ReportError(HXR_XML_GENERALERROR,
  1577. XML_BAD_ATTRIBUTE_NAME);
  1578. m_cQuote = pData[ulPos];
  1579. pCb[m_ulCurrentBufferPos++] = '\';
  1580. m_fileState = InAttributeValue;
  1581.     }
  1582.     else
  1583.     {
  1584. ReportError(HXR_XML_BADATTRIBUTE, 
  1585. XML_BAD_ATTRIBUTE_NAME);
  1586. // lets go back to the attribute name state.
  1587. m_fileState = InAttributeName;
  1588.     }
  1589.     //Push the character back on so the renderer
  1590.     // can deal with it:
  1591.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1592. }
  1593.     }
  1594.     break;
  1595. case InBeginAttributeValue:
  1596.     {
  1597. if ( isspace(pData[ulPos]) )
  1598. {
  1599.     // preserve all lines so line numbers in error messages
  1600.     // are accurate
  1601.     if (pData[ulPos] == 'n'  ||  ('r' == pData[ulPos]  &&
  1602.     ulPos+1 < ulSize  &&  'n' != pData[ulPos+1]) )
  1603.     {
  1604. if ('r' == pData[ulPos])
  1605. {
  1606.     pCb[m_ulCurrentBufferPos++] = 'n';
  1607. }
  1608. else
  1609. {
  1610.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1611. }
  1612.     }
  1613.     // continue...
  1614. }
  1615. else if ( pData[ulPos] == ''' )
  1616. {
  1617.     m_cQuote = pData[ulPos];
  1618.     m_fileState = InAttributeValue;
  1619.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1620. }
  1621. else if ( pData[ulPos] == '"' )
  1622. {
  1623.     m_cQuote = pData[ulPos];
  1624.     pCb[m_ulCurrentBufferPos++] = '\';
  1625.     pCb[m_ulCurrentBufferPos++] = '"';
  1626.     m_fileState = InAttributeValue;
  1627. }
  1628. else if ( pData[ulPos] == '>' )
  1629. {
  1630.     ReportError(HXR_XML_GENERALERROR,
  1631.      XML_MISSING_ATTRIBUTE_VALUE);
  1632.     m_fileState = InContent;
  1633.     pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1634. }
  1635.     }
  1636.     break;
  1637. case InAttributeValue:
  1638.     {
  1639. if ( pData[ulPos] == m_cQuote )
  1640. {
  1641.     if ( m_cQuote == '"' )
  1642.     {
  1643. pCb[m_ulCurrentBufferPos++] = '\';
  1644.     }
  1645.     m_fileState = InTag;
  1646. }
  1647. else if ( pData[ulPos] == '"' )
  1648. {
  1649.     pCb[m_ulCurrentBufferPos++] = '\';
  1650. }
  1651. else if ( pData[ulPos] == '\' )
  1652. {
  1653.     pCb[m_ulCurrentBufferPos++] = '\';
  1654. }
  1655. pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1656.     }
  1657.     break;
  1658. case InComment:
  1659.     {
  1660. if ( pData[ulPos] == '-' && pData[ulPos+1] == '-' &&
  1661.     pData[ulPos+2] == '>' )
  1662. {
  1663.     m_fileState = InContent;
  1664.     ulPos += 2;
  1665. }
  1666. // preserve all lines so line numbers in error messages
  1667. // are accurate
  1668. else if (pData[ulPos] == 'n'  ||  ('r' == pData[ulPos]  &&
  1669.     ulPos+1 < ulSize  &&  'n' != pData[ulPos+1]) )
  1670. {
  1671.     if ('r' == pData[ulPos])
  1672.     {
  1673. pCb[m_ulCurrentBufferPos++] = 'n';
  1674.     }
  1675.     else
  1676.     {
  1677. pCb[m_ulCurrentBufferPos++] = pData[ulPos];
  1678.     }
  1679. }
  1680. // else continue...
  1681.     }
  1682.     break;
  1683. default:
  1684.     HX_ASSERT(FALSE);
  1685. }
  1686.     }
  1687.     return result;
  1688. }
  1690. HX_RESULT CSmilFileFormat::ReportError(HX_RESULT result, 
  1691.        const char* errStr)
  1692. {
  1693.     if ( m_bLogErrors )
  1694.     {
  1695. IHXErrorMessages* pLog = NULL;
  1696. m_pContext->QueryInterface(IID_IHXErrorMessages, 
  1697. (void**)&pLog);
  1698. pLog->Report(HXLOG_ERR, result, 0, errStr,
  1699.     "http://www.real.com");
  1700. HX_RELEASE(pLog);
  1701.     }
  1702.     return HXR_OK;
  1703. }
  1705. /////////////////////////////////////////////////////////////////////////
  1706. //  Method:
  1707. // IHXFileResponse::WriteDone
  1708. //  Purpose:
  1709. // Notification interface provided by users of the IHXFileObject
  1710. // interface. This method is called by the IHXFileObject when the
  1711. // last write to the file is complete.
  1712. //
  1713. STDMETHODIMP CSmilFileFormat::WriteDone(HX_RESULT status)
  1714. {
  1715.     // We don't ever write, so we don't expect to get this...
  1716.     return HXR_UNEXPECTED;
  1717. }
  1719. /////////////////////////////////////////////////////////////////////////
  1720. //  Method:
  1721. // IHXFileResponse::SeekDone
  1722. //  Purpose:
  1723. // Notification interface provided by users of the IHXFileObject
  1724. // interface. This method is called by the IHXFileObject when the
  1725. // last seek in the file is complete.
  1726. //
  1727. STDMETHODIMP CSmilFileFormat::SeekDone(HX_RESULT status)
  1728. {
  1729.     HX_RESULT result = HXR_OK;
  1731.     return result;
  1732. }
  1734. /************************************************************************
  1735.  * Method:
  1736.  *     IHXPendingStatus::GetStatus
  1737.  * Purpose:
  1738.  *     Called by the user to get the current pending status from an object
  1739.  */
  1740. STDMETHODIMP
  1741. CSmilFileFormat::GetStatus
  1742. (
  1743.     REF(UINT16) uStatusCode, 
  1744.     REF(IHXBuffer*) pStatusDesc, 
  1745.     REF(UINT16) ulPercentDone
  1746. )
  1747. {
  1748.     HX_RESULT hResult = HXR_OK;
  1749.     IHXPendingStatus* pFileSystemStatus = NULL;
  1752.     // asking status information from the file system object
  1753.     if (m_pFileObject)
  1754.     {
  1755. if (HXR_OK == m_pFileObject->QueryInterface(IID_IHXPendingStatus,(void**)&pFileSystemStatus))
  1756. {
  1757.     hResult = pFileSystemStatus->GetStatus(uStatusCode, pStatusDesc, ulPercentDone);
  1759.     pFileSystemStatus->Release();
  1760.     return hResult;
  1761. }
  1762.     }
  1764.     // by default
  1765.     uStatusCode = HX_STATUS_READY;
  1766.     pStatusDesc = NULL;
  1767.     ulPercentDone = 0;
  1768.  
  1769.     return hResult;
  1770. }
  1772. /************************************************************************
  1773.  * Method:
  1774.  *     IHXThreadSafeMethods::IsThreadSafe
  1775.  */
  1776. STDMETHODIMP_(UINT32)
  1777. CSmilFileFormat::IsThreadSafe()
  1778. {
  1779.     return HX_THREADSAFE_METHOD_FF_GETPACKET |
  1780. HX_THREADSAFE_METHOD_FSR_READDONE;
  1781. }