smlparse.h

linux下的一款播放器

    CSmilMetadata*         makeMetadata(SMILNode* pNode);
    CSmilCustomTest*       makeCustomTest(SMILNode* pNode,
                                    REF(HX_RESULT) retVal);
    CSmilRendererPreFetch* makeRendererPreFetch(SMILNode* pNode);
    CSmilSource*           makeSource(SMILNode* pNode);
    CSmilPriorityClassElement* makePriorityClassElement(SMILNode* pNode);
    CSmilAAnchorElement*   makeAAnchorElement(SMILNode* pNode);
    CSmilAnchorElement*    makeAnchorElement(SMILNode* pNode);
    CSmilSeqElement*       makeSeqElement(SMILNode* pNode);
    CSmilParElement*       makeParElement(SMILNode* pNode);
    CSmilExclElement*      makeExclElement(SMILNode* pNode);
    CSmilParamElement*     makeParamElement(SMILNode* pNode);
    CSmilBodyElement*      makeBodyElement(SMILNode* pNode);
#if defined(HELIX_FEATURE_SMIL2_ANIMATION)
    CSmilAnimateElement*   makeAnimateElement(SMILNode* pNode);
    HX_RESULT              animSetupElement(CSmilAnimateElement* pAnim);
#if defined(XXXMEH_SPLINE_ANIMATION)
    HX_RESULT              checkSplineAnimation(CSmilAnimateElement* pAnim);
    HX_RESULT              makeSVGPathExplicit(CSmilAnimateElement* pAnim);
#endif
    HX_RESULT              animCountValues(const char* pszStr, REF(char*)  rpStr,
                                           REF(UINT32) rulNumValues, REF(char**) rppStr);
    HX_RESULT              animParseValue(CSmilAnimateElement* pAnim,
                                          const char*          pszVal,
                                          UINT32               i);
#endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
    SMILNode*              getSpecificAncestor(SMILNodeTag ancestor, SMILNode* pNode);
    SMILNode*              findAnyActiveDescendant(SMILNode* pNode,
                               LONG32 lCurTime, SMILNode* pButNotThisNode);
    SMILNode*              findActiveChildOfAncestorExcl(SMILNode* pNode, LONG32 lCurTime);
    SMILNode*              findLastDeferredChildOfAncestorExcl(
                                   SMILNode* pInterruptingNode, LONG32 lCurTime);
    SMILNode*              findLastDeferredDescendant(SMILNode* pNode,
                                     LONG32 lCurTime,
                                     SMILNode* pButNotThisNode,
                                     SMILNode* pLastDeferredChild);
    BOOL                   firstDependentChild(SMILNode* pNode);
    SMILNode*              findFirstNode(SMILNodeList* pNodelist, SMILNodeTag tag);
    // /Finds parent's next child; doesn't have to be a timeline element:
    SMILNode*              findNextSibling(SMILNode* pNode);
    SMILNode*              getTimelineDescendent(SMILNode* pParentNode, SMILNode* pSiblingNode);
    SMILNode*              getTimelineDescendent(SMILNode* pParentNode);
    const char*            assignID(const char* pPrefix);
    HX_RESULT              parseDuration(const char*          pDuration,
                                         CSmilElement*        pElement,
                                         SMILSyncAttributeTag nTag);
    HX_RESULT              parseMarkerClipBeginEnd(const char* pszStr,
                                                   REF(char*)  rpszMarkerName,
                                                   REF(char*)  rpszExtFileName);
    HX_RESULT              adjustDuration(CSmilElement* pElement);
    HX_RESULT              parseClockValue(const char* pValue, UINT32& ulClockValue);
    HX_RESULT              parseSyncBehaviorVal(const char*          pSyncBhvrBuf,
                                                CSmilElement*        pElement,
                                                SMILSyncAttributeTag nTag);
    HX_RESULT              parsePeersHigherLower(const char* pBuf,
                                CSmilPriorityClassElement* pPCElement,
                                SMILPriorityClassPeersHigherLowerAttrib nAttrib);
    HX_RESULT              parsePauseDisplay(const char* pBuf,
                                CSmilPriorityClassElement* pPCElement);
    BOOL                   inLanguagePreference(const char* pLang);
    BOOL                   isRelativeURL(const char* pURL);
    UINT8                  getColorElement(const char* pColorFragment, int len);
    void                   handleXMLParserError(XMLError* pError);
    void                   badAttributeError(SMILNodeTag tag,
                                             const char* pNodeName,
                                             UINT32      ulLineNumber,
                                             BOOL        bJustStore);
    void                   initTagAttributes();
    void                   deleteTagAttributes();
    BOOL                   isLegalAttribute(SMILNodeTag tag, const char* pAttrName);
    HX_RESULT              storeError(HX_RESULT   errCode, 
                                      const char* pErrorString, 
                                      const char* pFrameString,
                                      UINT32      ulLineNumber, 
                                      UINT32      ulLinePosition,
                                      BOOL        bXml = TRUE);
    BOOL                   isEndTagObject(SMILNode* pNode);
    const char*            removeSurroundingWhitespace(const char* pValue);
    HX_RESULT              parseBeginEnd(const char*          pBuffer, 
                                         CSmilElement*        pElement,
                                         SMILSyncAttributeTag nTag);
    HX_RESULT              parseSmil1SyncbaseValue(const char*          pCh, 
                                                   CSmilElement*        pElement,
                                                   SMILSyncAttributeTag nTag);
    HX_RESULT              parseCoord(IHXBuffer* pBuf, REF(float) f);
    HX_RESULT              parseDigit(IHXBuffer* pBuf, REF(UINT32) ul);
    HX_RESULT              parseRestart(const char* pBuffer, CSmilElement* pElement);
    HX_RESULT              parseRestartDefault(const char* pBuffer, CSmilElement* pElement);
    HX_RESULT              parseSensitivity(const char* pszValue, CSmilElement* pSource);
    FillDefaultType        getFillDefault(CSmilElement* pElement);
    void                   resolveFillValue(CSmilElement* pElement);
    BOOL                   isAttributeSpecified(CSmilElement* pElement, const char* pszAttr);
#if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
    HX_RESULT              getNextTransitionEnd(CSmilElement* pElement, REF(UINT32) rulTime);
#endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
    void                   initParsingMaps();
#if defined(HELIX_FEATURE_SMIL2_VALIDATION)
    void                   processCollection(CRNBinaryMap* pMap,
                                             UINT32        ulElement,
                                             UINT32        ulCollection);
    void                   deleteEnumAttrMaps();
    void                   deleteReqAttrLists();
#endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
    void                   deleteValidationNamespaceList();
    void                   checkForXMMFDependency(CSmilElement* pElement);
    void                   handleBeginEndListXMMFReferences(CSmilElement*  pElement,
                                                            CHXSimpleList* pList);
    void                   handleClipBeginEndXMMFReference(CSmilElement*  pElement,
                                                           BOOL           bIsClipBegin);
    HX_RESULT              setElementHandler(SMILNode* pNode, CSmilElementHandler* pHandler);
    void                   addToBeginOrEndTimeMap(SmilTimeValue*     pValue,
                                                  SmilTimingListType eType);
    void                   removeFromBeginOrEndTimeMap(SmilTimeValue*     pValue,
                                                       SmilTimingListType eType);
    BOOL                   isTimeValueListPresent(const char*         pszEventName,
                                                  const char*         pszElementID,
                                                  SmilTimingListType  eType,
                                                  REF(CHXSimpleList*) rpList);
    void                   clearTimeValueMap(SmilTimingListType eType);
    void                   checkNodeForExternalEvents(SMILNode* pNode);
    void                   checkNodeTimeListForExternalEvents(CHXSimpleList* pList);
    void                   addExternalEventToList(const char*     pszID,
                                                  const char*     pszFullName,
                                                  const char*     pszName,
                                                  CNamespaceInfo* pInfo);
    void                   clearExternalEventList();

    IUnknown*               m_pContext;
    IHXCommonClassFactory* m_pClassFactory;
    IHXSystemRequired*     m_pISystemRequired;
    IHXXMLParser*          m_pParser;
    CSmilParserResponse*    m_pResponse;
    SMILNode*               m_pCurNode;
    CHXStack*               m_pNodeDependencies;
    SMILNode*               m_pCurrentDependentNode;
    CHXStack*               m_pAnchorStack;
    CSmilAAnchorElement*    m_pCurrentAnchor;
    INT32                   m_lLastCheckPendingTime;
    CHXSimpleList*          m_pPacketQueue;
    CHXSimpleList*          m_pSourceUpdateList;
    CHXMapLongToObj*        m_pAddGroupMap;
    CHXMapLongToObj*        m_pTagAttributeMap;
    CHXMapStringToOb*       m_pIDMap;
    CHXMapStringToOb*       m_pRequireTagsMap;
#if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
    CHXMapStringToOb*       m_pTransitionMap;
#endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
    CHXMapStringToOb*       m_pActiveNamespaceMap;
    CHXMapStringToOb*       m_pCustomTestMap;
    CHXSimpleList*          m_pNSConflictList;
    CHXSimpleList*          m_pBeginTimeSyncList;
    CHXSimpleList*          m_pEndTimeSyncList;
    CHXSimpleList*          m_pBeginEventList;
    CHXSimpleList*          m_pEndEventList;
    CHXSimpleList*          m_pBeginMediaMarkerList;
    CHXSimpleList*          m_pEndMediaMarkerList;
    CHXSimpleList*          m_pClipBeginMarkerList;
    CHXSimpleList*          m_pClipEndMarkerList;
    CHXSimpleList*          m_pPendingBeginTimeList;
    CHXSimpleList*          m_pPendingEndTimeList;
    CHXSimpleList*          m_pOnLoadURLList;
    CHXSimpleList*          m_pOnLoadURLListCopyForPostSeek; 
    BOOL                    m_bHandlePostSeekOnLoadURLs;
    char*                   m_pBasePath;
    CHXSimpleList*          m_pTrackHintList;
    UINT32                  m_ulBandwidthPreference;
    UINT32                  m_ulScreenHeightPreference;
    UINT32                  m_ulScreenWidthPreference;
    UINT32                  m_ulScreenDepthPreference;
    UINT32                  m_ulDurIfNoInitialTracksScheduled;
    char*                   m_pOverdubOrCaptionPreference;
    char*                   m_pEncoding;
    CHXSimpleList*          m_pLanguagePreferenceList;
    CHXPtrArray*            m_pErrors;
    time_t                  m_tRefTime;
    HXVERSIONINFO           m_versionInfo;
    ULONG32                 m_ulPlatformVer; // /Ret val of HXGetWinVer().
    CHXMapStringToOb*       m_pElementMap;
    CHXMapStringToOb*       m_pAttributeMap;
#if defined(HELIX_FEATURE_SMIL2_VALIDATION)
    CHXMapStringToOb*       m_pExtElementMap;
    CHXMapStringToOb*       m_pExtAttributeMap;
    CHXMapStringToOb*       m_pNamespaceMap;
    CRNBinaryMap*           m_pLegalAttrMap;
    CRNBinaryMap*           m_pContentModelMap;
    XMLAttributeType*       m_pAttrType;
    CHXMapStringToOb**      m_ppEnumAttrMap;
    CHXSimpleList**         m_ppReqAttrList;
#endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
    CHXSimpleList*          m_pValNSList;
    CHXSimpleList*          m_pXMMFElementList;
    UINT32                  m_ulPersistentComponentID;
    ElementWithinTag        m_elementWithinTag;
    UINT16                  m_usNumGroups;
    HX_RESULT               m_lParseError;
    CHXSimpleList*          m_pAnimateElementList;
    CHXMapStringToOb*       m_pBeginTimeMap;
    CHXMapStringToOb*       m_pEndTimeMap;
    CHXSimpleList*          m_pExternalEventList;
    LISTPOSITION            m_pExternalEventListPos;
    CHXSimpleList*          m_pElementsWithHandlerList;
    char*                   m_pVarName;
    UINT32                  m_ulNextVar;
    static const char* const zm_pSupportedSMIL2ModuleNamespaces[
                               NUM_SUPPORTED_SMIL_2_0_MODULE_NAMESPACES + 1];
    // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
    // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
    HX_BITFIELD             m_bIgnoreUnrecognizedElements : 1;
    HX_BITFIELD             m_bNoNamespaces : 1;
    HX_BITFIELD             m_bRNNamespace : 1;
    HX_BITFIELD             m_bSMILRootLayoutAlreadyFound : 1;
    HX_BITFIELD             m_bCaptionsPreference : 1;
    HX_BITFIELD             m_bSystemAudioDescPreference : 1;
    HX_BITFIELD             m_bUseSystemCPU : 1;
    HX_BITFIELD             m_bUseSystemOS : 1;
    HX_BITFIELD             m_bContainsSource : 1;
    HX_BITFIELD             m_bContainsInitiallyScheduledTrack: 1;
    HX_BITFIELD             m_bStoreErrors : 1;
    HX_BITFIELD             m_bFirstPacket : 1;
    HX_BITFIELD             m_bTimestampsResolved : 1;
    HX_BITFIELD             m_bAllowPlaylistBehavior : 1;
    HX_BITFIELD             m_bAllTracksNeedReflushHint : 1;
};

#if defined(HELIX_FEATURE_SMIL2_VALIDATION)

inline BOOL CSmilParser::isXMLLetter(char ch) const
{
    BOOL bRet = FALSE;

    // /Fixes some gcc compiler warnings that might actually be bugs in our
    // UNIX player; need to compare unsigneds with the 0x..'s which are unsigned:
    const unsigned char c = (unsigned char)ch;

    if ((c >= 0x41 && c <= 0x5A) ||
        (c >= 0x61 && c <= 0x7A) ||
        (c >= 0xC0 && c <= 0xD6) ||
        (c >= 0xD8 && c <= 0xF6) ||
        (c >= 0xF8 && c <= 0xFF))
    {
        bRet = TRUE;
    }

    return bRet;
}

inline BOOL CSmilParser::isXMLDigit(char c) const
{
    return ((c >= 0x30 && c <= 0x39) ? TRUE : FALSE);
}

inline BOOL CSmilParser::isXMLNameChar(char ch) const
{
    BOOL bRet = FALSE;

    // /Fixes some gcc compiler warnings that might actually be bugs in our
    // UNIX player; need to compare unsigneds with the 0x..'s which are unsigned:
    const unsigned char c = (unsigned char)ch;

    if (isXMLLetter(c) ||
        isXMLDigit(c)  ||
        c == '.'       ||
        c == '-'       ||
        c == '_'       ||
        c == ':'       ||
        c == 0xB7)
    {
        bRet = TRUE;
    }

    return bRet;
}

#endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */

#endif  /* _SMLPARSE_H_ */