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

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

Symbian

开发平台：

C/C++

smlprstime.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. // system
  37. #include <time.h>
  38. #ifdef _UNIX
  39. #include <ctype.h>
  40. #endif
  41. // include
  42. #include "hxtypes.h"
  43. #include "hxwintyp.h"
  44. #include "hxcom.h"
  45. #include "hxxml.h"
  46. #include "smiltype.h"
  47. // pncont
  48. #include "hxstring.h"
  49. #include "hxslist.h"
  50. // pnmisc
  51. #include "nptime.h"
  52. #include "smpte.h"
  53. #include "hxwinver.h"
  54. // rnxmllib
  55. #include "hxxmlprs.h"
  56. // rmasmil
  57. #include "smlerror.h"
  58. #include "smlparse.h"
  59. #include "smlelem.h"
  60. #include "smlprstime.h"
  61. // pndebug
  62. #include "hxheap.h"
  63. #ifdef _DEBUG
  64. #undef HX_THIS_FILE
  65. static const char HX_THIS_FILE[] = __FILE__;
  66. #endif
  68. SmilTimeValue::SmilTimeValue(IUnknown* pContext, UINT32 ulStartLine,
  69.      CSmilElement* pElement)
  70. : m_pContext(pContext)
  71. , m_pElement(pElement)
  72. , m_ulStartLine(ulStartLine)
  73. , m_type(SmilTimeNone)
  74. , m_position(SMILEventSourceEnd)
  75. , m_uRepeatIteration(0)
  76. , m_bTreatSyncArcAsEvent(FALSE)
  77. , m_lOffset(0)
  78. , m_lOriginalOffset(0)
  79. , m_year(-1)
  80. , m_month(-1)
  81. , m_day(-1)
  82. , m_hour(0)
  83. , m_min(0)
  84. , m_sec(0)
  85. , m_ms(0)
  86. , m_UTCOffsetMin(0)
  87. , m_bRelativeToUTC(FALSE)
  88. , m_pszMarkerName(NULL)
  89. , m_bIsExternalMarker(FALSE)
  90. , m_pszExternalMarkerFileName(NULL)
  91. , m_pszExternalMarkerName(NULL)
  92. , m_ulMarkerTime(0)
  93. , m_bUsedToBeMediaMarker(FALSE)
  94. , m_pEventName(NULL)
  95. , m_bTimeIsResolved(FALSE)
  96. , m_lResolvedToTime(SMILTIME_INFINITY)
  97. , m_lWhenTimeWasResolved(SMILTIME_INFINITY)
  98. , m_lTimeOfPause(SMILTIME_INFINITY)
  99. {
  100.     m_pContext->AddRef();
  101. }
  103. SmilTimeValue::~SmilTimeValue()
  104. {
  105.     HX_RELEASE(m_pContext); // /fixes mem leak.
  106.     HX_VECTOR_DELETE(m_pszMarkerName);
  107.     HX_VECTOR_DELETE(m_pszExternalMarkerFileName);
  108.     HX_VECTOR_DELETE(m_pszExternalMarkerName);
  109.     HX_VECTOR_DELETE(m_pEventName);
  110. }
  112. // /This returns the resolved time, including any positive offset,
  113. // and includes only the part of a negative offset that is after
  114. // the resolved-AT time (which is m_lWhenTimeWasResolved).  In other
  115. // words, this returns the time at which the element will actually
  116. // begin or end based on this SmilTimeValue:
  117. //
  118. // Returns HXR_OK if resolved time is returned in lEffectiveResolveTime,
  119. // else returns HXR_FAILED.
  120. HX_RESULT
  121. SmilTimeValue::getEffectiveResolvedTime(REF(INT32) lEffectiveResolvedTime)
  122. {
  123.     HX_RESULT retval = HXR_OK;
  124.     lEffectiveResolvedTime = SMILTIME_NEGATIVE_INFINITY;
  125.     switch (m_type)
  126.     {
  127. case SmilTimeSyncBase:
  128. #if defined(ENABLE_SYNC_TO_PREV)
  129. case SmilTimeSyncToPrev:
  130. #endif
  131. case SmilTimeMediaMarker:
  132. case SmilTimeEvent:
  133. {
  134.     if (isTimeResolved())
  135.     {
  136. // /EH- the following should *always* be true:
  137. HX_ASSERT(m_lResolvedToTime >= m_lWhenTimeWasResolved);
  138. // /Note: resolvedToTime doesn't include offset:
  139. lEffectiveResolvedTime = m_lResolvedToTime;
  140. #define XXXEH_OFFSET_NOT_ALREADY_ACCOUNTED_FOR
  141. #if defined(XXXEH_OFFSET_NOT_ALREADY_ACCOUNTED_FOR)
  142. if (SmilTimeEvent == m_type
  143. // /XXXEH- TODO: handle SmilTimeMediaMarker here, too,
  144. // if and when we get internal markers (event-like
  145. // ones) working:
  146. ||  (isSyncBaseTimeVal()  &&  m_bTreatSyncArcAsEvent))
  147. {
  148.     INT32 lEffectiveOffset = m_lOffset;
  149.     if (lEffectiveOffset < 0)
  150.     {
  151. lEffectiveOffset = m_lWhenTimeWasResolved -
  152. m_lResolvedToTime;
  153. if (lEffectiveOffset < m_lOffset)
  154. {
  155.     // /Resolved-at time was well before resolved-to
  156.     // time minus |offset|, so the entire offset is
  157.     // used:
  158.     lEffectiveOffset = m_lOffset;
  159. }
  160.     }
  161.     lEffectiveResolvedTime += lEffectiveOffset;
  162. }
  163. #endif
  164.     }
  165.     else
  166.     {
  167. retval = HXR_FAILED;
  168.     }
  169. }
  170. break;
  172. // /XXXEH- TODO: figure out how to handle wallclock; I think
  173. // it should just work the same as clock values:
  174. case SmilTimeWallclock:
  175. case SmilTimeClockValue:
  176. case SmilTimeOffset:
  177. {
  178.     if (isTimeResolved())
  179.     {
  180. lEffectiveResolvedTime = m_lOffset;
  181.     }
  182.     else
  183.     {
  184. retval = HXR_FAILED;
  185. // /All wallclock, clock, and offset values should have
  186. // been set as resolved at parse time:
  187. HX_ASSERT(isTimeResolved());
  188.     }
  189. }
  190. break;
  192. default:
  193. {
  194.     retval = HXR_FAILED;
  195. }
  196. break;
  197.     }
  198.     return retval;
  199. }
  202. HX_RESULT
  203. SmilTimeValue::parseValue(const char* pPos,
  204.   SMILSyncAttributeTag nTag,
  205.   // /Needed for self-references:
  206.   const char* pThisElementID)
  207. {
  208.     HX_RESULT ret = HXR_OK;
  210.     if (pPos == (const char*)NULL)
  211.     {
  212. ret = HXR_FAIL;
  213.     }
  214.     else if (*pPos == '+' || *pPos == '-')
  215.     {
  216. HX_ASSERT(nTag == SMILSyncAttrBegin);
  217. if (nTag == SMILSyncAttrBegin)
  218. {
  219.     ret = parseOffset(pPos);
  220.     m_type = SmilTimeOffset;
  221.     if (SUCCEEDED(ret))
  222.     {
  223. m_bTimeIsResolved = TRUE;
  224.     }
  225. }
  226. else
  227. {
  228.     CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  229.     errHandler.ReportError(SMILErrorBadTimeValue, pPos, 
  230. m_ulStartLine);
  231.     return ret;
  232. }
  233.     }
  234.     else if (isdigit(*pPos)
  235. // /Fixes PR 42592:
  236. // "0.5s" was OK but ".5s" was being treated as unresolved:
  237. ||  '.' == *pPos)
  238.     {
  239. ret = parseOffset(pPos);
  240. if (SUCCEEDED(ret))
  241. {
  242.     m_bTimeIsResolved = TRUE;
  243. }
  245. // this is actually a Clock Value if it is an end
  246. // time.
  247. if (nTag == SMILSyncAttrBegin)
  248. {
  249.     m_type = SmilTimeOffset;
  250. }
  251. else // nTag == SMILSyncAttrEnd
  252. {
  253.     m_type = SmilTimeClockValue;
  254. }
  255.     }
  256. #if defined(ENABLE_SYNC_TO_PREV)
  257.     else if (strncmp(pPos, "prev", 4) == 0)
  258.     {
  259. // syncToPrev-value
  260. ret = parseSyncToPrev(pPos);
  261.     }
  262. #endif
  263.     else if (strncmp(pPos, "wallclock", 9) == 0)
  264.     {
  265. // wallclock-sync-value
  266. ret = parseWallClockValue(pPos);
  267.     }
  268.     else
  269.     {
  270. const char* pDotPos = NULL;
  271. BOOL bEscape = FALSE;
  273. UINT32 len = strlen(pPos);
  274. char* idref = new char [len+1];
  275. char* idrefPos = idref;
  276. *idrefPos = '';
  277. char* command = new char [len+1];
  278. char* commandPos = command;
  279. *commandPos = '';
  281. const char* pOffset = NULL;
  283. enum { IDREF, ESCAPE, COMMAND, END, OFFSET } state = IDREF;
  285. const char* pBegin = pPos;
  287. while (*pPos)
  288. {
  289.     switch (state)
  290.     {
  291.     case ESCAPE:
  292. *idrefPos++ = *pPos;
  293. state = IDREF;
  294. break;
  295.     case IDREF:
  296. if (*pPos == '\')
  297. {
  298.     // /Don't include escape char in idref; go to next char:
  299.     state = ESCAPE;
  300. }
  301. else if (*pPos == '.')
  302. {
  303.     *idrefPos = '';
  304.     state = COMMAND;
  305. }
  306. else if (isspace(*pPos))
  307. {
  308.     *idrefPos = '';
  309.     state = END;
  310. }
  311. else if (*pPos == '+' || *pPos == '-')
  312. {
  313.     *idrefPos++ = '';
  314.     pOffset = pPos;
  315.     state = OFFSET;
  316. }
  317. else
  318. {
  319.     *idrefPos++ = *pPos;
  320. }
  321. break;
  322.     case COMMAND:
  323.         if (isspace(*pPos))
  324. {
  325.     *commandPos = '';
  326.     state = END;
  327. }
  328. else if (*pPos == '+' || *pPos == '-')
  329. {
  330.     pOffset = pPos;
  331.     *commandPos = '';
  332.     state = OFFSET;
  333. }
  334. else
  335. {
  336.     *commandPos++ = *pPos;
  337. }
  338. break;
  339.     case END:
  340. if (*pPos == '+' || *pPos == '-')
  341. {
  342.     pOffset = pPos;
  343.     state = OFFSET;
  344. }
  345. break;
  346.     case OFFSET:
  347. break;
  348.     }
  349.     ++pPos;
  350. }
  352. if (state == COMMAND)
  353. {
  354.     *commandPos = '';
  355. }
  356. else if (state == IDREF || state == ESCAPE)
  357. {
  358.     *idrefPos = '';
  359. }
  361.         // XXXMEH - if this is an animation element, then we
  362.         // will handle the ".repeat(x)" syntax differently than
  363.         // we treat sources. We will treat ".repeat(x)" as an
  364.         // event rather than a sync-arc.
  365.         BOOL bIsAnimate = FALSE;
  366.         if (m_pElement && m_pElement->m_pNode &&
  367.             (m_pElement->m_pNode->m_tag == SMILAnimate       ||
  368.              m_pElement->m_pNode->m_tag == SMILSet           ||
  369.              m_pElement->m_pNode->m_tag == SMILAnimateMotion ||
  370.              m_pElement->m_pNode->m_tag == SMILAnimateColor))
  371.         {
  372.             bIsAnimate = TRUE;
  373.         }
  374. if (*command == '')
  375. {
  376.     // /The SMIL Boston draft supports the fact that the name of the
  377.     // event ("Event-symbol") is required and is what is used when
  378.     // no "Eventbase-element." precedes it.  Thus, we need to
  379.     // treat the idref as the command string and use this 
  380.     // element's id for the idref:
  381.     // /HOWEVER, for PR 69849 (needed for PR 58290) fix, if event is
  382.     // "accesskey(...)", then the event is not self-generated and is
  383.     // not raised for another element, so give it a fake id here so
  384.     // special-case code isn't needed in multiple places, elsewhere:
  385.     if (!strncmp(idref, "accesskey(", 10))
  386.     {
  387. ret = parseEvent(
  388. // /Use this string (an invalid XML id) as the fake ID:
  389. ACCESSKEY_EVENT_FAKE_ID_STRING, // /fake ID.
  390. idref, // /<==actually the command (i.e., Event-symbol)
  391. pOffset);
  392.     }
  393.     else
  394.     {
  395. ret = parseEvent(pThisElementID,
  396. idref, // /<==actually the command (i.e., Event-symbol)
  397. pOffset);
  398.     }
  399. }
  400. else if (strcmp(command, "begin") == 0 ||
  401. #if defined(XXXEH_REPEAT_VALUE_TIMING_SHOULD_BE_EVENT_BASED)
  402. #else
  403. ((0 == strncmp(command, "repeat(", 7)) && !bIsAnimate)  ||
  404. #endif
  405.  strcmp(command, "end") == 0)
  406. {
  407. // base, memeber, offset
  408.     ret = parseSyncBase(idref, command, pOffset);
  409. }
  410. else if (strncmp(command, "marker(", 7) == 0)
  411. {
  412.     ret = parseMarker(idref, command, pOffset);
  413. }
  414. else // /everything else is an event (i.e., "Event-symbol") name:
  415. {
  416.     ret = parseEvent(idref, command, pOffset);
  417. }
  419. HX_VECTOR_DELETE(command);
  420. HX_VECTOR_DELETE(idref);
  421.     }
  423.     // /We need to make sure we set scheduled time values' resolved-to times
  424.     // in case these times are used AFTER the element has already begun
  425.     // playing or finished playing:
  426.     if (SmilTimeOffset == m_type   || 
  427. SmilTimeClockValue == m_type  ||
  428. SmilTimeWallclock == m_type)
  429.     {
  430. setResolvedToTime(0);
  431. setWhenTimeWasResolved(0);
  432.     }
  434.     return ret;
  435. }
  437. HX_RESULT
  438. SmilTimeValue::setTimeOffset(time_t tRefTime)
  439. {
  440.     HX_RESULT ret = HXR_OK;
  441.     if (m_type == SmilTimeWallclock)
  442.     {
  443. struct tm ourtime;
  445. ourtime.tm_sec = m_sec; 
  446. ourtime.tm_min = m_min;
  447. ourtime.tm_hour = m_hour;
  448. if (m_day != -1 && m_year != -1 && m_month != -1)
  449. {
  450.     ourtime.tm_mday = m_day;
  451.     // /tm::tm_mon is 0-based, while m_month is 1-based, so we need
  452.     // to subtract 1 (and our parser already made sure m_month is
  453.     // greater than 0 and less than 13):
  454.     ourtime.tm_mon = m_month - 1;
  455.     ourtime.tm_year = m_year - 1900;
  456. }
  457. else
  458. {
  459.     time_t thetime;
  460.     time(&thetime);
  461.     struct tm* cur;
  462.     cur = localtime(&thetime);
  463.     ourtime.tm_mday = cur->tm_mday;
  464.     ourtime.tm_mon = cur->tm_mon;
  465.     ourtime.tm_year = cur->tm_year;
  466.     ourtime.tm_isdst = cur->tm_isdst;
  467. }
  469. time_t thisTime = mktime(&ourtime);
  471. double diff = 0.0;
  472. if (m_bRelativeToUTC)
  473. {
  474. //XXXJHUG need a crossplatform way to get the timezone offset.
  475. #ifdef _WIN32
  476.     diff = difftime(thisTime + _timezone, tRefTime + m_UTCOffsetMin);
  477. #else
  478.     diff = difftime(thisTime, tRefTime + m_UTCOffsetMin);
  479. #endif
  480. }
  481. else
  482. {
  483.     diff = difftime(thisTime, tRefTime);
  484. }
  486.         double dDiffMS  = diff * 1000.0;
  487.         double dMaxDiff = (double) 0x7FFFFFFF;
  488.         double dMinDiff = -dMaxDiff; 
  490.         // Clip at the min and max 
  491.         if (dDiffMS > dMaxDiff)
  492.         {
  493.             dDiffMS = dMaxDiff - 10;
  494.         }
  495.         else if (dDiffMS < dMinDiff)
  496.         {
  497.             dDiffMS = dMinDiff +10;
  498.         }
  500.         // Now convert to INT32
  501.         m_lOffset = (INT32) dDiffMS;
  502. m_lOriginalOffset = m_lOffset;
  503.     }
  505.     return ret;
  506. }
  508. HX_RESULT
  509. SmilTimeValue::parseOffset(const char* pCh)
  510. {
  511.     HX_RESULT pnretval = HXR_OK;
  512.     // eat whitespace
  513.     while (*pCh && isspace(*pCh))
  514.     {
  515. ++pCh;
  516.     }
  518.     if (*pCh == '-')
  519.     {
  520. // /Eat any whitespace following the '-'
  521. do
  522. {
  523.     ++pCh;
  524. } while (*pCh  &&  isspace(*pCh));
  525. UINT32 clockTime = 0;
  526. pnretval = parseClockValue(pCh, clockTime);
  527. m_lOffset = -(INT32)clockTime;
  528.     }
  529.     else if (*pCh == '+')
  530.     {
  531. // /Eat any whitespace following the '+'
  532. do
  533. {
  534.     ++pCh;
  535. } while (*pCh  &&  isspace(*pCh));
  536. UINT32 clockTime = 0;
  537. pnretval = parseClockValue(pCh, clockTime);
  538. m_lOffset = (INT32)clockTime;
  539.     }
  540.     else
  541.     {
  542. UINT32 clockTime = 0;
  543. pnretval = parseClockValue(pCh, clockTime);
  544. m_lOffset = (INT32)clockTime;
  545.     }
  546.     m_lOriginalOffset = m_lOffset;
  548.     return pnretval;
  549. }
  551. HX_RESULT
  552. SmilTimeValue::parseClockValue(const char* pValue, 
  553.        UINT32& ulTimeValue)
  554. {
  555.     if (!pValue  ||  strlen(pValue) < 1)
  556.     {
  557. return HXR_FAILED;
  558.     }
  559.     // try npt
  560.     char* pPtr = (char *)strstr(pValue, "npt=");
  561.     if(pPtr)
  562.     {
  563. pPtr += 4;  // point to beginning of clock value
  564. NPTime clockTime(pPtr);
  565. ulTimeValue = (UINT32)clockTime;
  566. return HXR_OK;
  567.     }
  568.     // try smpte
  569.     pPtr = (char *)strstr(pValue, "smpte=");
  570.     if(pPtr)
  571.     {
  572. pPtr += 6;  // point to beginning of clock value
  573. SMPTETimeCode clockTime(pPtr);
  574. ulTimeValue = (UINT32)clockTime;
  575. return HXR_OK;
  576.     }
  577.     pPtr = (char *)strstr(pValue, "smpte-30-drop=");
  578.     if(pPtr)
  579.     {
  580. pPtr += 14;  // point to beginning of clock value
  581. SMPTETimeCode clockTime(pPtr);
  582. ulTimeValue = (UINT32)clockTime;
  583. return HXR_OK;
  584.     }
  585.     pPtr = (char *)strstr(pValue, "smpte-25=");
  586.     if(pPtr)
  587.     {
  588. pPtr += 9;  // point to beginning of clock value
  589. SMPTETimeCode clockTime;
  590.         clockTime.m_framesPerSec = SMPTETimeCode::FPS_25;
  591.         clockTime.fromString(pPtr);
  592. ulTimeValue = (UINT32)clockTime;
  593. return HXR_OK;
  594.     }
  595.     else
  596.     {
  597. BOOL bAllow_h_min_s_ms_units = TRUE;
  598. BOOL bSucceeded = FALSE;
  599. // /First, get rid of trailing spaces:
  600. UINT32 ulStrlen = (UINT32)strlen(pValue);
  601. char* pEnd = (char*)(&pValue[ulStrlen-1]);
  602. while (isspace(*pEnd)  &&  pEnd>pValue)
  603. {
  604.     pEnd--;
  605. }
  606. pEnd[1] = '';
  607. // /This first tries just hh:mm:ss with no prefix/suffix
  608. // and then tries suffixes: {"h" | "min" | "s" | "ms"} with
  609. // the default (no ":" inside and no prefix or suffix) being
  610. // in seconds per the SMIL 1.0 spec ([SMIL 1.0 compliance]
  611. // Fixes PR 22673):
  612. NPTime clockTime(pValue, bAllow_h_min_s_ms_units, bSucceeded);
  613. if (bSucceeded)
  614. {
  615.     ulTimeValue = (UINT32)clockTime;
  616.     return HXR_OK;
  617. }
  618.     }
  620.     return HXR_FAIL;
  621. }
  624. HX_RESULT
  625. SmilTimeValue::parseEvent(const char* pBase, const char* pEvent, 
  626.   const char* pOffset)
  627. {
  628.     HX_RESULT rslt = HXR_OK;
  630.     m_type = SmilTimeEvent;
  631.     UINT32 ulLen = 0;
  632.     if (pBase)
  633.     {
  634. ulLen = strlen(pBase);
  635. m_idRef = pBase;
  636.     }
  637.     
  638.     if( !pEvent  ||  !strlen(pEvent))
  639.     {
  640. // /XXXEH- not sure why we'd ever get this state so put assert here
  641. // to check it out:
  642. HX_ASSERT(pEvent  &&  strlen(pEvent));
  643. m_pEventName = NULL;
  644. rslt = HXR_UNEXPECTED; // /XXXEH- at least I *think* it's unexpected.
  645.     }
  646.     else
  647.     {
  648. // /Handle "foo.xyz" as meaning the "xyz" event that may have the
  649. // same name as a sync-arc, e.g., "foo.begin".  Treat them as
  650. // events that get resolved when the m_idRef element (renderer)
  651. // fires off a an event with the matching name:
  652. if ('\' == *pEvent  &&  strlen(pEvent)>=2)
  653. {
  654.     // /Add -1 for removing the  '', +1 for the terminating '':
  655.     m_pEventName = new char[strlen(pEvent)-1 + 1];
  656.     if (m_pEventName)
  657.     {
  658. strcpy(m_pEventName, &pEvent[1]); /* Flawfinder: ignore */
  659.     }
  660.     else
  661.     {
  662. rslt = HXR_OUTOFMEMORY;
  663.     }
  664. }
  665. else
  666. {
  667.     m_pEventName = new char[strlen(pEvent)+1];
  668.     if (m_pEventName)
  669.     {
  670. strcpy(m_pEventName, pEvent); /* Flawfinder: ignore */
  671.     }
  672.     else
  673.     {
  674. rslt = HXR_OUTOFMEMORY;
  675.     }
  676. }
  677.     }
  679.     if (SUCCEEDED(rslt)  &&  pOffset && *pOffset)
  680.     {
  681. parseOffset(pOffset);
  682.     }
  683.     return rslt;
  684. }
  686. HX_RESULT
  687. SmilTimeValue::parseSyncBase(const char* pBase, const char* pCommand, 
  688.      const char* pOffset)
  689. {
  690.     m_type = SmilTimeSyncBase;
  691.     UINT32 ulLen = strlen(pBase);
  692.     if (pBase  &&  pCommand)
  693.     {
  694. m_idRef = pBase;
  695.     }
  696.     else
  697.     {
  698. HX_ASSERT(FALSE);
  699. return HXR_FAIL;
  700.     }
  702.     BOOL bTimeValueOK = FALSE;
  703.     BOOL bRepeatValueParsed = FALSE;
  704.     if (strncmp(pCommand, "begin", 5) == 0)
  705.     {
  706. m_position = SMILEventSourceBegin;
  707. bTimeValueOK = TRUE;
  708.     }
  709.     else if (strncmp(pCommand, "end", 3) == 0)
  710.     {
  711. m_position = SMILEventSourceEnd;
  712. bTimeValueOK = TRUE;
  713.     }
  714. #if defined(XXXEH_REPEAT_VALUE_TIMING_SHOULD_BE_EVENT_BASED)
  715. #else
  716.     else if (strncmp(pCommand, "repeat(", 7) == 0)
  717.     {
  718. bRepeatValueParsed = TRUE;
  719. INT32 strlenCommand = strlen(pCommand);
  720. if (strlenCommand >= 9  &&  ')' == pCommand[strlenCommand-1])
  721. {
  722.     m_position = SMILEventSourceBegin;
  723.     char* pTmp = (char*)&pCommand[7];
  724.     // /Make sure that every character inside the () is a number:
  725.     while (*pTmp  &&  ')' != *pTmp  &&  '0'<=*pTmp  &&  '9'>=*pTmp)
  726.     {
  727. pTmp++;
  728.     }
  729.     if (pTmp == (char*)&pCommand[strlenCommand-1])
  730.     {
  731. INT32 lNum = (INT32)atoi(&pCommand[7]);
  732. // /0 or negative repeat iterations are not allowed, even
  733. // though repeat(0) *could* have been interpreted as the
  734. // first play of foo (prior to it repeating), but wasn't:
  735. if (lNum > 0)
  736. {
  737.     *pTmp = '';
  738.     m_idRef += "_repeat_copy_";
  739.     m_idRef += &pCommand[7];
  740.     *pTmp = ')'; // /restore it.
  741.     m_uRepeatIteration = (UINT16)lNum;
  742.     bTimeValueOK = TRUE;
  743. }
  744.     }
  745. }
  746.     }
  747. #endif
  748.     if (!bTimeValueOK)
  749.     {
  750. if (!bRepeatValueParsed)
  751. {
  752.     HX_ASSERT(FALSE);
  753. }
  754. CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  755. errHandler.ReportError(SMILErrorBadTimeValue, pCommand, 
  756.     m_ulStartLine);
  757. return HXR_FAIL;
  758.     }
  760.     if (pOffset)
  761.     {
  762. parseOffset(pOffset);
  763.     }
  765.     return HXR_OK;
  766. }
  768. HX_RESULT SmilTimeValue::parseMarker(const char* pBase, const char* pMarker, const char* pOffset)
  769. {
  770.     HX_RESULT retVal = HXR_FAIL;
  772.     if (pBase && pMarker)
  773.     {
  774.         // Set the type
  775.         m_type = SmilTimeMediaMarker;
  776.         // Set the base
  777.         m_idRef = pBase;
  778.         // Set the offset (if we have one)
  779.         if (pOffset)
  780.         {
  781.             parseOffset(pOffset);
  782.         }
  783.         // Move past the "marker.(", which we already
  784.         // checked for before we were called
  785.         pMarker += 7;
  786.         // Allocate space for our string
  787.         HX_VECTOR_DELETE(m_pszMarkerName);
  788.         m_pszMarkerName = new char [strlen(pMarker) + 1];
  789.         if (m_pszMarkerName)
  790.         {
  791.             // Look for the end of the marker name
  792.             char* pEnd = (char *)strchr(pMarker, ')');
  793.             if (pEnd)
  794.             {
  795.                 // Copy the full marker name - might or
  796.                 // might not contain an external file reference
  797.                 strncpy(m_pszMarkerName, pMarker, pEnd - pMarker); /* Flawfinder: ignore */
  798.                 m_pszMarkerName[pEnd - pMarker] = '';
  799.                 // Now parse to see if there is an external file reference
  800.                 CHXString cMarker;
  801.                 CHXString cExtFileName;
  802.                 BOOL      bIsExternalMarker = m_bIsExternalMarker;
  803.                 retVal = CSmilParser::parseMarkerURI(m_pszMarkerName,
  804.                                                      cMarker,
  805.                                                      bIsExternalMarker,
  806.                                                      cExtFileName);
  807.                 m_bIsExternalMarker = bIsExternalMarker;
  808.                 if (SUCCEEDED(retVal) && m_bIsExternalMarker)
  809.                 {
  810.                     // Set the flag in the element that this
  811.                     // element references an external media marker file
  812.                     m_pElement->m_bUsesExternalMediaMarkerFile = TRUE;
  813.                     // We just need to copy the marker string and
  814.                     // the external file name string into our members
  815.                     HX_VECTOR_DELETE(m_pszExternalMarkerFileName);
  816.                     m_pszExternalMarkerFileName = new char [cExtFileName.GetLength() + 1];
  817.                     if (m_pszExternalMarkerFileName)
  818.                     {
  819.                         strcpy(m_pszExternalMarkerFileName, (const char*) cExtFileName); /* Flawfinder: ignore */
  820.                         HX_VECTOR_DELETE(m_pszExternalMarkerName);
  821.                         m_pszExternalMarkerName = new char [cMarker.GetLength() + 1];
  822.                         if (m_pszExternalMarkerName)
  823.                         {
  824.                             strcpy(m_pszExternalMarkerName, (const char*) cMarker); /* Flawfinder: ignore */
  825.                         }
  826.                         else
  827.                         {
  828.                             retVal = HXR_OUTOFMEMORY;
  829.                         }
  830.                     }
  831.                     else
  832.                     {
  833.                         retVal = HXR_OUTOFMEMORY;
  834.                     }
  835.                 }
  836.             }
  837.         }
  838.     }
  840.     if (FAILED(retVal))
  841.     {
  842. HX_ASSERT(FALSE);
  843. CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  844. errHandler.ReportError(SMILErrorBadTimeValue, pMarker, m_ulStartLine);
  845.     }
  847.     return retVal;
  848. }
  851. #if defined(ENABLE_SYNC_TO_PREV)
  852. HX_RESULT
  853. SmilTimeValue::parseSyncToPrev(REF(const char*) pCh)
  854. {
  855.     HX_RESULT ret = HXR_OK;
  856.     // move past "prev."
  857.     pCh += 5;
  858.     m_type = SmilTimeSyncToPrev;
  859.     if (strncmp(pCh, "begin", 5) == 0)
  860.     {
  861. m_position = SMILEventSourceBegin;
  862. pCh += 5;
  863.     }
  864.     else if (strncmp(pCh, "end", 3) == 0)
  865.     {
  866. m_position = SMILEventSourceEnd;
  867. pCh += 3;
  868.     }
  869.     else
  870.     {
  871. HX_ASSERT(FALSE);
  872. CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  873. errHandler.ReportError(SMILErrorBadTimeValue, pCh, 
  874.     m_ulStartLine);
  875. return HXR_FAIL;
  876.     }
  878.     // eat white space
  879.     while (*pCh && isspace(*pCh))
  880.     {
  881. ++pCh;
  882.     }
  884.     if (*pCh == '+' || *pCh == '-')
  885.     {
  886. ret = parseOffset(pCh);
  887.     }
  888.     
  889.     return ret;
  890. }
  891. #endif
  894. HX_RESULT
  895. SmilTimeValue::parseWallClockValue(REF(const char*) pCh)
  896. {
  897.     HX_RESULT ret = HXR_OK;
  898.     m_type = SmilTimeWallclock;
  899.     m_bTimeIsResolved = TRUE;
  900.     // move past "wallclock("
  901.     pCh += 10;
  903.     // eat whitespace.
  904.     while (*pCh && isspace(*pCh))
  905.     {
  906. ++pCh;
  907.     }
  909.     // find the end ')'
  911.     const char* begin = pCh;
  912.     const char* end = NULL;
  913.     const char* pT = NULL;
  914.     const char* pTimeZone = NULL;
  915.     const char* pTimePos = NULL;
  916.     const char* pDatePos = NULL;
  918.     INT32 year = -1;
  919.     INT32 month = -1;
  920.     INT32 day = -1;
  922.     INT32 hour = 0;
  923.     INT32 min = 0;
  924.     INT32 sec = 0;
  925.     INT32 ms = 0;
  927.     char buf[10]; /* Flawfinder: ignore */
  928.     
  929.     // store offset in min.
  930.     INT32 UTCOffset = 0;
  932.     while (*pCh)
  933.     {
  934. if (*pCh == ')')
  935. {
  936.     end = pCh;
  937. }
  938. else if (*pCh == 'T')
  939. {
  940.     pT = pCh;
  941. }
  942. else if (isspace(*pCh) || *pCh == '+' || *pCh == '-' || *pCh == 'Z')
  943. {
  944.     // this will find the last +, - or Z... which is what we want.
  945.     pTimeZone = pCh;
  946. }
  947. else if (!isdigit(*pCh) && *pCh != ':' && *pCh != '-' && *pCh != '.')
  948. {
  949.     ret = HXR_FAIL;
  951. }
  952. ++pCh;
  953.     }
  955.     if (FAILED(ret))
  956.     {
  957. CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  958. errHandler.ReportError(SMILErrorBadWallClockValue, begin, 
  959.     m_ulStartLine);
  960. goto cleanup;
  961.     }
  963.     // check for a 'T'
  964.     if (pT)
  965.     {
  966. //YYYY-MM-DDT
  967. if (*(begin+4) == '-' && *(begin+7) == '-' && pT == (begin+10))
  968. {
  969.     pDatePos = begin;
  970.     if (pTimeZone < begin+10)
  971.     {
  972. pTimeZone = NULL;
  973.     }
  974. }
  975. else
  976. {
  977.     ret = HXR_FAIL;
  978.     CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  979.     errHandler.ReportError(SMILErrorBadWallClockValue, begin, 
  980. m_ulStartLine);
  981.     goto cleanup;
  982. }
  984. if (*(pT+3) == ':')
  985. {
  986.     pTimePos = pT+1;
  987. }
  988. else
  989. {
  990.     ret = HXR_FAIL;
  991.     CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  992.     errHandler.ReportError(SMILErrorBadWallClockValue, begin, 
  993. m_ulStartLine);
  994.     goto cleanup;
  995. }
  996.     }
  997.     // else just the date or time.
  998.     //YYYY-MM-DDT
  999.     else if (*(begin+4) == '-' && *(begin+7) == '-' && pT == (begin+10))
  1000.     {
  1001. // just date
  1002. // there is a date.
  1003. pDatePos = begin;
  1004. if (pTimeZone < begin+10)
  1005. {
  1006.     pTimeZone = NULL;
  1007. }
  1008.     }
  1009.     else if (*(begin+2) == ':')
  1010.     {
  1011. pTimePos = begin;
  1012.     }
  1013.     else
  1014.     {
  1015. ret = HXR_FAIL;
  1016. CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  1017. errHandler.ReportError(SMILErrorBadWallClockValue, begin, 
  1018.     m_ulStartLine);
  1019. goto cleanup;
  1020.     }
  1022.     // there is a date.
  1023.     if (pDatePos)
  1024.     {
  1025. //YYYY-MM-DDT
  1026. const char* pos = pDatePos;
  1027. strncpy(buf, pos, 4); /* Flawfinder: ignore */
  1028. buf[4] = '';
  1029. pos += 5;
  1030. year = HX_SAFEINT(strtol(buf, 0, 10));
  1031. if (year < 0 || year > 9999)
  1032. {
  1033.     ret = HXR_FAIL;
  1034.     CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  1035.     errHandler.ReportError(SMILErrorBadWallClockValue, pDatePos, 
  1036. m_ulStartLine);
  1037.     goto cleanup;
  1038. }
  1040. strncpy(buf, pos, 2); /* Flawfinder: ignore */
  1041. buf[2] = '';
  1042. pos += 3;
  1043. month = HX_SAFEINT(strtol(buf, 0, 10));
  1044. // /month can't be 0 or less or greater than 12 (i.e., it's
  1045. // 1-based):
  1046. if (month < 1 || month > 12)
  1047. {
  1048.     ret = HXR_FAIL;
  1049.     CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  1050.     errHandler.ReportError(SMILErrorBadWallClockValue, pDatePos, 
  1051. m_ulStartLine);
  1052.     goto cleanup;
  1053. }
  1056. strncpy(buf, pos, 2); /* Flawfinder: ignore */
  1057. buf[2] = '';
  1058. pos += 3;
  1059. day = HX_SAFEINT(strtol(buf, 0, 10));
  1060. if (day < 0 || day > 31)
  1061. {
  1062.     ret = HXR_FAIL;
  1063.     CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  1064.     errHandler.ReportError(SMILErrorBadWallClockValue, pDatePos, 
  1065. m_ulStartLine);
  1066.     goto cleanup;
  1067. }
  1069.     }
  1071.     if (pTimePos)
  1072.     {
  1073.     //HH:MM...
  1074. const char* pos = pTimePos;
  1075. strncpy(buf, pos, 2); /* Flawfinder: ignore */
  1076. buf[2] = '';
  1077. pos += 3;
  1078. hour = HX_SAFEINT(strtol(buf, 0, 10));
  1079. if (hour < 0 || hour > 24)
  1080. {
  1081.     ret = HXR_FAIL;
  1082.     CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  1083.     errHandler.ReportError(SMILErrorBadWallClockValue, pTimePos, 
  1084. m_ulStartLine);
  1085.     goto cleanup;
  1086. }
  1088. // just time
  1090. strncpy(buf, pos, 2); /* Flawfinder: ignore */
  1091. buf[2] = '';
  1092. pos += 3;
  1093. min = HX_SAFEINT(strtol(buf, 0, 10));
  1094. if (min < 0 || min > 59)
  1095. {
  1096.     ret = HXR_FAIL;
  1097.     CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  1098.     errHandler.ReportError(SMILErrorBadWallClockValue, pTimePos, 
  1099. m_ulStartLine);
  1100.     goto cleanup;
  1101. }
  1103. if (*(pos-1) == ':')
  1104. {
  1105.     strncpy(buf, pos, 2); /* Flawfinder: ignore */
  1106.     buf[2] = '';
  1107.     pos +=3;
  1108.     sec = HX_SAFEINT(strtol(buf, 0, 10));
  1109.     if (sec < 0 || sec > 59)
  1110.     {
  1111. ret = HXR_FAIL;
  1112. CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  1113. errHandler.ReportError(SMILErrorBadWallClockValue, pTimePos, 
  1114.     m_ulStartLine);
  1115. goto cleanup;
  1116.     }
  1118.     if (*(pos-1) == '.')
  1119.     {
  1120. // find end.
  1121. UINT32 len = 0;
  1122. if (pTimeZone)
  1123. {
  1124.     len = pTimeZone - pos;
  1125. }
  1126. else
  1127. {
  1128.     len = end - pos;
  1129. }
  1130. strncpy(buf, pos, len); /* Flawfinder: ignore */
  1131. buf[len] = '';
  1132. pos += len;
  1133. if (*buf)
  1134. {
  1135.     if (isdigit(*buf))
  1136.     {
  1137. ms = (*buf - '0') * 100;
  1138. if (isdigit(*(buf+1)))
  1139. {
  1140.     ms += (*buf - '0') * 10;
  1141.     if (isdigit(*(buf+2)))
  1142.     {
  1143. ms += (*buf - '0');
  1144.     }
  1145. }
  1146.     }
  1147.     else
  1148.     {
  1149. ret = HXR_FAIL;
  1150. CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  1151. errHandler.ReportError(SMILErrorBadWallClockValue, pTimePos, 
  1152.     m_ulStartLine);
  1153. goto cleanup;
  1154.     }
  1155. }
  1156.     }
  1157. }
  1158.     }
  1160.     if (pTimeZone)
  1161.     {
  1162. BOOL bSyntaxOK = FALSE;
  1163. const char* begin = pTimeZone;
  1165. if (*pTimeZone == 'Z')
  1166. {
  1167.     m_bRelativeToUTC = TRUE;
  1168.     UTCOffset = 0;
  1169.     bSyntaxOK = TRUE;
  1170. }
  1171. else if ((*pTimeZone == '+' || *pTimeZone == '-') && *(pTimeZone+3) == ':')
  1172. {
  1173.     m_bRelativeToUTC = TRUE;
  1174.     int sign = 1;
  1175.     if (*pTimeZone == '-')
  1176.     {
  1177. ++pTimeZone;
  1178. sign = -1;
  1179.     }
  1180.     else if (*pTimeZone == '+')
  1181.     {
  1182. ++pTimeZone;
  1183.     }
  1184.     strncpy(buf, pTimeZone, 2); /* Flawfinder: ignore */
  1185.     buf[2] = '';
  1186.     pTimeZone += 3;
  1187.     INT32 hour = HX_SAFEINT(strtol(buf, 0, 10));
  1188.     if (hour < 0 || hour > 12)
  1189.     {
  1190. ret = HXR_FAIL;
  1191. CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  1192. errHandler.ReportError(SMILErrorBadWallClockValue, begin, 
  1193.     m_ulStartLine);
  1194. goto cleanup;
  1195.     }
  1196.     UTCOffset = hour * 60;
  1198.     strncpy(buf, pTimeZone, 2); /* Flawfinder: ignore */
  1199.     buf[2] = '';
  1200.     pTimeZone += 3;
  1202.     INT32 min = HX_SAFEINT(strtol(buf, 0, 10));
  1203.     if (min < 0 || min > 59)
  1204.     {
  1205. ret = HXR_FAIL;
  1206. CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  1207. errHandler.ReportError(SMILErrorBadWallClockValue, begin, 
  1208.     m_ulStartLine);
  1209. goto cleanup;
  1210.     }
  1211.     UTCOffset += min;
  1212.     UTCOffset *= sign;
  1213.     bSyntaxOK = TRUE;
  1214. }
  1215. else if (isspace(*pTimeZone))
  1216. {
  1217.     bSyntaxOK = TRUE;
  1218.     do
  1219.     {
  1220. *pTimeZone++;
  1221. if (!(*pTimeZone)  ||  ')' == *pTimeZone)
  1222. {
  1223.     break;
  1224. }
  1225. if (!isspace(*pTimeZone))
  1226. {
  1227.     bSyntaxOK = FALSE;
  1228.     break;
  1229. }
  1230.     } while (*pTimeZone);
  1231. }
  1233. if (!bSyntaxOK)
  1234. {
  1235.     ret = HXR_FAIL;
  1236.     CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
  1237.     errHandler.ReportError(SMILErrorBadWallClockValue, begin, 
  1238. m_ulStartLine);
  1239.     goto cleanup;
  1240. }
  1241.     }
  1242.     // else use the -1 value.
  1244.     m_UTCOffsetMin = (INT16)UTCOffset;
  1245.     m_ms = (UINT16)ms;
  1246.     m_sec = (UINT8)sec;
  1247.     m_min = (UINT8)min;
  1248.     m_hour = (UINT8)hour;
  1249.     m_day = (INT8)day;
  1250.     m_month = (INT8)month;
  1251.     m_year = (INT16)year;
  1253. cleanup:
  1254.     if (SUCCEEDED(ret))
  1255.     {
  1256. m_bTimeIsResolved = TRUE;
  1257.     }
  1259.     return ret;
  1260. }
  1262. void SmilTimeValue::setIsTimeResolved(BOOL bIsResolved)
  1263. {
  1264.     m_bTimeIsResolved = bIsResolved;
  1265. }
  1267. HX_RESULT
  1268. SmilTimeValue::setPauseTime(LONG32 lTimeOfPause)
  1269. {
  1270.     HX_RESULT pnr = HXR_OK;
  1271.     if (!isResumeEvent())
  1272.     {
  1273. pnr = HXR_UNEXPECTED;
  1274.     }
  1275.     else
  1276.     {
  1277. m_lTimeOfPause = lTimeOfPause;
  1278.     }
  1280.     return pnr;
  1281. }
  1285. BOOL
  1286. SmilTimeValue::isSameTimeValue(SmilTimeValue* pOtherTimeVal)
  1287. {
  1288.     BOOL bIsSame = FALSE;
  1290.     // /Using this fixes freeze-up in use of strcmp(NULL,...) [PR 65817]
  1291.     // found while fixing Interop Timing #18.37 which has begin="0s;7s" :
  1292.     BOOL bHasSameEventNameOrBothHaveNoEventName = 
  1293.     (NULL == m_pEventName  &&  NULL == pOtherTimeVal->m_pEventName);
  1294.     if (!bHasSameEventNameOrBothHaveNoEventName)
  1295.     {
  1296. if (NULL != m_pEventName  &&  NULL != pOtherTimeVal->m_pEventName)
  1297. {
  1298.     bHasSameEventNameOrBothHaveNoEventName =
  1299.     !strcmp(m_pEventName, pOtherTimeVal->m_pEventName);
  1300. }
  1301.     }
  1303.     // /Now compare type, timing, event name, ...etc:
  1304.     if (pOtherTimeVal == this)
  1305.     {
  1306. bIsSame = TRUE;
  1307.     }
  1308.     else if (pOtherTimeVal  &&
  1309.     m_pElement == pOtherTimeVal->m_pElement  &&
  1310.     m_type == pOtherTimeVal->m_type  &&
  1311.     m_position == pOtherTimeVal->m_position  &&
  1312.     m_uRepeatIteration == pOtherTimeVal->m_uRepeatIteration  &&
  1313.     m_pszMarkerName == pOtherTimeVal->m_pszMarkerName  &&
  1314.     bHasSameEventNameOrBothHaveNoEventName  &&
  1315.     m_lOffset == pOtherTimeVal->m_lOffset  &&
  1316.     m_bTimeIsResolved == pOtherTimeVal->m_bTimeIsResolved)
  1317.     {
  1318. // /Note: if time isn't resolved, we don't care if times are same:
  1319. if (m_bTimeIsResolved  &&
  1320. m_lResolvedToTime  == pOtherTimeVal->m_lResolvedToTime)
  1321. {
  1322.     bIsSame = TRUE;
  1323. }
  1324. else
  1325. {
  1326.     switch (m_type)
  1327.     {
  1328. case SmilTimeOffset:
  1329. case SmilTimeClockValue:
  1330. case SmilTimeWallclock:
  1331. case SmilTimeNone:
  1332. {
  1333.     bIsSame = TRUE;
  1334. }
  1335. break;
  1337. case SmilTimeSyncBase:
  1338. #if defined(ENABLE_SYNC_TO_PREV)
  1339. case SmilTimeSyncToPrev:
  1340. #endif
  1341. case SmilTimeMediaMarker:
  1342. case SmilTimeEvent:
  1343. {
  1344.     HX_ASSERT(m_idRef.GetLength());
  1345.     HX_ASSERT(pOtherTimeVal->m_idRef.GetLength());
  1346.     bIsSame = !strcmp(m_idRef, pOtherTimeVal->m_idRef);
  1347. }
  1348. break;
  1349.     }
  1350. }
  1351.     }
  1353.     return bIsSame;
  1354. }
  1357. BOOL
  1358. SmilTimeValue::deferUntil(LONG32 lNewStartTime)
  1359. {
  1360.     BOOL bSucceeded = FALSE;
  1362.     if (m_bTimeIsResolved  &&  m_lResolvedToTime < lNewStartTime)
  1363.     {
  1364. // /XXXEH- TODO: determine if it's necessary to have a separate
  1365. // variable that keeps track of the deferred amount, and that is
  1366. // reset to 0 if and when this time is used to begin the element.
  1367. // This might be needed if this SmilTimeValue gets reused due to
  1368. // a repeat, seek, or ???
  1369. switch (m_type)
  1370. {
  1371.     case SmilTimeWallclock:
  1372.     case SmilTimeClockValue:
  1373.     case SmilTimeOffset:
  1374.     {
  1375. // /Fixes PR 55936.  Add the amount deferred by to the
  1376. // offset instead of just setting offset to newStartTime:
  1377. m_lOffset += (lNewStartTime - m_lResolvedToTime);
  1378. bSucceeded = TRUE;
  1379.     }
  1380.     break;
  1382.     case SmilTimeSyncBase:
  1383. #if defined(ENABLE_SYNC_TO_PREV)
  1384.     case SmilTimeSyncToPrev:
  1385. #endif
  1386.     case SmilTimeMediaMarker:
  1387.     case SmilTimeEvent:
  1388.     {
  1389. m_lResolvedToTime = lNewStartTime;
  1390. bSucceeded = TRUE;
  1391.     }
  1392.     break;
  1394.     default:
  1395. HX_ASSERT(0);
  1396.     break;
  1397. }
  1398.     }
  1400.     return (bSucceeded);
  1401. }
  1403. void SmilTimeValue::setMarkerTime(UINT32 ulTime)
  1404. {
  1405.     // Only do this if either we aren't resolved
  1406.     if (!m_bTimeIsResolved && m_type == SmilTimeMediaMarker)
  1407.     {
  1408.         // Save our marker time
  1409.         m_ulMarkerTime = ulTime;
  1410.         // This time is an offset from the beginning
  1411.         // of the media. We need to add this offset to
  1412.         // any previously existing offset
  1413.         m_lOffset += (INT32) ulTime;
  1414.         // Convert ourselves to a syncbase and
  1415.         // set the flag which will tell us that
  1416.         // we used to be a media marker.
  1417.         m_type = SmilTimeSyncBase;
  1418.         m_bUsedToBeMediaMarker = TRUE;
  1419.         // By definition we are an offset from the beginning
  1420.         // of the media
  1421.         m_position = SMILEventSourceBegin;
  1422.         // Set the flag saying we are resolved
  1423.         m_bTimeIsResolved = TRUE;
  1424.     }
  1425. }