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

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

Symbian

开发平台：

Visual C++

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