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

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