imagemgr.cpp

linux下的一款播放器

            }
        }
        else
        {
            retVal = HXR_NOT_INITIALIZED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

HX_RESULT PXImageManager::OnImageDataPacket(UINT32 ulHandle, IHXBuffer* pOpaque, IHXBuffer* pData)
{
    HX_RESULT retVal  = HXR_OK;

    if (ulHandle && pOpaque && pData)
    {
        // If we get a packet for which we don't have an image, we will just
        // throw it away.
        PXImageHelper* pHelper = NULL;
        HX_RESULT rv           = GetImageHelper(ulHandle, &pHelper);
        if (SUCCEEDED(rv))
        {
            if (!pHelper->GetIgnoreDataPackets())
            {
                retVal = pHelper->OnImageDataPacket(pOpaque, pData);
            }
        }
        HX_RELEASE(pHelper);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

void PXImageManager::ReleasePresentationImages()
{
    if (m_pHandleToImageMap)
    {
        // Run through the map, deleting all image objects
        POSITION pos = m_pHandleToImageMap->GetStartPosition();
        while (pos)
        {
            // Get the object pointer at the current position
            // and advance to the next position
            LONG32 lKey     = 0;
            void*  pElement = NULL;
            m_pHandleToImageMap->GetNextAssoc(pos, lKey, pElement);

            // Release the object
            PXImageHelper* pHelper = (PXImageHelper*) pElement;
            HX_RELEASE(pHelper);
        }
        // Clear the map
        m_pHandleToImageMap->RemoveAll();
    }
}

HX_RESULT PXImageManager::GetImage(UINT32 ulHandle, PXImage** ppImage) const
{
    HX_RESULT retVal = HXR_OK;

    if (ulHandle && ppImage)
    {
        if (m_pHandleToImageMap)
        {
            // Set out parameter default
            *ppImage = NULL;
            // Check to see if there really is an entry for this handle
            void* pVoid         = NULL;
            BOOL  bEntryPresent = m_pHandleToImageMap->Lookup((LONG32) ulHandle, pVoid);
            if (bEntryPresent)
            {
                // Get the helper object
                PXImageHelper* pHelper = (PXImageHelper*) pVoid;
                if (pHelper)
                {
                    retVal = pHelper->GetFrame(0, ppImage);
                }
                else
                {
                    retVal = HXR_FAIL;
                }
            }
            else
            {
                retVal = HXR_FAIL;
            }
        }
        else
        {
            retVal = HXR_NOT_INITIALIZED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

HX_RESULT PXImageManager::IsImagePresent(UINT32 ulHandle, BOOL* pbPresent) const
{
    HX_RESULT retVal = HXR_OK;

    if (ulHandle && pbPresent)
    {
        // Set default
        *pbPresent = FALSE;
        if (m_pHandleToImageMap)
        {
            // Check to see if there really is an entry for this handle
            void* pVoid = NULL;
            *pbPresent  = m_pHandleToImageMap->Lookup((LONG32) ulHandle, pVoid);
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

BOOL PXImageManager::IsImagePresent(UINT32 ulHandle) const
{
    BOOL bPresent = FALSE;
    IsImagePresent(ulHandle, &bPresent);
    return bPresent;
}

HX_RESULT PXImageManager::IsImageCompletelyDecoded(UINT32 ulHandle, BOOL* pbComplete)
{
    HX_RESULT retVal = HXR_OK;

    if (ulHandle && pbComplete)
    {
        // Set default
        *pbComplete = FALSE;

        PXImageHelper* pHelper = NULL;
        retVal                 = GetImageHelper(ulHandle, &pHelper);
        if (SUCCEEDED(retVal))
        {
            *pbComplete = pHelper->AllBytesDecoded();
        }
        HX_RELEASE(pHelper);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImageManager::GetNumImages(UINT32* pulNumImages) const
{
    HX_RESULT retVal = HXR_OK;

    if (pulNumImages)
    {
        // Set default
        *pulNumImages = 0;
        if (m_pHandleToImageMap)
        {
            *pulNumImages = m_pHandleToImageMap->GetCount();
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

UINT32 PXImageManager::GetNumImages() const
{
    UINT32 ulNum = 0;
    GetNumImages(&ulNum);
    return ulNum;
}

HX_RESULT PXImageManager::GetDisplayImage(PXImage** ppImage)
{
    HX_RESULT retVal = HXR_OK;

    if (ppImage)
    {
        if (m_pDisplayImage)
        {
            *ppImage = m_pDisplayImage;
            (*ppImage)->AddRef();
        }
        else
        {
            retVal = HXR_UNEXPECTED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

HX_RESULT PXImageManager::GetDisplaySubImage(PXImage** ppImage, UINT32 ulX, UINT32 ulY,
                                             UINT32 ulW, UINT32 ulH, BOOL bCopy)
{
    HX_RESULT   retVal    = HXR_OK;
    PXImage*    pSubImage = NULL;
    IHXBuffer* pScratch  = NULL;

    if (ppImage)
    {
        // Assign default for out parameter
        *ppImage = NULL;
        // Make sure we're initialized
        if (m_pDisplayImage)
        {
            // Create an image object
            retVal = PXImage::CreateObject(&pSubImage);
            if (SUCCEEDED(retVal))
            {
                // Addref the image
                pSubImage->AddRef();

                if (bCopy)
                {
                    // We need a COPY of the subrect of the display image (as
                    // opposed to just referencing the same memory. Therefore,
                    // we will: 1) determine how many bytes we need; 2) get
                    // a scratch buffer which has that many bytes; and 3) init
                    // the image with that buffer
                    if (ulW == 0 || ulW > (UINT32) m_pDisplayImage->GetWidth())
                    {
                        ulW = m_pDisplayImage->GetWidth();
                    }
                    if (ulX + ulW > (UINT32) m_pDisplayImage->GetWidth())
                    {
                        ulX = m_pDisplayImage->GetWidth() - ulW;
                    }
                    if (ulH == 0 || ulH > (UINT32) m_pDisplayImage->GetHeight())
                    {
                        ulH = m_pDisplayImage->GetHeight();
                    }
                    if (ulY + ulH > (UINT32) m_pDisplayImage->GetHeight())
                    {
                        ulH = m_pDisplayImage->GetHeight() - ulY;
                    }
                    UINT32 ulBytesNeeded = ulW * ulH * m_ulDefaultBytesPerPixel;
                    retVal               = GetScratchBuffer(ulBytesNeeded, &pScratch);
                    if (SUCCEEDED(retVal))
                    {
                        retVal = pSubImage->CreateSubImageFromBuffer(m_pDisplayImage,
                                                                     (INT32) ulX,
                                                                     (INT32) ulY,
                                                                     (INT32) ulW,
                                                                     (INT32) ulH,
                                                                     pScratch);
                    }
                }
                else
                {
                    // We only need a reference to the display image's buffer. So
                    // we can just create a subimage that refs the display image's
                    // image store.
                    retVal = pSubImage->CreateSubImage(m_pDisplayImage,
                                                       (INT32) ulX,
                                                       (INT32) ulY,
                                                       (INT32) ulW,
                                                       (INT32) ulH);
                }

                if (SUCCEEDED(retVal))
                {
                    // Set the out parameter
                    *ppImage = pSubImage;
                    // Addref it before it goes out
                    (*ppImage)->AddRef();
                }
            }
        }
        else
        {
            retVal = HXR_NOT_INITIALIZED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    // Release our local ref
    HX_RELEASE(pScratch);
    HX_RELEASE(pSubImage);

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

HX_RESULT PXImageManager::GetDisplaySubImage(PXImage** ppImage, const PXRect& rSubRect, BOOL bCopy)
{
    return GetDisplaySubImage(ppImage, (INT32) rSubRect.GetX(), (INT32) rSubRect.GetY(),
                              (INT32) rSubRect.GetWidth(), (INT32) rSubRect.GetHeight(), bCopy);
}