rpparser.cpp

linux下的一款播放器

                    case kAttrTimeformat:
                        break;
                    case kAttrAspect:
                        {
                            BOOL bTmp = FALSE;
                            retVal    = ConvertBoolValue(pValue, bTmp);
                            if (SUCCEEDED(retVal))
                            {
                                m_pRealPixFile->SetDefaultAspectFlag(bTmp);
                            }
                            else
                            {
                                SetError(IDS_ERR_PIX_BADASPECTFLAG, ulLine, ulCol, NULL, NULL, rpError);
                            }
                        }
                        break;
                    case kAttrCenter:
                        {
                            ulMinVer = REDSTONE_VERSION;
                            BOOL bTmp = FALSE;
                            retVal    = ConvertBoolValue(pValue, bTmp);
                            if (SUCCEEDED(retVal))
                            {
                                m_pRealPixFile->SetDefaultCenterFlag(bTmp);
                            }
                            else
                            {
                                SetError(IDS_ERR_PIX_BADCENTERFLAG, ulLine, ulCol, NULL, NULL, rpError);
                            }
                        }
                        break;
                    case kAttrUrl:
                        {
                            retVal = CheckStringContents(pValue);
                            if (SUCCEEDED(retVal))
                            {
                                retVal = m_pRealPixFile->SetDefaultURL(pValue);
                            }

                            if (FAILED(retVal))
                            {
                                SetError(IDS_ERR_PIX_NULLURL, ulLine, ulCol, NULL, NULL, rpError);
                            }
                        }
                        break;
                    case kAttrVersion:
                        break;
                    case kAttrBackgroundcolor:
                        {
                            ulMinVer     = U2_VERSION;
                            BYTE ucRed   = 0;
                            BYTE ucGreen = 0;
                            BYTE ucBlue  = 0;
                            retVal       = ConvertColorValue(pValue, ucRed, ucGreen, ucBlue);
                            if (SUCCEEDED(retVal))
                            {
                                m_pRealPixFile->SetBackgroundColor(ucRed, ucGreen, ucBlue);
                            }
                            else
                            {
                                SetError(IDS_ERR_PIX_BADBGCOLOR, ulLine, ulCol, NULL, NULL, rpError);
                            }
                        }
                        break;
                    case kAttrBackgroundOpacity:
                        {
                            // Set the minimum version
                            ulMinVer = OPACITY_VERSION;
                            // Parse the opacity
                            UINT32 ulOpacity = 255;
                            HXParseOpacity((const char*) pValue->GetBuffer(), ulOpacity);
                            m_pRealPixFile->SetBackgroundOpacity(ulOpacity);
                        }
                        break;
                }

                if (SUCCEEDED(retVal))
                {
                    retVal = CheckVersion(ulMinVer);
                    if (SUCCEEDED(retVal))
                    {
                        HX_RELEASE(pValue);
                        rv = pAttr->GetNextPropertyCString(pszName, pValue);
                    }
                    else
                    {
                        SetError(IDS_ERR_PIX_INCOMPATVERSION, ulLine, ulCol, (const char*) pValue->GetBuffer(), NULL, rpError);
                    }
                }
            }
            HX_RELEASE(pValue);
        }

        if (SUCCEEDED(retVal))
        {
            // Here we check for logical (parsed OK, but conflicting values)
            // kind of errors
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXRealPixParser::ParseImageTag(IHXValues* pAttr, UINT32 ulLine, UINT32 ulCol,
                                         REF(IHXBuffer*) rpError)
{
    HX_RESULT retVal = HXR_OK;

    if (pAttr)
    {
        // Get the handle attribute
        const char* pszAttrStr = NULL;
        IHXBuffer* pValue     = NULL;
        GetAttributeNameFromID(kAttrHandle, pszAttrStr);
        retVal = pAttr->GetPropertyCString(pszAttrStr, pValue);
        if (SUCCEEDED(retVal))
        {
            UINT32 ulHandle = strtoul((const char*) pValue->GetBuffer(), NULL, 10);
            if (ulHandle)
            {
                // Get the name attribute
                GetAttributeNameFromID(kAttrName, pszAttrStr);
                HX_RELEASE(pValue);
                retVal = pAttr->GetPropertyCString(pszAttrStr, pValue);
                if (SUCCEEDED(retVal))
                {
                    retVal = CheckStringContents(pValue);
                    if (SUCCEEDED(retVal))
                    {
                        if (!m_pRealPixFile->IsImagePresent(ulHandle))
                        {
                            retVal = m_pRealPixFile->AddImage(ulHandle, pValue);
                            if (SUCCEEDED(retVal))
                            {
                                // Get the size attribute string
                                GetAttributeNameFromID(kAttrSize, pszAttrStr);
                                // See if we have a size attribute
                                HX_RELEASE(pValue);
                                HX_RESULT rv = pAttr->GetPropertyCString(pszAttrStr, pValue);
                                if (SUCCEEDED(rv))
                                {
                                    retVal = CheckVersion(REDSTONE_VERSION);
                                    if (SUCCEEDED(retVal))
                                    {
                                        UINT32 ulSize = strtoul((const char*) pValue->GetBuffer(), NULL, 10);
                                        if (ulSize)
                                        {
                                            retVal = m_pRealPixFile->SetImageSize(ulHandle, ulSize);
                                        }
                                        else
                                        {
                                            retVal = HXR_FAIL;
                                            SetError(IDS_ERR_PIX_ZEROSIZE, ulLine, ulCol, NULL, NULL, rpError);
                                        }
                                    }
                                    else
                                    {
                                        SetError(IDS_ERR_PIX_INCOMPATVERSION, ulLine, ulCol,
                                                 (const char*) pValue->GetBuffer(), NULL, rpError);
                                    }
                                }
                                // Get the mime type attribute string
                                GetAttributeNameFromID(kAttrMime, pszAttrStr);
                                // See if we have a mime type attribute
                                HX_RELEASE(pValue);
                                rv = pAttr->GetPropertyCString(pszAttrStr, pValue);
                                if (SUCCEEDED(rv))
                                {
                                    retVal = CheckVersion(REDSTONE_VERSION);
                                    if (SUCCEEDED(retVal))
                                    {
                                        retVal = m_pRealPixFile->SetImageFileMimeType(ulHandle, pValue);
                                    }
                                    else
                                    {
                                        SetError(IDS_ERR_PIX_INCOMPATVERSION, ulLine, ulCol,
                                                 (const char*) pValue->GetBuffer(), NULL, rpError);
                                    }
                                }
                            }
                        }
                        else
                        {
                            retVal = HXR_FAIL;
                            SetError(IDS_ERR_PIX_DUPHANDLE, ulLine, ulCol, NULL, NULL, rpError);
                        }
                    }
                    else
                    {
                        SetError(IDS_ERR_PIX_NULLNAME, ulLine, ulCol, NULL, NULL, rpError);
                    }
                }
                else
                {
                    SetError(IDS_ERR_PIX_NONAME, ulLine, ulCol, NULL, NULL, rpError);
                }
            }
            else
            {
                SetError(IDS_ERR_PIX_BADHANDLE, ulLine, ulCol, NULL, NULL, rpError);
                retVal = HXR_FAIL;
            }
        }
        else
        {
            SetError(IDS_ERR_PIX_NOHANDLE, ulLine, ulCol, NULL, NULL, rpError);
        }
        HX_RELEASE(pValue);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXRealPixParser::ParseEffectTag(UINT32 ulTagID, IHXValues* pAttr, UINT32 ulLine,
                                          UINT32 ulCol, REF(IHXBuffer*) rpError)
{
    HX_RESULT retVal = HXR_OK;

    if (ulTagID < kNumTags && pAttr)
    {
        // Get the tag name
        const char* pszTagName = NULL;
        GetTagNameFromID(ulTagID, pszTagName);

        // Create a PXEffect object
        PXEffect* pEffect = NULL;
        retVal            = PXEffect::CreateObject(&pEffect);
        if (SUCCEEDED(retVal))
        {
            // AddRef the object
            pEffect->AddRef();

            // Set effect type
            BYTE ucEffectType = 0;
            switch (ulTagID)
            {
                case kTagFill:
                    ucEffectType = PXEffect::kEffectTypeFill;
                    break;
                case kTagFadein:
                    ucEffectType = PXEffect::kEffectTypeFadeIn;
                    break;
                case kTagFadeout:
                    ucEffectType = PXEffect::kEffectTypeFadeOut;
                    break;
                case kTagCrossfade:
                    ucEffectType = PXEffect::kEffectTypeCrossFade;
                    break;
                case kTagWipe:
                    ucEffectType = PXEffect::kEffectTypeWipe;
                    break;
                case kTagViewchange:
                    ucEffectType = PXEffect::kEffectTypeViewChange;
                    break;
                case kTagEffect:
                    ucEffectType = PXEffect::kEffectTypeExternal;
                    break;
                case kTagAnimate:
                    ucEffectType = PXEffect::kEffectTypeAnimate;
                    break;
            }
            pEffect->SetEffectType(ucEffectType);

            // Set defaults
            pEffect->SetAspectFlag(m_pRealPixFile->GetDefaultAspectFlag());
            pEffect->SetMaxFps(m_pRealPixFile->GetDefaultMaxFps());
            pEffect->SetCenterFlag(m_pRealPixFile->GetDefaultCenterFlag());

            // Loop through the attributes
            BOOL   bThrowError      = TRUE;
            BOOL   bNeedLastTarget  = TRUE;
            BOOL   bNeedLastRects   = TRUE;
            const char* pszAttrName = NULL;
            IHXBuffer* pAttrValue  = NULL;
            HX_RESULT   rv          = pAttr->GetFirstPropertyCString(pszAttrName, pAttrValue);
            while (SUCCEEDED(rv) && SUCCEEDED(retVal))
            {
                // Get the attribute ID. Don't need to check return value
                // since we have already check validity of each attribute
                UINT32 ulAttrID = 0;
                GetAttributeIDFromName(pszAttrName, ulAttrID);

                // Choose different action based on attribute ID
                UINT32 ulMinVer = BASE_VERSION;
                switch (ulAttrID)
                {
                    case kAttrStart:
                        {
                            UINT32 ulTmp = 0;
                            retVal       = ConvertTimeValue(pAttrValue, m_pRealPixFile->GetTimeFormat(), ulTmp);
                            if (SUCCEEDED(retVal))
                            {
                                pEffect->SetStart(ulTmp);
                            }
                        }
                        break;
                    case kAttrDuration:
                        {
                            UINT32 ulTmp = 0;
                            retVal       = ConvertTimeValue(pAttrValue, m_pRealPixFile->GetTimeFormat(), ulTmp);
                            if (SUCCEEDED(retVal))
                            {
                                pEffect->SetDuration(ulTmp);
                            }
                        }
                        break;
                    case kAttrTarget:
                        {
                            bNeedLastTarget = FALSE;
                            UINT32 ulTmp    = strtoul((const char*) pAttrValue->GetBuffer(), NULL, 10);
                            pEffect->SetTarget(ulTmp);
                        }
                        break;
                    case kAttrSrcx:
                        {