pximage.cpp

来自「symbian 下的helix player源代码」· C++ 代码 · 共 1,933 行 · 第 1/5 页

        {
            *pDst = MAKE_RGB32(pLUT1[GETRED32(*pSrc1)]   + ucFadedR,
                               pLUT1[GETGREEN32(*pSrc1)] + ucFadedG,
                               pLUT1[GETBLUE32(*pSrc1)]  + ucFadedB);
            pSrc1++;
            pDst++;
        }
        pSrcRow1 += lSrc1Jump;
        pDstRow  += lDstJump;
    }

    return HXR_OK;
}

HX_RESULT PXImage::RecursiveBlendToColor(const PXColor& rColor, BYTE* pLUT1, BYTE* pLUT2)
{
    if (!pLUT1 || !pLUT2 || !m_bInitialized)
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    FILTER_OUT_UNSUPPORTED_FORMATS;

    BYTE ucFadedR = pLUT2[rColor.GetRed()];
    BYTE ucFadedG = pLUT2[rColor.GetGreen()];
    BYTE ucFadedB = pLUT2[rColor.GetBlue()];

    UINT32* pDstRow  = (UINT32*) m_pImageBuffer;
    INT32   lDstJump = m_lRowJump       >> 2;
    for (INT32 lY = m_lSubImageHeight; lY; lY--)
    {
        UINT32* pDst  = pDstRow;
        for (INT32 lX = m_lSubImageWidth; lX; lX--)
        {
            *pDst = MAKE_RGB32(pLUT1[GETRED32(*pDst)]   + ucFadedR,
                               pLUT1[GETGREEN32(*pDst)] + ucFadedG,
                               pLUT1[GETBLUE32(*pDst)]  + ucFadedB);
            pDst++;
        }
        pDstRow  += lDstJump;
    }

    return HXR_OK;
}

HX_RESULT PXImage::ChangeSizeFromNN(PXImage* pImg)
{
    if (!pImg || !m_bInitialized || !pImg->m_bInitialized)
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    FILTER_OUT_UNSUPPORTED_FORMATS;

    if (!Compatible(pImg))
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    return ChangeSize32NN((UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
                          pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2,
                          (UINT32*) m_pImageBuffer,       m_lSubImageWidth,
                          m_lSubImageHeight,              m_lRowJump >> 2);
}

HX_RESULT PXImage::ChangeSizeFromNNTransparent32(PXImage* pImg)
{
    HX_RESULT retVal = HXR_OK;

    if (pImg)
    {
        if (m_bInitialized && pImg->m_bInitialized)
        {
            if (m_cBitmapInfo.biBitCount          == 32      &&
                pImg->m_cBitmapInfo.biBitCount    == 32      &&
                CompressionSupported()                       &&
                pImg->CompressionSupported())
            {
                if (Compatible(pImg))
                {
                    retVal = ChangeSize32NNTransparent((UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
                                                       pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2,
                                                       (UINT32*) m_pImageBuffer,       m_lSubImageWidth,
                                                       m_lSubImageHeight,              m_lRowJump >> 2);
                }
                else
                {
                    retVal = HXR_FAIL;
                }
            }
            else
            {
                retVal = HXR_FAIL;
            }
        }
        else
        {
            retVal = HXR_NOT_INITIALIZED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImage::ChangeSizeIntoNN(PXImage* pImg)
{
    if (!pImg || !m_bInitialized || !pImg->m_bInitialized)
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    FILTER_OUT_UNSUPPORTED_FORMATS;

    if (!Compatible(pImg))
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    return ChangeSize32NN((UINT32*) m_pImageBuffer,       m_lSubImageWidth,
                          m_lSubImageHeight,              m_lRowJump >> 2,
                          (UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
                          pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2);
}

HX_RESULT PXImage::ChangeSizeIntoNNTransparent32(PXImage* pImg)
{
    HX_RESULT retVal = HXR_OK;

    if (pImg)
    {
        if (m_bInitialized && pImg->m_bInitialized)
        {
            if (m_cBitmapInfo.biBitCount          == 32      &&
                pImg->m_cBitmapInfo.biBitCount    == 32      &&
                CompressionSupported()                       &&
                pImg->CompressionSupported())
            {
                if (Compatible(pImg))
                {
                    retVal = ChangeSize32NNTransparent((UINT32*) m_pImageBuffer,       m_lSubImageWidth,
                                                       m_lSubImageHeight,              m_lRowJump >> 2,
                                                       (UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
                                                       pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2);
                }
                else
                {
                    retVal = HXR_FAIL;
                }
            }
            else
            {
                retVal = HXR_FAIL;
            }
        }
        else
        {
            retVal = HXR_NOT_INITIALIZED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImage::CopyFrom(PXImage* pImg)
{
    if (!pImg || !m_bInitialized)
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    FILTER_OUT_UNSUPPORTED_FORMATS;

    if (!Compatible(pImg) || !SameSize(pImg))
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    Copy32((UINT32*) pImg->m_pImageBuffer, (UINT32*) m_pImageBuffer,
            pImg->m_lRowJump >> 2,         m_lRowJump >> 2,
            pImg->m_bHasAlpha);

    return HXR_OK;
}

HX_RESULT PXImage::CopyFromTransparent32(PXImage* pImg)
{
    HX_RESULT retVal = HXR_OK;

    if (pImg)
    {
        if (m_bInitialized && pImg->m_bInitialized)
        {
            if (m_cBitmapInfo.biBitCount          == 32      &&
                pImg->m_cBitmapInfo.biBitCount    == 32      &&
                CompressionSupported()                       &&
                pImg->CompressionSupported())
            {
                if (Compatible(pImg) && SameSize(pImg))
                {
                    CopyTransparent32((UINT32*) pImg->m_pImageBuffer,
                                      (UINT32*) m_pImageBuffer,
                                      pImg->m_lRowJump >> 2,
                                      m_lRowJump >> 2);
                }
                else
                {
                    retVal = HXR_INVALID_PARAMETER;
                }
            }
            else
            {
                retVal = HXR_FAIL;
            }
        }
        else
        {
            retVal = HXR_NOT_INITIALIZED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImage::CopyFromAlpha32(PXImage* pImg, BYTE* pLUT)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pImg)
    {
        if (m_bInitialized && pImg->m_bInitialized)
        {
            if (m_cBitmapInfo.biBitCount          == 32      &&
                pImg->m_cBitmapInfo.biBitCount    == 32      &&
                CompressionSupported()                       &&
                pImg->CompressionSupported())
            {
                if (Compatible(pImg) && SameSize(pImg))
                {
                    CopyAlpha32((UINT32*) pImg->m_pImageBuffer,
                                (UINT32*) m_pImageBuffer,
                                pImg->m_lRowJump >> 2,
                                m_lRowJump >> 2,
                                pLUT);
                    retVal = HXR_OK;
                }
            }
        }
    }

    return retVal;
}

HX_RESULT PXImage::CopyTo(PXImage* pImg)
{
    if (!pImg || !m_bInitialized)
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    FILTER_OUT_UNSUPPORTED_FORMATS;

    if (!Compatible(pImg) || !SameSize(pImg))
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    Copy32((UINT32*) m_pImageBuffer, (UINT32*) pImg->m_pImageBuffer,
           m_lRowJump >> 2,          pImg->m_lRowJump >> 2,
           m_bHasAlpha);

    return HXR_OK;
}

HX_RESULT PXImage::CopyToTransparent32(PXImage* pImg)
{
    HX_RESULT retVal = HXR_OK;

    if (pImg)
    {
        if (m_bInitialized && pImg->m_bInitialized)
        {
            if (m_cBitmapInfo.biBitCount          == 32      &&
                pImg->m_cBitmapInfo.biBitCount    == 32      &&
                CompressionSupported()                       &&
                pImg->CompressionSupported())
            {
                if (Compatible(pImg) && SameSize(pImg))
                {
                    CopyTransparent32((UINT32*) m_pImageBuffer,
                                      (UINT32*) pImg->m_pImageBuffer,
                                      m_lRowJump >> 2,
                                      pImg->m_lRowJump >> 2);
                }
                else
                {
                    retVal = HXR_INVALID_PARAMETER;
                }
            }
            else
            {
                retVal = HXR_FAIL;
            }
        }
        else
        {
            retVal = HXR_NOT_INITIALIZED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImage::CopyToAlpha32(PXImage* pImg, BYTE* pLUT)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pImg)
    {
        if (m_bInitialized && pImg->m_bInitialized)
        {
            if (m_cBitmapInfo.biBitCount          == 32      &&
                pImg->m_cBitmapInfo.biBitCount    == 32      &&
                CompressionSupported()                       &&
                pImg->CompressionSupported())
            {
                if (Compatible(pImg) && SameSize(pImg))
                {
                    CopyAlpha32((UINT32*) m_pImageBuffer,
                                (UINT32*) pImg->m_pImageBuffer,
                                m_lRowJump >> 2,
                                pImg->m_lRowJump >> 2,
                                pLUT);
                    retVal = HXR_OK;
                }
            }
        }
    }

    return retVal;
}

HX_RESULT PXImage::FlipFrom(PXImage* pImg, BOOL bVerticalAxis)
{
    HX_RESULT retVal = HXR_OK;

    if (pImg)
    {
        if (m_bInitialized)
        {
            if (Compatible(pImg) && SameSize(pImg))
            {
                if (bVerticalAxis)
                {
                    VertAxisFlip32((UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
                                   pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2,
                                   (UINT32*) m_pImageBuffer,       m_lSubImageWidth,
                                   m_lSubImageHeight,              m_lRowJump >> 2);
                }
                else
                {
                    HorzAxisFlip32((UINT32*) pImg->m_pImageBuffer, pImg->m_lSubImageWidth,
                                   pImg->m_lSubImageHeight,        pImg->m_lRowJump >> 2,