smlparse.h

linux下的一款播放器

public:
    CSmilParser(IUnknown* pContext);
    virtual ~CSmilParser();

    HX_RESULT            init(BOOL bStoreErrors = FALSE);
    HX_RESULT            parse(IHXBuffer* pBuffer, BOOL bIsFinal);
    HX_RESULT            parse(const char* pSmilText);
#if defined(HELIX_FEATURE_SMIL2_VALIDATION)
    HX_RESULT            validateContentModel(UINT32 ulElement, SMILNodeList* pChildren);
    HX_RESULT            validateNode(SMILNode* pNode);
    HX_RESULT            validateCDATA(const char* pszStr) const;
    HX_RESULT            validateIDREF(const char* pszStr) const;
    HX_RESULT            validateNMTOKEN(const char* pszStr) const;
    HX_RESULT            validateEnumerated(UINT32 ulElem, UINT32 ulAttr, const char* pszStr);
    BOOL                 isXMLLetter(char c) const;
    BOOL                 isXMLDigit(char c) const;
    BOOL                 isXMLNameChar(char c) const;
    BOOL                 isNamespacePrefixed(const char* pszStr);
    HX_RESULT            normalizeAttribute(const char* pszStr,
                                            BOOL        bIsCDATA,
                                            REF(char*)  rpszNormal);
    HX_RESULT            validateAttribute(UINT32 ulElement, UINT32 ulAttrib,
                                           const char* pszStr, REF(char*) rpszNormStr);
    HX_RESULT            validateElementName(SMILNode* pNode);
    HX_RESULT            setupValidationNamespaces(SMILNode* pNode);
    HX_RESULT            validateAgainstDTD();
    HX_RESULT            checkExtensionElementNamespace(SMIL2Element eElem,
                                                        SupportedNamespace eNS);
    HX_RESULT            checkExtensionAttributeNamespace(SMIL2Attribute eAttr,
                                                          SupportedNamespace eNS);
#endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
    CNamespaceInfo*      getNamespaceInfo(const char* pszStr, REF(const char*) rpszAttr);
    HX_RESULT            createElements();
    HX_RESULT            durationResolved(const char* pID, UINT32 ulDuration,
                                          BOOL bSetByParent=FALSE,
                                          BOOL bDurationExtendingDueToPause=FALSE);
    HX_RESULT            trackRemoved(const char* pID, UINT32 ulDuration);
    HX_RESULT            adjustForNegativeOffset(const char* pID);
    void                 insertTimelineElement(const char* pID, UINT32 ulDelay);
    void                 resetTimelineElementDuration(const char* pID,
                                                      UINT32 ulDuration,
                                                      UINT32 ulPriorDuration);
    void                 resetTimelineElementDelay(const char* pID, UINT32 ulDelay,
                                                   UINT32 ulPriorDelay);
    void                 resetTimeline();
    HX_RESULT		 prepForSeek(UINT32 ulOldTime, UINT32 ulNewTime);
    HX_RESULT            handlePrefetchFinished(const char* pID, UINT32 ulTimeFinished);
    UINT16               getFragmentGroup(const char* pFragment);
    UINT32               getFragmentOffset(const char* pFragment,
                                           BOOL& bFragFoundAndResolved,
                                           BOOL bResolveBeginOfFragmentTarget=FALSE,
                                           ULONG32 ulCurTime=0);
    HX_RESULT            handleNextElement(CSmilElementHandler* pHandler);
    HX_RESULT            setAllElementHandlers(CSmilElementHandler* pHandler);
    SMILNode*            findFirstNode(SMILNodeTag tag);
    SMILNode*            getFirstNodeChild(SMILNode* pNode);
    SMILNode*            getPrevNode(SMILNode* pCurrentNode);
    CSmilElement*        findElement(const char* pID);
    SMILNode*            getNextNodeChild();
    SMILNodeTag          getSyncTag(SMILNode* pNode);
    void                 getPacketPending(UINT16 unStreamNumber);
    HX_RESULT            addGlobalNamespace(const char* pNamespace, const char* pPrefix);
    HX_RESULT            storeNamespaces(SMILNode* pNode);
    HX_RESULT            addToNamespaceScope(SMILNode* pNode);
    HX_RESULT            removeFromNamespaceScope(SMILNode* pNode);
    BOOL                 isSupportedNonRNNamespace(const char* pNamespace);
    HX_RESULT            addBeginTimeSyncElement(CSmilElement* pElement);
    HX_RESULT            addEndTimeSyncElement(CSmilElement* pElement);
    HX_RESULT            resolveSyncBaseElements();
    HX_RESULT            handleExclDescendants();
    HX_RESULT            addBeginEventElement(SmilTimeValue* pTimeVal);
    HX_RESULT            tryToResolveBeginEndEvents(const char* pEventName,
                                                    const char* pEventElementId,
                                                    ULONG32     ulEventTime);
    HX_RESULT            addEndEventElement(SmilTimeValue* pTimeVal);
    HX_RESULT            addBeginMediaMarkerSyncElement(SmilTimeValue* pTmpVal);
    HX_RESULT            addEndMediaMarkerSyncElement(SmilTimeValue* pTmpVal);
    HX_RESULT            resolveMediaMarkerTime(const char* pszID,
                                                const char* pszMarkerName,
                                                UINT32      ulMarkerTime,
                                                REF(BOOL)   rbNeedHandleElements);
    HX_RESULT            handlePendingScheduling(INT32 lCurTime,
                                                 INT16 iCurrentGroupIndex,
                                                 REF(BOOL) bSomeScheduleWasChanged,
                                                 /*OUT*/ CHXSimpleList* pPauseDisplayElementHideList,
                                                 /*OUT*/ CHXSimpleList* pPauseDisplayDisableElementList);
    HX_RESULT            checkPendingBeginAndEndTimes(INT32     lCurTime,
                                                      INT16 iCurrentGroupIndex,
                                                      REF(BOOL) bREFSomeScheduleWasChanged,
                                                      INT32     lRecursionCount,
                                                      /*OUT*/ CHXSimpleList* pPauseDisplayElementHideList,
                                                      /*OUT*/ CHXSimpleList* pPauseDisplayDisableElementList,
                                                      BOOL bDoHandleExclBeforePlaybackStarts);
    HX_RESULT            insertElementWithPendingBeginOrEnd(CSmilElement*      pElement,
                                                            INT32              lCurTime,
                                                            SmilTimingListType listType);
    void                 handleAllXMMFReferences();
    CHXMapStringToOb*    findNextPendingOnLoadURL(UINT32 lCurTime);
    BOOL                 hasActivateEventListener(const char* pMediaID,
                                                  INT16 iCurrentGroupIndex);
    const char*          getDefaultNamespace();
    // note -- the pErr array returned has the same scope as the SMILParser 
    // object
    HX_RESULT            getErrors(CHXPtrArray** pErrs);
    SMILNode*            getSyncAncestor(SMILNode* pNode);
    // /NOTE: sync base is not always begin of sync ancestor; in a seq, it's
    // end of prior sibling (if any), so this calculates all that:
    virtual ULONG32      getSyncBaseTimeInGroupTimeCoords(SMILNode* pNode);

    // /Tells whether any node all the way up to the root has specified
    // ancestor tag:
    BOOL                 hasAncestor(SMILNodeTag ancestor, SMILNode* pNode);

    // Added to be able to quickly lookup <anchor> or <area> tags
    // by id and not by the region they map to.
    CSmilAnchorElement*  getAnchorOrAreaElement(const char* pID);
    // XXXMEH - moved this from private to public so that we 
    // could animate the coords attribute. This method is needed
    // to parse the coords attribute.
    HX_RESULT            parseAnchorCoords(const char*         pCoords,
                                           CSmilAnchorElement* pAnchor);
    BOOL                 presentationContainsASource() {return m_bContainsSource; }
    BOOL                 presentationContainsInitiallyScheduledTrack() {
	                    return m_bContainsInitiallyScheduledTrack; }
    ULONG32              presentationDurIfNoInitialTracksScheduled() {
                            return m_ulDurIfNoInitialTracksScheduled; }
    BOOL                 EstablishBeginTimeList();
    BOOL                 EstablishEndTimeList();
    BOOL                 EstablishBeginEventList();
    BOOL                 EstablishEndEventList();
    CHXSimpleList*       GetPendingBeginTimeList() {return m_pPendingBeginTimeList;}
    CHXSimpleList*       GetPendingEndTimeList() {return m_pPendingEndTimeList;}
    CHXSimpleList*       GetBeginEventList() {return m_pBeginEventList;}
    CHXSimpleList*       GetEndEventList()   {return m_pEndEventList;}
    BOOL                 isDuplicateEntry(CHXSimpleList* pList,
                                          SmilTimeValue* pTimeValue);
    HX_RESULT            addResumeEvent(SmilTimeValue* pTimeValue,
                                        REF(BOOL) bOldResumeEventWasRemoved);
    HX_RESULT            addUndeferEvent(SmilTimeValue* pTimeValue,
                                        REF(BOOL) bOldUndeferEventWasRemoved);
    HX_RESULT            addResumeOrUndeferEvent(SmilTimeValue* pTimeValue,
                                        REF(BOOL) bOldSuchEventWasRemoved,
					BOOL bIsResumeEvent);
    HX_RESULT            computeRemoveTime(const char* pszID,
                                           REF(UINT32) rulRemoveTime);
    void                 InitPersistent(UINT32 ulPersistentComponentID, IHXValues* pProperties);
    BOOL                 isTimelineObject(SMILNode* pNode);
    static BOOL          isMediaObject(SMILNode* pNode);
    BOOL                 isNonMediaPlayableObject(SMILNode* pNode);
    BOOL                 isTimeContainerObject(SMILNode* pNode);
    UINT16               getNumGroups() const { return m_usNumGroups; }
    const char*          getEnumAttrString(SMIL2Attribute eAttr, BYTE ucVal);
    void                 setParseError(HX_RESULT rv) { m_lParseError = rv;   }
    HX_RESULT            getParseError() const       { return m_lParseError; }
    BOOL                 isAttributeAnimated(const char* pszElementID,
                                             UINT32      ulAttrName);
    SMIL2Element         getSMIL2Element(const char* pszStr);
    SMIL2Attribute       getSMIL2Attribute(const char* pszStr);
    void                 checkForExternalEvents();
    BOOL                 anyExternalEvents(const char* pszID);
    ExternalEventInfo*   getFirstExternalEvent(const char* pszID);
    ExternalEventInfo*   getNextExternalEvent(const char* pszID);
    void                 checkForEventHandlers();
    AccessErrorBehavior  getAccessErrorBehavior(SMILNode* pNode);
    UINT32               GetUniqueNumber() { return m_ulNextVar++; }

    // CSmilParser static public member methods
    static HX_RESULT     parseRegionDimension(const char*   pszStr,
                                              REF(double)   rdValue,
                                              REF(CSS2Type) reType);
    static HX_RESULT     parseZIndex(const char*   pszStr,
                                     REF(INT32)    rlValue,
                                     REF(CSS2Type) reType);
    static HX_RESULT     parseColor(const char*   pszStr,
                                    REF(UINT32)   rulColor,
                                    REF(CSS2Type) reType);
    static HX_RESULT     parseFit(const char*   pszStr,
                                  REF(Fit)      reValue);
    static HX_RESULT     parseRegAlign(const char*   pszStr,
                                       REF(RegAlign) reValue);
    static HX_RESULT     parseOpacity(const char* pszStr, REF(UINT32) rulOpacity);
    static HX_RESULT     parseFill(const char* pszStr, REF(FillType) reFill);
    static HX_RESULT     getFillString(FillType eFill, REF(CHXString) rcFill);
    static HX_RESULT     getEraseString(EraseType eErase, REF(CHXString) rcErase);
    static HX_RESULT     parseFillDefault(const char* pszStr, REF(FillDefaultType) reFillDefault);
    static HX_RESULT     parseAccelDecel(const char* pszStr, REF(double) rdVal);
#if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
    static HX_RESULT     getDefaultTransitionSubType(const char* pszType, REF(CHXString) rcSubType);
    static BOOL          isLegalTransitionType(const char* pszType);
    static BOOL          isLegalTransitionSubType(const char* pszType, const char* pszSubType);
#endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
    static HX_RESULT     parseMarkerURI(const char*    pszStr,
                                        REF(CHXString) rcMarker,
                                        REF(BOOL)      rbExternal,
                                        REF(CHXString) rcExternalFileName);
    static HX_RESULT     parseHandlerForID(const char*    pszStr,
                                           REF(CHXString) rcHandlerID);
    static HX_RESULT     parseAccessErrorBehavior(const char* pszStr,
                                                  REF(AccessErrorBehavior) reErr);
#if defined(XXXMEH_SPLINE_ANIMATION)
    static HX_RESULT     parseKeyTimes(const char* pszVal, CSmilAnimateElement* pAnim);
    static HX_RESULT     parseKeySplines(const char* pszVal, CSmilAnimateElement* pAnim);
    static HX_RESULT     parseSVGPath(const char* pszVal, CSmilAnimateElement* pAnim);
#endif
    static BOOL          isDataURL(const char* pszURL);
    static HX_RESULT     validateDataURL(const char* pszURL);
    static void          addStringProperty(IHXValues* pValues,
                                           IUnknown*   pContext,
                                           const char* pszName,
                                           const char* pszValue);

    BOOL                 allTracksNeedReflushHint() { return m_bAllTracksNeedReflushHint; }

    // CSmilParser public members    
    CHXStack*     m_pNodeListStack;
    SMILNodeList* m_pNodeList;
    UINT32        m_ulErrorLineNumber;
    UINT32        m_ulErrorColumnNumber;
    IHXBuffer*   m_pErrorText;
    IHXBuffer*   m_pDefaultNamespace;
    UINT32        m_ulPersistentComponentDelay;
    UINT32        m_ulPersistentComponentDuration;
    CSmilTimelineElementManager* m_pTimelineElementManager;
    friend class CSmilParserResponse;
private:
    void                   close();
    void                   initRequireTags();
    void		   GetSystemScreenInfo(REF(UINT32) rulScreenHeight,
					       REF(UINT32) rulScreenWidth,
					       REF(UINT32) rulScreenBitDepth);
    void                   getPreferences();
    HX_RESULT              createHeadElements(SMILNodeList* pNodeList);
    HX_RESULT              createSeqWrapper(SMILNodeList* pNodeList, BOOL bMakeInnerPar);
    HX_RESULT              createBodyElements(SMILNodeList* pNodeList);
    HX_RESULT              createElementForAnchorTarget(CSmilAAnchorElement* pAnchor,
                                                       SMILNodeList* pNodeList);
#if 0  /*XXXEH- I wrote this and then didn't need it but it may come in
         handy later so #if(0) it out: */
    BOOL                   hasNoSourceChildren(SMILNode* pNode);
#endif
    HX_RESULT              assignGroupIndexes(SMILNodeList* pNodeList);
    HX_RESULT              assignGroupIndexOnPar(SMILNode* pNode, UINT16 nGroup);
    HX_RESULT              assignGroupIndexOnSeq(SMILNode* pNode, UINT16& nGroup);
    HX_RESULT              constructTimelineElements(SMILNodeList* pNodeList);
    HX_RESULT              setInitialDelays(SMILNodeList* pNodeList);
    void                   setInitialDelay(SMILNode* pNode);
    void                   setInitialDelayOnSeq(SMILNode* pNode);
    HX_RESULT              expandRepeatElements(SMILNodeList* pNodeList);
    HX_RESULT              printBodyElements(SMILNodeList* pNodeList);
    HX_RESULT              updateEventElements(SMILNodeList* pNodeList);
    HX_RESULT              insertElementByTimestamp(CSmilElement* pElement);
    HX_RESULT              addGroup(SMILNode* pNode);
    HX_RESULT              insertGroups();
    HX_RESULT              mapID(SMILNode* pNode, BOOL bOverWrite = FALSE);
    HX_RESULT              mapChildrenIDs(SMILNodeList* pNodeList, BOOL bOverWrite = FALSE);
    HX_RESULT              markRepeatReplica(SMILNodeList* pNodeList, RepeatTag repeatTag);

    BOOL                   testAttributeFailed(SMILNode* pNode);
    BOOL                   customTestFailed(SMILNode* pNode);
    BOOL                   systemComponentFailed(IHXBuffer* pRequiredValue);
    HX_RESULT              markTestAttributeNodes(SMILNodeList* pNodeList);
    HX_RESULT              selectSwitchNodes(SMILNode* pNode);

    BOOL                   inSeq(SMILNode* pNode);
    HX_RESULT              createParent(SMILNode* pChildNode, SMILNodeTag tag,
                                        SMILNode*& pParent, SMILNode*& pParentEnd);
    void                   resolveTimestamps();
    void                   resolveTimestamps(SMILNodeList* pNodeList);
    UINT32                 getStartTime(SMILNode* pNode);
    CSmilRegion*           makeRegion(SMILNode* pNode);
    CSmilRegPoint*         makeRegPoint(SMILNode* pNode);
#if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
    CSmilViewport*         makeViewport(SMILNode* pNode);
#endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
    CSmilTransition*       makeTransition(SMILNode* pNode, REF(HX_RESULT) retVal);
    CSmilRootLayout*       makeRootLayout(SMILNode* pNode);
    CSmilMeta*             makeMeta(SMILNode* pNode);