fxseshun.cpp

linux下的一款播放器

    HX_RELEASE(m_pErrorMessages);
    HX_RELEASE(m_pDstImage);
}

IMPLEMENT_COM_CREATE_FUNCS(PXFillEffectSession);

HX_RESULT PXFillEffectSession::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 fill effect
        if (pEffect->GetEffectType() == PXEffect::kEffectTypeFill)
        {
            // Set the initialized flag
            m_bInitialized = TRUE;
        }
        else
        {
            retVal = HXR_FAIL;
        }
    }

    if (FAILED(retVal))
    {
        Reset();
        Deallocate();
    }

    return retVal;
}

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

    if (m_bInitialized)
    {
        if (IsTimeEqualOrLater(m_pEffect->GetStart(), ulTime) && !m_bFinished)
        {
            // No need to do the maxfps check, since a fill is a one-shot effect.

            // Do the fill
            retVal      = m_pDstImage->Fill(m_pEffect->GetColor());
            // 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
        {
            ResetDamage();
        }
    }
    else
    {
        retVal = HXR_NOT_INITIALIZED;
    }

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

    return retVal;
}

IMPLEMENT_COM_CREATE_FUNCS(PXFadeOutEffectSession);

HX_RESULT PXFadeOutEffectSession::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 fadeout effect
        if (pEffect->GetEffectType() == PXEffect::kEffectTypeFadeOut)
        {
            // Check to see if we can use recursive
            m_bRecursive = FALSE;
// XXXMEH - turn off recursive fadeouts for now 04/15/99
//            retVal       = m_pEffectsManager->CanUseRecursive(m_pEffect, m_bRecursive);
            if (SUCCEEDED(retVal))
            {
                // If we are NOT recursive, then we need to copy the dst rect
                if (!m_bRecursive)
                {
                    HX_RELEASE(m_pDstCopy);
                    retVal = m_pImageManager->GetDisplaySubImage(&m_pDstCopy,
                                                                 pEffect->GetDstRect(),
                                                                 TRUE); // need a copy
                }

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

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

    return retVal;
}

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

    if (m_bInitialized)
    {
        if (!m_bFinished)
        {
            if (IsTimeEqualOrLater(m_pEffect->GetEnd(), ulTime))
            {
                // Just fill with the color
                retVal = m_pDstImage->Fill(m_pEffect->GetColor());
                // 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 (IsTimeEqualOrLater(m_pEffect->GetStart(), ulTime) &&
                     IsTimeLater(ulTime, m_pEffect->GetEnd()))
            {
                // Check the maxfps
                if (MaxFramesPerSecondCheck(ulTime))
                {
                    // We WILL actually do the effect
                    BYTE* pLUT1 = NULL;
                    BYTE* pLUT2 = NULL;
                    if (m_bRecursive)
                    {
                        retVal = m_pEffectsManager->GetRecursiveFadeLUT(m_pEffect->GetStart(), m_pEffect->GetEnd(),
                                                                        ulTime, m_ulLastExeTime,
                                                                        &pLUT1, &pLUT2);
                        if (SUCCEEDED(retVal))
                        {
                            retVal = m_pDstImage->RecursiveBlendToColor(m_pEffect->GetColor(), pLUT1, pLUT2);
                        }
                    }
                    else
                    {
                        retVal = m_pEffectsManager->GetNormalFadeLUT(m_pEffect->GetStart(), m_pEffect->GetEnd(),
                                                                     ulTime, &pLUT1, &pLUT2);
                        if (SUCCEEDED(retVal))
                        {
                            retVal = m_pDstImage->BlendToColor(m_pDstCopy, m_pEffect->GetColor(), pLUT1, pLUT2);
                        }
                    }
                    // 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;
                }
            }
        }
        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(PXFadeInEffectSession);

HX_RESULT PXFadeInEffectSession::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 fadein or crossfade effect
        if (pEffect->GetEffectType() == PXEffect::kEffectTypeFadeIn ||
            pEffect->GetEffectType() == PXEffect::kEffectTypeCrossFade)
        {
            // Check to see if we can use recursive
            m_bRecursive = FALSE;
// XXXMEH - turn off recursive fadeins for now 04/15/99
//            retVal       = m_pEffectsManager->CanUseRecursive(m_pEffect, m_bRecursive);
            if (SUCCEEDED(retVal))
            {
                // If we are NOT recursive, then we need to copy the dst rect
                if (!m_bRecursive && pEffect->GetDuration() > 0)
                {
                    HX_RELEASE(m_pStartImage);
                    retVal = m_pImageManager->GetDisplaySubImage(&m_pStartImage,
                                                                 pEffect->GetDstRect(),
                                                                 TRUE); // need a copy
                }

                // 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))
                    {
                        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 PXFadeInEffectSession::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 (IsTimeEqualOrLater(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
                    BYTE* pLUT1 = NULL;
                    BYTE* pLUT2 = NULL;
                    if (m_bRecursive)
                    {
                        retVal = m_pEffectsManager->GetRecursiveFadeLUT(m_pEffect->GetStart(), m_pEffect->GetEnd(),
                                                                        ulTime, m_ulLastExeTime,
                                                                        &pLUT1, &pLUT2);
                        if (SUCCEEDED(retVal))
                        {
                            retVal = m_pDstImage->RecursiveBlend(m_pEndImage, pLUT2, pLUT1);
                        }
                    }
                    else
                    {
                        retVal = m_pEffectsManager->GetNormalFadeLUT(m_pEffect->GetStart(), m_pEffect->GetEnd(),
                                                                     ulTime, &pLUT1, &pLUT2);
                        if (SUCCEEDED(retVal))
                        {
                            retVal = m_pDstImage->Blend(m_pStartImage, m_pEndImage, pLUT1, pLUT2);
                        }
                    }
                    // Set the damaged display flag
                    m_bDisplayDamaged = TRUE;
                    // Set the damage rect