imghelpr.cpp

linux下的一款播放器

                                }
                            }
                        }
                    }
                }
            }
        }
    }

    return retVal;
}

HX_RESULT PXImageHelper::GetFrame(UINT32 i, PXImage** ppFrame)
{
    HX_RESULT retVal = HXR_OK;

    if (i < m_ulNumFrames && ppFrame)
    {
        if (m_pFrameData[i].m_pFrame)
        {
            *ppFrame = m_pFrameData[i].m_pFrame;
            (*ppFrame)->AddRef();
        }
        else
        {
            retVal = HXR_UNEXPECTED;
        }
    }
    else
    {
        return HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImageHelper::GetFrameInfo(UINT32 i, IHXValues** ppFrameInfo)
{
    HX_RESULT retVal = HXR_OK;

    if (i < m_ulNumFrames && ppFrameInfo)
    {
        if (m_pFrameData[i].m_pFrameInfo)
        {
            *ppFrameInfo = m_pFrameData[i].m_pFrameInfo;
            (*ppFrameInfo)->AddRef();
        }
        else
        {
            retVal = HXR_UNEXPECTED;
        }
    }
    else
    {
        return HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImageHelper::GetFrameDim(UINT32 i, REF(HXxRect) rFrameDim)
{
    HX_RESULT retVal = HXR_OK;

    if (i < m_ulNumFrames)
    {
        if (m_pFrameData[i].m_pFrameInfo)
        {
            rFrameDim = m_pFrameData[i].m_cFrameDim;
        }
        else
        {
            retVal = HXR_UNEXPECTED;
        }
    }
    else
    {
        return HXR_INVALID_PARAMETER;
    }

    return retVal;
}

BOOL PXImageHelper::AllBytesDecoded() const
{
    BOOL bRetVal = FALSE;

    if (m_ulFileLength         >  0 &&
        m_ulFileBytesProcessed >= m_ulFileLength)
    {
        bRetVal = TRUE;
    }

    return bRetVal;
}

HX_RESULT PXImageHelper::CreateNestedBuffer(IHXBuffer* pBuffer, UINT32 ulOffset,
                                            UINT32 ulSize, IHXBuffer** ppBuffer)
{
    HX_RESULT retVal = HXR_OK;

    if (ppBuffer)
    {
        CHXNestedBuffer* pNested = NULL;
        retVal                   = CHXNestedBuffer::CreateObject(&pNested);
        if (SUCCEEDED(retVal))
        {
            pNested->AddRef();
            retVal = pNested->Init(pBuffer, ulOffset, ulSize);
            if (SUCCEEDED(retVal))
            {
                retVal = pNested->QueryInterface(IID_IHXBuffer, (void**) ppBuffer);
            }
        }
        HX_RELEASE(pNested);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImageHelper::InitHeader(IHXBuffer* pData, IHXBuffer* pOpaque)
{
    HX_RESULT retVal = HXR_OK;

    if (pData && pOpaque)
    {
        // Clear out all current images
        DeallocateImages();
        // Get the header info
        retVal = m_pCodec->GetHeaderInfo(pData, pOpaque, m_cImageDim, m_ulNumFrames,
                                         m_pImageInfo, m_ulSessionHandle);
        if (SUCCEEDED(retVal))
        {
#ifdef XXXMEH_DEBUG_LOG
            DEBUG_OUTF("c:\\realpix.log",
                       (s, "PXImageHelper::InitHeader() - allocating %lu frames\n",
                       m_ulNumFrames));
#endif
            // Allocate vector of FrameData structs
            m_pFrameData = new FrameData [m_ulNumFrames];
            if (m_pFrameData)
            {
                // NULL out the pointers
                UINT32 i;
                for (i = 0; i < m_ulNumFrames; i++)
                {
                    m_pFrameData[i].m_pFrame           = NULL;
                    m_pFrameData[i].m_pFrameInfo       = NULL;
                    m_pFrameData[i].m_cFrameDim.left   = 0;
                    m_pFrameData[i].m_cFrameDim.top    = 0;
                    m_pFrameData[i].m_cFrameDim.right  = 0;
                    m_pFrameData[i].m_cFrameDim.bottom = 0;
                    m_pFrameData[i].m_bNeedAlphaCheck  = FALSE;
                }

                // Loop through each frame
                for (i = 0; i < m_ulNumFrames; i++)
                {
                    retVal = m_pCodec->GetFrameInfo(m_ulSessionHandle,
                                                    i,
                                                    m_pFrameData[i].m_cFrameDim,
                                                    m_pFrameData[i].m_pFrameInfo);
                    if (SUCCEEDED(retVal))
                    {
                        // Create an image object for this frame
                        retVal = PXImage::CreateObject(&m_pFrameData[i].m_pFrame);
                        if (SUCCEEDED(retVal))
                        {
                            // Addref the object
                            m_pFrameData[i].m_pFrame->AddRef();
#ifdef XXXMEH_DEBUG_OUT
                            DEBUG_OUT(m_pErrorMessages,
                                      DOL_REALPIX_EXTENDED,
                                      (s, "Creating presentation image of size w=%ld, h=%ld",
                                       HXxRECT_WIDTH(m_pFrameData[i].m_cFrameDim),
                                       HXxRECT_HEIGHT(m_pFrameData[i].m_cFrameDim)));
#endif
                            retVal = m_pFrameData[i].m_pFrame->Create(HXxRECT_WIDTH(m_pFrameData[i].m_cFrameDim),
                                                                      HXxRECT_HEIGHT(m_pFrameData[i].m_cFrameDim),
                                                                      m_ulBitsPerPixel,
                                                                      m_ulFormat,
                                                                      m_bRowsInverted);
                            if (SUCCEEDED(retVal))
                            {
                                IHXBuffer* pImageStore = NULL;
                                retVal                  = m_pFrameData[i].m_pFrame->GetImageStore(&pImageStore);
                                if (SUCCEEDED(retVal))
                                {
                                    HXxSize cSize;
                                    cSize.cx = HXxRECT_WIDTH(m_pFrameData[i].m_cFrameDim);
                                    cSize.cy = HXxRECT_HEIGHT(m_pFrameData[i].m_cFrameDim);
                                    retVal = m_pCodec->SetDecompressParam(m_ulSessionHandle,
                                                                          i,
                                                                          pImageStore,
                                                                          cSize,
                                                                          m_pFrameData[i].m_pFrame->GetRowStride(),
                                                                          m_pFrameData[i].m_pFrame->GetBitsPerPixel(),
                                                                          m_pFrameData[i].m_pFrame->GetFormat(),
                                                                          m_pFrameData[i].m_pFrame->GetRowsInverted(),
                                                                          NULL);
                                    if (SUCCEEDED(retVal))
                                    {
                                        // Do we have a FrameInfo IHXValues from the codec?
                                        if (m_pFrameData[i].m_pFrameInfo)
                                        {
                                            // Do we have a "UsesAlphaChannel" ULONG32 property?
                                            ULONG32   ulFlag = 0;
                                            HX_RESULT rv     = m_pFrameData[i].m_pFrameInfo->GetPropertyULONG32("UsesAlphaChannel", ulFlag);
                                            if (SUCCEEDED(rv))
                                            {
                                                // We did have the flag, so set the member in the PXImage
                                                m_pFrameData[i].m_pFrame->SetHasAlpha((ulFlag ? TRUE : FALSE));
                                            }
                                            else
                                            {
                                                // There was no flag present, so after the image is decoded,
                                                // we'll have to self-determine it from the image bits themselves.
                                                // So here we simply need to set the flag that tells us to
                                                // perform that operation later.
                                                m_pFrameData[i].m_bNeedAlphaCheck = TRUE;
                                            }
                                        }
                                    }
                                }
                                HX_RELEASE(pImageStore);
                            }
                        }
                    }

                    if (FAILED(retVal))
                    {
                        break;
                    }
                }
            }
            else
            {
                retVal = HXR_OUTOFMEMORY;
            }
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    if (FAILED(retVal))
    {
        DeallocateImages();
    }

    return retVal;
}

void PXImageHelper::DeallocateImages()
{
    if (m_pFrameData)
    {
        for (UINT32 i = 0; i < m_ulNumFrames; i++)
        {
            HX_RELEASE(m_pFrameData[i].m_pFrame);
            HX_RELEASE(m_pFrameData[i].m_pFrameInfo);
        }
        HX_VECTOR_DELETE(m_pFrameData);
    }
}