wirefmgr.cpp

linux下的一款播放器

    return retVal;
}

HX_RESULT PXWireFormatManager::OnHeader(IHXValues* pHeader)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pHeader)
    {
        pHeader->GetPropertyULONG32("Duration",          m_ulDuration);
        pHeader->GetPropertyULONG32("ContentVersion",    m_ulContentVersion);
        pHeader->GetPropertyULONG32("RendererFlags",     m_ulRendererFlags);
        pHeader->GetPropertyULONG32("BackgroundOpacity", m_ulBackgroundOpacity);

        IHXBuffer* pBuffer = NULL;
        retVal              = pHeader->GetPropertyBuffer("OpaqueData", pBuffer);
        if (SUCCEEDED(retVal))
        {
            if (m_ulStreamVersion <= m_ulHighestSupportedStreamVersion)
            {
                // Get the display width and display height
                BYTE *pBuf = pBuffer->GetBuffer();
                UnPack32(pBuf, m_ulDisplayWidth);
                UnPack32(pBuf, m_ulDisplayHeight);

                // Get default URL
                HX_RELEASE(m_pDefaultURLStr);
                retVal = UnPackStringBuffer(pBuf, &m_pDefaultURLStr);
                if (SUCCEEDED(retVal))
                {
                    // Unpack total mimes
                    UINT32 ulTotalMimes = 0;
                    UnPack32(pBuf, ulTotalMimes);

                    // Unpack codec mimes
                    UINT32 ulNumCodecs = 0;
                    UnPack32(pBuf, ulNumCodecs);
                    ReleaseAllCodecMimes();
                    if (ulNumCodecs > 0)
                    {
                        for (UINT32 i = 0; i < ulNumCodecs; i++)
                        {
                            IHXBuffer* pMime = NULL;
                            retVal            = UnPackStringBuffer(pBuf, &pMime);
                            if (SUCCEEDED(retVal))
                            {
                                retVal = AddCodecMime(pMime);
                            }
                            HX_RELEASE(pMime);

                            if (FAILED(retVal))
                            {
                                break;
                            }
                        }
                    }

                    if (SUCCEEDED(retVal))
                    {
                        // Unpack fxpackage mimes
                        UINT32 ulNumFXPackages = 0;
                        UnPack32(pBuf, ulNumFXPackages);
                        ReleaseAllFXPackageMimes();
                        if (ulNumFXPackages > 0)
                        {
                            for (UINT32 i = 0; i < ulNumFXPackages; i++)
                            {
                                IHXBuffer* pMime = NULL;
                                retVal            = UnPackStringBuffer(pBuf, &pMime);
                                if (SUCCEEDED(retVal))
                                {
                                    retVal = AddFXPackageMime(pMime);
                                }
                                HX_RELEASE(pMime);

                                if (FAILED(retVal))
                                {
                                    break;
                                }
                            }
                        }

                        if (SUCCEEDED(retVal))
                        {
                            // If the stream version is greater than or equal to 1.1.0.0,
                            // then get the background color
                            if (m_ulStreamVersion >= U2_STREAM_VERSION)
                            {
                                UnPack32(pBuf, m_ulBackgroundColor);
                            }
                        }
                    }
                }
            }
            else
            {
                retVal = HXR_FAIL;
            }
        }
        HX_RELEASE(pBuffer);
    }

    if (FAILED(retVal))
    {
        // We had an error, so reset the state
        m_ulDisplayWidth  = 0;
        m_ulDisplayHeight = 0;
        HX_RELEASE(m_pDefaultURLStr);
        ReleaseAllCodecMimes();
        ReleaseAllFXPackageMimes();
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::GetPacketType(IHXPacket* pPacket, REF(UINT32) rulType)
{
    HX_RESULT retVal = HXR_OK;

    if (pPacket)
    {
        IHXBuffer* pBuffer = pPacket->GetBuffer();
        if (pBuffer)
        {
            BYTE* pBuf = pBuffer->GetBuffer();
            if (pBuf)
            {
                UnPack32(pBuf, rulType);
            }
            else
            {
                retVal = HXR_FAIL;
            }
        }
        else
        {
            retVal = HXR_FAIL;
        }
        HX_RELEASE(pBuffer);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::GetImageHeaderInfo(IHXPacket* pPacket, REF(UINT32) rulHandle,
                                                  REF(UINT32) rulFileLength, REF(UINT32) rulFlags,
                                                  IHXBuffer** ppMimeStr, REF(UINT32) rulOpaqueSize)
{
    HX_RESULT retVal = HXR_OK;

    if (pPacket && ppMimeStr)
    {
        IHXBuffer* pBuffer = pPacket->GetBuffer();
        if (pBuffer)
        {
            BYTE* pBuf = pBuffer->GetBuffer();
            if (pBuf)
            {
                UINT32 ulType = 0xFFFFFFFF;
                UnPack32(pBuf, ulType);

                if (ulType == kPacketTypeImageHeader)
                {
                    UINT32      ulHandle = 0;
                    UINT32      ulLength = 0;
                    UINT32      ulFlags  = 0;
                    IHXBuffer* pMimeStr = NULL;

                    UnPack32(pBuf, ulHandle);
                    UnPack32(pBuf, ulLength);
                    UnPack32(pBuf, ulFlags);

                    retVal = UnPackStringBuffer(pBuf, &pMimeStr);
                    if (SUCCEEDED(retVal))
                    {
                        // Assign out parameters
                        rulHandle      = ulHandle;
                        rulFileLength  = ulLength;
                        rulFlags       = ulFlags;
                        *ppMimeStr     = pMimeStr;
                        (*ppMimeStr)->AddRef();
                        // XXXMEH - this SHOULD come from the image header data,
                        // instead of having it hard-coded in the renderer. Having it
                        // hard-coded introduces codec<->renderer dependencies where
                        // none should exist. However, the current wire format does
                        // not have this information.
                        rulOpaqueSize  = GetOpaqueSize((const char*) pMimeStr->GetBuffer());
                    }
                    HX_RELEASE(pMimeStr);
                }
                else
                {
                    retVal = HXR_FAIL;
                }
            }
            else
            {
                retVal = HXR_FAIL;
            }
        }
        else
        {
            retVal = HXR_FAIL;
        }
        HX_RELEASE(pBuffer);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::SetImageHeaderInfo(UINT32 ulHandle, UINT32 ulFileLength, UINT32 ulFlags,
                                                  const char* pszMime, UINT32 ulTimeStamp, REF(IHXPacket*) rpPacket)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pszMime)
    {
        IHXBuffer* pMimeStr = NULL;
        retVal               = SetString(pszMime, pMimeStr);
        if (SUCCEEDED(retVal))
        {
            retVal = SetImageHeaderInfo(ulHandle, ulFileLength, ulFlags, pMimeStr, ulTimeStamp, rpPacket);
        }
        HX_RELEASE(pMimeStr);
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::SetImageHeaderInfo(UINT32 ulHandle, UINT32 ulFileLength, UINT32 ulFlags,
                                                  IHXBuffer* pMimeStr, UINT32 ulTimeStamp, REF(IHXPacket*) rpPacket)
{
    HX_RESULT retVal = HXR_FAIL;

    if (ulHandle && ulFileLength && pMimeStr)
    {
        // Create an IHXBuffer
        IHXBuffer* pBuffer = NULL;
        retVal              = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
                                                                    (void**) &pBuffer);
        if (SUCCEEDED(retVal))
        {
            // Compute the size
            UINT32 ulSize = 0;
            ulSize       += 16; // packet type, handle, length, flags
            ulSize       += 2;  // mime type string length
            UINT32 ulLen  = strlen((const char*) pMimeStr->GetBuffer());
            if (ulLen)
            {
                ulSize += ulLen + 1;
            }

            // Set the size of the buffer
            retVal = pBuffer->SetSize(ulSize);
            if (SUCCEEDED(retVal))
            {
                // Pack the buffer
                BYTE* pBuf = pBuffer->GetBuffer();
                Pack32(pBuf,           kPacketTypeImageHeader);
                Pack32(pBuf,           ulHandle);
                Pack32(pBuf,           ulFileLength);
                Pack32(pBuf,           ulFlags);
                PackStringBuffer(pBuf, pMimeStr);

                // Create an IHXPacket
                IHXPacket* pPacket = NULL;
                retVal              = m_pCommonClassFactory->CreateInstance(CLSID_IHXPacket,
                                                                            (void**) &pPacket);
                if (SUCCEEDED(retVal))
                {
                    retVal = pPacket->Set(pBuffer,           // opaque data
                                          ulTimeStamp,       // time stamp
                                          0,                 // stream 0
                                          HX_ASM_SWITCH_ON, // ASM flag
                                          1);                // ASM rule 1
                    if (SUCCEEDED(retVal))
                    {
                        // Assign to out parameter
                        HX_RELEASE(rpPacket);
                        rpPacket = pPacket;
                        rpPacket->AddRef();
                    }
                }
                HX_RELEASE(pPacket);
            }
        }
        HX_RELEASE(pBuffer);
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::GetImageDataHandle(IHXPacket* pPacket, REF(UINT32) rulHandle)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pPacket)
    {
        IHXBuffer* pBuffer = pPacket->GetBuffer();
        if (pBuffer)
        {
            BYTE* pBuf = pBuffer->GetBuffer();
            if (pBuf)
            {
                // Make sure this is an image data packet
                UINT32 ulType = 0xFFFFFFFF;
                UnPack32(pBuf, ulType);

                if (ulType == kPacketTypeImageData)
                {
                    // Unpack the handle
                    UnPack32(pBuf, rulHandle);
                    retVal = HXR_OK;
                }
            }
        }
        HX_RELEASE(pBuffer);
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::GetImageDataInfo(IHXPacket* pPacket, UINT32 ulOpaqueSize,
                                                REF(IHXBuffer*) rpOpaque, REF(IHXBuffer*) rpData)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pPacket)
    {
        IHXBuffer* pBuffer = pPacket->GetBuffer();
        if (pBuffer)
        {
            BYTE* pBuf = pBuffer->GetBuffer();
            if (pBuf)
            {
                // Make sure this is an image data packet
                UINT32 ulType = 0xFFFFFFFF;
                UnPack32(pBuf, ulType);

                if (ulType == kPacketTypeImageData)
                {
                    // Create a nested buffer class
                    CHXNestedBuffer *pOpaque = NULL;
                    retVal = CHXNestedBuffer::CreateObject(&pOpaque);
                    if (SUCCEEDED(retVal))
                    {
                        // Addref the object
                        pOpaque->AddRef();
                        // Init the object
                        retVal = pOpaque->Init(pBuffer, 8, ulOpaqueSize);
                        if (SUCCEEDED(retVal))
                        {
                            // Create a nested buffer class
                            CHXNestedBuffer *pData = NULL;
                            retVal = CHXNestedBuffer::CreateObject(&pData);
                            if (SUCCEEDED(retVal))
                            {
                                // Addref the object
                                pData->AddRef();
                                // Init the object
                                UINT32 ulDataOffset = 8 + ulOpaqueSize;
                                retVal = pData->Init(pBuffer, ulDataOffset, pBuffer->GetSize() - ulDataOffset);
                                if (SUCCEEDED(retVal))
                                {
                                    // Assign the out parameters
                                    HX_RELEASE(rpOpaque);
                                    rpOpaque = pOpaque;
                                    rpOpaque->AddRef();
                                    HX_RELEASE(rpData);
                                    rpData   = pData;
                                    rpData->AddRef();
                                    retVal = HXR_OK;
                                }
                            }
                            HX_RELEASE(pData);
                        }
                    }
                    HX_RELEASE(pOpaque);
                }
            }
        }
        HX_RELEASE(pBuffer);