fxseshun.cpp

linux下的一款播放器

/* ***** BEGIN LICENSE BLOCK *****
 * Source last modified: $Id: fxseshun.cpp,v 1.2.6.1 2004/07/09 01:51:47 hubbe Exp $
 * 
 * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
 * 
 * The contents of this file, and the files included with this file,
 * are subject to the current version of the RealNetworks Public
 * Source License (the "RPSL") available at
 * http://www.helixcommunity.org/content/rpsl unless you have licensed
 * the file under the current version of the RealNetworks Community
 * Source License (the "RCSL") available at
 * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
 * will apply. You may also obtain the license terms directly from
 * RealNetworks.  You may not use this file except in compliance with
 * the RPSL or, if you have a valid RCSL with RealNetworks applicable
 * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
 * the rights, obligations and limitations governing use of the
 * contents of the file.
 * 
 * Alternatively, the contents of this file may be used under the
 * terms of the GNU General Public License Version 2 or later (the
 * "GPL") in which case the provisions of the GPL are applicable
 * instead of those above. If you wish to allow use of your version of
 * this file only under the terms of the GPL, and not to allow others
 * to use your version of this file under the terms of either the RPSL
 * or RCSL, indicate your decision by deleting the provisions above
 * and replace them with the notice and other provisions required by
 * the GPL. If you do not delete the provisions above, a recipient may
 * use your version of this file under the terms of any one of the
 * RPSL, the RCSL or the GPL.
 * 
 * This file is part of the Helix DNA Technology. RealNetworks is the
 * developer of the Original Code and owns the copyrights in the
 * portions it created.
 * 
 * This file, and the files included with this file, is distributed
 * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
 * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
 * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
 * ENJOYMENT OR NON-INFRINGEMENT.
 * 
 * Technology Compatibility Kit Test Suite(s) Location:
 *    http://www.helixcommunity.org/content/tck
 * 
 * Contributor(s):
 * 
 * ***** END LICENSE BLOCK ***** */

// include
#include "hxtypes.h"
#include "hxwintyp.h"
#include "hxresult.h"
#include "hxcom.h"
#include "hxwin.h"
#include "ihxpckts.h"
#include "hxvsurf.h"
#include "hxfiles.h"
#include "hxerror.h"

#ifdef _MACINTOSH
#include "hxwin.h"	/* for _HXFocusContext; needed for other platforms too? */
#endif

// pncont
#include "hxslist.h"
#include "hxmap.h"

// pnmisc
#include "unkimp.h"
#include "baseobj.h"

// pxcomlib
#include "pxrect.h"
#include "pxcolor.h"
#include "pximage.h"
#include "pxeffect.h"
#include "pxcmpmgr.h"
#include "pxrndcod.h"
#include "rpeffect.h"
#include "pxtime.h"

// pxrend
#include "hlinkmgr.h"
#include "rncodmgr.h"
#include "imghelpr.h"
#include "imagemgr.h"
#include "fxpkgmgr.h"
#include "fxmanagr.h"
#include "fxseshun.h"

// pndebug
#include "errdbg.h"
#include "hxheap.h"
#ifdef _DEBUG
#undef HX_THIS_FILE             
static char HX_THIS_FILE[] = __FILE__;
#endif

BEGIN_INTERFACE_LIST_NOCREATE(PXEffectSession)
END_INTERFACE_LIST

PXEffectSession::PXEffectSession()
{
    m_pEffectsManager = NULL;
    m_pEffect         = NULL;
    m_pImageManager   = NULL;
    m_pErrorMessages  = NULL;
    m_pDstImage       = NULL;
    Reset();
};

PXEffectSession::~PXEffectSession()
{
    Deallocate();
};

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

    if (pEffectsManager && pEffect && pImageManager)
    {
        // Clear out everything
        Reset();
        Deallocate();

        // 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();


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

        // Adjust the src rect if necessary
        if (m_pEffect->HasTarget())
        {
            PXImage* pTmpImg = NULL;
            retVal           = m_pImageManager->GetImage(m_pEffect->GetTarget(), &pTmpImg);
            if (SUCCEEDED(retVal))
            {
                PXRect cRect;
                cRect = m_pEffect->GetSrcRect();
                cRect.AdjustForZeroValues(pTmpImg->GetWidth(), pTmpImg->GetHeight());
                cRect.AdjustForOvershoot(pTmpImg->GetWidth(), pTmpImg->GetHeight());
                m_pEffect->SetSrcRect(cRect);
            }
            HX_RELEASE(pTmpImg);
        }

        if (SUCCEEDED(retVal))
        {
            // Fix any zero-values or overshoot in the dst rect
            PXRect cRect;
            cRect = m_pEffect->GetDstRect();
            cRect.AdjustForZeroValues(m_pImageManager->GetDisplayWidth(),
                                      m_pImageManager->GetDisplayHeight());
            cRect.AdjustForOvershoot(m_pImageManager->GetDisplayWidth(),
                                     m_pImageManager->GetDisplayHeight());
            m_pEffect->SetDstRect(cRect);
            // Get a subimage of the display image as our destination image
            retVal = m_pImageManager->GetDisplaySubImage(&m_pDstImage,
                                                         pEffect->GetDstRect(),
                                                         FALSE); // don't need a copy, just a ref
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

void PXEffectSession::ResetDamage()
{
    m_bDisplayDamaged    = FALSE;
    m_cDamageRect.left   = 0;
    m_cDamageRect.top    = 0;
    m_cDamageRect.right  = 0;
    m_cDamageRect.bottom = 0;
}

HX_RESULT PXEffectSession::GetEffect(PXEffect** ppEffect)
{
    HX_RESULT retVal = HXR_OK;

    if (ppEffect)
    {
        if (m_pEffect)
        {
            *ppEffect = m_pEffect;
            (*ppEffect)->AddRef();
        }
        else
        {
            retVal = HXR_UNEXPECTED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

BOOL PXEffectSession::NeedsPostDurationUpdate() const
{
    BOOL bRetVal = FALSE;

    if (m_pEffect && m_pImageManager)
    {
        if (m_pEffect->HasTarget())
        {
            BOOL      bComplete = FALSE;
            HX_RESULT retVal    = m_pImageManager->IsImageCompletelyDecoded(m_pEffect->GetTarget(), &bComplete);
            if (SUCCEEDED(retVal))
            {
                bRetVal = (bComplete ? FALSE : TRUE);
            }
        }
    }

    return bRetVal;
}

HX_RESULT PXEffectSession::ReleaseTargetImage()
{
    HX_RESULT retVal = HXR_OK;

    if (m_pEffect)
    {
        if (m_pEffect->HasTarget() && m_pEffect->GetLastUse())
        {
            retVal = m_pImageManager->DeleteImage(m_pEffect->GetTarget());
        }
    }
    else
    {
        retVal = HXR_UNEXPECTED;
    }

    return retVal;
}

BOOL PXEffectSession::MaxFramesPerSecondCheck(UINT32 ulTime)
{
    BOOL bRet = FALSE;

    if (m_pEffect)
    {
        // If we haven't reached the start time, then of course
        // we won't do the effect
        if (IsTimeEqualOrLater(m_pEffect->GetStart(), ulTime))
        {
            if (m_bFirstExe)
            {
                // If this is the first time we've executed the
                // effect, then we always do the effect. We also
                // initialize the last exe time to the current time.
                bRet            = TRUE;
                m_ulLastExeTime = ulTime;
                m_bFirstExe     = FALSE;
            }
            else
            {
                // This is not the first time we've done the effect, so
                // we will actually calculate if it's been long enough
                // in between execute's.
                //
                // Check the maxfps attribute
                if (m_pEffect->GetMaxFps())
                {
                    // maxfps WAS specified. Therefore, we must compute
                    // the minimum elapsed time in between draws.
                    UINT32 ulMinElapsedTime = 1000 / m_pEffect->GetMaxFps();
                    UINT32 ulTimeSinceLast  = ulTime - m_ulLastExeTime;
                    if (ulTimeSinceLast >= ulMinElapsedTime)
                    {
                        // We will update the last exe time at the end of execute
                        bRet = TRUE;
                    }
                }
                else
                {
                    // maxfps was not specified. Therefore, we do the
                    // effect every time we're called.
                    bRet = TRUE;
                }
            }
        }
    }

    return bRet;
}

void PXEffectSession::Reset()
{
    m_bInitialized                 = FALSE;
    m_bFinished                    = FALSE;
    m_ulPostDurationExpirationTime = 0;
    m_bFirstExe                    = TRUE;
    m_ulLastExeTime                = 0;
    m_bDelayedInit                 = FALSE;
    ResetDamage();
}

void PXEffectSession::Deallocate()
{
    HX_RELEASE(m_pEffectsManager);
    HX_RELEASE(m_pEffect);
    HX_RELEASE(m_pImageManager);