rpparser.cpp

linux下的一款播放器

STDMETHODIMP PXRealPixParser::HandleDefault(IHXBuffer* pBuffer,
                                            UINT32      ulLineNumber,
                                            UINT32      ulColumnNumber)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

HX_RESULT PXRealPixParser::SetError(UINT32 ulErrorID, UINT32 ulLine, UINT32 ulCol,
                                    const char* pszArg1, const char* pszArg2,
                                    REF(IHXBuffer*) rpErrStr)
{
    HX_RESULT retVal = HXR_OK;

    const char* pszFileName = NULL;
    if (m_pRealPixFile)
    {
        pszFileName = m_pRealPixFile->GetFileName();
    }

    PXError cErr(m_pContext);
    if (pszFileName)
    {
        retVal = cErr.SetError(pszFileName, ulErrorID, ulLine, ulCol, pszArg1, pszArg2, rpErrStr);
    }
    else
    {
        retVal = cErr.SetError(ulErrorID, ulLine, ulCol, pszArg1, pszArg2, rpErrStr);
    }

    return retVal;
}

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

    // Clear out any present error string
    HX_RELEASE(rpError);

    switch(ulTagID)
    {
        case kTagRoot:
            {
                if (m_ulState == kStateInitialized)
                {
                    m_ulState = kStateSawRootStart;
                }
                else
                {
                    SetError(IDS_ERR_PIX_ROOTNOTFIRST, ulLine, ulCol, NULL, NULL, rpError);
                    retVal = HXR_FAIL;
                }
            }
            break;
        case kTagHead:
            {
                if (m_ulState == kStateInitialized)
                {
                    SetError(IDS_ERR_PIX_ROOTNOTFIRST, ulLine, ulCol, NULL, NULL, rpError);
                    retVal = HXR_FAIL;
                }
                else if (m_ulState == kStateSawRootStart)
                {
                    // Process head here
                    retVal = ParseHeadTag(pAttr, ulLine, ulCol, rpError);
                    if (SUCCEEDED(retVal))
                    {
                        // Set the next state
                        m_ulState = kStateSawHead;
                    }
                }
                else
                {
                    SetError(IDS_ERR_PIX_HEADNOTFIRST, ulLine, ulCol, NULL, NULL, rpError);
                    retVal = HXR_FAIL;
                }
            }
            break;
        case kTagImage:
            {
                if (m_ulState == kStateInitialized)
                {
                    SetError(IDS_ERR_PIX_ROOTNOTFIRST, ulLine, ulCol, NULL, NULL, rpError);
                    retVal = HXR_FAIL;
                }
                else if (m_ulState == kStateSawRootStart)
                {
                    SetError(IDS_ERR_PIX_HEADNOTFIRST, ulLine, ulCol, NULL, NULL, rpError);
                    retVal = HXR_FAIL;
                }
                else if (m_ulState == kStateSawHead)
                {
                    retVal = ParseImageTag(pAttr, ulLine, ulCol, rpError);
                }
            }
            break;
        case kTagFill:
        case kTagFadein:
        case kTagCrossfade:
        case kTagFadeout:
        case kTagWipe:
        case kTagAnimate:
        case kTagViewchange:
        case kTagEffect:
            {
                if (m_ulState == kStateInitialized)
                {
                    SetError(IDS_ERR_PIX_ROOTNOTFIRST, ulLine, ulCol, NULL, NULL, rpError);
                    retVal = HXR_FAIL;
                }
                else if (m_ulState == kStateSawRootStart)
                {
                    SetError(IDS_ERR_PIX_HEADNOTFIRST, ulLine, ulCol, NULL, NULL, rpError);
                    retVal = HXR_FAIL;
                }
                else if (m_ulState == kStateSawHead)
                {
                    retVal = ParseEffectTag(ulTagID, pAttr, ulLine, ulCol, rpError);
                }
            }
            break;
    }

    return retVal;
}

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

    if (pAttr)
    {
        // First we check the content version attribute
        const char* pszAttr = NULL;
        IHXBuffer* pValue  = NULL;
        GetAttributeNameFromID(kAttrVersion, pszAttr);
        HX_RESULT rv        = pAttr->GetPropertyCString(pszAttr, pValue);
        if (SUCCEEDED(rv))
        {
            UINT32 ulTmp = 0;
            retVal       = ConvertVersionValue(pValue, ulTmp);
            if (SUCCEEDED(retVal))
            {
                if (ulTmp <= m_ulHighestSupportedContentVersion)
                {
                    m_pRealPixFile->SetContentVersion(ulTmp);
                    m_bVersionSpecified = TRUE;
                }
                else
                {
                    SetError(IDS_ERR_PIX_FUTUREVERSION, ulLine, ulCol, (const char*) pValue->GetBuffer(), NULL, rpError);
                    retVal = HXR_FAIL;
                }
            }
            else
            {
                SetError(IDS_ERR_PIX_NULLVERSION, ulLine, ulCol, NULL, NULL, rpError);
            }
        }
        else
        {
            // Set the default to 0.0.0.0
            m_pRealPixFile->SetContentVersion(0);
            m_bVersionSpecified = FALSE;
        }
        HX_RELEASE(pValue);

        // Next we get the timeformat property in order to be able to
        // correctly interpret time values
        if (SUCCEEDED(retVal))
        {
            GetAttributeNameFromID(kAttrTimeformat, pszAttr);
            rv = pAttr->GetPropertyCString(pszAttr, pValue);
            if (SUCCEEDED(rv))
            {
                if (!strcmp((const char*) pValue->GetBuffer(), "dd:hh:mm:ss.xyz"))
                {
                    // Set timeformat to days/hours/minutes/seconds
                    m_pRealPixFile->SetTimeFormat(PXRealPixFile::kTimeFormatDHMS);
                }
                else if (!strcmp((const char*) pValue->GetBuffer(), "milliseconds"))
                {
                    // default is milliseconds
                    m_pRealPixFile->SetTimeFormat(PXRealPixFile::kTimeFormatMilliseconds);
                }
                else
                {
                    // Unknown time format
                    SetError(IDS_ERR_PIX_BADTIMEFORMAT, ulLine, ulCol, (const char*) pValue->GetBuffer(), NULL, rpError);
                    retVal = HXR_FAIL;
                }
            }
            else
            {
                // No timeformat specified, so set to default of milliseconds
                m_pRealPixFile->SetTimeFormat(PXRealPixFile::kTimeFormatMilliseconds);
            }
            HX_RELEASE(pValue);

            // Now loop through the attributes of the head tag
            const char* pszName = NULL;
            rv                  = pAttr->GetFirstPropertyCString(pszName, pValue);
            while (SUCCEEDED(rv) && SUCCEEDED(retVal))
            {
                // Get the attribute ID
                UINT32 ulAttrID = kNumAttr;
                GetAttributeIDFromName(pszName, ulAttrID);

                UINT32 ulMinVer = BASE_VERSION;
                switch (ulAttrID)
                {
                    case kAttrTitle:
                        {
                            retVal = CheckStringContents(pValue);
                            if (SUCCEEDED(retVal))
                            {
                                retVal = m_pRealPixFile->SetTitle(pValue);
                            }

                            if (FAILED(retVal))
                            {
                                SetError(IDS_ERR_PIX_NULLTITLE, ulLine, ulCol, NULL, NULL, rpError);
                            }
                        }
                        break;
                    case kAttrAuthor:
                        {
                            retVal = CheckStringContents(pValue);
                            if (SUCCEEDED(retVal))
                            {
                                retVal = m_pRealPixFile->SetAuthor(pValue);
                            }

                            if (FAILED(retVal))
                            {
                                SetError(IDS_ERR_PIX_NULLAUTHOR, ulLine, ulCol, NULL, NULL, rpError);
                            }
                        }
                        break;
                    case kAttrCopyright:
                        {
                            retVal = CheckStringContents(pValue);
                            if (SUCCEEDED(retVal))
                            {
                                retVal = m_pRealPixFile->SetCopyright(pValue);
                            }

                            if (FAILED(retVal))
                            {
                                SetError(IDS_ERR_PIX_NULLCOPYRIGHT, ulLine, ulCol, NULL, NULL, rpError);
                            }
                        }
                        break;
                    case kAttrStart:
                        {
                            UINT32 ulTmp = 0;
                            retVal       = ConvertTimeValue(pValue, m_pRealPixFile->GetTimeFormat(), ulTmp);
                            if (SUCCEEDED(retVal))
                            {
                                m_pRealPixFile->SetStart(ulTmp);
                            }
                            else
                            {
                                SetError(IDS_ERR_PIX_BADSTARTTIME, ulLine, ulCol, NULL, NULL, rpError);
                            }
                        }
                        break;
                    case kAttrDuration:
                        {
                            UINT32 ulTmp = 0;
                            retVal       = ConvertTimeValue(pValue, m_pRealPixFile->GetTimeFormat(), ulTmp);
                            if (SUCCEEDED(retVal))
                            {
                                m_pRealPixFile->SetDuration(ulTmp);
                            }
                            else
                            {
                                SetError(IDS_ERR_PIX_BADDURATION, ulLine, ulCol, NULL, NULL, rpError);
                            }
                        }
                        break;
                    case kAttrPreroll:
                        {
                            UINT32 ulTmp = 0;
                            retVal       = ConvertTimeValue(pValue, m_pRealPixFile->GetTimeFormat(), ulTmp);
                            if (SUCCEEDED(retVal))
                            {
                                m_pRealPixFile->SetPreroll(ulTmp);
                            }
                            else
                            {
                                SetError(IDS_ERR_PIX_BADPREROLL, ulLine, ulCol, NULL, NULL, rpError);
                            }
                        }
                        break;
                    case kAttrBitrate:
                        {
                            UINT32 ulTmp = strtoul((const char*) pValue->GetBuffer(), NULL, 10);
                            m_pRealPixFile->SetBitrate(ulTmp);
                        }
                        break;
                    case kAttrWidth:
                        {
                            UINT32 ulTmp = strtoul((const char*) pValue->GetBuffer(), NULL, 10);
                            m_pRealPixFile->SetDisplayWidth(ulTmp);
                        }
                        break;
                    case kAttrHeight:
                        {
                            UINT32 ulTmp = strtoul((const char*) pValue->GetBuffer(), NULL, 10);
                            m_pRealPixFile->SetDisplayHeight(ulTmp);
                        }
                        break;
                    case kAttrMaxfps:
                        {
                            UINT32 ulTmp = strtoul((const char*) pValue->GetBuffer(), NULL, 10);
                            m_pRealPixFile->SetDefaultMaxFps(ulTmp);
                        }
                        break;