smlparse.cpp

linux下的一款播放器

    SMILNode* pFoundNode = 0;
    CHXSimpleList::Iterator i;
    for(i=pNodeList->Begin();i!=pNodeList->End();++i)
    {
	SMILNode* pNode = (SMILNode*)(*i);
	if(pNode->m_tag == tag)
	{
	    pFoundNode = pNode;
	}
	else
	{
	    pFoundNode = findFirstNode(pNode->m_pNodeList, tag);
	}
	if(pFoundNode)
	{
	    break;
	}
    }
    return pFoundNode;
}

SMILNode*
CSmilParser::findFirstNode(SMILNodeTag tag)
{
    return findFirstNode(m_pNodeList, tag);
}

SMILNode*
CSmilParser::getFirstNodeChild(SMILNode* pNode)
{
    m_pCurNode = pNode;
    if(!m_pCurNode)
    {
	return 0;
    }
   return m_pCurNode->getFirstChild();
}

SMILNode*
CSmilParser::getNextNodeChild()
{
    if(!m_pCurNode)
    {
	return 0;
    }
    return m_pCurNode->getNextChild();
}

HX_RESULT
CSmilParser::parseClockValue(const char* pValue, UINT32& ulTimeValue)
{
    // try npt
    char* pPtr = (char *)strstr(pValue, "npt=");
    if(pPtr)
    {
	pPtr += 4;  // point to beginning of clock value
	//[SMIL 1.0 compliance] fixes PR 26445: if "npt=4h" is specified,
	// we need to convert to "14400s" otherwise the 4 is treated as
	// seconds:
	char* pHourChar = strchr(pPtr, 'h');
	if (pHourChar  &&  !strchr(pPtr, ':')) //then it's hours without ':'
	{
	    IHXBuffer* pBuf = new CHXBuffer;
	    if (pBuf)
	    {
		pBuf->AddRef();

		*pHourChar = '\0'; //get rid of the 'h' in pPtr.
		pBuf->Set((const unsigned char *)pPtr,
		    strlen(pPtr) + strlen(":00:00") + 1);
		char* pTmp = (char*)pBuf->GetBuffer();
		strcat(pTmp, ":00:00"); /* Flawfinder: ignore */
		NPTime clockTime((const char*)pTmp);
		ulTimeValue = (UINT32)clockTime;
		pBuf->Release();
	    }
	    else
	    {
		return HXR_OUTOFMEMORY;
	    }
	}
	//END fix for PR 26445.
	else
	{
	    NPTime clockTime(pPtr);
	    ulTimeValue = (UINT32)clockTime;
	}
	return HXR_OK;
    }
    // try smpte
    pPtr = (char *)strstr(pValue, "smpte=");
    if(pPtr)
    {
	pPtr += 6;  // point to beginning of clock value
	SMPTETimeCode clockTime(pPtr);
	ulTimeValue = (UINT32)clockTime;
	return HXR_OK;
    }
    pPtr = (char *)strstr(pValue, "smpte-30-drop=");
    if(pPtr)
    {
	pPtr += 14;  // point to beginning of clock value
	SMPTETimeCode clockTime(pPtr);
	ulTimeValue = (UINT32)clockTime;
	return HXR_OK;
    }
    pPtr = (char *)strstr(pValue, "smpte-25=");
    if(pPtr)
    {
	pPtr += 9;  // point to beginning of clock value
	SMPTETimeCode clockTime;
        clockTime.m_framesPerSec = SMPTETimeCode::FPS_25;
        clockTime.fromString(pPtr);
	ulTimeValue = (UINT32)clockTime;
	return HXR_OK;
    }
    else if(strchr(pValue, ':'))     // try just hh:mm:ss with no prefix/suffix
    {
	NPTime clockTime(pValue);
	ulTimeValue = (UINT32)clockTime;
	return HXR_OK;
    }

    // ok, try h/min/s/ms

    char* pEndPtr = 0;
    double dVal = strtod(pValue, &pEndPtr);
    if(strcmp(pEndPtr, "h") == 0)
    {
	ulTimeValue = (UINT32)(dVal * 60.0 * 60.0 * 1000.0);
	return HXR_OK;
    }
    else if(strcmp(pEndPtr, "min") == 0)
    {
	ulTimeValue = (UINT32)(dVal * 60.0 * 1000.0);
	return HXR_OK;
    }
    else if(strcmp(pEndPtr, "s") == 0  ||
	    //[SMIL 1.0 compliance] Fixes PR 22673: the SMIL doc says that we
	    // need to default to seconds if no unit-type is given:
	    //     Timecount-val         ::= Timecount ("." Fraction)?
	    //              ("h" | "min" | "s" | "ms")? ; default is "s"
	    (!strlen(pEndPtr)) )
    {
	ulTimeValue = (UINT32)(dVal * 1000.0);
	return HXR_OK;
    }
    else if(strcmp(pEndPtr, "ms") == 0)
    {
	ulTimeValue = (UINT32)(dVal);
	return HXR_OK;
    }
    //else something other than "h", "min", "s", "", or "ms" was specified:
    else
    {
	return HXR_FAIL;
    }
}

HX_RESULT
CSmilParser::parseSyncBehaviorVal(const char* pSyncBehaviorBuf,
		       CSmilElement* pElement,
		       SMILSyncAttributeTag nTag)
{
    HX_RESULT ret = HXR_OK;
    if (NULL == pSyncBehaviorBuf  ||  (SMILSyncAttrSyncBehavior != nTag  &&
	    SMILSyncAttrSyncBehaviorDefault != nTag))
    {
	HX_ASSERT(FALSE);
	return HXR_UNEXPECTED;
    }

    // First, eat all whitespace:
    const char* pCh = pSyncBehaviorBuf;
    while (*pCh  &&  isspace(*pCh))
    {
	++pCh;
    }

    if (*pCh == '\0')
    {
	// nothing, empty attribute...
	return HXR_OK;
    }

    BOOL bParsedOK = TRUE;
    SMILSyncBehaviorType sbtype = SmilSyncBehaviorInvalid;
    if (strncmp(pCh, "canSlip", 7) == 0)
    {
	pCh += 7;
	sbtype = SmilSyncBehaviorCanSlip;
    }
    else if (strncmp(pCh, "locked", 6) == 0)
    {
	pCh += 6;
	sbtype = SmilSyncBehaviorLocked;
    }
    else if (strncmp(pCh, "independent", 11) == 0)
    {
	pCh += 11;
	sbtype = SmilSyncBehaviorIndependent;
    }
    else if (strncmp(pCh, "default", 7) == 0)
    {
	pCh += 7;
	sbtype = SmilSyncBehaviorDefault;
    }
    else if (strncmp(pCh, "inherit", 7) == 0)
    {
	pCh += 7;
	sbtype = SmilSyncBehaviorInherit;
    }
    else
    {
	bParsedOK = FALSE;
    }

    if (bParsedOK)
    {
	while (*pCh  &&  isspace(*pCh))
	{
	    ++pCh;
	}
	if (*pCh)
	{
	    bParsedOK = FALSE;  // /Should only be whitespace after value.
	}
    }

    if (SMILSyncAttrSyncBehavior == nTag)
    {
	pElement->m_syncBehavior = sbtype;
	// /syncBehavior can not be "inherit":
	bParsedOK = bParsedOK  &&  (SmilSyncBehaviorInherit != sbtype);
    }
    else
    {
	pElement->m_syncBehaviorDefault = sbtype;
	// /syncBehaviorDefault can not be "default":
	bParsedOK = bParsedOK  &&  (SmilSyncBehaviorDefault != sbtype);
    }

    if (SmilSyncBehaviorInvalid == sbtype  ||  !bParsedOK)
    {
	ret = HXR_INVALID_PARAMETER;
    }

    return ret;
}

HX_RESULT
CSmilParser::parsePeersHigherLower(const char* pBuf,
		       CSmilPriorityClassElement* pPCElement,
		       SMILPriorityClassPeersHigherLowerAttrib nAttrib)
{
    HX_RESULT ret = HXR_OK;
    if (NULL == pBuf  ||  (SMILPriorityClassPeers != nAttrib  &&
	    SMILPriorityClassHigher != nAttrib  &&
	    SMILPriorityClassLower != nAttrib))
    {
	HX_ASSERT(FALSE);
	return HXR_UNEXPECTED;
    }

    BOOL bParsedOK = TRUE;
    SMILPriorityClassPeersHigherLowerVal val =
	    SMILPriorityClassPeersHigherLowerInvalid;

    // First, eat all whitespace:
    const char* pCh = pBuf;
    while (*pCh  &&  isspace(*pCh))
    {
	++pCh;
    }

    if (*pCh == '\0')
    {
	ret = HXR_INVALID_PARAMETER;
	goto cleanup;
    }

    if (strncmp(pCh, "stop", 4) == 0)
    {
	pCh += 4;
	val = SMILPriorityClassStop;
    }
    else if (strncmp(pCh, "pause", 5) == 0)
    {
	pCh += 5;
	val = SMILPriorityClassPause;
    }
    else if (strncmp(pCh, "defer", 5) == 0)
    {
	pCh += 5;
	val = SMILPriorityClassDefer;
    }
    else if (strncmp(pCh, "never", 5) == 0)
    {
	pCh += 5;
	val = SMILPriorityClassNever;
    }
    else
    {
	bParsedOK = FALSE;
    }

    if (bParsedOK)
    {
	while (*pCh  &&  isspace(*pCh))
	{
	    ++pCh;
	}
	if (*pCh)
	{
	    bParsedOK = FALSE;  // /Should only be whitespace after value.
	}
    }

    if (SMILPriorityClassPeers == nAttrib)
    {
	pPCElement->m_peers = val;
    }
    else if (SMILPriorityClassHigher == nAttrib)
    {
	pPCElement->m_higher = val;
	// /higher can't be "defer" or "never":
	bParsedOK = bParsedOK  &&  (SMILPriorityClassDefer != val  &&
		SMILPriorityClassNever != val);
    }
    else // /SMILPriorityClassLower
    {
	pPCElement->m_lower = val;
	// /lower can't be "stop" or "pause":
	bParsedOK = bParsedOK  &&  (SMILPriorityClassStop != val  &&
		SMILPriorityClassPause != val);
    }

    if (SMILPriorityClassPeersHigherLowerAttribInvalid== val  ||  !bParsedOK)
    {
	ret = HXR_INVALID_PARAMETER;
    }

cleanup:
    return ret;
}

HX_RESULT
CSmilParser::parsePauseDisplay(const char* pBuf,
		       CSmilPriorityClassElement* pPCElement)
{
    HX_RESULT ret = HXR_OK;
    if (NULL == pBuf)
    {
	HX_ASSERT(FALSE);
	return HXR_UNEXPECTED;
    }

    BOOL bParsedOK = TRUE;

    // First, eat all whitespace:
    const char* pCh = pBuf;
    while (*pCh  &&  isspace(*pCh))
    {
	++pCh;
    }

    if (*pCh == '\0')
    {
	ret = HXR_INVALID_PARAMETER;
	goto cleanup;
    }

    pPCElement->m_pauseDisplay = SMILPriorityClassPauseDisplayInvalid;
    if (strncmp(pCh, "disable", 7) == 0)
    {
	pCh += 7;
	pPCElement->m_pauseDisplay = SMILPriorityClassPauseDisplayDisable;
    }
    else if (strncmp(pCh, "hide", 4) == 0)
    {
	pCh += 4;
	pPCElement->m_pauseDisplay = SMILPriorityClassPauseDisplayHide;
    }
    else if (strncmp(pCh, "show", 4) == 0)
    {
	pCh += 4;
	pPCElement->m_pauseDisplay = SMILPriorityClassPauseDisplayShow;
    }
    else
    {
	bParsedOK = FALSE;
    }

    if (bParsedOK)
    {
	while (*pCh  &&  isspace(*pCh))
	{
	    ++pCh;
	}
	if (*pCh)
	{
	    bParsedOK = FALSE;  // /Should only be whitespace after value.
	}
    }

    if (SMILPriorityClassPauseDisplayInvalid == pPCElement->m_pauseDisplay
	    ||  !bParsedOK)
    {
	ret = HXR_INVALID_PARAMETER;
    }

cleanup:
    return ret;
}


HX_RESULT
CSmilParser::parseAnchorCoords(const char* pCoords,
			       CSmilAnchorElement* pAnchor)
{
    HX_RESULT rc = HXR_OK;

    INT16 iNumCoords = 0;

    BOOL bIsCircle = FALSE;
    BOOL bIsPoly = FALSE;

    if (0==pAnchor->m_shape.GetLength()  ||
	    0==strcmp(pAnchor->m_shape, "rect"))
    {
	iNumCoords = 4;
    }
    else if (0==strcmp(pAnchor->m_shape, "circle"))
    {
	bIsCircle = TRUE;
	iNumCoords = 3;
    }
    // /XXXEH- TODO: handle shape="poly":
    else if (0==strcmp(pAnchor->m_shape, "poly"))
    {
	// /Handles conversion of string to array:
	pAnchor->convertRawPolyData(pCoor