pxcjpgrn.cpp

linux下的一款播放器

                        BYTE* pBuf = pOpaquePacketData->GetBuffer();
                        if (pBuf)
                        {
// XXXMEH - seq num is now beginning of opaque
//                            // Advance to seq num
//                            pBuf += 8;
                            // Get seq num
                            UINT32 ulSeqNum = 0;
                            UnPack32(pBuf, ulSeqNum);
                            // Check seq num
                            if (ulSeqNum != pWrapper->GetLastSequenceNumber() + 1)
                            {
                                // We lost one or more packets in between
                                //
                                // Do we have restart markers in this image?
                                if (pWrapper->GetRestartInterval() == 0)
                                {
                                    // This image has no restart markers. Therefore, we set the image to invalid
                                    pWrapper->SetValid(FALSE);
                                }
                                else
                                {
                                    // Insert some fake data with proper restart markers
                                    retVal = InsertDummyData(pWrapper, pBuffer, pOpaquePacketData);
                                }
                            }
                            else
                            {
                                // Update the last sequence number
                                pWrapper->SetLastSequenceNumber(ulSeqNum);
                            }
                        }
                        else
                        {
                            retVal = HXR_FAIL;
                        }
                    }

                    if (SUCCEEDED(retVal) && pWrapper->GetValid())
                    {
                        // Append this buffer to the wrapper's list
                        pWrapper->AppendBuffer(pBuffer);
                        // Now call decompress for the wrapper
                        retVal = pWrapper->Decompress();
                        if (SUCCEEDED(retVal))
                        {
                            // Set the last opaque buffer in the wrapper
                            pWrapper->SetLastOpaqueBuffer(pOpaquePacketData);
                        }
                    }
                }
                else
                {
                    pWrapper->SetNeedPacket(TRUE);
                }
            }
        }
    }

    return retVal;
}

STDMETHODIMP CRealPixJPEGRendererCodec::GetDecompressStatus(UINT32     ulSessionHandle,
                                                            REF(INT32) rlStatus)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pMapManager)
    {
        CIJGLibraryWrapper* pWrapper = NULL;
        retVal                       = m_pMapManager->GetEntry(ulSessionHandle, (void**) &pWrapper);
        if (SUCCEEDED(retVal))
        {
            if (!pWrapper->GetValid())
            {
                rlStatus = DECOMPRESS_STATUS_ABORTED;
            }
            else if (pWrapper->IsFinished())
            {
                rlStatus = DECOMPRESS_STATUS_FINISHED;
            }
            else
            {
                rlStatus = DECOMPRESS_STATUS_INPROGRESS;
            }
        }
    }

    return retVal;
}

STDMETHODIMP CRealPixJPEGRendererCodec::FinishDecompress(UINT32 ulSessionHandle)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pMapManager)
    {
        CIJGLibraryWrapper* pWrapper = NULL;
        retVal                       = m_pMapManager->DeleteEntry(ulSessionHandle, (void**) &pWrapper);
        if (SUCCEEDED(retVal))
        {
            pWrapper->Terminate();
        }
        HX_RELEASE(pWrapper);
    }

    return retVal;
}

HX_RESULT STDAPICALLTYPE CRealPixJPEGRendererCodec::HXCreateInstance(IUnknown** ppIUnknown)
{
    HX_RESULT retVal = HXR_OK;

    if (ppIUnknown)
    {
        // Create renderer codec
        CRealPixJPEGRendererCodec* pCodec = new CRealPixJPEGRendererCodec();
        if (pCodec)
        {
            // QI for IUnknown
            retVal = pCodec->QueryInterface(IID_IUnknown, (void**) ppIUnknown);
        }
        else
        {
            retVal = HXR_OUTOFMEMORY;
        }
        if (FAILED(retVal))
        {
            HX_DELETE(pCodec);
        }
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;
}

HX_RESULT CRealPixJPEGRendererCodec::ComputeStatistics(BYTE *pBuf,            UINT32 ulLen,
                                                       UINT32 &rulNumPackets, UINT32 &rulMinSize,
                                                       UINT32 &rulMaxSize,    UINT32 &rulAvgSize)
{
    UINT32 ulNumPackets = 0;
    UINT32 ulMinSize    = 0xFFFFFFFF;
    UINT32 ulMaxSize    = 0;
    UINT32 ulPacketSize;

    // Parse the header
    UINT32 ulRestartInterval = 0;
    BOOL   bHeaderComplete   = FALSE;
    BYTE  *pCurByte          = pBuf;
    BYTE  *pBufLimit         = pBuf + ulLen;
    while (bHeaderComplete == FALSE && pCurByte < pBufLimit)
    {
        // Look for a 0xFF, which would signify a marker
        if (*pCurByte++ == 0xFF)
        {
            // Now take different actions depending on what kind of
            // marker this is - some markers have data associated with
            // them (such as DRI) and others don't (such as SOI and EOI)
            BYTE ucMarker = *pCurByte++;

            if (!(ucMarker == kMarkerSOI ||
                  ucMarker == kMarkerEOI ||
                  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')
                    {
                        return HXR_FAIL;
                    }
                }
                else if (ucMarker == kMarkerSOF0)
                {
                    // We look at this marker to extract the width and height
//                    m_ulImageHeight = (pCurByte[3] << 8) | pCurByte[4];
//                    m_ulImageWidth  = (pCurByte[5] << 8) | pCurByte[6];
                }
                else if (ucMarker == kMarkerDRI)
                {
                    // We look at this marker to extract the restart interval
                    ulRestartInterval = (pCurByte[2] << 8) | pCurByte[3];
                }
                else if (ucMarker == kMarkerSOS)
                {
                    // This marker is the last marker in the header
                    bHeaderComplete = TRUE;
                }

                // Advance the pointer
                pCurByte += ulSegLen;
            }
        }
    }

    // Did we get a valid header?
    if (!bHeaderComplete)
    {
        return HXR_FAIL;
    }

    // Update statistics
    ulPacketSize = pCurByte - pBuf;
    if (ulPacketSize < ulMinSize)
    {
        ulMinSize = ulPacketSize;
    }
    if (ulPacketSize > ulMaxSize)
    {
        ulMaxSize = ulPacketSize;
    }
    ulNumPackets++;

    // If the restart interval is zero, something's wrong
    if (ulRestartInterval == 0)
    {
        return HXR_FAIL;
    }

    BOOL bImageComplete = FALSE;
    while (pCurByte < pBufLimit && bImageComplete == FALSE)
    {
        BOOL   bPacketComplete = FALSE;
        BYTE  *pCurStart       = pCurByte;
        while (bPacketComplete == FALSE && pCurByte < pBufLimit)
        {
            if (*pCurByte++ == 0xFF)
            {
                BYTE ucMarker = *pCurByte++;
                if (ucMarker >= kMarkerRST0 && ucMarker <= kMarkerRST7)
                {
                    bPacketComplete = TRUE;
                }
                else if (ucMarker == kMarkerEOI)
                {
                    bPacketComplete = TRUE;
                    bImageComplete  = TRUE;
                }
            }
        }

        // Did we get a valid packet?
        if (bPacketComplete == FALSE)
        {
            return HXR_FAIL;
        }

        // Update statistics
        ulPacketSize = pCurByte - pCurStart;
        if (ulPacketSize < ulMinSize)
        {
            ulMinSize = ulPacketSize;
        }
        if (ulPacketSize > ulMaxSize)
        {
            ulMaxSize = ulPacketSize;
        }
        ulNumPackets++;
    }

    // Did we finish the image OK?
    if (bImageComplete == FALSE)
    {
        return HXR_FAIL;
    }

    // Assign statistics
    rulNumPackets = ulNumPackets;
    rulMinSize    = ulMinSize;
    rulMaxSize    = ulMaxSize;

    // Compute average
    rulAvgSize = (ulLen + (ulNumPackets >> 1)) / ulNumPackets;

    return HXR_OK;
}

void CRealPixJPEGRendererCodec::ReleaseAllWrappers()
{
    if (m_pMapManager)
    {
        UINT32              ulHandle = 0;
        CIJGLibraryWrapper* pWrapper = NULL;
        HX_RESULT           retVal   = m_pMapManager->GetFirstEntry(ulHandle, (void**) &pWrapper);
        while (SUCCEEDED(retVal))
        {
            HX_RELEASE(pWrapper);
            retVal = m_pMapManager->GetNextEntry(ulHandle, (void**) &pWrapper);
        }
        m_pMapManager->DeleteAllEntries();
    }
}