hxaudses.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:22k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #ifndef _HXAUDSES_H
  36. #define _HXAUDSES_H
  37. #include "hxaudtyp.h" 
  38. #ifdef _UNIX
  39. #include <fcntl.h>
  40. #include <sys/stat.h>
  41. #endif
  42. // foward decls.
  43. struct IHXCallback;
  44. struct IHXScheduler;
  45. struct IHXPreferences;
  46. struct IHXAudioDeviceResponse;
  47. struct IHXAudioPlayerResponse;
  48. struct IHXAudioAdviseSink;
  49. struct IHXAudioDeviceManager;
  50. struct IHXAudioHook;
  51. struct IHXInterruptState;
  52. typedef struct _HXAudioFormat HXAudioFormat;
  53. class CHXAudioPlayer;
  54. class CHXAudioDevice;
  55. class CHXAudioStream;
  56. class CHXSimpleList;
  57. class HXVolumeAdviseSink;
  58. struct IHXBuffer;
  59. class Timeval;
  60. class HXThread;
  61. class HXMutex;
  62. class HXEvent;
  63. #ifdef HELIX_CONFIG_MIN_PCM_PUSHDOWN_BYTES
  64. #define MINIMUM_INITIAL_PUSHDOWN    100
  65. #else
  66. #define MINIMUM_INITIAL_PUSHDOWN    4000
  67. #endif
  68. typedef enum
  69. {
  70.     BUFFER_NONE     = 0,
  71.     BUFFER_PLAYER   = 1,
  72.     BUFFER_SESSION  = 2
  73. } BufType;
  74. class   CHXAudioSession : public IHXAudioDeviceResponse, 
  75.                           public IHXAudioDeviceManager,
  76.                           public IHXAudioHookManager,
  77.                           public IHXAudioDeviceManager2,
  78. #ifdef HELIX_FEATURE_VOLUME                          
  79.                           public IHXVolumeAdviseSink,
  80. #endif                          
  81.                           public IHXCallback,
  82.                           public IHXAudioResamplerManager,
  83.                           public IHXAudioPushdown2
  84. {
  85.   public:
  86.     /*
  87.      *      IUnknown methods
  88.      */
  89.     STDMETHOD(QueryInterface)   (THIS_
  90.                                  REFIID riid,
  91.                                  void** ppvObj);
  92.     STDMETHOD_(ULONG32,AddRef)  (THIS);
  93.     STDMETHOD_(ULONG32,Release) (THIS);
  94.     CHXAudioSession(void);
  95. #ifdef HELIX_FEATURE_VOLUME                          
  96.     //IHXVolumeAdviseSink methods
  97.     inline STDMETHOD(OnVolumeChange) (THIS_ const UINT16 uVolume )
  98.     {
  99.         SetVolume(uVolume);
  100.         return HXR_OK;
  101.     }
  102.     inline STDMETHOD(OnMuteChange)(THIS_ const BOOL bMute )
  103.     {
  104.         SetMute(bMute);
  105.         return HXR_OK;
  106.     }
  107. #endif
  108.     
  109.     /*
  110.      *      IHXAudioDeviceManager methods
  111.      */
  112.     /************************************************************************
  113.      *  Method:
  114.      *      IHXAudioDeviceManager::Replace
  115.      *  Purpose:
  116.      *  This is used to replace the default implementation of the audio
  117.      *  device by the given audio device interface. 
  118.      */
  119.     STDMETHOD(Replace) (THIS_
  120.                         IHXAudioDevice*    /*IN*/ pAudioDevice);
  121.     /************************************************************************
  122.      *  Method:
  123.      *      IHXAudioDeviceManager::Remove
  124.      *  Purpose:
  125.      *  This is used to remove the audio device given to the manager in
  126.      *  the earlier call to Replace.
  127.      */
  128.     STDMETHOD(Remove) (THIS_
  129.                        IHXAudioDevice*    /*IN*/ pAudioDevice);
  130.     /************************************************************************
  131.      *  Method:
  132.      *   IHXAudioDeviceManager::AddFinalHook
  133.      *  Purpose:
  134.      *       One last chance to modify data being written to the audio device.
  135.      *       This hook allows the user to change the audio format that
  136.      *   is to be written to the audio device. This can be done in call
  137.      *   to OnInit() in IHXAudioHook.
  138.      */
  139.     STDMETHOD(SetFinalHook) (THIS_
  140.                              IHXAudioHook*      /*IN*/ pHook
  141.                              );
  142.     /************************************************************************
  143.      *  Method:
  144.      *   IHXAudioDeviceManager::RemoveFinalHook
  145.      *  Purpose:
  146.      *       Remove final hook
  147.      */
  148.     STDMETHOD(RemoveFinalHook)  (THIS_
  149.                                  IHXAudioHook*    /*IN*/ pHook
  150.                                  );
  151.     /************************************************************************
  152.      *  Method:
  153.      *      IHXAudioDeviceManager::GetAudioFormat
  154.      *  Purpose:
  155.      *           Returns the audio format in which the audio device is opened.
  156.      *           This function will fill in the pre-allocated HXAudioFormat 
  157.      *           structure passed in.
  158.      */
  159.     STDMETHOD(GetAudioFormat)   (THIS_
  160.                                  HXAudioFormat*      /*IN/OUT*/pAudioFormat);
  161.     /*
  162.      *      IHXAudioDeviceResponse methods
  163.      */
  164.     /************************************************************************
  165.      *  Method:
  166.      *      IHXAudioDeviceResponse::OnTimeSync
  167.      *  Purpose:
  168.      *      Notification interface provided by users of the IHXAudioDevice
  169.      *      interface. This method is called by the IHXAudioDevice when
  170.      *      audio playback occurs.
  171.      */
  172.     STDMETHOD(OnTimeSync) (THIS_
  173.                            ULONG32                         /*IN*/ ulTimeEnd);
  174.     /*
  175.      *  IHXAudioHookManager methods
  176.      */
  177.     /************************************************************************
  178.      *  Method:
  179.      *      IHXAudioHookManager::AddHook
  180.      *  Purpose:
  181.      *           Use this to add a hook 
  182.      */
  183.     STDMETHOD(AddHook)   (THIS_
  184.                           IHXAudioHook* /*IN*/ pHook);
  185.     /************************************************************************
  186.      *  Method:
  187.      *      IHXAudioHookManager::RemoveHook
  188.      *  Purpose:
  189.      *           Use this to remove a hook 
  190.      */
  191.     STDMETHOD(RemoveHook) (THIS_
  192.                            IHXAudioHook* /*IN*/ pHook);
  193.     /*
  194.      *  IHXAudioDeviceManager2 methods
  195.      */
  196.     /**********************************************************************
  197.      *  Method:
  198.      *      IHXAudioDeviceManager2::IsReplacedDevice
  199.      *  Purpose:
  200.      *  This is used to determine if the audio device has been replaced.
  201.      */
  202.     STDMETHOD_(BOOL, IsReplacedDevice) (THIS);
  203.     /*
  204.      *  IHXAudioResamplerManager methods
  205.      *
  206.      */
  207.     STDMETHOD(CreateResampler) (THIS_
  208.                                 HXAudioFormat               inAudioFormat,
  209.                                 REF(HXAudioFormat)          outAudioFormat,
  210.                                 REF(IHXAudioResampler*)    pResampler);
  211.     /*
  212.      *  IHXAudioPushdown methods
  213.      */
  214.     /************************************************************************
  215.      *  Method:
  216.      *      IHXAudioPushdown::SetAudioPushdown
  217.      *  Purpose:
  218.      *           Use this to set the minimum audio pushdown value in ms.
  219.      *           This is the amount of audio data that is being written 
  220.      *           to the audio device before starting playback.
  221.      */
  222.     STDMETHOD(SetAudioPushdown) (THIS_
  223.                                  UINT32 /*IN*/ ulMinimumPushdown);
  224.     /************************************************************************
  225.      *  Method:
  226.      *      IHXAudioPushdown2::GetAudioPushdown
  227.      *  Purpose:
  228.      *           Use this to get the minimum audio pushdown value in ms.
  229.      *           This is the amount of audio data that is being written 
  230.      *           to the audio device before starting playback.
  231.      */
  232.     STDMETHOD(GetAudioPushdown) (THIS_
  233.                                  REF(UINT32) /*OUT*/ ulAudioPushdown);
  234.     /************************************************************************
  235.      *  Method:
  236.      *      IHXAudioPushdown2::GetCurrentAudioDevicePushdown
  237.      *  Purpose:
  238.      *           Use this to get the audio pushed down to the audio device and haven't
  239.      *           been played yet
  240.      */
  241.     STDMETHOD(GetCurrentAudioDevicePushdown)   (THIS_
  242.                                                 REF(UINT32) /*OUT*/ ulAudioPusheddown);
  243.     /* It gets Scheduler interface from the context.
  244.      * The session object keeps a list of audio player objects.
  245.      * Create a session list; add this session to the list.
  246.      */
  247.     HX_RESULT Init(IUnknown* pContext);
  248.     /* Setup is called by Audio Player object.
  249.      */
  250.     HX_RESULT Setup (BOOL bHasStreams);
  251.     /* Create audio player. The RMA session object calls this
  252.      * for each Player it knows about.
  253.      */
  254.     virtual HX_RESULT CreateAudioPlayer(CHXAudioPlayer**  ppAudioPlayer);
  255.     HX_RESULT         _CreateAudioPlayer(CHXAudioPlayer** ppAudioPlayer);
  256.     HX_RESULT       CloseAudioPlayer( CHXAudioPlayer*   pAudioPlayer);
  257.     void            Close(void);
  258.     /* The session object determines the audio device format based
  259.      * on all of its players.
  260.      */
  261.     HX_RESULT       GetDeviceFormat(void);
  262.     /* Open is called to open the audio device.
  263.      */
  264.     HX_RESULT       OpenAudio    (void);
  265.     HX_RESULT       OpenDevice   (void);
  266.         
  267.     /* PlayAudio is called by Audio Player object.
  268.      */
  269.     HX_RESULT       PlayAudio    (UINT16 uNumBlocks = 1);
  270.     /* Pause is called by Audio Player object.
  271.      */
  272.     HX_RESULT       Pause (CHXAudioPlayer* p);
  273.     /* Resume is called by Audio Player object.
  274.      */
  275.     HX_RESULT       Resume (CHXAudioPlayer* pPlayer = NULL);
  276.     /* Stop is called by Audio Player object.
  277.      */
  278.     HX_RESULT       Stop  (CHXAudioPlayer* p, BOOL bFlush);
  279.     /* Seek is called by Audio Player object.
  280.      */
  281.     HX_RESULT       Seek    (
  282.         CHXAudioPlayer* pPlayerToExclude, 
  283.         const UINT32    ulSeekTime
  284.         );
  285.     /* Return the device volume interface */
  286.     inline IHXVolume* GetDeviceVolume()
  287.     {
  288. #if defined(HELIX_FEATURE_VOLUME)
  289.         if( m_pDeviceVolume )
  290.             m_pDeviceVolume->AddRef();
  291.         return m_pDeviceVolume;
  292. #else
  293.         return NULL;
  294. #endif /* HELIX_FEATURE_VOLUME */
  295.     }
  296.     /* The player object sets the granularity; I think the RMA session
  297.      * object should do this after it resolves the granularity amongst
  298.      * all of its players.
  299.      */
  300.     /* Granularity is always 100ms now...
  301.      * The core keeps track of the granularity requirements for each 
  302.      * renderer and queries audio sesssion. 
  303.      */
  304.     ULONG32         SetGranularity(ULONG32 ulGranularity);
  305.     /* Reset audio session; flush buffers, etc.
  306.      */
  307.     virtual void        ResetSession(void);
  308.     virtual HX_RESULT   ProcessAudioHook(PROCESS_ACTION action, 
  309.                                          IHXAudioHook* pAudioHook);
  310.     virtual HX_RESULT   ProcessAudioDevice(PROCESS_ACTION action, 
  311.                                            IHXAudioDevice* pAudioDevice);
  312.     virtual HX_RESULT   CreateAudioDevice();
  313.     void                ReleaseAudioDevice();
  314.     void                RestoreReplacedDevice();
  315.     ULONG32         GetCurrentPlayBackTime(void);
  316.     /* Get format that audio device was opened with. */
  317.     void GetFormat( HXAudioFormat*       pAudioFmt );
  318.     /* Return the core scheduler interface.
  319.      */
  320.     inline void GetScheduler(IHXScheduler** pScheduler)
  321.     {
  322.         *pScheduler = m_pScheduler;
  323.     };
  324.     void SetVolume(const UINT16 uVolume );
  325.     UINT16 GetVolume();
  326.     void SetMute(const BOOL bMute);
  327.     inline BOOL GetMute()
  328.     {
  329.         return m_bMute;
  330.     }
  331.     
  332.     /* Return the current time in timeline. */
  333.     //ULONG32       GetCurrentPlaybackTime(void);
  334.     /* Returns true if any audio player is playing... */
  335.     BOOL            IsPlaying(void);
  336.     /* Returns number of active players (which are not is a STOP state).*/
  337.     UINT16          NumberOfActivePlayers(void);
  338.     UINT16          NumberOfResumedPlayers(void);
  339.     inline void     ToBeRewound() {m_bToBeRewound = TRUE;};
  340.     BOOL            CheckDisableWrite(void);
  341.     ULONG32         GetInitialPushdown(BOOL bAtStart = FALSE);
  342.     HX_RESULT       CheckToPlayMoreAudio();
  343.     HX_RESULT       TryOpenAudio    (void); // attempt to open audio
  344.         
  345.     void            StopAllOtherPlayers();
  346.     inline HX_RESULT     CheckForBufferReuse();
  347.     void            ConvertTo8BitAndOrMono(HXAudioData* pAudioData);
  348.     
  349.     double          ConvertMsToBytes(UINT32 ulCurrentTime);
  350.     inline double          NumberOfBytesWritten() {return m_dNumBytesWritten;};
  351.     inline double          GetNumBytesPlayed() {return m_dNumBytesPlayed;};
  352.     void            SetCoreMutex(HXMutex* pMutex) {m_pCoreMutex = pMutex;};
  353.     void            CheckIfLastNMilliSecsToBeStored();
  354.     void            RewindSession(CHXAudioPlayer* pPlayerToExclude = NULL);
  355.     void            RewindAllPlayers(UINT32 ulCurTime,
  356.                                      UINT32 ulTimeToRewind,
  357.                                      CHXAudioPlayer* pPlayerToExclude);
  358.     HX_RESULT       ActualResume();
  359.     inline UINT32   GetLastRewindTimestamp(void) {return m_ulLastRewindTimestamp;};
  360.     BOOL            ReallyNeedData();
  361.     inline void     UseCoreThread() {m_bShouldOpenOnCoreThread = TRUE;};
  362.     inline void     PostMixHooksUpdated(void) { m_bPostMixHooksUpdated = TRUE; };
  363.     BOOL GetDisableMultiPlayPauseSupport();
  364.     //IHXCallback stuff
  365.     STDMETHOD(Func) (THIS);
  366.     IUnknown*                       m_pContext;
  367.     class HXDeviceSetupCallback :
  368.         public IHXCallback,
  369.         public IHXInterruptSafe
  370.     {
  371.     private:
  372.         ~HXDeviceSetupCallback();
  373.         PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
  374.         
  375.         CHXAudioSession* m_pAudioSessionObject;
  376.         ULONG32          m_ulCallbackID;
  377.         LONG32           m_lRefCount;
  378.     public:
  379.         HXDeviceSetupCallback(CHXAudioSession* it);
  380.         STDMETHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj);
  381.         STDMETHOD_(ULONG32,AddRef) (THIS);
  382.         STDMETHOD_(ULONG32,Release) (THIS);
  383.         STDMETHOD(Func) (THIS);
  384.         STDMETHOD_(BOOL,IsInterruptSafe) (THIS);
  385.         void PendingID(ULONG32 it )
  386.             { m_ulCallbackID = it;}
  387.         ULONG32 PendingID()
  388.             { return m_ulCallbackID; }
  389.         
  390.     };
  391.     friend class CHXAudioSession::HXDeviceSetupCallback;
  392.   protected:
  393.     ~CHXAudioSession(void);
  394.     PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
  395.     void _ConstructIfNeeded();
  396.     
  397.         private:
  398. #ifdef _MACINTOSH
  399.     static  BOOL                                    zm_Locked;
  400. #endif
  401.     LONG32                          m_lRefCount;
  402.     IHXScheduler*                   m_pScheduler;
  403.     IHXPreferences*         m_pPreferences;
  404.     IHXInterruptState*              m_pInterruptState;
  405.     HXAudioFormat                  m_BeforeHookDeviceFmt;       // Actual Audio device format.
  406.     HXAudioFormat                  m_ActualDeviceFmt;       // Actual Audio device format.
  407.     HXAudioFormat                  m_DeviceFmt;            // Audio device format used for all calculations.
  408.     IHXBuffer*                      m_pPlayerBuf;
  409.     IHXBuffer*                      m_pSessionBuf;
  410.     ULONG32                         m_ulGranularity;         // Amount of audio to push (ms).
  411.     double                          m_dGranularity;
  412.     ULONG32                         m_ulMinimumPushdown;
  413.     ULONG32                         m_ulIdealMinimumPushdown;
  414.     ULONG32                         m_ulMinBlocksTobeQueued;
  415.     ULONG32                         m_ulMinBlocksTobeQueuedAtStart;
  416.     ULONG32                         m_ulBytesPerGran;       // Number of bytes in gran
  417.     ULONG32                         m_ulBlocksWritten;      // Number of blocks written so far
  418.     ULONG32 m_ulCallbackID;
  419.     BOOL    m_bFakeAudioTimeline;
  420.     
  421.     BOOL                            m_bShouldOpenOnCoreThread;
  422.     BOOL                            m_bToBeReOpened;
  423.     HXDeviceSetupCallback*          m_pDeviceCallback;
  424.     BOOL                            m_bHasStreams;          // True if there are audio streams
  425.     /* We keep a track of the current time when we use Scheduler for 
  426.      * genertaing time syncs.
  427.      */
  428.     ULONG32                         m_ulIncreasingTimer;
  429.     /* This is the actual time we report back to the player->renderers
  430.      * It gets set in the OnTimeSync
  431.      */
  432.     ULONG32                         m_ulCurrentTime;
  433.     ULONG32                         m_ulLastAudioTime;
  434.     ULONG32                         m_ulLastAudioReturnTime;
  435.     ULONG32                         m_ulLastSystemTime;
  436.     BOOL                            m_bAtLeastOneTimeReceived;
  437.     ULONG32                         m_ulStartTime;
  438.     BOOL                            m_bTimeSyncReceived;
  439.     BOOL                            m_bPaused;
  440.     BOOL                            m_bStoppedDuringPause;
  441.     ULONG32                         m_ulLastFakeCallbackTime;
  442.     Timeval*                        m_pFakeAudioCBTime;
  443.     HXAudioData*                    m_pInDataPtr;
  444.     HXAudioData*                    m_pOutDataPtr;
  445.     /*
  446.      * Should be in a data structure with the player objects and stuffed
  447.      * on the list.
  448.      */
  449.     IHXAudioPlayerResponse*         m_pPlayerResponse; // Notification interface
  450.     BOOL                            m_bFirstPlayAudio;
  451.     UINT16                          m_uVolume;              // Default volume
  452.     BOOL                            m_bMute;                // the mute state
  453.     BOOL                            m_bAudioDeviceSupportsVolume;
  454.     /*
  455.      * Continuous session play back time. This is the time written to the audio
  456.      * device object for each buffer. This is the time that each audio player 
  457.      * retrieves as its start time.
  458.      */
  459.     double                          m_dBufEndTime;
  460.     BOOL                            m_bDisableWrite;
  461.     BOOL                            m_bInPlayAudio;
  462.     BOOL                            m_bInActualResume;
  463.     double                          m_dNumBytesWritten;
  464.     double                          m_dNumBytesPlayed;
  465.     /* CheckAudioFormat Interface is called by audio player to 
  466.      * check resample audio format with audio device format.
  467.      */
  468.     HX_RESULT               CheckAudioFormat( 
  469.         HXAudioFormat* pAudioFormat );
  470.     /* Create the playback buffer.
  471.      */
  472.     HX_RESULT               CreatePlaybackBuffer(void);
  473.     void                    OnTimerCallback();
  474.     inline void CheckAudioVolume()
  475.     {}
  476.     
  477.     /* Write audio data to post mix hooks. */
  478.     HX_RESULT               ProcessPostMixHooks(
  479.         CHXAudioPlayer* pPlayer,
  480.         IHXBuffer*&    pInBuffer,
  481.         BOOL*           bDisableWrite,
  482.         UINT32          ulBufTime,
  483.         BOOL&           bChanged);
  484.         
  485.     void                    InitHooks();
  486.     void                    ProcessHooks(HXAudioData* pAudioData);
  487.     /* Convert 16-bit buffer to 8-bit */
  488.     void                    ConvertToEight(void);
  489.     BOOL                    IsAudioOnlyTrue(void);
  490.         
  491.     UINT32                  AnchorDeviceTime(UINT32 ulCurTime);
  492.     void                    AdjustInRealTime();
  493.     HX_RESULT               Rewind();
  494.     void                    UpdateMinimumPushdown();
  495.     void                    ReopenDevice();
  496.     
  497.   protected:
  498.     BOOL                m_bInited;          // is audio setup?
  499.     IHXAudioDevice*    m_pAudioDev; // device layer
  500.     IHXAudioDevice*    m_pCurrentAudioDev;  // keep track of the current device layer
  501.     IHXAudioDevice*    m_pReplacedAudioDev; // keep track of replaced audio device
  502.     BOOL                m_bReplacedDev;     // is audio device replaced?
  503.     CHXSimpleList*      m_pPlayerList;      // list of player audio sessions
  504.     CHXSimpleList*      m_pHookList;        // hook list
  505.     // Any audio buffers that we were not able to write to the audio 
  506.     // device successfully
  507.     CHXSimpleList*      m_pAuxiliaryAudioBuffers;
  508.     HXMutex*            m_pMutex;
  509.     IHXAudioHook*       m_pFinalHook;
  510.     BOOL                m_bUseFinalHook;
  511.     HXMutex*            m_pCoreMutex;
  512.     UINT16              m_uAskFromAudioDevice;
  513.     BOOL                m_bDeferActualResume;
  514.     CHXAudioPlayer*     m_pLastPausedPlayer;
  515.     BOOL                m_bUsingReplacedDevice;
  516.     BOOL                m_bToBeRewound;
  517.     UINT32              m_ulLastRewindTimestamp;
  518.     UINT16              m_uNumToBePushed;
  519.     BOOL                m_bSessionBufferDirty;
  520.     BOOL                m_bPostMixHooksUpdated;
  521.     IHXMultiPlayPauseSupport* m_pMPPSupport;
  522. #ifdef HELIX_FEATURE_VOLUME
  523.     IHXVolume*          m_pDeviceVolume;
  524. #endif    
  525. };
  526. #endif  // _HXAUDSES_H