wirefmgr.cpp

来自「symbian 下的helix player源代码」· C++ 代码 · 共 1,873 行 · 第 1/5 页

                            // 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);
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::SetImageDataInfo(UINT32 ulHandle, IHXBuffer* pData, IHXBuffer* pOpaque,
                                                UINT32 ulPacketIndex, UINT32 ulTimeStamp, BOOL bRequired,
                                                REF(IHXPacket*) rpPacket)
{
    HX_RESULT retVal = HXR_FAIL;

    if (ulHandle && pData)
    {
        // Create an IHXBuffer
        IHXBuffer* pBuffer = NULL;
        retVal              = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
                                                                    (void**) &pBuffer);
        if (SUCCEEDED(retVal))
        {
            // Compute the size
// XXXMEH - move seq num into opaque temporarily
//            UINT32 ulSize = 12; // packet type, handle, seq num
            UINT32 ulSize = 8; // packet type, handle
            if (pOpaque)
            {
                ulSize += pOpaque->GetSize();
            }
            ulSize += pData->GetSize();

            // Set the size of the buffer
            retVal = pBuffer->SetSize(ulSize);
            if (SUCCEEDED(retVal))
            {
                // Pack the buffer
                //
                // First we pack the generic (codec-agnostic) header
                BYTE* pBuf = pBuffer->GetBuffer();
                Pack32(pBuf, kPacketTypeImageData);
                Pack32(pBuf, ulHandle);
// XXXMEH - move seq num into opaque temporarily
//                Pack32(pBuf, ulPacketIndex);
                // Now we pack the codec-specific per-packet opaque data
                if (pOpaque)
                {
                    memcpy(pBuf, pOpaque->GetBuffer(), pOpaque->GetSize()); /* Flawfinder: ignore */
                    pBuf += pOpaque->GetSize();
                }
                // Now we pack the codec-specific data straight from the file
                memcpy(pBuf, pData->GetBuffer(), pData->GetSize()); /* Flawfinder: ignore */
                pBuf += pData->GetSize();

                // 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
                                          (bRequired ? 1 : 0)); // ASM rule (0 if not required, 1 if required)
                    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::GetEffectType(IHXPacket* pPacket, REF(UINT32) rulType)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pPacket)
    {
        IHXBuffer* pBuffer = pPacket->GetBuffer();
        if (pBuffer)
        {
            BYTE* pBuf = pBuffer->GetBuffer();
            if (pBuf)
            {
                UINT32 ulPacketType = 0;
                UnPack32(pBuf, ulPacketType);
                if (ulPacketType == PXWireFormatManager::kPacketTypeEffect)
                {
                    UINT32 ulFlags      = 0;
                    UINT32 ulEffectType = 0;
                    UnPack32(pBuf, ulFlags);
                    UnPack32(pBuf, rulType);
                    retVal = HXR_OK;
                }
            }
        }
        HX_RELEASE(pBuffer);
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::GetEffectInfo(IHXPacket* pPacket, PXEffect** ppEffect)
{
    HX_RESULT retVal = HXR_OK;

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

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

                        // Initialize it from the opaque data
                        pBuf -= 4; // back up to the beginning
                        pEffect->UnPack(pBuf, HX_GET_MAJOR_VERSION(m_ulStreamVersion),
                                              HX_GET_MINOR_VERSION(m_ulStreamVersion));
                        if (SUCCEEDED(retVal))
                        {
                            // Assign the out parameter
                            *ppEffect = pEffect;
                            (*ppEffect)->AddRef();
                        }
                    }
                    // Release our ref on the packet
                    HX_RELEASE(pEffect);
                }
                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::SetEffectPacketParameters(IHXPacket* pPacket,
	UINT32 ulEffectType, UINT32 ulStart, UINT32 ulDuration)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pPacket)
    {
        IHXBuffer* pOldBuffer    = NULL;
        UINT32      ulOldTime     = 0;
        UINT16      usOldStrNum   = 0;
        UINT8       ucOldASMFlags = 0;
        UINT16      usOldRuleNum  = 0;
        retVal = pPacket->Get(pOldBuffer, ulOldTime, usOldStrNum, ucOldASMFlags,
		    usOldRuleNum);

        if (SUCCEEDED(retVal))
        {
            PXEffect* pEffect = NULL;
            retVal            = PXEffect::CreateObject(&pEffect);
            if (SUCCEEDED(retVal))
            {
		pEffect->AddRef();
                BYTE* pBuf = pOldBuffer->GetBuffer();
                pEffect->UnPack(pBuf,
                                HX_GET_MAJOR_VERSION(m_ulStreamVersion),
                                HX_GET_MINOR_VERSION(m_ulStreamVersion));
                // Update the parameters
                pEffect->SetEffectType((BYTE) ulEffectType);
                pEffect->SetStart(ulStart);
                pEffect->SetDuration(ulDuration);

                // Get a new buffer for it
                IHXBuffer* pNewBuffer = NULL;
                retVal                 = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
                                                                               (void**) &pNewBuffer);
                if (SUCCEEDED(retVal))
                {
                    // Set its size
                    retVal = pNewBuffer->SetSize(pEffect->PackedSize(HX_GET_MAJOR_VERSION(m_ulStreamVersion),
                                                                     HX_GET_MINOR_VERSION(m_ulStreamVersion)));
                    if (SUCCEEDED(retVal))
                    {
                        // Pack the new effect
                        BYTE* pBuf = pNewBuffer->GetBuffer();
                        pEffect->Pack(pBuf,
                                      HX_GET_MAJOR_VERSION(m_ulStreamVersion),
                                      HX_GET_MINOR_VERSION(m_ulStreamVersion));
                        // Set the new buffer into the packet
                        retVal = pPacket->Set(pNewBuffer, ulOldTime, usOldStrNum,
                                              ucOldASMFlags, usOldRuleNum);
                    }
                }
                HX_RELEASE(pNewBuffer);
            }
            HX_RELEASE(pEffect);
        }
        HX_RELEASE(pOldBuffer);
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::SetEffectInfo(PXEffect* pEffect, UINT32 ulTimeStamp, REF(IHXPacket*) rpPacket)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pEffect)
    {
        // Create an IHXBuffer
        IHXBuffer* pBuffer = NULL;
        retVal              = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
                                                                    (void**) &pBuffer);
        if (SUCCEEDED(retVal))
        {
            // Compute the size
            UINT32 ulSize = pEffect->PackedSize(HX_GET_MAJOR_VERSION(m_ulStreamVersion),
                                                HX_GET_MINOR_VERSION(m_ulStreamVersion));

            // Set the size of the buffer
            retVal = pBuffer->SetSize(ulSize);
            if (SUCCEEDED(retVal))
            {
                // Pack the buffer
                BYTE* pBuf = pBuffer->GetBuffer();
                pEffect->Pack(pBuf,
                              HX_GET_MAJOR_VERSION(m_ulStreamVersion),
                              HX_GET_MINOR_VERSION(m_ulStreamVersion));

                // 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::SetCookieInfo(UINT32 ulNumCookies, IHXBuffer** ppURL, IHXBuffer** ppCookie,
                                             UINT32 ulTimeStamp, REF(IHXPacket*) rpPacket)
{
    HX_RESULT retVal = HXR_OK;

    if (ulNumCookies && ppURL && ppCookie)
    {
        // Compute size of packet
        UINT32 ulSize = 8;
        UINT32 i      = 0;
        for (i = 0; i < ulNumCookies; i++)
        {
            if (ppURL[i] && ppCookie[i])
            {
                ulSize += 4;                      // Size of URL
                ulSize += ppURL[i]->GetSize();    // URL
                ulSize += 4;                      // Size of Set-Cookie
                ulSize += ppCookie[i]->GetSize(); // Set-Cookie
            }
            else
            {
                retVal = HXR_FAIL;

            }
        }

        if (SUCCEEDED(retVal))
        {
            // Create opaque data buffer
            IHXBuffer* pBuffer = NULL;
            retVal              = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer, (void**) &pBuffer);
            if (SUCCEEDED(retVal))
            {
                // Set its size
                retVal = pBuffer->SetSize(ulSize);
                if (SUCCEEDED(retVal))
                {
                    // Pack the buffer
                    BYTE* pBuf = pBuffer->GetBuffer();
                    Pack32(pBuf, kPacketTypeCookie);
                    Pack32(pBuf, ulNumCookies);
                    for (i = 0; i < ulNumCookies; i++)
                    {
                        Pack32(pBuf, ppURL[i]->GetSize());
                        memcpy(pBuf, ppURL[i]->GetBuffer(), ppURL[i]->GetSize()); /* Flawfinder: ignore */
                        pBuf += ppURL[i]->GetSize();
                        Pack32(pBuf, ppCookie[i]->GetSize());
                        memcpy(pBuf, ppCookie[i]->GetBuffer(), ppCookie[i]->GetSize()); /* Flawfinder: ignore */
                        pBuf += ppCookie[i]->GetSize();
                    }
                    // Create an IHXPacket object
                    IHXPacket* pPacket = NULL;
                    retVal              = m_pCommonClassFactory->CreateInstance(CLSID_IHXPacket, (void**) &pPacket);
                    if (SUCCEEDED(retVal))
                    {
                        // Set the packet parameters
                        retVal = pPacket->Set(pBuffer,           // opaque data