fxseshun.cpp

linux下的一款播放器

                    m_pDstImage->GetSubRect(m_cDamageRect);
                    // Update the last exe time
                    m_ulLastExeTime = ulTime;
                }
            }
        }
        else
        {
            ResetDamage();
        }
    }
    else
    {
        retVal = HXR_NOT_INITIALIZED;
    }

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

    return retVal;
}

IMPLEMENT_COM_CREATE_FUNCS(PXWipeEffectSession);

HX_RESULT PXWipeEffectSession::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 wipe effect
        if (pEffect->GetEffectType() == PXEffect::kEffectTypeWipe)
        {
            // Set the first time flag
            m_bFirstTime = TRUE;
            // Check to see if we can use recursive
            m_bRecursive = FALSE;
// XXXMEH - turn off recursive wipes for now 04/15/99
//            retVal       = m_pEffectsManager->CanUseRecursive(m_pEffect, m_bRecursive);
            if (SUCCEEDED(retVal))
            {
                // Get our end image (what we're fading to)
                if (SUCCEEDED(retVal))
                {
                    HX_RELEASE(m_pEndImage);
                    retVal = m_pImageManager->GetPresentationSubImage(&m_pEndImage,
                                                                      pEffect->GetTarget(),
                                                                      pEffect->GetSrcRect(),
                                                                      pEffect->GetDstRect(),
                                                                      pEffect->GetAspectFlag());
                    if (SUCCEEDED(retVal))
                    {
                        // If this is a push wipe AND m_pEndImage (the image we
                        // are wiping to) uses transparency, then we need to
                        // remove the transparency by blending it with the background
                        // color.
                        if (pEffect->GetWipeType() == PXEffect::kWipeTypePush &&
                            m_pEndImage->GetHasAlpha())
                        {
                            // We have to make a copy of the image
                            PXImage* pTmp = NULL;
                            retVal        = PXImage::CreateObject(&pTmp);
                            if (SUCCEEDED(retVal))
                            {
                                // AddRef the object
                                pTmp->AddRef();
                                // Copy the current end image
                                retVal = pTmp->CreateSubImage(m_pEndImage, 0, 0, m_pEndImage->GetWidth(),
                                                              m_pEndImage->GetHeight(), TRUE, TRUE);
                                if (SUCCEEDED(retVal))
                                {
                                    // This method removes the alpha channel by pre-multiplying
                                    // it against the specified color - in this case the
                                    // background color.
                                    pTmp->PreMultiplyAlphaChannel(m_pImageManager->GetBackgroundColor());
                                    // Now replace the end image
                                    HX_RELEASE(m_pEndImage);
                                    m_pEndImage = pTmp;
                                    m_pEndImage->AddRef();
                                }
                            }
                            HX_RELEASE(pTmp);
                        }
                        // Set the initialized flag
                        m_bInitialized = TRUE;
                    }
                }
            }
        }
        else
        {
            retVal = HXR_FAIL;
        }
    }

    if (FAILED(retVal))
    {
        Reset();
        Deallocate();
        HX_RELEASE(m_pStartImage);
        HX_RELEASE(m_pEndImage);
        m_ulLastExeTime = 0;
        m_bRecursive    = FALSE;
    }

    return retVal;
}

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

    if (m_bInitialized)
    {
        if (!m_bFinished)
        {
            if (IsTimeEqualOrLater(m_pEffect->GetEnd(), ulTime))
            {
                // Just copy the end image to the display image
                retVal = m_pDstImage->CopyFrom(m_pEndImage);
                // Set the finished flag
                m_bFinished = TRUE;
                // Set the damaged display flag
                m_bDisplayDamaged = TRUE;
                // Set the damage rect
                m_pDstImage->GetSubRect(m_cDamageRect);
            }
            else if (IsTimeLater(m_pEffect->GetStart(), ulTime) &&
                     IsTimeLater(ulTime, m_pEffect->GetEnd()))
            {
                // Check the maxfps
                if (MaxFramesPerSecondCheck(ulTime))
                {
                    // We passed the maxfps check, so we WILL do the effect
                    if (m_bRecursive)
                    {
                        PXRect cDamageRect;
                        retVal = m_pDstImage->RecursiveWipe(m_pEndImage,
                                                            m_pEffect->GetWipeType(),
                                                            m_pEffect->GetWipeDirection(),
                                                            m_ulLastExeTime - m_pEffect->GetStart(),
                                                            ulTime          - m_pEffect->GetStart(),
                                                            m_pEffect->GetDuration(),
                                                            cDamageRect);
                        if (SUCCEEDED(retVal))
                        {
                            m_bDisplayDamaged    = TRUE;
                            m_cDamageRect.left   = cDamageRect.GetX();
                            m_cDamageRect.top    = cDamageRect.GetY();
                            m_cDamageRect.right  = cDamageRect.GetX() + cDamageRect.GetWidth();
                            m_cDamageRect.bottom = cDamageRect.GetY() + cDamageRect.GetHeight();
                        }
                    }
                    else
                    {
                        if (m_bFirstTime)
                        {
                            HX_RELEASE(m_pStartImage);
                            retVal = m_pImageManager->GetDisplaySubImage(&m_pStartImage,
                                                                         m_pEffect->GetDstRect(),
                                                                         TRUE); // need a copy
                        }
                        if (SUCCEEDED(retVal))
                        {
                            retVal = m_pDstImage->Wipe(m_pStartImage,
                                                       m_pEndImage,
                                                       m_pEffect->GetWipeType(),
                                                       m_pEffect->GetWipeDirection(),
                                                       ulTime - m_pEffect->GetStart(),
                                                       m_pEffect->GetDuration());
                            if (SUCCEEDED(retVal))
                            {
                                // Set the damaged display flag
                                m_bDisplayDamaged = TRUE;
                                // Set the damage rect
                                m_pDstImage->GetSubRect(m_cDamageRect);
                            }
                        }
                    }
                    // Update the last exe time
                    m_ulLastExeTime = ulTime;
                    // Clear the first time flag if necessary
                    if (m_bFirstTime)
                    {
                        m_bFirstTime = FALSE;
                    }
                }
            }
        }
        else
        {
            ResetDamage();
        }
    }
    else
    {
        retVal = HXR_NOT_INITIALIZED;
    }

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

    return retVal;
}

IMPLEMENT_COM_CREATE_FUNCS(PXViewchangeEffectSession);

HX_RESULT PXViewchangeEffectSession::Init(PXEffectsManager*  pEffectsManager,
                                          PXEffect*          pEffect,
                                          PXImageManager*    pImageManager,
                                          IHXErrorMessages* pErrorMessages)
{
    HX_RESULT retVal = HXR_OK;

    if (pEffectsManager && pEffect && pImageManager)
    {
        // Clear out everything
        Reset();
        Deallocate();
        m_bSrcChanges = FALSE;
        m_bDstChanges = FALSE;
        m_bDstMoves   = FALSE;
        m_bRestoreDst = NULL;
        HX_RELEASE(m_pSrcImage);
        HX_RELEASE(m_pPrevDst);

        // Save copies of needed objects
        m_pEffectsManager = pEffectsManager;
        m_pEffectsManager->AddRef();
        m_pEffect = pEffect;
        m_pEffect->AddRef();
        m_pImageManager = pImageManager;
        m_pImageManager->AddRef();
        m_pErrorMessages = pErrorMessages;
        m_pErrorMessages->AddRef();

        // Initialize the last exe time and flag
        m_ulLastExeTime = m_pEffect->GetStart();
        m_bFirstExe     = TRUE;

        // Adjust the src rect if necessary
        PXImage* pTargetImage = NULL;
        retVal                = m_pImageManager->GetImage(m_pEffect->GetTarget(), &pTargetImage);
        if (SUCCEEDED(retVal))
        {
            // Set the proper src rectangles
            PXRect cRect;
            cRect = m_pEffect->GetSrcRect();
            cRect.AdjustForZeroValues(pTargetImage->GetWidth(), pTargetImage->GetHeight());
            cRect.AdjustForOvershoot(pTargetImage->GetWidth(), pTargetImage->GetHeight());
            m_pEffect->SetSrcRect(cRect);
            cRect = m_pEffect->GetStartSrcRect();
            cRect.AdjustForZeroValues(pTargetImage->GetWidth(), pTargetImage->GetHeight());
            cRect.AdjustForOvershoot(pTargetImage->GetWidth(), pTargetImage->GetHeight());
            m_pEffect->SetStartSrcRect(cRect);

            // Fix dst rectangles if necessary
            cRect = m_pEffect->GetDstRect();
            cRect.AdjustForZeroValues(m_pImageManager->GetDisplayWidth(),
                                      m_pImageManager->GetDisplayHeight());
            cRect.AdjustForOvershoot(m_pImageManager->GetDisplayWidth(),
                                     m_pImageManager->GetDisplayHeight());
            m_pEffect->SetDstRect(cRect);
            cRect = m_pEffect->GetStartDstRect();
            cRect.AdjustForZeroValues(m_pImageManager->GetDisplayWidth(),
                                      m_pImageManager->GetDisplayHeight());
            cRect.AdjustForOvershoot(m_pImageManager->GetDisplayWidth(),
                                     m_pImageManager->GetDisplayHeight());
            m_pEffect->SetStartDstRect(cRect);

            // Now set up the member booleans
            m_bSrcChanges = (m_pEffect->GetStartSrcRect() == m_pEffect->GetSrcRect() ? FALSE : TRUE);
            m_bDstChanges = (m_pEffect->GetStartDstRect() == m_pEffect->GetDstRect() ? FALSE : TRUE);

            // Determine if we need to restore the destination
            if (m_bDstChanges)
            {
                // Does the dst width and height stay constant?
                if (m_pEffect->GetStartDstRect().GetWidth()  == m_pEffect->GetDstRect().GetWidth() &&
                    m_pEffect->GetStartDstRect().GetHeight() == m_pEffect->GetDstRect().GetHeight())
                {
                    m_bDstMoves = TRUE;
                }
                else
                {
                    m_bDstMoves = FALSE;
                }

                // If the ending dst rect completely contains the starting dst
                // rect, then every draw of this viewchange will completely
                // obscure the last draw. However, the ending dst rect DOES NOT
                // completely contain the starting dst rect, then we need to
                // restore the background.
                if (m_pEffect->GetDstRect().Contains(m_pEffect->GetStartDstRect()))
                {
                    m_bRestoreDst = FALSE;
                }
                else
                {
                    m_bRestoreDst = TRUE;
                }
            }

            // Ok, now we can set up the images (maybe)
            if (!m_bSrcChanges)
            {
                // The src rect DOES NOT change throughout the entire effect.
                retVal = m_pImageManager->GetPresentationSubImage(&m_pSrcImage,
                                                                  m_pEffect->GetTarget(),
                                                                  m_pEffect->GetSrcRect());
            }

            if (SUCCEEDED(retVal))
            {