mp3format.cpp

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

        nRet += head.pad;

        if (nRet > (int)dwSize)
            nRet = 0;
    }

    return nRet;
}

int CMp3Format::UnformatMP3Frame(CMp3Queue* pQueue,
                                 UINT8* pDest,
                                 UINT32 &ulTime)
{
    tFrameInfo* pInfo = pQueue->GetHead();
    ulTime = pInfo->ulTime;

    // Do we have enough bytes for the frame
    if (pInfo->ulFrameSize - pInfo->ulHdrSize <= pQueue->GetDataBytes())
    {
        int nFrameSize = pInfo->ulFrameSize,
            nRet = pInfo->ulFrameSize;

        memcpy(pDest, pInfo->pHdr, pInfo->ulHdrSize); /* Flawfinder: ignore */
        pDest += pInfo->ulHdrSize;

        memcpy(pDest, pInfo->pData, pInfo->ulDataSize); /* Flawfinder: ignore */
        nFrameSize -= pInfo->ulDataSize + pInfo->ulHdrSize;

        pQueue->RemoveDataBytes(pInfo->ulDataSize);

        pInfo->pData += pInfo->ulDataSize;
        pDest += pInfo->ulDataSize;
        pInfo->ulDataSize = 0;

        int nCopy;

        // Copy data from future frames until we comple this frame
        while (nFrameSize)
        {
            pInfo = pQueue->Next();

            nCopy = min(pInfo->ulDataSize, (UINT32)nFrameSize);
            memcpy(pDest, pInfo->pData, nCopy); /* Flawfinder: ignore */

            pDest += nCopy;
            pInfo->pData += nCopy;

            pInfo->ulDataSize -= nCopy;
            nFrameSize -= nCopy;

            pQueue->RemoveDataBytes(nCopy);
        }

        pQueue->RemoveHead();
        return nRet;
    }
    else
        return 0;
}

INT32 CMp3Format::ScanForSyncWord(UINT8 *pBuf,
                                  INT32 lSize,
                                  int &nFrameSize)
{
    UINT8       *pStart = pBuf,
                *pEnd = pBuf + lSize - 4,
                *pTemp = NULL,
                ySyncCheck = 0;
    MPEG_HEAD   head;
    int         iFrameSize = 0;

    if (lSize < 4)
        return -1;

    nFrameSize = 0;

    for (; pBuf < pEnd; pBuf++)
    {
        if (pBuf[0] != 0xFF)
            continue;
            
        if (m_ySyncWord)
        {
            if (!IsValidSyncWord(pBuf[1]))
                continue;
        }
        else if ((pBuf[1] & 0xE0) != 0xE0)
            continue;

        ySyncCheck = pBuf[1];

        memset(&head, 0, sizeof(head));
        iFrameSize = head_info(pBuf, pEnd-pBuf, &head, m_bTrustPackets);

        // Looks like a valid frame
        if (iFrameSize)
        {
            iFrameSize += head.pad;

            // Check for another frame
            if (pBuf+iFrameSize < pEnd+3)
            {
                pTemp = pBuf + iFrameSize;

                // We do not have consequitve frames..what to do, what to do?
                if ((pTemp[0] != 0xFF) |
                    (pTemp[1] != ySyncCheck))
                {
                    INT32 lHeaderSize = 0;

                    // First, check for know non-mp3 data that may
                    // reside in an mp3 stream and terminate a frame.
                    BOOL bFoundHdr = FALSE;
                    
                    if (m_pMisc)
                        bFoundHdr = m_pMisc->CheckForHeaders(pTemp,
                                                             pEnd-pTemp+4,
                                                             lHeaderSize);
                    if (bFoundHdr)
                        nFrameSize = iFrameSize;

                    // Next, check if the padding bit was incorrectly set 
                    else if ((pTemp[-1] == 0xFF) &
                             (pTemp[0] == ySyncCheck))
                        nFrameSize = iFrameSize;

                    // Finally, check if the padding bit was not set and
                    // should have been.
                    else if ((pTemp[1] == 0xFF) &
                             (pTemp[2] == ySyncCheck))
                        nFrameSize = iFrameSize;

                    // Did not find consequtive frames.  Keep looking
                    else
                        continue;
                }
                else
                {
                    // We found a frame
                    nFrameSize = iFrameSize;
                }
            }
            // There is one full frame in this buffer
            else if (pBuf+iFrameSize == pEnd+4)
            {
                // We found a frame
                nFrameSize = iFrameSize;             
            }

            break;
        }
    }                                                                      

    if (nFrameSize)
        return pBuf - pStart;
    else
        return -1;
}

BOOL CMp3Format::CheckForHeaders(UINT8 *pBuf,
                                 UINT32 dwSize,
                                 INT32 &lHeaderSize)  
{
    if (m_pMisc)
        return m_pMisc->CheckForHeaders(pBuf, dwSize, lHeaderSize);
    else
        return FALSE;
}

eHeaderType CMp3Format::GetHeaderType()
{
    if (m_pMisc)
        return m_pMisc->GetHeaderType();
    else
        return eNone;
}

// Functions to access the Id3 header values
UINT8* CMp3Format::GetId3Title(int &nLen)
{
    if (m_pMisc)
        return m_pMisc->GetId3Title(nLen);
    else
        return NULL;
}

UINT8* CMp3Format::GetId3Artist(int &nLen)
{
    if (m_pMisc)
        return m_pMisc->GetId3Artist(nLen);
    else
        return NULL;
}

UINT8* CMp3Format::GetId3Album(int &nLen)
{
    if (m_pMisc)
        return m_pMisc->GetId3Album(nLen);
    else
        return NULL;
}

UINT8* CMp3Format::GetId3Genre(int &nLen)
{
    if (m_pMisc)
        return m_pMisc->GetId3Genre(nLen);
    else
        return NULL;
}

int CMp3Format::GetMetaOffset()
{
    if (m_pMisc)
        return m_pMisc->GetMetaOffset();
    else
        return 0;
}

int CMp3Format::GetMetaRepeat()
{
    if (m_pMisc)
        return m_pMisc->GetMetaRepeat();
    else
        return 0;
}

///////////////////////////////////////////////////////////////////////////////
// Private Functions

BOOL CMp3Format::GetDataOffsetMPEG1(UINT8 *pHeader,
                                    UINT32 dwSize,
                                    int &nFrameSize,
                                    int &nHeaderSize,
                                    int &nDataOffset,
                                    int trustPackets)
{
    // Get header info
    MPEG_HEAD h;
    memset(&h, 0, sizeof(h));
    nFrameSize = head_info(pHeader, dwSize, &h, trustPackets);
    
    if (nFrameSize)
        nFrameSize += h.pad;

    // HeaderSize is the sync word, CRC, and side info
    nHeaderSize = 4;

    // Check protection bit
    if ((pHeader[1] & 1) == 0)
        nHeaderSize += 2;

    // Not enough data to check main_data_begin
    if (dwSize < (unsigned int)nHeaderSize + 2)
        return 0;

    // Extract main_data_begin offset (9 bits)
    nDataOffset = (pHeader[nHeaderSize] << 1) +
                  (pHeader[nHeaderSize + 1] >> 7);

    // Side info (256 bits for stereo, 136 for mono)
    if (3 == h.mode)
        nHeaderSize += 17;
    else
        nHeaderSize += 32;

    return 1;
}

BOOL CMp3Format::GetDataOffsetMPEG2(UINT8 *pHeader,
                                    UINT32 dwSize,
                                    int &nFrameSize,
                                    int &nHeaderSize,
                                    int &nDataOffset,
                                    int trustPackets)
{
    // Get header info
    MPEG_HEAD h;
    memset(&h, 0, sizeof(h));
    nFrameSize = head_info(pHeader, dwSize, &h, trustPackets);
    
    if (nFrameSize)
        nFrameSize += h.pad;

    // HeaderSize is the sync word, CRC, and side info
    nHeaderSize = 4;

    // Check protection bit
    if ((pHeader[1] & 1) == 0)
        nHeaderSize += 2;

    // Not enough data to check main_data_begin
    if (dwSize < (unsigned int)nHeaderSize + 1)
        return 0;

    // Extract main_data_begin offset (8 bits)
    nDataOffset = pHeader[nHeaderSize];

    // Side info (136 bits for stereo, 72 for mono)
    if (3 == h.mode)
        nHeaderSize += 9;
    else
        nHeaderSize += 17;

    return 1;
}