wirefmgr.cpp

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

                                              ulTimeStamp,       // time stamp
                                              0,                 // stream 0
                                              HX_ASM_SWITCH_ON, // ASM flag
                                              0);                // ASM rule 0
                        if (SUCCEEDED(retVal))
                        {
                            // Assign the out parameters
                            HX_RELEASE(rpPacket);
                            rpPacket = pPacket;
                            rpPacket->AddRef();
                        }
                    }
                    HX_RELEASE(pPacket);
                }
            }
            HX_RELEASE(pBuffer);
        }
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;
}

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

    if (pPacket)
    {
        IHXBuffer* pBuffer = pPacket->GetBuffer();
        if (pBuffer)
        {
            BYTE*  pBuf         = pBuffer->GetBuffer();
            UINT32 ulPacketType = 0;
            UINT32 ulNumCookies = 0;
            UnPack32(pBuf, ulPacketType);
            UnPack32(pBuf, ulNumCookies);

            if (ulPacketType == kPacketTypeCookie)
            {
                retVal        = HXR_OK;
                rulNumCookies = ulNumCookies;
            }
        }
        HX_RELEASE(pBuffer);
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::GetCookie(IHXPacket* pPacket, UINT32 ulIndex,
                                         REF(IHXBuffer*) rpURL, REF(IHXBuffer*) rpBuffer)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pPacket)
    {
        IHXBuffer* pBuffer = pPacket->GetBuffer();
        if (pBuffer)
        {
            BYTE*  pBuf         = pBuffer->GetBuffer();
            UINT32 ulPacketType = 0;
            UINT32 ulNumCookies = 0;
            UnPack32(pBuf, ulPacketType);
            UnPack32(pBuf, ulNumCookies);

            if (ulPacketType == kPacketTypeCookie &&
                ulIndex      <  ulNumCookies)
            {
                // Advance up to the proper cookie
                UINT32 ulURLSize    = 0;
                UINT32 ulCookieSize = 0;
                for (UINT32 i = 0; i < ulIndex; i++)
                {
                    UnPack32(pBuf, ulURLSize);
                    pBuf += ulURLSize;
                    UnPack32(pBuf, ulCookieSize);
                    pBuf += ulCookieSize;
                }
                // Get the size of the URL
                UnPack32(pBuf, ulURLSize);
                // Get the offset of the URL
                UINT32 ulURLOffset = pBuf - pBuffer->GetBuffer();
                // Advance to the cookie
                pBuf += ulURLSize;
                // Create a nested buffer class
                CHXNestedBuffer *pNestedURLBuffer = NULL;
                retVal = CHXNestedBuffer::CreateObject(&pNestedURLBuffer);
                if (SUCCEEDED(retVal))
                {
                    // Addref the object
                    pNestedURLBuffer->AddRef();
                    // Init the object
                    retVal = pNestedURLBuffer->Init(pBuffer, ulURLOffset, ulURLSize);
                    if (SUCCEEDED(retVal))
                    {
                        // Get the size of the cookie
                        UnPack32(pBuf, ulCookieSize);
                        // Get the offset of this cookie
                        UINT32 ulCookieOffset = pBuf - pBuffer->GetBuffer();
                        // Create a nested buffer class
                        CHXNestedBuffer *pNestedCookieBuffer = NULL;
                        retVal = CHXNestedBuffer::CreateObject(&pNestedCookieBuffer);
                        if (SUCCEEDED(retVal))
                        {
                            // Addref the object
                            pNestedCookieBuffer->AddRef();
                            // Init the object
                            retVal = pNestedCookieBuffer->Init(pBuffer, ulCookieOffset, ulCookieSize);
                            if (SUCCEEDED(retVal))
                            {
                                // Assign the nested buffer to the out parameter
                                HX_RELEASE(rpURL);
                                retVal = pNestedURLBuffer->QueryInterface(IID_IHXBuffer, (void**) &rpURL);
                                if (SUCCEEDED(retVal))
                                {
                                    HX_RELEASE(rpBuffer);
                                    retVal = pNestedCookieBuffer->QueryInterface(IID_IHXBuffer, (void**) &rpBuffer);
                                }
                            }
                        }
                        HX_RELEASE(pNestedCookieBuffer);
                    }
                }
                HX_RELEASE(pNestedURLBuffer);
            }
        }
        HX_RELEASE(pBuffer);
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::SetNoOpInfo(UINT32 ulSize, UINT32 ulTimeStamp, REF(IHXPacket*) rpPacket)
{
    HX_RESULT retVal = HXR_FAIL;

    if (ulSize >= 4)
    {
        IHXBuffer* pBuffer = NULL;
        retVal              = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer, (void**) &pBuffer);
        if (SUCCEEDED(retVal))
        {
            retVal = pBuffer->SetSize(ulSize);
            if (SUCCEEDED(retVal))
            {
                BYTE* pBuf = pBuffer->GetBuffer();
                Pack32(pBuf, 0xFFFFFFFF);
                
                IHXPacket* pPacket = NULL;
                retVal              = m_pCommonClassFactory->CreateInstance(CLSID_IHXPacket, (void**) &pPacket);
                if (SUCCEEDED(retVal))
                {
                    // Set the packet parameters
                    retVal = pPacket->Set(pBuffer,           // opaque data
                                          ulTimeStamp,       // time stamp
                                          0,                 // stream 0
                                          HX_ASM_SWITCH_ON, // ASM flag
                                          0);                // ASM rule 0
                    if (SUCCEEDED(retVal))
                    {
                        // Assign the out parameters
                        HX_RELEASE(rpPacket);
                        rpPacket = pPacket;
                        rpPacket->AddRef();
                    }
                }
                HX_RELEASE(pPacket);
            }
        }
        HX_RELEASE(pBuffer);
    }

    return retVal;
}

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

    if (pPacket)
    {
        IHXBuffer* pBuffer = pPacket->GetBuffer();
        if (pBuffer)
        {
            BYTE* pBuf = pBuffer->GetBuffer();
            if (pBuf)
            {
                UINT32 ulOpCode = UnPackUINT32(pBuf);
                if (ulOpCode == 0x34414453) // "4ADS"
                {
                    rulHandle      = UnPackUINT32(pBuf);
                    rulTimeStopped = UnPackUINT32(pBuf);
                    retVal         = HXR_OK;
                }
            }
        }
        HX_RELEASE(pBuffer);
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::SetBackChannelInfo(UINT32 ulHandle, UINT32 ulTimeStopped,
                                                  REF(IHXPacket*) rpPacket)
{
    HX_RESULT retVal = HXR_OK;

    if (ulHandle)
    {
        IHXBuffer* pBuffer = NULL;
        retVal              = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
                                                                    (void**) &pBuffer);
        if (SUCCEEDED(retVal))
        {
            retVal = pBuffer->SetSize(12);
            if (SUCCEEDED(retVal))
            {
                // Pack the opaque buffer
                BYTE* pBuf = pBuffer->GetBuffer();
                PackUINT32(pBuf, 0x34414453);
                PackUINT32(pBuf, ulHandle);
                PackUINT32(pBuf, ulTimeStopped);
                // Create the packet
                IHXPacket* pPacket = NULL;
                retVal              = m_pCommonClassFactory->CreateInstance(CLSID_IHXPacket,
                                                                            (void**) &pPacket);
                if (SUCCEEDED(retVal))
                {
                    // Set the packet parameters
                    retVal = pPacket->Set(pBuffer,            // opaque data
                                          0,                  // time stamp
                                          0,                  // stream 0
                                          HX_ASM_SWITCH_OFF, // ASM flag
                                          0);                 // 
                    if (SUCCEEDED(retVal))
                    {
                        // Pass the packet back
                        HX_RELEASE(rpPacket);
                        rpPacket = pPacket;
                        rpPacket->AddRef();
                    }
                }
                HX_RELEASE(pPacket);
            }
        }
        HX_RELEASE(pBuffer);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

UINT32 PXWireFormatManager::GetEffectWireSize(PXEffect* pEffect)
{
    UINT32 ulRet = 0;

    if (pEffect)
    {
        ulRet += pEffect->PackedSize(HX_GET_MAJOR_VERSION(m_ulStreamVersion),
                                     HX_GET_MINOR_VERSION(m_ulStreamVersion));
        ulRet += kIHXPacketOverhead;
    }

    return ulRet;
}

UINT32 PXWireFormatManager::GetImageWireSize(IHXBuffer* pStreamMimeStr, UINT32 ulImageFileSize)
{
    UINT32 ulRet = 0;

    if (pStreamMimeStr && ulImageFileSize)
    {
        // First we add the image header packet
        //
        // Add fixed size of image header packet
        ulRet += 18;
        // Add stream mime type string length of image header packet
        UINT32 ulMimeLen = strlen((const char*) pStreamMimeStr->GetBuffer());
        if (ulMimeLen)
        {
            ulRet += ulMimeLen + 1;
        }
        // Add the IHXPacket overhead of the image header packet
        ulRet += kIHXPacketOverhead;

        // Now we make a worst-case estimate of the number of packets
        // for this image.
        UINT32 ulWorstCaseNumPackets = (ulImageFileSize + kMinImageDataPacketSize - 1) / kMinImageDataPacketSize;
        // Now, based on this estimated number of packets we can
        // compute the overhead
        UINT32 ulWorstCaseOverhead   = (kIHXPacketOverhead + 8 + GetOpaqueSize((const char*) pStreamMimeStr->GetBuffer())) *
                                       ulWorstCaseNumPackets;
        // Now add the wire size for the image data packets - this
        // is the file size plus the worst case overhead
        ulRet += ulImageFileSize;
        ulRet += ulWorstCaseOverhead;
    }

    return ulRet;
}

UINT32 PXWireFormatManager::GetPacketSize(IHXPacket* pPacket)
{
    UINT32 ulSize = 0;

    if (pPacket)
    {
        IHXBuffer* pBuffer = pPacket->GetBuffer();
        if (pBuffer)
        {
            ulSize = pBuffer->GetSize();
        }
        HX_RELEASE(pBuffer);
    }

    return ulSize;
}

UINT32 PXWireFormatManager::GetOpaqueSize(const char* pszMimeType)
{
    UINT32 ulRetVal = kDefaultOpaqueSize;
    if (m_pMapMimeToOpaqueSize)
    {
        void *pVoid = NULL;
        if (m_pMapMimeToOpaqueSize->Lookup(pszMimeType, pVoid))
        {
            ulRetVal = (UINT32) pVoid;
        }
    }
    return ulRetVal;
}

void PXWireFormatManager::ReleaseAllCodecMimes()
{
    if (m_pCodecMimeList)
    {
        LISTPOSITION pos = m_pCodecMimeList->GetHeadPosition();
        while (pos)
        {
            IHXBuffer* pBuffer = (IHXBuffer*) m_pCodecMimeList->GetNext(pos);
            HX_RELEASE(pBuffer);
        }
        m_pCodecMimeList->RemoveAll();
    }
}

void PXWireFormatManager::ReleaseAllFXPackageMimes()
{
    if (m_pFXPackageMimeList)
    {
        LISTPOSITION pos = m_pFXPackageMimeList->GetHeadPosition();
        while (pos)
        {
            IHXBuffer* pBuffer = (IHXBuffer*) m_pFXPackageMimeList->GetNext(pos);
            HX_RELEASE(pBuffer);
        }
        m_pFXPackageMimeList->RemoveAll();
    }
}

void PXWireFormatManager::Deallocate()
{
    HX_RELEASE(m_pContext);
    HX_RELEASE(m_pCommonClassFactory);
    HX_RELEASE(m_pTitleStr);
    HX_RELEASE(m_pAuthorStr);
    HX_RELEASE(m_pCopyrightStr);