pxcjpgff.cpp

linux下的一款播放器

                                pParam->SetPropertyULONG32("TotalReqBytes",    pSession->GetTotalRequiredBytes());
                                pParam->SetPropertyULONG32("TotalNonReqBytes", pSession->GetTotalNonRequiredBytes());
                                pParam->SetPropertyULONG32("ImageWidth",       (UINT32) rImageDim.cx);
                                pParam->SetPropertyULONG32("ImageHeight",      (UINT32) rImageDim.cy);
                                // Set the outgoing parameters
                                rulNumPackets = pSession->GetNumPackets();
                                HX_RELEASE(rpParam);
                                rpParam = pParam;
                                rpParam->AddRef();
#ifdef XXXMEH_DUMP_IMAGE_PACKETS
                                FILE* fp = fopen("e:\\test\\u1bug\\packets.jpg", "wb");
                                if (fp)
                                {
                                    for (UINT32 i = 0; i < rulNumPackets; i++)
                                    {
                                        IHXBuffer* pData = NULL;
                                        IHXBuffer* pOpaq = NULL;
                                        BOOL        bReq  = FALSE;
                                        HX_RESULT rv      = pSession->GetPacket(i, pData, pOpaq, bReq);
                                        if (SUCCEEDED(rv))
                                        {
                                            fwrite(pData->GetBuffer(), 1, pData->GetSize(), fp);
                                        }
                                        HX_RELEASE(pData);
                                        HX_RELEASE(pOpaq);

                                    }
                                    fclose(fp);
                                }
#endif
                            }
                            HX_RELEASE(pParam);
                        }
                    }
                }
            }
        }
        else
        {
            retVal = HXR_OUTOFMEMORY;
        }
        HX_RELEASE(pSession);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

STDMETHODIMP CRealPixJPEGFileFormatCodec::GetImagePacket(UINT32           ulSessionHandle,
                                                         UINT32           ulPacketNum,
                                                         REF(IHXBuffer*) rpPacketBuffer,
                                                         REF(IHXBuffer*) rpOpaquePacketData,
                                                         REF(BOOL)        rbRequired)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pMapManager)
    {
        PXParseSession* pSession = NULL;
        retVal                   = m_pMapManager->GetEntry(ulSessionHandle, (void**) &pSession);
        if (SUCCEEDED(retVal))
        {
            // Get the packet from the session
            retVal = pSession->GetPacket(ulPacketNum,
                                         rpPacketBuffer,
                                         rpOpaquePacketData,
                                         rbRequired);
        }
    }

    return retVal;
}

STDMETHODIMP CRealPixJPEGFileFormatCodec::ReleaseImage(UINT32 ulSessionHandle)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pMapManager)
    {
        PXParseSession* pSession = NULL;
        retVal                   = m_pMapManager->DeleteEntry(ulSessionHandle, (void**) &pSession);
        HX_RELEASE(pSession);
    }

    return retVal;
}

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

    if (ppIUnknown)
    {
        // Create file format codec
        CRealPixJPEGFileFormatCodec* pCodec = new CRealPixJPEGFileFormatCodec();
        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 CRealPixJPEGFileFormatCodec::ParseBuffer(IHXBuffer*     pBuffer,
                                                   PXParseSession* pSession,
                                                   REF(HXxSize)    rImageDim)
{
    HX_RESULT retVal = HXR_OK;

    if (pBuffer && pSession)
    {
        // Get the size of the header packet, ignoring APP1-APP15
        // markers and COMment markers.
        UINT32 ulHdrSize        = 0;
        UINT32 ulNumBytesParsed = 0;
        retVal = ComputeHeaderSize(pBuffer->GetBuffer(), pBuffer->GetSize(),
                                   ulHdrSize, ulNumBytesParsed);
        if (SUCCEEDED(retVal))
        {
            // Add the first buffers
            IHXBuffer* pData             = NULL;
            IHXBuffer* pOpaque           = NULL;
            UINT32      ulIndex           = 0;
            UINT32      ulWidth           = 0;
            UINT32      ulHeight          = 0;
            UINT32      ulRestartInterval = 0;
            retVal = GetHeaderBuffers(pBuffer,   // original buffer
                                      0,         // data buffer offset
                                      ulHdrSize, // data buffer size
                                      ulIndex,   // packet index
                                      0,         // starting block
                                      0,         // num blocks
                                      pData,
                                      pOpaque,
                                      ulWidth,
                                      ulHeight,
                                      ulRestartInterval);
            if (SUCCEEDED(retVal))
            {
                // Assign the width and height
                rImageDim.cx = (INT32) ulWidth;
                rImageDim.cy = (INT32) ulHeight;
                // Increment the packet index
                ulIndex++;
                // Add the first buffers to the session
                retVal = pSession->AddPacket(pData, pOpaque, TRUE);
                if (SUCCEEDED(retVal))
                {
                    // Set the parsing pointer to the end of the header
                    BYTE* pCurByte  = pBuffer->GetBuffer() + ulNumBytesParsed;
                    BYTE* pBufLimit = pBuffer->GetBuffer() + pBuffer->GetSize();
                    // If the restart interval is non-zero, then we need to look for
                    // restart markers. This gives us some measure of loss tolerance.
                    if (ulRestartInterval > 0)
                    {
                        BOOL   bImageComplete = FALSE;
                        UINT16 usCurBlock     = 0; 
                        while (pCurByte < pBufLimit && bImageComplete == FALSE)
                        {
                            BOOL   bPacketComplete = FALSE;
                            UINT16 usNumRSTMarkers = 0;
                            BYTE  *pCurStart       = pCurByte;
                            while (bPacketComplete == FALSE && pCurByte < pBufLimit)
                            {
                                if (*pCurByte++ == 0xFF)
                                {
                                    BYTE ucMarker = *pCurByte++;
                                    if (ucMarker >= kMarkerRST0 && ucMarker <= kMarkerRST7)
                                    {
                                        usNumRSTMarkers++;
                                        if (pCurByte - pCurStart >= kDefaultPacketSize)
                                        {
                                            bPacketComplete = TRUE;
                                        }
                                    }
                                    else if (ucMarker == kMarkerEOI)
                                    {
                                        bPacketComplete = TRUE;
                                        bImageComplete = TRUE;
                                    }
                                }
                            }
                            // Did we get a valid packet?
                            if (bPacketComplete)
                            {
                                HX_RELEASE(pData);
                                HX_RELEASE(pOpaque);
                                retVal = GetBuffers(pBuffer,                          // original buffer
                                                    pCurStart - pBuffer->GetBuffer(), // data buffer offset
                                                    pCurByte - pCurStart,             // data buffer size
                                                    ulIndex,                          // packet index
                                                    usCurBlock,                       // starting block
                                                    usNumRSTMarkers,                  // num blocks
                                                    pData,
                                                    pOpaque);
                                if (SUCCEEDED(retVal))
                                {
                                    // Increment the packet index
                                    ulIndex++;
                                    // Add packet to session
                                    retVal = pSession->AddPacket(pData, pOpaque, FALSE);
                                    if (SUCCEEDED(retVal))
                                    {
                                        usCurBlock += usNumRSTMarkers;
                                    }
                                }
                            }
                            else
                            {
                                retVal = HXR_FAIL;
                            }
                            if (FAILED(retVal))
                            {
                                break;
                            }
                        }
                        // Did we finish the image OK?
                        if (!bImageComplete)
                        {
                            retVal = HXR_FAIL;
                        }
                    } // if (ulRestartInteval > 0)
                    else
                    {
                        while (pCurByte < pBufLimit)
                        {
                            BYTE *pCurStart = pCurByte;
                            pCurByte       += kDefaultPacketSize;
                            if (pCurByte > pBufLimit)
                            {
                                pCurByte = pBufLimit;
                            }
                            HX_RELEASE(pData);
                            HX_RELEASE(pOpaque);
                            retVal = GetBuffers(pBuffer,                          // original buffer
                                                pCurStart - pBuffer->GetBuffer(), // data buffer offset
                                                pCurByte - pCurStart,             // data buffer size
                                                ulIndex,                          // packet index
                                                0,                                // starting block
                                                0,                                // num blocks
                                                pData,
                                                pOpaque);
                            if (SUCCEEDED(retVal))
                            {
                                // Increment the packet index
                                ulIndex++;
                                // Add the packet to the session
                                retVal = pSession->AddPacket(pData, pOpaque, FALSE);
                            }
                            if (FAILED(retVal))
                            {
                                break;
                            }
                        }
                    } // if (ulRestartInterval > 0) else
                }
            }
            HX_RELEASE(pData);
            HX_RELEASE(pOpaque);
        }
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;

}

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

    if (pBuffer)
    {
        // Create an nested buffer for the data
        CHXNestedBuffer* pNested = NULL;
        retVal                   = CHXNestedBuffer::CreateObject(&pNested);
        if (SUCCEEDED(retVal))
        {
            // Addref the nested buffer object
            pNested->AddRef();
            // Init the nested buffer object
            retVal = pNested->Init(pBuffer, ulOffset, ulSize);
            if (SUCCEEDED(retVal))
            {
                // Get an IHXBuffer interface from it
                IHXBuffer* pDataBuffer = NULL;