fxseshun.cpp

linux下的一款播放器

                if (m_bDstChanges)
                {
                    if (m_bRestoreDst)
                    {
                        // Compute the biggest size the restore image needs to be
                        INT32 lStartW = m_pEffect->GetStartDstRect().GetWidth();
                        INT32 lStartH = m_pEffect->GetStartDstRect().GetHeight();
                        INT32 lEndW   = m_pEffect->GetDstRect().GetWidth();
                        INT32 lEndH   = m_pEffect->GetDstRect().GetHeight();
                        INT32 lMaxW   = PXMAX(lStartW, lEndW);
                        INT32 lMaxH   = PXMAX(lStartH, lEndH);
                        // Get a scratch image which can handle this size
                        retVal = m_pImageManager->GetScratchImage(&m_pPrevDst, lMaxW, lMaxH);
                        if (SUCCEEDED(retVal))
                        {
                            // Set the initial restore rect
                            m_cRestoreRect.left   = m_pEffect->GetStartDstRect().GetX();
                            m_cRestoreRect.top    = m_pEffect->GetStartDstRect().GetY();
                            m_cRestoreRect.right  = m_pEffect->GetStartDstRect().GetX() +
                                                    m_pEffect->GetStartDstRect().GetWidth();
                            m_cRestoreRect.bottom = m_pEffect->GetStartDstRect().GetY() +
                                                    m_pEffect->GetStartDstRect().GetHeight();
                            // Now set up the image for the initial restore size
                            retVal = m_pPrevDst->Create(HXxRECT_WIDTH(m_cRestoreRect),
                                                        HXxRECT_HEIGHT(m_cRestoreRect),
                                                        m_pImageManager->GetDefaultBitsPerPixel(),
                                                        m_pImageManager->GetDefaultPixelFormat(),
                                                        m_pImageManager->GetDefaultRowsInverted(),
                                                        FALSE); // Use the same buffer!!
                            if (SUCCEEDED(retVal))
                            {
                                retVal = m_pPrevDst->Fill32(m_pImageManager->GetBackgroundColor());
                            }
                        }
                    }
                }
                else
                {
                    // The destination rect doesn't change, so we can set it up once.
                    retVal = m_pImageManager->GetDisplaySubImage(&m_pDstImage, m_pEffect->GetDstRect());
                }

                if (SUCCEEDED(retVal))
                {
                    m_bInitialized = TRUE;
                }
            }

        }
        HX_RELEASE(pTargetImage);
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    if (FAILED(retVal))
    {
        Reset();
        Deallocate();
        m_bSrcChanges = FALSE;
        m_bDstChanges = FALSE;
        m_bDstMoves   = FALSE;
        m_bRestoreDst = NULL;
        HX_RELEASE(m_pSrcImage);
        HX_RELEASE(m_pPrevDst);
        HX_ASSERT(FALSE);
    }

    return retVal;
}

HX_RESULT PXViewchangeEffectSession::Execute(UINT32 ulTime)
{
    HX_RESULT retVal = HXR_OK;

    if (m_bInitialized)
    {
        if (!m_bFinished)
        {
            if (IsTimeEqualOrLater(m_pEffect->GetStart(), ulTime))
            {
                // Do the maxfps check
                BOOL bDoEffect = MaxFramesPerSecondCheck(ulTime);

                // Check if this is the last time
                if (IsTimeEqualOrLater(m_pEffect->GetEnd(), ulTime))
                {
                    m_bFinished = TRUE;
                    bDoEffect   = TRUE;
                    ulTime      = m_pEffect->GetEnd();
                }

                if (bDoEffect)
                {
                    if (m_bSrcChanges)
                    {
                        PXRect cSrcRect;
                        cSrcRect.InterpolateRect(ulTime, m_pEffect->GetStart(), m_pEffect->GetEnd(),
                                                 m_pEffect->GetStartSrcRect(), m_pEffect->GetSrcRect());
                        HX_RELEASE(m_pSrcImage);
                        retVal = m_pImageManager->GetPresentationSubImage(&m_pSrcImage,
                                                                          m_pEffect->GetTarget(),
                                                                          cSrcRect);
                    }

                    if (SUCCEEDED(retVal))
                    {
                        PXRect cDstRect;
                        cDstRect = m_pEffect->GetDstRect();
                        if (m_bDstChanges)
                        {
                            cDstRect.InterpolateRect(ulTime, m_pEffect->GetStart(), m_pEffect->GetEnd(),
                                                     m_pEffect->GetStartDstRect(), m_pEffect->GetDstRect());
                            HX_RELEASE(m_pDstImage);
                            retVal = m_pImageManager->GetDisplaySubImage(&m_pDstImage, cDstRect);
                        }

                        if (SUCCEEDED(retVal))
                        {
                            HXxRect cOldRestoreRect;
                            if (m_bRestoreDst)
                            {
                                // Copy the old dest rect back - first we get a display
                                // subimage rect and then copy it.
                                PXImage* pTmp = NULL;
                                retVal        = m_pImageManager->GetDisplaySubImage(&pTmp, m_cRestoreRect);
                                if (SUCCEEDED(retVal))
                                {
                                    retVal = pTmp->CopyFrom(m_pPrevDst);
                                    if (SUCCEEDED(retVal))
                                    {
                                        // Now before we do the new draw we save what's under the
                                        // rect we're about to draw on
                                        //
                                        // First save the old restore rect, so we can resolve the
                                        // damage rect later and update the restore rect
                                        cOldRestoreRect       = m_cRestoreRect;
                                        m_cRestoreRect.left   = cDstRect.GetX();
                                        m_cRestoreRect.top    = cDstRect.GetY();
                                        m_cRestoreRect.right  = cDstRect.GetX() + cDstRect.GetWidth();
                                        m_cRestoreRect.bottom = cDstRect.GetY() + cDstRect.GetHeight();
                                        // Now setup our scratch image to handle the new size of the
                                        // the restore rect. It's very important that we tell the Create()
                                        // method FALSE for the last argument, for this forces the
                                        // image to reuse the same buffer (which we know is big enough).
                                        // This just makes for efficient use of memory.
                                        retVal = m_pPrevDst->Create(HXxRECT_WIDTH(m_cRestoreRect),
                                                                    HXxRECT_HEIGHT(m_cRestoreRect),
                                                                    m_pImageManager->GetDefaultBitsPerPixel(),
                                                                    m_pImageManager->GetDefaultPixelFormat(),
                                                                    m_pImageManager->GetDefaultRowsInverted(),
                                                                    FALSE); // Use the same buffer!!
                                        if (SUCCEEDED(retVal))
                                        {
                                            HX_RELEASE(pTmp);
                                            retVal = m_pImageManager->GetDisplaySubImage(&pTmp, m_cRestoreRect);
                                            if (SUCCEEDED(retVal))
                                            {
                                                retVal = m_pPrevDst->CopyFrom(pTmp);
                                            }
                                        }
                                    }
                                }
                                HX_RELEASE(pTmp);
                            }

                            if (SUCCEEDED(retVal))
                            {
                                retVal = SizeAspectCopy(m_pSrcImage,
                                                        m_pDstImage,
                                                        m_pEffect->GetAspectFlag(),
                                                        m_pImageManager->GetBackgroundColor());

                                if (SUCCEEDED(retVal))
                                {
                                    // Set the damaged display flag
                                    m_bDisplayDamaged = TRUE;
                                    // Set the damage rect
                                    m_pDstImage->GetSubRect(m_cDamageRect);

                                    if (m_bRestoreDst)
                                    {
                                        m_cDamageRect.left   = PXMIN(m_cDamageRect.left,   cOldRestoreRect.left);
                                        m_cDamageRect.top    = PXMIN(m_cDamageRect.top,    cOldRestoreRect.top);
                                        m_cDamageRect.right  = PXMAX(m_cDamageRect.right,  cOldRestoreRect.right);
                                        m_cDamageRect.bottom = PXMAX(m_cDamageRect.bottom, cOldRestoreRect.bottom);
                                    }
                                }
                            }
                        }
                    }

                    // Update the last exe time
                    m_ulLastExeTime = ulTime;
                }
            }
        }
        else
        {
            ResetDamage();
        }
    }
    else
    {
        retVal = HXR_NOT_INITIALIZED;
    }

    if (FAILED(retVal))
    {
        HX_ASSERT(FALSE);
    }

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

    return retVal;
}

HX_RESULT PXViewchangeEffectSession::SizeAspectCopy(PXImage* pSrcImage, PXImage* pDstImage,
                                                    BOOL bAspectFlag, UINT32 ulBackgroundColor)
{
    HX_RESULT retVal = HXR_OK;

    if (pSrcImage && pDstImage)
    {
        if (bAspectFlag)
        {
            // We have to preserve aspect ratio, so we need to resolve the rectangles
            HXxRect cSrc;
            pSrcImage->GetSubRect(cSrc);
            HXxRect cDst;
            pDstImage->GetSubRect(cDst);

            HXxRect cNewDst;
            HXxRect cFill1;
            HXxRect cFill2;
            retVal = m_pImageManager->ResolveAspectRatio(cSrc, cDst, cNewDst, cFill1, cFill2, TRUE);
            if (SUCCEEDED(retVal))
            {
                if (HXxRECT_WIDTH(cFill1) > 0 && HXxRECT_HEIGHT(cFill1) > 0)
                {
                    PXImage cTmp;
                    retVal = cTmp.CreateSubImage(pDstImage, cFill1);
                    if (SUCCEEDED(retVal))
                    {
                        retVal = cTmp.Fill32(ulBackgroundColor);
                    }
                }

                if (SUCCEEDED(retVal))
                {
                    if (HXxRECT_WIDTH(cNewDst) > 0 && HXxRECT_HEIGHT(cNewDst) > 0)
                    {
                        PXImage cTmpDst;
                        retVal = cTmpDst.CreateSubImage(pDstImage, cNewDst);
                        if (SUCCEEDED(retVal))
                        {
                            if (cTmpDst.SameSize(pSrcImage))
                            {
                                retVal = cTmpDst.CopyFrom(pSrcImage);
                            }
                            else
                            {
                                retVal = cTmpDst.ChangeSizeFromNN(pSrcImage);
                            }
                        }
                    }

                    if (SUCCEEDED(retVal))
                    {
                        if (HXxRECT_WIDTH(cFill2) > 0 && HXxRECT_HEIGHT(cFill2) > 0)
                        {
                            PXImage cTmp;
                            retVal = cTmp.CreateSubImage(pDstImage, cFill2);
                            if (SUCCEEDED(retVal))
                            {
                                retVal = cTmp.Fill32(ulBackgroundColor);
                            }
                        }
                    }
                }
            }
        }
        else
        {
            // We don't have to preserve aspect ratio, so we simply
            // need to copy if they are the same size and ChangeSize
            // if they are not
            if (pDstImage->SameSize(pSrcImage))
            {
                retVal = pDstImage->CopyFrom(pSrcImage);
            }
            else
            {
                retVal = pDstImage->ChangeSizeFromNN(pSrcImage);
            }
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

IMPLEMENT_COM_CREATE_FUNCS(PXSimpleViewchangeEffectSession);

HX_RESULT PXSimpleViewchangeEffectSession::Init(PXEffectsManager*  pEffectsManager,
                                                PXEffect*          pEffect,
                                                PXImageManager*    pImageManager,
                                                IHXErrorMessages* pErrorMessages)
{
    // Call the super-class' Init()
    HX_RESULT retVal = PXEffectSession::Init(pEffectsManager,
                                             pEffect,
                                             pImageManager,
                                             pErrorMessages);
    if (SUCCEEDED(retVal))
    {
        // Make sure this is a viewchange effect