gifimage.cpp

linux下的一款播放器

HX_RESULT CGIFImage::GetRGBImageEx(BYTE *pLogicalScreen, UINT32 ulWidth, UINT32 ulHeight, UINT32 ulPadWidth,
                                   UINT32 ulBytesPerPixel, BOOL bRowsInverted, BOOL bRGBOrdering,
                                   UINT32 ulBgColor, BOOL bMediaOpacity, UINT32 ulMediaOpacity,
                                   BOOL bChromaKey, UINT32 ulChromaKey, UINT32 ulChromaKeyTol, UINT32 ulChromaKeyOpacity)
{
    HX_RESULT retVal = HXR_OK;

    if (pLogicalScreen && 
        m_cID.m_ulImageLeft + m_cID.m_ulImageWidth  <= ulWidth &&
        m_cID.m_ulImageTop  + m_cID.m_ulImageHeight <= ulHeight &&
        (m_cID.m_bLocalColorTablePresent || m_bGlobalColorMapPresent))
    {
        BYTE *pSrc       = m_pOutputBuffer;
        BYTE *pDst       = NULL;
        INT32 lRowStride = 0;
        if (bRowsInverted)
        {
            pDst       = pLogicalScreen + (ulHeight - 1 - m_cID.m_ulImageTop) * ulPadWidth +
                         m_cID.m_ulImageLeft * ulBytesPerPixel;
            lRowStride = - ((INT32) ulPadWidth);
        }
        else
        {
            pDst       = pLogicalScreen + m_cID.m_ulImageTop * ulPadWidth +
                         m_cID.m_ulImageLeft * ulBytesPerPixel;
            lRowStride = ulPadWidth;
        }
        BYTE *pColorMap = m_pucGlobalColorMap;
        if (m_cID.m_bLocalColorTablePresent)
        {
            pColorMap = m_pucLocalColorMap;
        }
        UINT32 ulRedIndex;
        UINT32 ulGreenIndex;
        UINT32 ulBlueIndex;
        UINT32 ulAlphaIndex;
        if (bRGBOrdering)
        {
            ulAlphaIndex = 0;
            ulRedIndex   = 1;
            ulGreenIndex = 2;
            ulBlueIndex  = 3;
        }
        else
        {
            ulAlphaIndex = 3;
            ulRedIndex   = 2;
            ulGreenIndex = 1;
            ulBlueIndex  = 0;
        }

        BYTE ucBackAlpha = (BYTE) ((ulBgColor & 0xFF000000) >> 24);
        BYTE ucBackRed   = (BYTE) ((ulBgColor & 0x00FF0000) >> 16);
        BYTE ucBackGreen = (BYTE) ((ulBgColor & 0x0000FF00) >>  8);
        BYTE ucBackBlue  = (BYTE)  (ulBgColor & 0x000000FF);

        // Compute the media alpha
        BYTE ucMediaAlpha = 0;
        if (bMediaOpacity)
        {
            INT32 lAlpha = (INT32) (255 - ulMediaOpacity);
            if (lAlpha < 0)   lAlpha = 0;
            if (lAlpha > 255) lAlpha = 255;
            ucMediaAlpha = (BYTE) lAlpha;
        }
        // Compute the chroma key alpha
        BYTE ucChromaAlpha = 255;
        if (bChromaKey)
        {
            // We need to adjust the chroma key opacity by the media
            // opacity
            UINT32 ulNewChromaKeyOpacity = ulChromaKeyOpacity * ulMediaOpacity / 255;
            INT32 lAlpha = (INT32) (255 - ulNewChromaKeyOpacity);
            if (lAlpha < 0)   lAlpha = 0;
            if (lAlpha > 255) lAlpha = 255;
            ucChromaAlpha = (BYTE) lAlpha;
        }

        if (m_bGCEPresent && m_cGCE.m_bTransparentIndexGiven)
        {
            // Here we take care of a special case: when the current frame is a subimage and
            // the disposal method for this frame is restore to background. Then we have to
            // go to all the pixels in the logical screen outside the subimage and also restore
            // them to the background color. This fixes PR6182.
            if (m_cGCE.m_ulDisposalMethod == kDisposalMethodRestoreToBackground &&
                (m_cID.m_ulImageWidth < ulWidth || m_cID.m_ulImageHeight < ulHeight))
            {
                for (UINT32 ulLogY = 0; ulLogY < ulHeight; ulLogY++)
                {
                    BYTE *pLogRow = pLogicalScreen + ulLogY * ulPadWidth;
                    for (UINT32 ulLogX = ulWidth; ulLogX; ulLogX--)
                    {
                        pLogRow[ulRedIndex]   = ucBackRed;
                        pLogRow[ulGreenIndex] = ucBackGreen;
                        pLogRow[ulBlueIndex]  = ucBackBlue;
                        pLogRow[ulAlphaIndex] = ucBackAlpha;
                        pLogRow              += ulBytesPerPixel;
                    }
                }
            }

            UINT32 ulX;
            UINT32 ulY;
            INT32  lDstJump = lRowStride - ((INT32) (m_cID.m_ulImageWidth * ulBytesPerPixel));
            BYTE  *pMap;
            for (ulY = m_cID.m_ulImageHeight; ulY; ulY--)
            {
                for (ulX = m_cID.m_ulImageWidth; ulX; ulX--)
                {
                    UINT32 ulColorIndex = *pSrc++;
                    if (ulColorIndex != m_cGCE.m_ulTransparentColorIndex)
                    {
                        pMap               = pColorMap + (ulColorIndex * 3);
                        pDst[ulRedIndex]   = pMap[0];
                        pDst[ulGreenIndex] = pMap[1];
                        pDst[ulBlueIndex]  = pMap[2];
                        pDst[ulAlphaIndex] = ucMediaAlpha;
                        if (bChromaKey)
                        {
                            UINT32 ulMapColor = (pMap[0] << 16) | (pMap[1] << 8) | pMap[2];
                            if (DoesChromaKeyMatch(ulMapColor, ulChromaKey, ulChromaKeyTol))
                            {
                                pDst[ulAlphaIndex] = ucChromaAlpha;
                            }
                        }
                    }
                    else
                    {
                        if (m_cGCE.m_ulDisposalMethod == kDisposalMethodRestoreToBackground)
                        {
                           pDst[ulRedIndex]   = ucBackRed;
                           pDst[ulGreenIndex] = ucBackGreen;
                           pDst[ulBlueIndex]  = ucBackBlue;
                           pDst[ulAlphaIndex] = ucBackAlpha;
                        }
                    }
                    pDst += ulBytesPerPixel;
                }
                pDst += lDstJump;
            }
        }
        else
        {
            UINT32 ulX;
            UINT32 ulY;
            INT32  lDstJump = lRowStride - ((INT32) (m_cID.m_ulImageWidth * ulBytesPerPixel));
            BYTE  *pMap;
            for (ulY = m_cID.m_ulImageHeight; ulY; ulY--)
            {
                for (ulX = m_cID.m_ulImageWidth; ulX; ulX--)
                {
                    UINT32 ulColorIndex = *pSrc++;
                    pMap                = pColorMap + (ulColorIndex * 3);
                    pDst[ulRedIndex]    = pMap[0];
                    pDst[ulGreenIndex]  = pMap[1];
                    pDst[ulBlueIndex]   = pMap[2];
                    pDst[ulAlphaIndex]  = ucMediaAlpha;
                    if (bChromaKey)
                    {
                        UINT32 ulMapColor = (pMap[0] << 16) | (pMap[1] << 8) | pMap[2];
                        if (DoesChromaKeyMatch(ulMapColor, ulChromaKey, ulChromaKeyTol))
                        {
                            pDst[ulAlphaIndex] = ucChromaAlpha;
                        }
                    }
                    pDst               += ulBytesPerPixel;
                }
                pDst += lDstJump;
            }
        }
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;
}

HX_RESULT CGIFImage::GetRGB32(BYTE *pBuffer, UINT32 ulRowStride, BOOL bRowsInverted)
{
    HX_RESULT retVal = HXR_OK;

    if (pBuffer)
    {
        if (m_pOutputBuffer)
        {
            BYTE* pColorMap = NULL;
            if (m_cID.m_bLocalColorTablePresent)
            {
                pColorMap = m_pucLocalColorMap;
            }
            else if (m_bGlobalColorMapPresent)
            {
                pColorMap = m_pucGlobalColorMap;
            }
            else
            {
                retVal = HXR_FAIL;
            }

            if (SUCCEEDED(retVal))
            {
                BYTE*   pSrc     = m_pOutputBuffer;
                UINT32* pDstRow  = NULL;
                INT32   lRowJump = 0;
                if (bRowsInverted)
                {
                    pDstRow  = (UINT32*) (pBuffer + (m_cID.m_ulImageHeight - 1) * ulRowStride);
                    lRowJump = - (INT32) (ulRowStride >> 2);
                }
                else
                {
                    pDstRow  = (UINT32*) pBuffer;
                    lRowJump = ulRowStride >> 2;
                }

                if (m_bGCEPresent && m_cGCE.m_bTransparentIndexGiven)
                {
                    UINT32 ulTransparentPixel = 0xFF000000;
                    for (UINT32 ulY = m_cID.m_ulImageHeight; ulY; ulY--)
                    {
                        UINT32* pDst = pDstRow;
                        for (UINT32 ulX = m_cID.m_ulImageWidth; ulX; ulX--)
                        {
                            UINT32 ulColorIndex = *pSrc++;
                            if (ulColorIndex == m_cGCE.m_ulTransparentColorIndex)
                            {
                                *pDst++ = ulTransparentPixel;
                            }
                            else
                            {
                                BYTE* pMap = pColorMap + (ulColorIndex * 3);
                                *pDst++    = (pMap[0] << 16) | (pMap[1] << 8) | pMap[2];
                            }
                        }
                        pDstRow += lRowJump;
                    }
                }
                else
                {
                    for (UINT32 ulY = m_cID.m_ulImageHeight; ulY; ulY--)
                    {
                        UINT32* pDst = pDstRow;
                        for (UINT32 ulX = m_cID.m_ulImageWidth; ulX; ulX--)
                        {
                            UINT32 ulColorIndex = *pSrc++;
                            BYTE*  pMap         = pColorMap + (ulColorIndex * 3);
                            *pDst++             = (pMap[0] << 16) | (pMap[1] << 8) | pMap[2];
                        }
                        pDstRow += lRowJump;
                    }
                }
            }
        }
        else
        {
            retVal = HXR_UNEXPECTED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

void CGIFImage::BumpPixel()
{
    /* Bump the current X position */
    m_ulCurX++;

    /*
     * If we are at the end of a scan line, set current x back to the beginning
     * If we are interlaced, bump the current y to the appropriate spot,
     * Otherwise, just increment it.
     */
    if(m_ulCurX == m_cID.m_ulImageWidth)
    {
        m_ulCurX = 0;
        if(m_cID.m_bInterlaced == FALSE)
        {
            ++m_ulCurY;
        }
        else
        {
            switch(m_ulPass)
            {
                case 0:
                    m_ulCurY += 8;
                    if(m_ulCurY >= m_cID.m_ulImageHeight)
                    {
                        ++m_ulPass;
                        m_ulCurY = 4;
                    }
                    break;
                case 1:
                    m_ulCurY += 8;
                    if(m_ulCurY >= m_cID.m_ulImageHeight)
                    {
                        ++m_ulPass;
                        m_ulCurY = 2;
                    }
                    break;
                case 2:
                    m_ulCurY += 4;
                    if(m_ulCurY >= m_cID.m_ulImageHeight)
                    {
                        ++m_ulPass;
                        m_ulCurY = 1;
                    }
                    break;
                case 3:
                    m_ulCurY += 2;
                    break;
            }
        }
    }
}