wirefmgr.cpp

linux下的一款播放器

            }
        }
        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);
    HX_RELEASE(m_pDefaultURLStr);
    ReleaseAllCodecMimes();
    HX_DELETE(m_pCodecMimeList);
    ReleaseAllFXPackageMimes();
    HX_DELETE(m_pFXPackageMimeList);
    HX_DELETE(m_pMapMimeToOpaqueSize);
    HX_RELEASE(m_pASMRuleBook);
    HX_RELEASE(m_pStreamMimeType);
}

void PXWireFormatManager::Reset()
{
    m_ulStreamVersion     = HX_ENCODE_PROD_VERSION(0, 0, 0, 0);
    m_ulStart             = 0;
    m_ulDuration          = 0;
    m_bIsLive             = FALSE;
    m_bMinimizeLatency    = FALSE;
    m_ulPreroll           = 0;
    m_bPrerollAfterSeek   = TRUE;
    m_ulPreData           = 0;
    m_bPreDataAtStart     = TRUE;
    m_ulBitrate           = 0;
    m_ulDisplayWidth      = 0;
    m_ulDisplayHeight     = 0;
    m_bDefaultAspectFlag  = TRUE;
    m_ulDefaultMaxFps     = 0;
    m_ulContentVersion    = HX_ENCODE_PROD_VERSION(0, 0, 0, 0);
    m_ulBackgroundColor   = 0x00000000;
    m_ulBackgroundOpacity = 255;
    m_pCodecListPos       = NULL;
    m_pFXPackageListPos   = NULL;
    m_ulRendererFlags     = 0;
}

UINT32 PXWireFormatManager::PackStreamHeader(BYTE*& rpBuf, BOOL bPack)
{
    UINT32 ulSize = 0;

    if (HX_GET_MAJOR_VERSION(m_ulStreamVersion) <=
        HX_GET_MAJOR_VERSION(m_ulHighestSupportedStreamVersion) &&
        HX_GET_MINOR_VERSION(m_ulStreamVersion) <=
        HX_GET_MINOR_VERSION(m_ulHighestSupportedStreamVersion))
    {
        // Pack/add display width and height
        ulSize += 8;
        if (bPack)
        {
            Pack32(rpBuf, m_ulDisplayWidth);
            Pack32(rpBuf, m_ulDisplayHeight);
        }
        
        // Pack/add size of default URL
        ulSize += 2; // default URL size
        if (m_pDefaultURLStr)
        {
            UINT32 ulLen = (UINT32) strlen((const char*) m_pDefaultURLStr->GetBuffer());
            if (ulLen > 0)
            {
                ulSize += ulLen + 1;
            }