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

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 _AUDUNIX
  36. #define _AUDUNIX
  37. #include "hxengin.h"
  38. #include "hxcom.h"
  39. #include "hxausvc.h"
  40. #include "auderrs.h"
  41. #include "hxaudev.h"
  42. #include "hxaudply.h"
  43. #if defined(_THREADED_AUDIO) && defined(_UNIX_THREADS_SUPPORTED)
  44. #  include "unix/UnixThreads.h"
  45. #  define LOCK(a)   if( m_bUserWantsThreads) (a)->Lock()
  46. #  define UNLOCK(a) if( m_bUserWantsThreads) (a)->Unlock()
  47. #else
  48. #  define LOCK(a)   
  49. #  define UNLOCK(a)
  50. #endif
  51. #define MAX_DEV_NAME 255
  52. class CAudioOutUNIX : public CHXAudioDevice
  53. {
  54.   public:
  55.     CAudioOutUNIX();
  56.     
  57.     //How big can device names be under UNIX?
  58.     
  59.     //-1 is usually considered to be no file descriptor.
  60.     static const int NO_FILE_DESCRIPTOR;
  61.     static const int MAX_VOLUME;
  62.     
  63.     // Used to indicate the current exported state of the virtual audio device.
  64.     typedef enum audio_state
  65.     {
  66.         RA_AOS_CLOSED,          // Normal non-playing state
  67.         RA_AOS_OPENING,         // Opened, before first audio buffer play b
  68.         RA_AOS_OPEN_PAUSED,     // Opened and paused
  69.         RA_AOS_OPEN_PLAYING,    // Opened and after first audio buffer play begins
  70.         RA_AOS_CLOSING          // We've been told to close after audio fin
  71.     } AUDIOSTATE;
  72.     
  73.     inline BOOL IsOpen() const { return (m_wState==RA_AOS_OPEN_PLAYING || m_wState==RA_AOS_OPEN_PAUSED);}
  74.     
  75.     // Create friend class for scheduled playback callback.
  76.     class HXPlaybackCountCB : public IHXCallback
  77.     {
  78.       private:
  79.         BOOL           m_timed;
  80.         LONG32         m_lRefCount;
  81.         CAudioOutUNIX* m_pAudioDeviceObject;
  82.         
  83.         virtual ~HXPlaybackCountCB();
  84.         PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
  85.       public:
  86.         //Ctors
  87.         HXPlaybackCountCB(CAudioOutUNIX* object, BOOL timed = TRUE) :
  88.             m_timed(timed),
  89.             m_lRefCount(0),
  90.             m_pAudioDeviceObject( object )
  91.         {};
  92.         //IUnkown methods
  93.         STDMETHOD(QueryInterface)   (THIS_ REFIID riid, void** ppvObj);
  94.         STDMETHOD_(ULONG32,AddRef)  (THIS);
  95.         STDMETHOD_(ULONG32,Release) (THIS);
  96.         
  97.         //IHXCallback methods
  98.         STDMETHOD(Func) (THIS);
  99.     };
  100.     friend class CAudioOutUNIX::HXPlaybackCountCB;
  101.     //To get the last return code.
  102.     HX_RESULT GetLastError() const { return m_wLastError; }
  103.     
  104.   protected:
  105.     //--------------------------------------------------
  106.     // NON-DEVICE SPECIFIC METHODS
  107.     //--------------------------------------------------
  108.     virtual ~CAudioOutUNIX();
  109.     
  110.     HX_RESULT _Imp_Open( const HXAudioFormat* pFormat );         //Implemented.
  111.     HX_RESULT _Imp_Close( void );                                 //Implemented.
  112.     HX_RESULT _Imp_Write( const HXAudioData* pAudioOutHdr );     //Implemented.
  113.     HX_RESULT _Imp_Reset( void );                                 //Implemented.
  114.     HX_RESULT _Imp_Drain( void );                                 //Implemented.
  115.     HX_RESULT _Imp_SetVolume( const UINT16 uVolume );             //Implemented.
  116.     HX_RESULT _Imp_GetCurrentTime( ULONG32& ulCurrentTime);       //Implemented.
  117.     BOOL      _Imp_SupportsVolume( void );                        //Implemented.
  118.     UINT16    _Imp_GetVolume( void );                             //Implemented.
  119.     //Not used but defined in CHXAudioDevice as pure virtual.
  120.     UINT16    _NumberOfBlocksRemainingToPlay(void);               //Implemented.
  121.     void      _initAfterContext();                                //Implemented.
  122.     //-------------------------------------------
  123.     // DEVICE SPECIFIC METHODS.
  124.     //-------------------------------------------
  125.     virtual HX_RESULT _Imp_Seek(ULONG32 ulSeekTime); //default provided
  126.     virtual HX_RESULT _Imp_Resume( void );           //default provided
  127.     virtual HX_RESULT _Imp_Pause( void );            //default provided
  128.     virtual HX_RESULT _Imp_CheckFormat( const HXAudioFormat* pFormat); //default provided.
  129.     //Device specific methods to Pause/Resume the device. If a device can't handle
  130.     //the pause/resume in hardware then it must return RA_AOE_NOTSUPPORTED, the
  131.     //default. In this case we use a 'rollback' method.
  132.     virtual HX_RESULT _Pause();                     //default provided.  
  133.     virtual HX_RESULT _Resume();                    //default provided.  
  134.     //Now a couple of routines to help us determine the type
  135.     //of hardware device we are dealing with.
  136.     
  137.     //A method to determine if the audio devices file descriptor,
  138.     //if it has one, should be added to the client core's select loop.
  139.     //The default implementation is 'yes it should be added'.
  140.     virtual BOOL _IsSelectable() const;
  141.     //A mehtod to let us know if the hardware supports puase/resume.
  142.     //We can use this to remove unneeded memcpys and other expensive
  143.     //operations. The default implementation is 'No, not supported'.
  144.     virtual BOOL _HardwarePauseSupported() const;
  145.     //The Imp_Write method just fills up our write list. This method
  146.     //is the one that actually sends the data to the audio device.
  147.     ULONG32 _PushBits();
  148. #if defined(_THREADED_AUDIO) && defined(_UNIX_THREADS_SUPPORTED)
  149.     //-------------------------------------------------------
  150.     // Thread support.
  151.     //-------------------------------------------------------
  152.     static void* AudioThread( void *thisPointer );
  153. #endif    
  154.     
  155.     
  156.     //-------------------------------------------------------
  157.     // These Device Specific methods must be implemented 
  158.     // by the platform specific sub-classes.
  159.     //-------------------------------------------------------
  160.     //What should we do if there are no file descriptors?
  161.     virtual INT16 _Imp_GetAudioFd(void) = 0;
  162.         
  163.     //Device specific method to return number of bytes played.
  164.     //default implementation is to do a low precision calculation
  165.     //to compute an estimate. Device capable of computing this 
  166.     //acturatly will override this method. This should never 
  167.     //return a number greater than m_ulTotalWritten.
  168.     virtual UINT64 _GetBytesActualyPlayed(void) const =0;
  169.     //Device specific method to set the audio device characteristics. Sample rate,
  170.     //bits-per-sample, etc.
  171.     //Method *must* set member vars. m_unSampleRate, m_unNumChannels and
  172.     //m_ulDeviceBufferSize.
  173.     virtual HX_RESULT _SetDeviceConfig( const HXAudioFormat* pFormat ) = 0;
  174.     //Device specific method to test whether or not the device supports the
  175.     //given format. If the device can not be opened, or otherwise tested,
  176.     //it should return RA_AOE_DEVBUSY.
  177.     virtual HX_RESULT _CheckFormat( const HXAudioFormat* pFormat );//default imp just returns OK.
  178.     //deprecated.....
  179.     virtual HX_RESULT _CheckSampleRate( ULONG32 ulSampleRate ) = 0;
  180.     //Device specific method to write bytes out to the audiodevice and return a
  181.     //count of bytes written. 
  182.     virtual HX_RESULT _WriteBytes( UCHAR* buffer, ULONG32 ulBuffLength, LONG32& lCount ) = 0;
  183.     //Device specific methods to open/close the mixer and audio devices.
  184.     virtual HX_RESULT _OpenAudio() = 0;
  185.     virtual HX_RESULT _CloseAudio() = 0;
  186.     virtual HX_RESULT _OpenMixer() = 0;
  187.     virtual HX_RESULT _CloseMixer() = 0;
  188.     //Device specific method to reset device and return it to a state that it 
  189.     //can accept new sample rates, num channels, etc.
  190.     virtual HX_RESULT _Reset() = 0;            
  191.     //Device specific method to get/set the devices current volume.
  192.     virtual UINT16    _GetVolume() const = 0;
  193.     virtual HX_RESULT _SetVolume(UINT16 volume) = 0;
  194.     //Device specific method to drain a device. This should play the remaining
  195.     //bytes in the devices buffer and then return.
  196.     virtual HX_RESULT _Drain() = 0;
  197.     //Device specific method to return the amount of room available on the
  198.     //audio device that can be written without blocking.
  199.     virtual HX_RESULT _GetRoomOnDevice( ULONG32& ulBytes ) const = 0;
  200.     //--------------------------------------------------
  201.     // Other stuff.
  202.     //--------------------------------------------------
  203.     void      DoTimeSyncs(void);
  204.     HX_RESULT ReschedPlaybackCheck(void);
  205.     HXPlaybackCountCB* m_pCallback;
  206.     
  207.     AUDIOSTATE        m_wState;               // This is 
  208.     BOOL              m_bMixerPresent;
  209.     UINT16            m_wBlockSize;
  210.     UINT64            m_ulLastNumBytes;       // Number of bytes played back since last open
  211.     BOOL              m_bFirstWrite;          // First write
  212.     UINT64            m_ulTotalWritten;       // Total bytes written
  213.     Timeval*          m_pPlaybackCountCBTime;
  214.     ULONG32           m_PendingCallbackID;    // Used for fake time sync
  215.     BOOL              m_bCallbackPending;     // Used for fake time sync
  216.     CHXSimpleList*    m_pWriteList;
  217.     UINT32            m_unSampleRate;
  218.     UINT32            m_unNumChannels;
  219.     mutable HX_RESULT m_wLastError;           // The last error d
  220.     //Some member vars to help keep track of data that is currently
  221.     //in the device. We use this do a smart Pause/Resume for those
  222.     //devices that can't do it in hardware.
  223.     //block size is in audUNIX::m_wBlockSize
  224.     //here is the buffer list to keep a copy of the data in the
  225.     //device. We need to keep as many buffers, at m_wBlockSize in
  226.     //size each, to cover the entire data space of the device.
  227.     //CHXAudioDevice passes in chunks of size m_wBlockSize.
  228.     //The device holds fragment_size*num_fragments as reported by
  229.     //the device after it has had a chance to compute the frag size.
  230.     //This occurs AFTER the other qualities like sample size, sample
  231.     //rate have already been set.
  232.     ULONG32 m_ulDeviceBufferSize; 
  233.     UCHAR*  m_pRollbackBuffer;
  234.     
  235. #if defined(_THREADED_AUDIO) && defined(_UNIX_THREADS_SUPPORTED)
  236.     //
  237.     // Audio thread support
  238.     //
  239.     // Mutext to protect the writelist and the play state of this
  240.     // device.
  241.     HXMutex*  m_mtxWriteListPlayStateLock;
  242.     HXMutex*  m_mtxDeviceStateLock;
  243.     HXThread* m_audioThread;
  244.     BOOL       m_bUserWantsThreads;
  245.     ULONG32    m_ulSleepTime;
  246. #endif    
  247.     
  248.   private:
  249.     
  250.     //protect the unintentional copy ctor.
  251.     CAudioOutUNIX( const CAudioOutUNIX& );
  252. };
  253. #endif  //_AudioOutUNIX