pxcjpgff.cpp

linux下的一款播放器

                retVal = pNested->QueryInterface(IID_IHXBuffer, (void**) &pDataBuffer);
                if (SUCCEEDED(retVal))
                {
                    // Create an IHXBuffer for the opaque data
                    IHXBuffer* pOpaqueBuffer = NULL;
                    retVal = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
                                                                   (void**) &pOpaqueBuffer);
                    if (SUCCEEDED(retVal))
                    {
// XXXMEH - move seq num to opaque
//                        retVal = pOpaqueBuffer->SetSize(8);
                        retVal = pOpaqueBuffer->SetSize(12);
                        if (SUCCEEDED(retVal))
                        {
                            // Pack the opaque buffer
                            BYTE* pBuf = pOpaqueBuffer->GetBuffer();
// XXXMEH - move seq num to opaque
                            Pack32(pBuf, ulPacketIndex); // seq num
                            Pack32(pBuf, 0);             // flags
                            Pack16(pBuf, usCurBlock);    // starting MCU
                            Pack16(pBuf, usNumBlocks);   // number of MCUs

                            // Set the outgoing parameters
                            HX_RELEASE(rpData);
                            rpData = pDataBuffer;
                            rpData->AddRef();
                            HX_RELEASE(rpOpaque);
                            rpOpaque = pOpaqueBuffer;
                            rpOpaque->AddRef();
                        }
                    }
                    HX_RELEASE(pOpaqueBuffer);
                }
                HX_RELEASE(pDataBuffer);
            }
        }
        HX_RELEASE(pNested);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT CRealPixJPEGFileFormatCodec::ComputeHeaderSize(BYTE* pBuf, UINT32 ulLen, REF(UINT32) rulSize,
                                                         REF(UINT32) rulNumBytesParsed)
{
    HX_RESULT retVal = HXR_OK;

    if (pBuf && ulLen)
    {
        BYTE*  pCurByte        = pBuf;
        BYTE*  pBufLimit       = pCurByte + ulLen;
        UINT32 ulRemoveBytes   = 0;
        BOOL   bHeaderComplete = FALSE;
        while (bHeaderComplete == FALSE && pCurByte < pBufLimit)
        {
            // Look for a 0xFF, which would signify a marker
            if (*pCurByte++ == 0xFF)
            {
                // Get the marker type
                BYTE ucMarker = *pCurByte++;
                // Switch based on marker type. Only the following markers
                // have parameters and therefore we need to find out the
                // length of the marker
                 if (!(ucMarker == kMarkerEOI ||
                       ucMarker == kMarkerSOI ||
                       ucMarker == kMarkerTEM ||
                      (ucMarker >= kMarkerRST0 && ucMarker <= kMarkerRST7)))
                {
                    UINT32 ulSegLen = (pCurByte[0] << 8) | pCurByte[1];
                    if (ucMarker == kMarkerAPP0)
                    {
                        // We look at this marker to verify this is a JFIF image file
                        if (pCurByte[0] != 0x00 || pCurByte[1] != 0x10 ||
                            pCurByte[2] != 'J'  || pCurByte[3] != 'F'  ||
                            pCurByte[4] != 'I'  || pCurByte[5] != 'F'  ||
                            pCurByte[6] != '\0')
                        {
                            retVal = HXR_FAIL;
                            break;
                        }
                    }
                    else if (ucMarker >= kMarkerAPP1 && ucMarker <= kMarkerAPP15)
                    {
                        // We will NOT send these markers. ulSegLen is the length
                        // of the marker (including the 2-byte-length, but excluding
                        // the 0xFF 0x<marker>
                        ulRemoveBytes += ulSegLen + 2;
                    }
                    else if (ucMarker == kMarkerCOM)
                    {
                        // We will NOT send comments
                        ulRemoveBytes += ulSegLen + 2;
                    }
                    else if (ucMarker == kMarkerSOS)
                    {
                        // This marker is the last marker in the header
                        bHeaderComplete = TRUE;
                    }
                    // Advance the pointer
                    pCurByte += ulSegLen;
                }
            }
        }

        if (bHeaderComplete)
        {
            rulNumBytesParsed = pCurByte - pBuf;
            rulSize           = rulNumBytesParsed - ulRemoveBytes;
        }
        else
        {
            retVal = HXR_FAIL;
        }
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;
}

void CRealPixJPEGFileFormatCodec::ReleaseAllSessions()
{
    if (m_pMapManager)
    {
        UINT32          ulHandle = 0;
        PXParseSession* pSession = NULL;
        HX_RESULT       retVal   = m_pMapManager->GetFirstEntry(ulHandle, (void**) &pSession);
        while (SUCCEEDED(retVal))
        {
            HX_RELEASE(pSession);
            retVal = m_pMapManager->GetNextEntry(ulHandle, (void**) &pSession);
        }
        m_pMapManager->DeleteAllEntries();
    }
}

HX_RESULT CRealPixJPEGFileFormatCodec::GetHeaderBuffers(IHXBuffer*      pBuffer,
                                                        UINT32           ulOffset,
                                                        UINT32           ulSize,
                                                        UINT32           ulPacketIndex,
                                                        UINT16           usCurBlock,
                                                        UINT16           usNumBlocks,
                                                        REF(IHXBuffer*) rpData,
                                                        REF(IHXBuffer*) rpOpaque,
                                                        REF(UINT32)      rulWidth,
                                                        REF(UINT32)      rulHeight,
                                                        REF(UINT32)      rulRestartInterval)
{
    HX_RESULT retVal = HXR_OK;

    if (pBuffer && ulSize)
    {
        // Create an IHXBuffer for the data (from the file) packet buffer
        IHXBuffer* pDataBuffer = NULL;
        retVal = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
                                                       (void**) &pDataBuffer);
        if (SUCCEEDED(retVal))
        {
            // Set its size
            retVal = pDataBuffer->SetSize(ulSize);
            if (SUCCEEDED(retVal))
            {
                retVal = CopyHeaderStripMarkers(pBuffer->GetBuffer(), pBuffer->GetSize(),
                                                pDataBuffer->GetBuffer(), pDataBuffer->GetSize(),
                                                rulWidth, rulHeight, rulRestartInterval);
                if (SUCCEEDED(retVal))
                {
                    // Create an IHXBuffer for the opaque data
                    IHXBuffer* pOpaqueBuffer = NULL;
                    retVal = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
                                                                   (void**) &pOpaqueBuffer);
                    if (SUCCEEDED(retVal))
                    {
// XXXMEH - move seq num to opaque
//                        retVal = pOpaqueBuffer->SetSize(8);
                        retVal = pOpaqueBuffer->SetSize(12);
                        if (SUCCEEDED(retVal))
                        {
                            // Pack the opaque buffer
                            BYTE* pBuf = pOpaqueBuffer->GetBuffer();
// XXXMEH - move seq num to opaque
                            Pack32(pBuf, ulPacketIndex); // seq num
                            Pack32(pBuf, 0);             // flags
                            Pack16(pBuf, usCurBlock);    // starting MCU
                            Pack16(pBuf, usNumBlocks);   // number of MCUs

                            // Set the outgoing parameters
                            HX_RELEASE(rpData);
                            rpData = pDataBuffer;
                            rpData->AddRef();
                            HX_RELEASE(rpOpaque);
                            rpOpaque = pOpaqueBuffer;
                            rpOpaque->AddRef();
                        }
                    }
                    HX_RELEASE(pOpaqueBuffer);
                }
            }
        }
        HX_RELEASE(pDataBuffer);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT CRealPixJPEGFileFormatCodec::CopyHeaderStripMarkers(BYTE*       pOrigBuf,
                                                              UINT32      ulOrigBufLen,
                                                              BYTE*       pHdrBuf,
                                                              UINT32      ulHdrBufLen,
                                                              REF(UINT32) rulWidth,
                                                              REF(UINT32) rulHeight,
                                                              REF(UINT32) rulRestartInterval)
{
    HX_RESULT retVal = HXR_OK;

    if (pOrigBuf && ulOrigBufLen && pHdrBuf && ulHdrBufLen)
    {
        BYTE* pSrc            = pOrigBuf;
        BYTE* pSrcLimit       = pSrc + ulOrigBufLen;
        BYTE* pDst            = pHdrBuf;
        BYTE* pDstLimit       = pDst + ulHdrBufLen;
        BOOL  bHeaderComplete = FALSE;
        while (!bHeaderComplete && pSrc < pSrcLimit && pDst < pDstLimit)
        {
            // Look for a 0xFF, which would signify a marker
            if (pSrc[0] == 0xFF)
            {
                // Get the marker type
                BYTE ucMarker = pSrc[1];
                // Switch based on marker type. Only the following markers
                // have parameters and therefore we need to find out the
                // length of the marker
                if (!(ucMarker == kMarkerEOI ||
                      ucMarker == kMarkerSOI ||
                      ucMarker == kMarkerTEM ||
                      (ucMarker >= kMarkerRST0 && ucMarker <= kMarkerRST7)))
                {
                    // Compute the length
                    UINT32 ulSegLen = (pSrc[2] << 8) | pSrc[3];
                    // Get info out of some markers
                    if (ucMarker >= kMarkerSOF0 && ucMarker <= kMarkerSOF15 &&
                        ucMarker != kMarkerDHT  && ucMarker != kMarkerDAC   &&
                        ucMarker != 0xC8)
                    {
                        // We look at this marker to extract the width and height
                        rulHeight = (pSrc[5] << 8) | pSrc[6];
                        rulWidth  = (pSrc[7] << 8) | pSrc[8];
                    }
                    else if (ucMarker == kMarkerDRI)
                    {
                        // We look at this marker to extract the restart interval
                        rulRestartInterval = (pSrc[4] << 8) | pSrc[5];
                    }
                    else if (ucMarker == kMarkerSOS)
                    {
                        bHeaderComplete = TRUE;
                    }
                    // If we are NOT an APP1-APP15 marker and we are NOT a COMment
                    // marker, then we need to copy
                    if (!(ucMarker == kMarkerCOM ||
                          (ucMarker >= kMarkerAPP1 && ucMarker <= kMarkerAPP15)))
                    {
			// /Make sure pDst+ulSegLen+2 <= pDstLimit before copying:
			UINT32 ulSafeLenToCopy = ulSegLen + 2;
			if (ulHdrBufLen < ulSafeLenToCopy)
			{
			    ulSafeLenToCopy = ulHdrBufLen;
			}
                        // Copy the data
                        memcpy(pDst, pSrc, ulSafeLenToCopy); /* Flawfinder: ignore */
                        // Advance the dst pointer
                        pDst += ulSegLen + 2;
                    }
                    // Advance the src pointer
                    pSrc += ulSegLen + 2;
                }
                else
                {
                    *pDst++ = *pSrc++;
                    *pDst++ = *pSrc++;
                }
            }
            else
            {
                *pDst++ = *pSrc++;
            }
        }

        if (!bHeaderComplete)
        {
            retVal = HXR_FAIL;
        }
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;
}