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

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

Symbian

开发平台：

Visual C++

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