pximage.cpp

linux下的一款播放器

                else
                {
                    HorzAxisFlip32((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_NOT_INITIALIZED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImage::Wipe(PXImage* pStartImg, PXImage* pEndImg, UINT32 ulType,
                        UINT32 ulDirection, UINT32 ulTime, UINT32 ulDuration)
{
    HX_RESULT retVal = HXR_OK;

    if (pStartImg                                       &&
        pEndImg                                         &&
        (ulType == PXEffect::kWipeTypeNormal         ||
         ulType == PXEffect::kWipeTypePush)             &&
        (ulDirection == PXEffect::kWipeDirectionUp   ||
         ulDirection == PXEffect::kWipeDirectionDown ||
         ulDirection == PXEffect::kWipeDirectionLeft ||
         ulDirection == PXEffect::kWipeDirectionRight)  &&
        ulTime     > 0                                  &&
        ulTime     < ulDuration                         &&
        ulDuration > 0)
    {
        if (m_bInitialized)
        {
            if (Compatible(pStartImg) && SameSize(pStartImg) &&
                Compatible(pEndImg)   && SameSize(pEndImg))
            {
                // Set up src and dst rectangles for both
                // the start and end images
                PXRect cStartSrc;
                PXRect cStartDst;
                PXRect cEndSrc;
                PXRect cEndDst;
                UINT32 ulW = pStartImg->GetWidth();
                UINT32 ulH = pStartImg->GetHeight();
                if (ulType == PXEffect::kWipeTypeNormal)
                {
                    if (ulDirection == PXEffect::kWipeDirectionUp)
                    {
                        UINT32 ulY = (ulDuration - ulTime) * ulH / ulDuration;
                        cStartSrc.Set(0, 0, ulW, ulY);
                        cEndSrc.Set(0, ulY, ulW, ulH - ulY);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionDown)
                    {
                        UINT32 ulY = ulTime * ulH / ulDuration;
                        cStartSrc.Set(0, ulY, ulW, ulH - ulY);
                        cEndSrc.Set(0, 0, ulW, ulY);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionLeft)
                    {
                        UINT32 ulX = (ulDuration - ulTime) * ulW / ulDuration;
                        cStartSrc.Set(0, 0, ulX, ulH);
                        cEndSrc.Set(ulX, 0, ulW - ulX, ulH);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionRight)
                    {
                        UINT32 ulX = ulTime * ulW / ulDuration;
                        cStartSrc.Set(ulX, 0, ulW - ulX, ulH);
                        cEndSrc.Set(0, 0, ulX, ulH);
                    }
                    cStartDst = cStartSrc;
                    cEndDst   = cEndSrc;
                }
                else
                {
                    if (ulDirection == PXEffect::kWipeDirectionUp)
                    {
                        UINT32 ulY = (ulDuration - ulTime) * ulH / ulDuration;
                        cStartSrc.Set(0, ulH - ulY, ulW, ulY);
                        cStartDst.Set(0, 0, ulW, ulY);
                        cEndSrc.Set(0, 0, ulW, ulH - ulY);
                        cEndDst.Set(0, ulY, ulW, ulH - ulY);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionDown)
                    {
                        UINT32 ulY = ulTime * ulH / ulDuration;
                        cStartSrc.Set(0, 0, ulW, ulH - ulY);
                        cStartDst.Set(0, ulY, ulW, ulH - ulY);
                        cEndSrc.Set(0, ulH - ulY, ulW, ulY);
                        cEndDst.Set(0, 0, ulW, ulY);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionLeft)
                    {
                        UINT32 ulX = (ulDuration - ulTime) * ulW / ulDuration;
                        cStartSrc.Set(ulW - ulX, 0, ulX, ulH);
                        cStartDst.Set(0, 0, ulX, ulH);
                        cEndSrc.Set(0, 0, ulW - ulX, ulH);
                        cEndDst.Set(ulX, 0, ulW - ulX, ulH);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionRight)
                    {
                        UINT32 ulX = ulTime * ulW / ulDuration;
                        cStartSrc.Set(0, 0, ulW - ulX, ulH);
                        cStartDst.Set(ulX, 0, ulW - ulX, ulH);
                        cEndSrc.Set(ulW - ulX, 0,ulX, ulH);
                        cEndDst.Set(0, 0, ulX, ulH);
                    }
                }

                // Copy from the start image
                if (cStartSrc.GetWidth() > 0 && cStartSrc.GetHeight() > 0)
                {
                    // Create the start src image
                    PXImage cStartSrcImg;
                    retVal = cStartSrcImg.CreateSubImage(pStartImg, cStartSrc);
                    if (SUCCEEDED(retVal))
                    {
                        // Create the start dst image
                        PXImage cStartDstImg;
                        retVal = cStartDstImg.CreateSubImage(this, cStartDst);
                        if (SUCCEEDED(retVal))
                        {
                            // Now copy the start image
                            retVal = cStartDstImg.CopyFrom(&cStartSrcImg);
                        }
                    }
                }

                if (SUCCEEDED(retVal))
                {
                    // Copy from the dst image
                    if (cEndSrc.GetWidth() > 0 && cEndSrc.GetHeight() > 0)
                    {
                        // Create the end src image
                        PXImage cEndSrcImg;
                        retVal = cEndSrcImg.CreateSubImage(pEndImg, cEndSrc);
                        if (SUCCEEDED(retVal))
                        {
                            // Create the end dst image
                            PXImage cEndDstImg;
                            retVal = cEndDstImg.CreateSubImage(this, cEndDst);
                            if (SUCCEEDED(retVal))
                            {
                                // Now copy the end image
                                retVal = cEndDstImg.CopyFrom(&cEndSrcImg);
                            }
                        }
                    }
                }
            }
            else
            {
                retVal = HXR_FAIL;
            }
        }
        else
        {
            retVal = HXR_NOT_INITIALIZED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImage::RecursiveWipe(PXImage* pEndImage, UINT32 ulType, UINT32 ulDirection, UINT32 ulLastTime,
                                 UINT32 ulTime, UINT32 ulDuration, PXRect& rDamageRect)
{
    HX_RESULT retVal = HXR_OK;

    if (pEndImage                                       &&
        (ulType == PXEffect::kWipeTypeNormal         ||
         ulType == PXEffect::kWipeTypePush)             &&
        (ulDirection == PXEffect::kWipeDirectionUp   ||
         ulDirection == PXEffect::kWipeDirectionDown ||
         ulDirection == PXEffect::kWipeDirectionLeft ||
         ulDirection == PXEffect::kWipeDirectionRight)  &&
        ulTime     > 0                                  &&
        ulTime     < ulDuration                         &&
        ulTime     > ulLastTime                         &&
        ulDuration > 0)
    {
        if (m_bInitialized)
        {
            if (Compatible(pEndImage) && SameSize(pEndImage))
            {
                // Set up src and dst rectangles for both
                // the start and end images
                UINT32 ulW = pEndImage->GetWidth();
                UINT32 ulH = pEndImage->GetHeight();
                if (ulType == PXEffect::kWipeTypeNormal)
                {
                    PXRect cRect;
                    if (ulDirection == PXEffect::kWipeDirectionUp)
                    {
                        UINT32 ulY     = (ulDuration - ulTime) * ulH / ulDuration;
                        UINT32 ulLastY = (ulDuration - ulLastTime) * ulH / ulDuration;
                        cRect.Set(0, ulY, ulW, ulLastY - ulY);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionDown)
                    {
                        UINT32 ulY     = ulTime * ulH / ulDuration;
                        UINT32 ulLastY = ulLastTime * ulH / ulDuration;
                        cRect.Set(0, ulLastY, ulW, ulY - ulLastY);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionLeft)
                    {
                        UINT32 ulX     = (ulDuration - ulTime) * ulW / ulDuration;
                        UINT32 ulLastX = (ulDuration - ulLastTime) * ulW / ulDuration;
                        cRect.Set(ulX, 0, ulLastX - ulX, ulH);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionRight)
                    {
                        UINT32 ulX     = ulTime * ulW / ulDuration;
                        UINT32 ulLastX = ulLastTime * ulW / ulDuration;
                        cRect.Set(ulLastX, 0, ulX - ulLastX, ulH);
                    }

                    // Make sure that we have something to copy
                    if (cRect.GetWidth() > 0 && cRect.GetHeight() > 0)
                    {
                        // Set up the source image
                        PXImage cEndSrcImg;
                        retVal = cEndSrcImg.CreateSubImage(pEndImage, cRect);
                        if (SUCCEEDED(retVal))
                        {
                            // Set up the destination image
                            PXImage cEndDstImg;
                            retVal = cEndDstImg.CreateSubImage(this, cRect);
                            if (SUCCEEDED(retVal))
                            {
                                retVal = cEndDstImg.CopyFrom(&cEndSrcImg);
                                if (SUCCEEDED(retVal))
                                {
                                    rDamageRect = cRect;
                                }
                            }
                        }
                    }
                }
                else
                {
                    PXRect cIntraSrcRect;
                    PXRect cIntraDstRect;
                    PXRect cEndSrcRect;
                    PXRect cEndDstRect;
                    if (ulDirection == PXEffect::kWipeDirectionUp)
                    {
                        UINT32 ulY     = (ulDuration - ulTime) * ulH / ulDuration;
                        UINT32 ulLastY = (ulDuration - ulLastTime) * ulH / ulDuration;
                        UINT32 ulYDiff = ulLastY - ulY;
                        cIntraSrcRect.Set(0, ulYDiff, ulW, ulH - ulYDiff);
                        cIntraDstRect.Set(0, 0, ulW, ulH - ulYDiff);
                        cEndSrcRect.Set(0, ulH - ulLastY, ulW, ulYDiff);
                        cEndDstRect.Set(0, ulH - ulYDiff, ulW, ulYDiff);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionDown)
                    {
                        UINT32 ulY     = ulTime * ulH / ulDuration;
                        UINT32 ulLastY = ulLastTime * ulH / ulDuration;
                        UINT32 ulYDiff = ulY - ulLastY;
                        cIntraSrcRect.Set(0, 0, ulW, ulH - ulYDiff);
                        cIntraDstRect.Set(0, ulYDiff, ulW, ulH - ulYDiff);
                        cEndSrcRect.Set(0, ulH - ulY, ulW, ulYDiff);
                        cEndDstRect.Set(0, 0, ulW, ulYDiff);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionLeft)
                    {
                        UINT32 ulX     = (ulDuration - ulTime) * ulW / ulDuration;
                        UINT32 ulLastX = (ulDuration - ulLastTime) * ulW / ulDuration;
                        UINT32 ulXDiff = ulLastX - ulX;
                        cIntraSrcRect.Set(ulXDiff, 0, ulW - ulXDiff, ulH);
                        cIntraDstRect.Set(0, 0, ulW - ulXDiff, ulH);
                        cEndSrcRect.Set(ulW - ulLastX, 0, ulXDiff, ulH);
                        cEndDstRect.Set(ulW - ulXDiff, 0, ulXDiff, ulH);
                    }
                    else if (ulDirection == PXEffect::kWipeDirectionRight)
                    {
                        UINT32 ulX     = ulTime * ulW / ulDuration;
                        UINT32 ulLastX = ulLastTime * ulW / ulDuration;
                        UINT32 ulXDiff = ulX - ulLastX;
                        cIntraSrcRect.Set(0, 0, ulW - ulXDiff, ulH);
                        cIntraDstRect.Set(ulXDiff, 0, ulW - ulXDiff, ulH);
                        cEndSrcRect.Set(ulW - ulX, 0, ulXDiff, ulH);
                        cEndDstRect.Set(0, 0, ulXDiff, ulH);
                    }

                    // Make sure we have something to copy
                    if (cIntraSrcRect.GetWidth() == 0 || cIntraSrcRect.GetHeight() == 0)
                    {
                        // This is all end image, so just do a copy
                        retVal = CopyFrom(pEndImage);
                    }
                    else if (cEndSrcRect.GetWidth() > 0 && cEndSrcRect.GetHeight() > 0)
                    {
                        // First we do an intra copy to copy the part of 
                        // the image which is already there.
                        retVal = IntraCopy(cIntraSrcRect, cIntraDstRect);
                        if (SUCCEEDED(retVal))
                        {
                            PXImage cEndSrcImg;
                            retVal = cEndSrcImg.CreateSubImage(pEndImage, cEndSrcRect);
                            if (SUCCEEDED(retVal))
                            {
                                PXImage cEndDstImg;
                                retVal = cEndDstImg.CreateSubImage(this, cEndDstRect);
                                if (SUCCEEDED(retVal))
                                {
                                    retVal = cEndDstImg.CopyFrom(&cEndSrcImg);
                                    if (SUCCEEDED(retVal))
                                    {
                                        rDamageRect.Set(0, 0, ulW, ulH);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                retVal = HXR_FAIL;
            }
        }
        else
        {
            retVal = HXR_NOT_INITIALIZED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImage::IntraCopy(const PXRect& rSrcRect, const PXRect& rDstRect)
{
    HX_RESULT retVal = HXR_OK;

    if (rSrcRect.GetWidth()  == rDstRect.GetWidth()        &&
        rSrcRect.GetHeight() == rDstRect.GetHeight()       &&
        rSrcRect.GetWidth()  <= (UINT32) m_lSubImageWidth  &&
        rSrcRect.GetHeight() <= (UINT32) m_lSubImageHeight &&
        rSrcRect.GetX() + rSrcRect.GetWidth()  <= (UINT32) m_lSubImageWidth  &&
        rSrcRect.GetY() + rSrcRect.GetHeight() <= (UINT32) m_lSubImageHeight &&
        rDstRect.GetX() + rDstRect.GetWidth()  <= (UINT32) m_lSubImageWidth  &&
        rDstRect.GetY() + rDstRect.GetHeight() <= (UINT32) m_lSubImageHeight)
    {
        // Make sure this is not a null copy
        if (rSrcRect.GetX() != rDstRect.GetX() ||
            rSrcRect.GetY() != rDstRect.GetY())
        {
            BOOL bUpCopy = (rDstRect.GetY() <= rSrcRect.GetY() ? TRUE : FALSE);
//            if (m_bRowsInverted)
//            {
//                // If we are row-inverted, then we reverse whatever, operation
//                // we were going to do.
//                bUpCopy = (bUpCopy ? FALSE : TRUE);
//            }
            if (rDstRect.GetX() <= rSrcRect.GetX())
            {
                // This is a left-ward copy
                if (bUpCopy)
                {
                    // This is an up-left copy, so we do L->R, T->B
                    UINT32* pSrcRow = (UINT32*) GetPixel(rSrcRect.GetX(), rSrcRect.GetY());
                    UINT32* pDstRow = (UINT32*) GetPixel(rDstRect.GetX(), rDstRect.GetY());
                    INT32   lJump   = m_lRowJump >> 2;
                    for (UINT32 ulY = rSrcRect.GetHeight(); ulY; ulY--)
                    {
                        UINT32* pSrcPixel = pSrcRow;
                        UINT32* pDstPixel = pDstRow;
                        for (UINT32 ulX = rSrcRect.GetWidth(); ulX; ulX--)
                        {
                            *pDstPixel++ = *pSrcPixel++;
                        }
                        pSrcRow += lJump;
                        pDstRow += lJump;
                    }
                }
                else
                {
                    // This is a down-left copy, so we do L->R, B->T