wirefmgr.cpp

linux下的一款播放器

        }
        if (bPack)
        {
            PackStringBuffer(rpBuf, m_pDefaultURLStr);
        }

        // Pack/add total mime count
        ulSize += 4;
        if (bPack)
        {
            Pack32(rpBuf, m_pCodecMimeList->GetCount() + m_pFXPackageMimeList->GetCount());
        }

        // Pack/add codec mime count
        ulSize += 4;
        if (bPack)
        {
            Pack32(rpBuf, m_pCodecMimeList->GetCount());
        }
        // Pack/add all the codec mime strings
        if (m_pCodecMimeList->GetCount() > 0)
        {
            // Loop through codec mime list and pack/add up strings
            LISTPOSITION pos = m_pCodecMimeList->GetHeadPosition();
            while (pos)
            {
                ulSize             += 2; // Add string size
                IHXBuffer* pBuffer = (IHXBuffer*) m_pCodecMimeList->GetNext(pos);
                if (pBuffer)
                {
                    UINT32 ulLen = (UINT32) strlen((const char*) pBuffer->GetBuffer());
                    if (ulLen > 0)
                    {
                        ulSize += ulLen + 1;
                    }
                }
                if (bPack)
                {
                    PackStringBuffer(rpBuf, pBuffer);
                }
            }
        }

        // Pack/add fxpackage mime count
        ulSize += 4;
        if (bPack)
        {
            Pack32(rpBuf, m_pFXPackageMimeList->GetCount());
        }
        // Pack/add all the fxpackage mime strings
        if (m_pFXPackageMimeList->GetCount() > 0)
        {
            // Loop through the fxpackage mime list and pack/add the strings
            LISTPOSITION pos = m_pFXPackageMimeList->GetHeadPosition();
            while (pos)
            {
                ulSize += 2; // Add string size
                IHXBuffer* pBuffer = (IHXBuffer*) m_pFXPackageMimeList->GetNext(pos);
                if (pBuffer)
                {
                    UINT32 ulLen = (UINT32) strlen((const char*) pBuffer->GetBuffer());
                    if (ulLen > 0)
                    {
                        ulSize += ulLen + 1;
                    }
                }
                if (bPack)
                {
                    PackStringBuffer(rpBuf, pBuffer);
                }
            }
        }
        // Add the size of the background color, if the
        // content version/stream version is 1.1.0.0
        if (m_ulContentVersion >= U2_STREAM_VERSION)
        {
            ulSize += 4;
            if (bPack)
            {
                Pack32(rpBuf, m_ulBackgroundColor);
            }
        }
    }

    return ulSize;
}

UINT32 PXWireFormatManager::UnPackUINT32(REF(BYTE*) rpBuffer)
{
    UINT32 ulRet = ((rpBuffer[0] << 24) & 0xFF000000) |
                   ((rpBuffer[1] << 16) & 0x00FF0000) |
                   ((rpBuffer[2] <<  8) & 0x0000FF00) |
                   ( rpBuffer[3]        & 0x000000FF);
    rpBuffer    += 4;
    return ulRet;
}

UINT32 PXWireFormatManager::UnPackUINT16(REF(BYTE*) rpBuffer)
{
    UINT32 ulRet = ((rpBuffer[0] << 8) & 0x0000FF00) |
                   ( rpBuffer[1]       & 0x000000FF);
    rpBuffer    += 2;
    return ulRet;
}

UINT32 PXWireFormatManager::UnPackUINT32_LE(REF(BYTE*) rpBuffer)
{
    UINT32 ulRet = ((rpBuffer[3] << 24) & 0xFF000000) |
                   ((rpBuffer[2] << 16) & 0x00FF0000) |
                   ((rpBuffer[1] <<  8) & 0x0000FF00) |
                   ( rpBuffer[0]        & 0x000000FF);
    rpBuffer    += 4;
    return ulRet;
}

UINT32 PXWireFormatManager::UnPackUINT16_LE(REF(BYTE*) rpBuffer)
{
    UINT32 ulRet = ((rpBuffer[1] << 8) & 0x0000FF00) |
                   ( rpBuffer[0]       & 0x000000FF);
    rpBuffer    += 2;
    return ulRet;
}

UINT32 PXWireFormatManager::UnPackBYTE(REF(BYTE*) rpBuffer)
{
    UINT32 ulRet = *rpBuffer++;
    return ulRet;
}

UINT32 PXWireFormatManager::UnPackVUINT(REF(BYTE*) rpBuffer)
{
    // Format of VUINT is:
    // 
    // 11bb bbbb  bbbb bbbb  bbbb bbbb  bbbb bbbb (value in range [0,0x3FFFFFFF])
    // 10bb bbbb  bbbb bbbb  (value in range [0,0x3FFF])
    // 0bbb bbbb (value in range [0,0x7F])
    //
    UINT32 ulRet       = 0;
    UINT32 ulFirstByte = rpBuffer[0];
    if (ulFirstByte & 0x00000080)
    {
        if (ulFirstByte & 0x00000040)
        {
            // This is a 4-byte value in range [0,0x3FFFFFFF]
            // but we have to mask out the highest two bits
            ulRet = UnPackUINT32(rpBuffer) & 0x3FFFFFFF;
        }
        else
        {
            // This is a 2-byte value in range [0,0x3FFF],
            // but we have to mask out the highest two bits
            ulRet = UnPackUINT16(rpBuffer) & 0x00003FFF;
        }
    }
    else
    {
        // This is a single byte value in range [0,0x7F]
        ulRet = UnPackBYTE(rpBuffer);
    }
    return ulRet;
}

void PXWireFormatManager::PackUINT32(REF(BYTE*) rpBuffer, UINT32 ulValue)
{
    rpBuffer[0] = (BYTE) ((ulValue >> 24) & 0x000000FF);
    rpBuffer[1] = (BYTE) ((ulValue >> 16) & 0x000000FF);
    rpBuffer[2] = (BYTE) ((ulValue >>  8) & 0x000000FF);
    rpBuffer[3] = (BYTE) ( ulValue        & 0x000000FF);
    rpBuffer   += 4;
}

void PXWireFormatManager::PackUINT16(REF(BYTE*) rpBuffer, UINT32 ulValue)
{
    HX_ASSERT(ulValue <= 0x0000FFFF);
    rpBuffer[0] = (BYTE) ((ulValue >> 8) & 0x000000FF);
    rpBuffer[1] = (BYTE) ( ulValue       & 0x000000FF);
    rpBuffer   += 2;
}

void PXWireFormatManager::PackBYTE(REF(BYTE*) rpBuffer, UINT32 ulValue)
{
    HX_ASSERT(ulValue <= 0x000000FF);
    rpBuffer[0] = (BYTE) ulValue;
    rpBuffer++;
}

void PXWireFormatManager::PackVUINT(REF(BYTE*) rpBuffer, UINT32 ulValue)
{
    // Format of VUINT is:
    // 
    // 11bb bbbb  bbbb bbbb  bbbb bbbb  bbbb bbbb (value in range [0,0x3FFFFFFF])
    // 10bb bbbb  bbbb bbbb  (value in range [0,0x3FFF])
    // 0bbb bbbb (value in range [0,0x7F])
    //
    HX_ASSERT(ulValue <= 0x3FFFFFFF);
    if (ulValue > 0x3FFF)
    {
        PackUINT32(rpBuffer, (ulValue | 0xC0000000));
    }
    else if (ulValue > 0x7F && ulValue <= 0x3FFF)
    {
        PackUINT16(rpBuffer, (ulValue | 0x00008000));
    }
    else
    {
        PackBYTE(rpBuffer, ulValue);
    }
}

UINT32 PXWireFormatManager::GetMask(UINT32 ulBitPos, UINT32 ulNumBits)
{
    UINT32 ulRet  = (1 << ulNumBits) - 1;
    INT32  lShift = (INT32) ulBitPos - ulNumBits + 1;
    if (lShift >= 0)
    {
        ulRet <<= lShift;
    }
    else
    {
        ulRet >>= -lShift;
    }
    return ulRet;
}

UINT32 PXWireFormatManager::GetUnsignedBits(REF(BYTE*) rpBuf, REF(UINT32) rulBitPos, UINT32 ulNumBits)
{
    UINT32 ulRet = 0;
    while (ulNumBits)
    {
        UINT32 ulBitsAvailable = rulBitPos + 1;
        if (ulNumBits >= ulBitsAvailable)
        {
            // We're gonna use the whole current byte and advance it
            ulRet     |= (*rpBuf & GetMask(rulBitPos, ulBitsAvailable)) << (ulNumBits - ulBitsAvailable);
            ulNumBits -= ulBitsAvailable;
            // Advance the buffer
            rpBuf++;
            rulBitPos = 7;
        }
        else
        {
            // We're only gonna use part of the current byte
            ulRet     |= (*rpBuf & GetMask(rulBitPos, ulNumBits)) >> (ulBitsAvailable - ulNumBits);
            // Advance the buffer
            rulBitPos -= ulNumBits;
            ulNumBits -= ulNumBits;
        }
    }

    return ulRet;
}

INT32 PXWireFormatManager::GetSignedBits(REF(BYTE*) rpBuf, REF(UINT32) rulBitPos, UINT32 ulNumBits)
{
    INT32 lRet = (INT32) GetUnsignedBits(rpBuf, rulBitPos, ulNumBits);
    if (lRet & (1L << (ulNumBits - 1)))
    {
        lRet |= (-1L << ulNumBits);
    }
    return lRet;
}

HX_RESULT PXWireFormatManager::SetTitle(const char* pszTitle)
{
    return SetString(pszTitle, m_pTitleStr);
}

HX_RESULT PXWireFormatManager::SetTitle(IHXBuffer* pTitleStr)
{
    return SetString(pTitleStr, m_pTitleStr);
}

HX_RESULT PXWireFormatManager::GetTitle(REF(IHXBuffer*) rpTitleStr)
{
    return SetString(m_pTitleStr, rpTitleStr);
}

HX_RESULT PXWireFormatManager::SetAuthor(const char* pszAuthor)
{
    return SetString(pszAuthor, m_pAuthorStr);
}

HX_RESULT PXWireFormatManager::SetAuthor(IHXBuffer* pAuthorStr)
{
    return SetString(pAuthorStr, m_pAuthorStr);
}

HX_RESULT PXWireFormatManager::GetAuthor(REF(IHXBuffer*) rpAuthorStr)
{
    return SetString(m_pAuthorStr, rpAuthorStr);
}

HX_RESULT PXWireFormatManager::SetCopyright(const char* pszCopyright)
{
    return SetString(pszCopyright, m_pCopyrightStr);
}

HX_RESULT PXWireFormatManager::SetCopyright(IHXBuffer* pCopyrightStr)
{
    return SetString(pCopyrightStr, m_pCopyrightStr);
}

HX_RESULT PXWireFormatManager::GetCopyright(REF(IHXBuffer*) rpCopyrightStr)
{
    return SetString(m_pCopyrightStr, rpCopyrightStr);
}

HX_RESULT PXWireFormatManager::SetDefaultURL(const char* pszDefaultURL)
{
    return SetString(pszDefaultURL, m_pDefaultURLStr);
}

HX_RESULT PXWireFormatManager::SetDefaultURL(IHXBuffer* pDefaultURLStr)
{
    return SetString(pDefaultURLStr, m_pDefaultURLStr);
}

HX_RESULT PXWireFormatManager::GetDefaultURL(REF(IHXBuffer*) rpDefaultURLStr)
{
    return SetString(m_pDefaultURLStr, rpDefaultURLStr);
}

HX_RESULT PXWireFormatManager::SetASMRuleBook(const char* pszRuleBook)
{
    return SetString(pszRuleBook, m_pASMRuleBook);
}

HX_RESULT PXWireFormatManager::SetASMRuleBook(IHXBuffer* pRuleBookStr)
{
    return SetString(pRuleBookStr, m_pASMRuleBook);
}

HX_RESULT PXWireFormatManager::GetASMRuleBook(REF(IHXBuffer*) rpRuleBookStr)
{
    return SetString(m_pASMRuleBook, rpRuleBookStr);
}

HX_RESULT PXWireFormatManager::SetStreamMimeType(const char* pszMime)
{
    return SetString(pszMime, m_pStreamMimeType);
}

HX_RESULT PXWireFormatManager::SetStreamMimeType(IHXBuffer* pMimeStr)
{
    return SetString(pMimeStr, m_pStreamMimeType);
}

HX_RESULT PXWireFormatManager::GetStreamMimeType(REF(IHXBuffer*) rpMimeStr)
{
    return SetString(m_pStreamMimeType, rpMimeStr);
}

HX_RESULT PXWireFormatManager::AddStringToList(const char* pszStr, CHXSimpleList* pList)
{
    HX_RESULT retVal = HXR_OK;

    if (pszStr && pList)
    {
        IHXBuffer* pBuffer = NULL;
        retVal              = SetString(pszStr, pBuffer);
        if (SUCCEEDED(retVal))
        {
            retVal = AddStringToList(pBuffer, pList);
        }
        HX_RELEASE(pBuffer);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXWireFormatManager::AddStringToList(IHXBuffer* pBufferStr, CHXSimpleList* pList)
{
    HX_RESULT retVal = HXR_OK;

    if (pBufferStr && pList)
    {
        // Let's make sure the string is not already in the list
        BOOL         bFoundMatch = FALSE;
        LISTPOSITION pos         = pList->GetHeadPosition();
        while (pos)
        {
            IHXBuffer* pStr = (IHXBuffer*) pList