rarender.h

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

/* ***** BEGIN LICENSE BLOCK *****
 * Version: RCSL 1.0/RPSL 1.0
 *
 * Portions Copyright (c) 1995-2002 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
 * Version 1.0 (the "RPSL") available at
 * http://www.helixcommunity.org/content/rpsl unless you have licensed
 * the file under the RealNetworks Community Source License Version 1.0
 * (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.
 *
 * 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 ***** */


#ifndef _RARENDER_H_
#define _RARENDER_H_

/****************************************************************************
 *  Defines
 */
#define STREAM_MAJOR_VERSION  0
#define STREAM_MINOR_VERSION  0

#define CONTENT_MAJOR_VERSION 0
#define CONTENT_MINOR_VERSION 0

/****************************************************************************
 *  Includes
 */
#include "hxcom.h"
#include "baseobj.h"
#include "hxtypes.h"
#include "hxslist.h"
#include "hxresult.h"
#include "hxmarsh.h"
#include "netbyte.h"
#include "hxmime.h"
#include "hxcom.h"
#include "chxpckts.h"
#include "hxheap.h"
#include "hxcomm.h"
#include "ihxpckts.h"

#include "hxfiles.h"
#include "hxcore.h"
#include "hxengin.h"
#include "hxprefs.h"
#include "hxrendr.h"
#include "hxplugn.h"
#include "hxbdwdth.h"
#include "hxausvc.h"
#include "hxslist.h"
#include "hxupgrd.h"
#include "raparser.h"
#include "hxasm.h"
#include "hxrasyn.h"
#include "rmfftype.h"
#include "hxthread.h"
#include "hxerror.h"
#include "pckunpck.h"
#include "adjtime.h"
#include "vbrdepack.h"

#include "dllpath.h"
#include "readpath.h"
#include "hxcodec.h"
#include "codec.h"

#include "errdbg.h"
#include "hxtick.h"
#include "hxstrutl.h"

#include "raformat.h"


/****************************************************************************
 *  Defines
 */
#define NO_STREAM_SET	0xFFFF


class CRealAudioRenderer;
class CDryNotificationCallback;


/////////////////////////////////////////////////////////////////////////////
//
//  Class:
//
//	CRealAudioRenderer
//
//  Purpose:
//
//	Implementation of a basic RealAudio renderer.
//
class RuleToFlagMap;
class HXMutex;

class CRealAudioRenderer :  public IHXPlugin,
                            public IHXRenderer,
			    public IHXInterruptSafe,
			    public IHXDryNotification,
			    public IHXBandwidthLister,
			    public IHXStatistics,
                            public IHXValues, // for HELIX_FEATURE_SETSRCPROPS
			    public IHXUpdateProperties,
			    public CHXBaseCountingObject
{
protected:
    LONG32		    m_lRefCount;
    IUnknown*		    m_pContext;
    IHXStream*		    m_pStream;
#if defined(HELIX_CONFIG_SLUGGISHAUTOUPGRADE)
    IHXASMStream2*          m_pASMStream;
#endif
    IHXSourceBufferingStats* m_pBufferingStats;
    IHXAudioPlayer*	    m_pAudioPlayer;
    IHXErrorMessages*	    m_pErrorMessages;
    CRaFormat**		    m_pRaFormats;
    IHXAudioStream**	    m_pAudioStreams;
    IHXCommonClassFactory* m_pCommonClassFactory;


    UINT32		    m_ulPreroll;
    UINT32		    m_ulDelay;
    UINT32		    m_ulDuration;
    LONG32		    m_lTimeLineOffset;
    UINT16		    m_usCurrentDryNotificationStream;
    UINT16		    m_usPreviousDryNotificationStream;
    UINT16		    m_usThisSourceStream;

    UINT32		    m_ulCurrentTimelineTime;

    // statistics
    IHXRegistry*	    m_pRegistry;
    UINT32		    m_ulRegistryID;
    UINT32		    m_ulNameRegID;
    UINT32		    m_ulSmartStreamRegID;
    UINT32		    m_ulCodecRegID;
    UINT32		    m_ulCodecTextRegID;
    UINT32		    m_ulCodec4CCRegID;
    UINT32		    m_ulRateRegID;
    UINT32		    m_ulChannelsRegID;
    UINT32		    m_ulSurroundRegID;

    HX_BITFIELD		    m_bDoneWritingPackets:1;
    HX_BITFIELD		    m_bEndOfPackets:1;
#ifdef _MACINTOSH
    HX_BITFIELD		    m_bProcessingPacket:1;
#endif	// _MACINTOSH
    HX_BITFIELD		    m_bAllStreamsToBeUnregistered:1;
    HX_BITFIELD		    m_bInSeekMode:1;
    HX_BITFIELD		    m_bReportOKStatus:1;

    HX_BITFIELD		    m_bStreamSwitchable:1;
    HX_BITFIELD		    m_bFirstPacket:1;
    HX_BITFIELD		    m_bDelayOffsetSet:1;
    HX_BITFIELD		    m_bPreRedstonePlayer:1;

    UINT32		    m_ulCurrentGranularity;
    IHXAudioPushdown2*	    m_pAudioPushdown2;

    // Stream Switching
    RuleToFlagMap*	    m_pRuleToFlagMap;

    UINT16		    m_uNumOfSubStreams;
    UINT16		    m_uNumOfRules;
    UINT16*		    m_pRuleMap;
    BOOL		    m_bSecurityBreached;

    typedef enum
    {
	stopped, buffering, playing, paused, seeking
    } PlayState;
    PlayState m_PlayState;

    typedef enum
    {
	none, unknownRAContentVersion
    } AutoUpgradeRequestExtraInfo;

    class CUnregisterInfo
    {
    public:
	CUnregisterInfo(UINT32 ulTime, UINT16 uStream)
	{
	    m_uStreamToBeUnregistered = uStream;
	    m_ulUnregisterTime = ulTime;
	}

	virtual ~CUnregisterInfo() {};

	UINT16		    m_uStreamToBeUnregistered;
	UINT32		    m_ulUnregisterTime;
    };

    UINT16		    m_uSyncUnregisterStream;
    UINT32		    m_ulSyncUnregisterTime;

    HXMutex*		    m_pMutex;
    UINT32		    m_ulLatestStreamTime;
    UINT32		    m_ulLatestActualTime;
    double		    m_fLatestStreamTime;
    UINT32                  m_ulSrcPropertySubStream;
    IHXValues*              m_pValues;
    CVBRSimpleDepacketizer** m_ppVBRDepack;

#ifdef _MACINTOSH
    CDryNotificationCallback* m_pDryCallback;
#endif

    static const char* const	    zm_pName;
    static const char* const	    zm_pDescription;
    static const char* const	    zm_pCopyright;
    static const char* const 	    zm_pMoreInfoURL;
    static const char* const	    zm_pStreamMimeTypes[];
    static const char* const 	    zm_pAdditionalAutoUpgradeInfo[];

    virtual CRaFormat* CreateRaFormat(UINT16 uStreamNum);

    BOOL HaveDataToWrite();

    virtual HX_RESULT FindLowestStartTime(UINT16 &uLowest,
					 UINT32 &ulLowestStartTime,
					 UINT32 &ulLowestEndTime,
					 UINT16 &nActive);

    virtual HX_RESULT FindLongestOverlap(UINT16 uLowest,
					 UINT32 ulLowestEndTime,
					 UINT16 nActive,
					 UINT16 &uLongestOverlap,
					 AUDIO_STATE &audioState);

    virtual void GetLatestTimesForStream(UINT16 uStream,
					 UINT32& ulLatestActualTime,
					 UINT32& ulLatestStreamTime);

    virtual void OffsetLatestTime(UINT16 uStreamNumber,
				  INT32 lTimeOffset);

    virtual BOOL IsCrossfadeInProgress(void);

    virtual HX_RESULT AttemptCrossfade(UINT16 uLowest,		// From
				       UINT16 uLongetOverlap,	// To
				       UINT32 ulLatestActualTime,
				       UINT32 ulLatestStreamTime,
				       UINT32& ulFromStreamTimeStart,
				       UINT32& ulFromActualTimeStart,
				       AUDIO_STATE audioState);

    virtual HX_RESULT AttemptCrossfadeTermination(UINT16& uStream,
						  UINT32 ulActualTimestamp,
						  BOOL bStreamDone);

    HX_RESULT AddDryNotification(UINT16 usStreamNumber);

    HX_RESULT CheckStreamVersions(IHXValues* pHeader);

    HX_RESULT InitAudioStream(CRaFormat* pRaFormat,
			      IHXValues* pHeader,
			      IHXAudioStream** ppAudioStream);

    HX_RESULT DoAudio(UINT32 &ulAudioTime,
		      AUDIO_STATE audioState);

    virtual HX_RESULT WriteToAudioServices(UINT16 uStreamNumber,
					   HXAudioData* pAuidoData,
					   UINT32 ulActualTimestamp);

    HX_RESULT GetQualityPreference(UINT16 &usQuality);

    virtual void CalculateMaxTimeStamp(UINT16 uStreamNumber,
				       HXAudioData* pAudioData,
				       UINT32 ulActualTimeStamp,
				       UINT32* pulDataDuration = NULL,
				       double *pfDataDuration = NULL);

    virtual void DoSyncRegister(UINT16 ulStreamNumber);
    virtual void QueueUnregisterSync(UINT16 ulStream, UINT32 ulTime);
    virtual void UnregisterTimeSyncs(UINT32 ulCurrentTime);
    virtual void FlushUnregisterQueue(BOOL bDestroy = FALSE);

    void ScheduleDryCallback(UINT32 ulAudioTimeWanted);

    inline  BOOL IsStreamActive(UINT16 usStreamNumber)
	{return m_pRaFormats[usStreamNumber]->IsActive();}

    inline void LogAudioWrite(UINT16 uStreamNumber,
			      HXAudioData* pAudioData,
			      UINT32 ulActualTimestamp,
			      HX_RESULT retVal);

    void      CheckForSetSourceProperties(BOOL bForceRefresh = FALSE);
    HX_RESULT GetSourcePropertyULONG32(const char* pszProp, REF(ULONG32) rulVal);
    HX_RESULT GetSourcePropertyCString(const char* pszProp, REF(IHXBuffer*) rpBuffer);

    void WriteCodecsToRegistry(const char* pAllCodecs);
    void AddCodec(IHXValues*, char*, UINT32, UINT32, int);
    void RemoveCurrentDryNotification();
    HX_RESULT _OnPacket(IHXPacket* pPacket, INT32 lTimeOffset);

    inline ULONG32 _AddRef(void);
    inline ULONG32 _Release(void);


public:

    static void AdvanceLatestTime(UINT32 uBaseStreamTime,
				  UINT32 ulBaseActualTime,
				  UINT32 ulDurationAdvance,
				  double fDurationAdvance,
				  UINT32 &ulLatestStreamTime,
				  double &fLatestStreamTime,
				  UINT32 &ulLatestActualTime);

    STDMETHOD(AttemptToSatisfyDryRequest)(THIS_ UINT32 ulAudioTimeWanted);

    CRealAudioRenderer();
    virtual ~CRealAudioRenderer();


    // *** IHXPlugin methods ***

    /************************************************************************
     *	Method:
     *	    IHXPlugin::GetPluginInfo
     *	Purpose:
     *	    Returns the basic information about this plugin. Including:
     *
     *	    bLoadMultiple	whether or not this plugin DLL can be loaded
     *				multiple times. All File Formats must set
     *				this value to TRUE.
     *	    pDescription	which is used in about UIs (can be NULL)
     *	    pCopyright		which is used in about UIs (can be NULL)
     *	    pMoreInfoURL	which is used in about UIs (can be NULL)
     */
    STDMETHOD(GetPluginInfo)	(THIS_
				REF(BOOL)        /*OUT*/ bLoadMultiple,
				REF(const char*) /*OUT*/ pDescription,
				REF(const char*) /*OUT*/ pCopyright,
				REF(const char*) /*OUT*/ pMoreInfoURL,
				REF(ULONG32)	 /*OUT*/ ulVersionNumber
				);

    /************************************************************************
     *	Method:
     *	    IHXPlugin::InitPlugin
     *	Purpose:
     *	    Initializes the plugin for use. This interface must always be
     *	    called before any other method is called. This is primarily needed
     *	    so that the plugin can have access to the context for creation of
     *	    IHXBuffers and IMalloc.
     */
    STDMETHOD(InitPlugin)   (THIS_
			    IUnknown*   /*IN*/  pContext);

    // *** IUnknown methods ***
    STDMETHOD(QueryInterface)	(THIS_
				REFIID riid,
				void** ppvObj);

    STDMETHOD_(ULONG32,AddRef)	(THIS);

    STDMETHOD_(ULONG32,Release)	(THIS);

    // *** IHXRenderer methods ***

    /************************************************************************
     *	Method:
     *	    IHXRenderer::GetRendererInfo
     *	Purpose:
     *	    Returns information vital to the instantiation of rendering
     *	    plugins.
     */
    STDMETHOD(GetRendererInfo)	    (THIS_
				    REF(const char**) /*OUT*/ pStreamMimeTypes,
				    REF(UINT32)      /*OUT*/ unInitialGranularity
				    );

    /////////////////////////////////////////////////////////////////////////
    //	Method:
    //	    IHXRenderer::StartStream
    //	Purpose:
    //	    Called by client engine to inform the renderer of the stream it
    //	    will be rendering. The stream interface can provide access to
    //	    its source or player. This method also provides access to the
    //	    primary client controller interface.