rpfilobj.cpp

linux下的一款播放器

                }
            }

            // Get preroll
            retVal = SetAttributeTimeValue(cAttrStr, m_pszHeadPrerollAttribute, m_ulTimeFormat, m_ulPreroll);
            if (retVal != HXR_OK)
            {
                if (retVal == HXR_PROP_NOT_FOUND)
                {
                    m_ulPreroll = 0;
                }
                else
                {
                    rulErrorID = IDS_ERR_PIX_BADPREROLL;
                    rErrText   = "";
                    return FALSE;
                }
            }

            bRet = SetAttributeValueBOOL(cAttrStr, m_pszHeadAspectAttribute, m_bAspectFlag);
            if (bRet == FALSE)
            {
                m_bAspectFlag = TRUE;
            }
            bRet = SetAttributeValue(cAttrStr, m_pszHeadURLAttribute, m_cURL);
            if (bRet == TRUE)
            {
                if (m_cURL.length() == 0)
                {
                    rulErrorID = IDS_ERR_PIX_NULLURL;
                    rErrText   = "";
                    return FALSE;
                }
                else
                {
                    char  *pszURL = (char *) m_cURL.c_str();
                    UINT32 ulLen  = strlen(pszURL);
                    if (ulLen > 0)
                    {
                        BOOL bWhitespaceOnly = TRUE;
                        for (UINT32 c = 0; c < ulLen; c++)
                        {
                            if (pszURL[c] != ' '  && pszURL[c] != '\t' &&
                                pszURL[c] != '\n' && pszURL[c] != '\r')
                            {
                                bWhitespaceOnly = FALSE;
                                break;
                            }
                        }
                        if (bWhitespaceOnly)
                        {
                            rulErrorID = IDS_ERR_PIX_URLALLWHITE;
                            rErrText   = "";
                            return FALSE;
                        }
                    }
                    else
                    {
                        rulErrorID = IDS_ERR_PIX_NULLURL;
                        rErrText   = "";
                        return FALSE;
                    }
                }
            }
            bRet = SetAttributeValue(cAttrStr, m_pszHeadMaxFps, m_ulMaxFps);
            if (bRet == FALSE)
            {
                m_ulMaxFps = 0;
            }

            // Duration can be automatically calculated from the effects, so it is not required.
            // If it is not present, we set a flag to have it calculate the duration
            retVal = SetAttributeTimeValue(cAttrStr, m_pszHeadDurationAttribute, m_ulTimeFormat, m_ulDuration);
            if (retVal != HXR_OK)
            {
                if (retVal == HXR_PROP_NOT_FOUND)
                {
                    m_ulDuration       = 0;
                    bComputeDuration = TRUE;
                }
                else
                {
                    rulErrorID = IDS_ERR_PIX_BADDURATION;
                    rErrText   = "";
                    return FALSE;
                }
            }
            else
            {
                bComputeDuration = FALSE;
            }

            if (m_ulDuration == 0 && bComputeDuration == FALSE)
            {
                // Zero duration - this is an error
                rulErrorID = IDS_ERR_PIX_ZERODURATION;
                rErrText   = "";
                return FALSE;
            }

            // The following are required tags, so we make sure they are present AND we check
            // their values. More checking for logical errors is done after everything is parsed.
            INT32 lTmpBitrate;
            bRet = SetAttributeValue(cAttrStr, m_pszHeadBitrateAttribute,  lTmpBitrate);
            if (bRet == FALSE)
            {
                rulErrorID = IDS_ERR_PIX_NOBITRATE;
                rErrText   = "";
                return FALSE;
            }
            // Added this fix to prevent someone from putting in a negative bitrate.
            if (lTmpBitrate <= 0)
            {
                rulErrorID = IDS_ERR_PIX_BADBITRATE;
                rErrText   = "";
                return FALSE;
            }
            else
            {
                m_ulBitrate = (UINT32) lTmpBitrate;
            }
            bRet = SetAttributeValue(cAttrStr, m_pszHeadWidthAttribute,    m_ulDisplayWidth);
            if (bRet == FALSE)
            {
                rulErrorID = IDS_ERR_PIX_NOWIDTH;
                rErrText   = "";
                return FALSE;
            }
            bRet = SetAttributeValue(cAttrStr, m_pszHeadHeightAttribute,   m_ulDisplayHeight);
            if (bRet == FALSE)
            {
                rulErrorID = IDS_ERR_PIX_NOHEIGHT;
                rErrText   = "";
                return FALSE;
            }

            bValidHead = TRUE;
        }
        else if (cTagStr == "image")
        {
            CIMFImage *pImage = new CIMFImage;
            if (!pImage)
            {
                return FALSE;
            }
            bRet = pImage->InitFromText(cAttrStr, rulErrorID, rErrText);
            if (bRet == FALSE)
            {
                delete pImage;
                return FALSE;
            }
            InsertImageIntoList(pImage);
        }
        else if (cTagStr == "fill")
        {
            CIMFFillEffect *pEffect = new CIMFFillEffect(this);
            if (!pEffect)
            {
                return FALSE;
            }
            pEffect->SetDefaultMaxFps(m_ulMaxFps);
            if (!pEffect->InitFromText(cAttrStr))
            {
                rulErrorID = IDS_ERR_PIX_BADEFFECT;
                rErrText   = cWholeTag.c_str();
                delete pEffect;
                return FALSE;
            }
            InsertEffectIntoList(pEffect);
        }
        else if (cTagStr == "fadein")
        {
            CIMFFadeinEffect *pEffect = new CIMFFadeinEffect(this);
            if (!pEffect)
            { 
                return FALSE;
            }
            pEffect->SetAspectDefault(m_bAspectFlag);
            pEffect->SetDefaultMaxFps(m_ulMaxFps);
            if (!pEffect->InitFromText(cAttrStr))
            {
                rulErrorID = IDS_ERR_PIX_BADEFFECT;
                rErrText   = cWholeTag.c_str();
                delete pEffect;
                return FALSE;
            }
            InsertEffectIntoList(pEffect);
            ulLastTarget = pEffect->GetTargetImageHandle();
        }
        else if (cTagStr == "fadeout")
        {
            CIMFFadeoutEffect *pEffect = new CIMFFadeoutEffect(this);
            if (!pEffect)
            {
                return FALSE;
            }
            pEffect->SetDefaultMaxFps(m_ulMaxFps);
            if (!pEffect->InitFromText(cAttrStr))
            {
                rulErrorID = IDS_ERR_PIX_BADEFFECT;
                rErrText   = cWholeTag.c_str();
                delete pEffect;
                return FALSE;
            }
            InsertEffectIntoList(pEffect);
        }
        else if (cTagStr == "crossfade")
        {
            CIMFCrossfadeEffect *pEffect = new CIMFCrossfadeEffect(this);
            if (!pEffect)
            {
                return FALSE;
            }
            pEffect->SetAspectDefault(m_bAspectFlag);
            pEffect->SetDefaultMaxFps(m_ulMaxFps);
            if (!pEffect->InitFromText(cAttrStr))
            {
                rulErrorID = IDS_ERR_PIX_BADEFFECT;
                rErrText   = cWholeTag.c_str();
                delete pEffect;
                return FALSE;
            }
            InsertEffectIntoList(pEffect);
            ulLastTarget = pEffect->GetTargetImageHandle();
        }
        else if (cTagStr == "wipe")
        {
            CIMFWipeEffect *pEffect = new CIMFWipeEffect(this);
            if (!pEffect)
            {
                return FALSE;
            }
            pEffect->SetAspectDefault(m_bAspectFlag);
            pEffect->SetDefaultMaxFps(m_ulMaxFps);
            if (!pEffect->InitFromText(cAttrStr))
            {
                rulErrorID = IDS_ERR_PIX_BADEFFECT;
                rErrText   = cWholeTag.c_str();
                delete pEffect;
                return FALSE;
            }
            InsertEffectIntoList(pEffect);
            ulLastTarget = pEffect->GetTargetImageHandle();
        }
        else if (cTagStr == "viewchange")
        {
            CIMFViewchangeEffect *pEffect = new CIMFViewchangeEffect(this);
            if (!pEffect)
            {
                return FALSE;
            }
            pEffect->SetAspectDefault(m_bAspectFlag);
            pEffect->SetDefaultMaxFps(m_ulMaxFps);
            if (!pEffect->InitFromText(cAttrStr))
            {
                rulErrorID = IDS_ERR_PIX_BADEFFECT;
                rErrText   = cWholeTag.c_str();
                delete pEffect;
                return FALSE;
            }
            // XXXMEH - design flaw in .rp language!!
            //
            // <viewchange> does not require the author to specify target - the target is
            // assumed from the last effect - therefore, we need to save the last
            // target and assign the viewchange's target from that.
            pEffect->SetTargetImageHandle(ulLastTarget);
            InsertEffectIntoList(pEffect);
        }
        else if (cTagStr == "effect")
        {
            CIMFExternalEffect *pEffect = new CIMFExternalEffect(this);
            if (!pEffect)
            {
                return FALSE;
            }
            pEffect->SetAspectDefault(m_bAspectFlag);
            pEffect->SetDefaultMaxFps(m_ulMaxFps);
            if (!pEffect->InitFromText(cAttrStr))
            {
                rulErrorID = IDS_ERR_PIX_BADEFFECT;
                rErrText   = cWholeTag.c_str();
                delete pEffect;
                return FALSE;
            }
            InsertEffectIntoList(pEffect);

            ulLastTarget = pEffect->GetTargetImageHandle();
        }
        else if (cTagStr == "animate")
        {
            // If we see an animate tag, we bump the content version
            // up to 0.1.0.0 instead of 0.0.0.0. This will force any
            // older renderers to auto-upgrade.
            if (m_ulContentVersion == BASE_VERSION)
            {
                m_ulContentVersion = U2_VERSION;
            }
            CIMFAnimateEffect *pEffect = new CIMFAnimateEffect(this);
            if (!pEffect)
            { 
                return FALSE;
            }
            pEffect->SetAspectDefault(m_bAspectFlag);
            pEffect->SetDefaultMaxFps(m_ulMaxFps);
            if (!pEffect->InitFromText(cAttrStr))
            {
                rulErrorID = IDS_ERR_PIX_BADEFFECT;
                rErrText   = cWholeTag.c_str();
                delete pEffect;
                return FALSE;
            }
            InsertEffectIntoList(pEffect);
            ulLastTarget = pEffect->GetTargetImageHandle();
        }
        else if (cTagStr == "!--")
        {
            // This is a comment tag - we ignore everything inside it
        }
        else
        {
            // This is an unknown tag - report an error
            rulErrorID = IDS_ERR_PIX_UNKNOWNTAG;
            rErrText   = cWholeTag.c_str();
            return FALSE;
        }
    }

    // Check for valid head tag
    if (bValidHead == FALSE)
    {
        rulErrorID = IDS_ERR_PIX_INVALIDHEAD;
        rErrText   = "";
        return FALSE;
    }

    // Make sure we have some effects
    if (m_cEffectList.Size() == 0)
    {
        rulErrorID = IDS_ERR_PIX_NOEFFECTS;
        rErrText   = "";
        return FALSE;
    }

    // Calculate the duration if none was specified
    if (bComputeDuration)
    {
        // Go through list of effects, computing max
        UINT32        ulMax = 0;
        GListIterator itr;
        for (itr = m_cEffectList.Begin(); itr != m_cEffectList.End(); itr++)
        {
            CIMFEffect *pEffect = (CIMFEffect *) *itr;
            if (pEffect)
            {
                UINT32 ulEffectMax = pEffect->GetStart();
                if (pEffect->HasDuration())
                {