Implements inheritance model for the audio layers

src/audio/Makefile.am

@@ -23,7 +23,7 @@ endif
 SUBDIRS = codecs
 
 libaudio_la_SOURCES =    audiofile.cpp	 tonelist.cpp    \
-audiortp.cpp         dtmf.cpp   tone.cpp  audiolayer.cpp audiolayer-pulse.cpp audiodevice.cpp  dtmfgenerator.cpp   \
+audiortp.cpp         dtmf.cpp   tone.cpp  alsalayer.cpp pulselayer.cpp audiodevice.cpp  dtmfgenerator.cpp   \
 tonegenerator.cpp   codecDescriptor.cpp \
 audioloop.cpp ringbuffer.cpp $(SPEEX_SOURCES_CPP)
 
@@ -31,7 +31,7 @@ AM_CXXFLAGS = -I$(top_srcdir)/include -I$(top_srcdir)/libs $(libccext2_CFLAGS) $
  	      -DCODECS_DIR=\""$(sflcodecdir)"\" $(SPEEX_FLAG) $(GSM_FLAG) $(ILBC_FLAG)	
 
 noinst_HEADERS = audioloop.h    common.h ringbuffer.h    audiofile.h  \
- tonelist.h         audiortp.h   audiolayer.h audiolayer.h audiodevice.h \
+ tonelist.h         audiortp.h   audiolayer.h alsalayer.h  pulselayer.h audiodevice.h \
  dtmfgenerator.h         tonegenerator.h     \
  codecDescriptor.h    dtmf.h tone.h 
 

src/audio/alsalayer.h

+/*
+ *  Copyright (C) 2007 - 2008 Savoir-Faire Linux inc.
+ *  Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *                                                                              
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *                                                                              
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _ALSA_LAYER_H
+#define _ALSA_LAYER_H
+
+#include "audiolayer.h"
+
+class RingBuffer;
+class ManagerImpl;
+
+/** Associate a sound card index to its string description */
+typedef std::pair<int , std::string> HwIDPair;
+
+/**
+ * @file  AlsaLayer.h
+ * @brief Main sound class. Manages the data transfers between the application and the hardware. 
+ */
+
+class AlsaLayer : public AudioLayer {
+  public:
+    /**
+     * Constructor
+     * @param manager An instance of managerimpl
+     */
+    AlsaLayer( ManagerImpl* manager );  
+
+    /**
+     * Destructor
+     */
+    ~AlsaLayer(void);
+
+    /**
+     * Check if no devices are opened, otherwise close them.
+     * Then open the specified devices by calling the private functions open_device
+     * @param indexIn	The number of the card choosen for capture
+     * @param indexOut	The number of the card choosen for playback
+     * @param sampleRate  The sample rate 
+     * @param frameSize	  The frame size
+     * @param stream	  To indicate which kind of stream you want to open
+     *			  SFL_PCM_CAPTURE
+     *			  SFL_PCM_PLAYBACK
+     *			  SFL_PCM_BOTH
+     * @param plugin	  The alsa plugin ( dmix , default , front , surround , ...)
+     */
+    bool openDevice(int indexIn, int indexOut, int sampleRate, int frameSize, int stream, std::string plugin);
+
+    /**
+     * Start the capture stream and prepare the playback stream. 
+     * The playback starts accordingly to its threshold
+     * ALSA Library API
+     */
+    void startStream(void);
+
+    /**
+     * Stop the playback and capture streams. 
+     * Drops the pending frames and put the capture and playback handles to PREPARED state
+     * ALSA Library API
+     */
+    void stopStream(void);
+    
+    /**
+     * Check if the playback is running
+     * @return true if the state of the playback handle equals SND_PCM_STATE_RUNNING
+     *	       false otherwise
+     */
+    bool isPlaybackActive( void );
+
+    /**
+     * Check if the capture is running
+     * @return true if the state of the capture handle equals SND_PCM_STATE_RUNNING
+     *	       false otherwise
+     */
+    bool isCaptureActive( void );
+
+    /**
+     * Check if both capture and playback are running
+     * @return true if capture and playback are running
+     *	       false otherwise
+     */
+    bool isStreamActive(void);
+
+    /**
+     * Check if both capture and playback are stopped
+     * @return true if capture and playback are stopped
+     *	       false otherwise
+     */
+    bool isStreamStopped(void);
+
+    /**
+     * Send samples to the audio device. 
+     * @param buffer The buffer containing the data to be played ( voice and DTMF )
+     * @param toCopy The number of samples, in bytes
+     * @param isTalking	If whether or not the conversation is running
+     * @return int The number of bytes played
+     */
+    int playSamples(void* buffer, int toCopy, bool isTalking);
+
+    /**
+     * Send a chunk of data to the hardware buffer to start the playback
+     * Copy data in the urgent buffer. 
+     * @param buffer The buffer containing the data to be played ( ringtones )
+     * @param toCopy The size of the buffer
+     * @return int  The number of bytes copied in the urgent buffer
+     */
+    int putUrgent(void* buffer, int toCopy);
+
+    /**
+     * Query the capture device for number of bytes available in the hardware ring buffer
+     * @return int The number of bytes available
+     */
+    int canGetMic();
+
+    /**
+     * Get data from the capture device
+     * @param buffer The buffer for data
+     * @param toCopy The number of bytes to get
+     * @return int The number of bytes acquired ( 0 if an error occured)
+     */
+    int getMic(void * buffer, int toCopy);
+    
+    /**
+     * Concatenate two strings. Used to build a valid pcm device name. 
+     * @param plugin the alsa PCM name
+     * @param card the sound card number
+     * @param subdevice the subdevice number
+     * @return std::string the concatenated string
+     */
+    std::string buildDeviceTopo( std::string plugin, int card, int subdevice );
+
+    /**
+     * Scan the sound card available on the system
+     * @param stream To indicate whether we are looking for capture devices or playback devices
+     *		   SFL_PCM_CAPTURE
+     *		   SFL_PCM_PLAYBACK
+     *		   SFL_PCM_BOTH
+     * @return std::vector<std::string> The vector containing the string description of the card
+     */
+    std::vector<std::string> getSoundCardsInfo( int stream );
+
+    /**
+     * Check if the given index corresponds to an existing sound card and supports the specified streaming mode
+     * @param card   An index
+     * @param stream  The stream mode
+     *		  SFL_PCM_CAPTURE
+     *		  SFL_PCM_PLAYBACK
+     *		  SFL_PCM_BOTH
+     * @return bool True if it exists and supports the mode
+     *		    false otherwise
+     */
+    bool soundCardIndexExist( int card , int stream );
+    
+    /**
+     * An index is associated with its string description
+     * @param description The string description
+     * @return	int	  Its index
+     */
+    int soundCardGetIndex( std::string description );
+
+    /**
+     * Get the current audio plugin.
+     * @return std::string  The name of the audio plugin
+     */
+    std::string getAudioPlugin( void ) { return _audioPlugin; }
+
+  private:
+
+    /**
+     * Drop the pending frames and close the capture device
+     * ALSA Library API
+     */
+    void closeCaptureStream( void );
+
+    /**
+     * Drop the pending frames and close the playback device
+     * ALSA Library API
+     */
+    void closePlaybackStream( void );
+
+    /**
+     * Fill the alsa internal ring buffer with chunks of data
+     */
+    void fillHWBuffer( void) ;
+
+    /**
+     * Callback used for asynchronous playback.
+     * Called when a certain amount of data is written ot the device
+     * @param pcm_callback  The callback pointer
+     */
+    static void AlsaCallBack( snd_async_handler_t* pcm_callback);
+
+    /**
+     * Callback used for asynchronous playback.
+     * Write tones buffer to the alsa internal ring buffer.
+     */
+    void playTones( void );
+
+    /**
+     * Open the specified device.
+     * ALSA Library API
+     * @param pcm_p The string name for the playback device
+     * @param pcm_c The string name for the capture device
+     * @param flag  To indicate which kind of stream you want to open
+     *		    SFL_PCM_CAPTURE
+     *		    SFL_PCM_PLAYBACK
+     *		    SFL_PCM_BOTH
+     * @return true if successful
+     *	       false otherwise
+     */
+    bool open_device( std::string pcm_p, std::string pcm_c, int flag); 
+
+    /**
+     * Copy a data buffer in the internal ring buffer
+     * ALSA Library API
+     * @param buffer The data to be copied
+     * @param length The size of the buffer
+     * @return int The number of frames actually copied
+     */
+    int write( void* buffer, int length);
+    
+    /**
+     * Read data from the internal ring buffer
+     * ALSA Library API
+     * @param buffer  The buffer to stock the read data
+     * @param toCopy  The number of bytes to get
+     * @return int The number of frames actually read
+     */
+    int read( void* buffer, int toCopy);
+    
+    /**
+     * Recover from XRUN state for capture
+     * ALSA Library API
+     */
+    void handle_xrun_capture( void );
+
+    /**
+     * Recover from XRUN state for playback
+     * ALSA Library API
+     */
+    void handle_xrun_playback( void );
+    
+    /**
+     * Handles to manipulate playback stream
+     * ALSA Library API
+     */
+    snd_pcm_t* _PlaybackHandle;
+
+    /**
+     * Handles to manipulate capture stream
+     * ALSA Library API
+     */
+    snd_pcm_t* _CaptureHandle;
+    
+    /**
+     * Alsa parameter - Size of a period in the hardware ring buffer
+     */
+    snd_pcm_uframes_t _periodSize;
+
+    /**
+     * Handle on asynchronous event
+     */
+    snd_async_handler_t *_AsyncHandler;
+    
+    /**
+     * Volume is controlled by the application. Data buffer are modified here to adjust to the right volume selected by the user on the main interface
+     * @param buffer  The buffer to adjust
+     * @param len The number of bytes
+     * @param stream  The stream mode ( PLAYBACK - CAPTURE )
+     */
+    void * adjustVolume( void * , int , int);
+
+    /**
+     * name of the alsa audio plugin used
+     */
+    std::string _audioPlugin;
+
+    /**
+     * Input channel (mic) should be 1 mono
+     */
+    unsigned int _inChannel; 
+
+    /**
+     * Output channel (stereo) should be 1 mono
+     */
+    unsigned int _outChannel; 
+
+    /**
+     * Default volume for incoming RTP and Urgent sounds.
+     */
+    unsigned short _defaultVolume; // 100
+
+
+    /** Vector to manage all soundcard index - description association of the system */
+    std::vector<HwIDPair> IDSoundCards;
+
+};
+
+#endif // _ALSA_LAYER_H_

src/audio/audiolayer.h

@@ -23,22 +23,22 @@
 #define _AUDIO_LAYER_H
 
 #include "../global.h"
+#include "../manager.h"
 #include "audiodevice.h"
 #include "ringbuffer.h"
 
 #include <cc++/thread.h> // for ost::Mutex
 #include <vector>
+
 #include <alsa/asoundlib.h>
+#include <pulse/pulseaudio.h>
+
 #include <iostream>
 #include <istream>
 #include <sstream>
-#define FRAME_PER_BUFFER	160
 
-class RingBuffer;
-class ManagerImpl;
+#define FRAME_PER_BUFFER	160
 
-/** Associate a sound card index to its string description */
-typedef std::pair<int , std::string> HwIDPair;
 
 /**
  * @file  audiolayer.h
@@ -51,12 +51,21 @@ class AudioLayer {
      * Constructor
      * @param manager An instance of managerimpl
      */
-    AudioLayer(ManagerImpl* manager);
+    AudioLayer( ManagerImpl* manager )
+      :	  _manager(manager)
+	, _urgentBuffer( SIZEBUF )
+    {
+      _inChannel  = 1; // don't put in stereo
+      _outChannel = 1; // don't put in stereo
+
+      deviceClosed = true;
+
+    }
     
     /**
      * Destructor
      */
-    ~AudioLayer(void);
+    ~AudioLayer(void){}
 
     /**
      * Check if no devices are opened, otherwise close them.
@@ -71,49 +80,35 @@ class AudioLayer {
      *			  SFL_PCM_BOTH
      * @param plugin	  The alsa plugin ( dmix , default , front , surround , ...)
      */
-    bool openDevice(int indexIn, int indexOut, int sampleRate, int frameSize, int stream, std::string plugin);
+    virtual bool openDevice(int indexIn, int indexOut, int sampleRate, int frameSize, int stream, std::string plugin) = 0;
 
     /**
      * Start the capture stream and prepare the playback stream. 
      * The playback starts accordingly to its threshold
      * ALSA Library API
      */
-    void startStream(void);
+    virtual void startStream(void) = 0;
 
     /**
      * Stop the playback and capture streams. 
      * Drops the pending frames and put the capture and playback handles to PREPARED state
      * ALSA Library API
      */
-    void stopStream(void);
-    
-    /**
-     * Check if the playback is running
-     * @return true if the state of the playback handle equals SND_PCM_STATE_RUNNING
-     *	       false otherwise
-     */
-    bool isPlaybackActive( void );
-
-    /**
-     * Check if the capture is running
-     * @return true if the state of the capture handle equals SND_PCM_STATE_RUNNING
-     *	       false otherwise
-     */
-    bool isCaptureActive( void );
+    virtual void stopStream(void) = 0;
     
     /**
      * Check if both capture and playback are running
      * @return true if capture and playback are running
      *	       false otherwise
      */
-    bool isStreamActive(void);
+    virtual bool isStreamActive(void) = 0;
 
     /**
-     * Check if both capture and playback are stopped
-     * @return true if capture and playback are stopped
+     * Check if the capture is running
+     * @return true if the state of the capture handle equals SND_PCM_STATE_RUNNING
      *	       false otherwise
      */
-    bool isStreamStopped(void);
+    virtual bool isCaptureActive( void ) = 0;
 
     /**
      * Send samples to the audio device. 
@@ -122,7 +117,7 @@ class AudioLayer {
      * @param isTalking	If whether or not the conversation is running
      * @return int The number of bytes played
      */
-    int playSamples(void* buffer, int toCopy, bool isTalking);
+    virtual int playSamples(void* buffer, int toCopy, bool isTalking) = 0;
 
     /**
      * Send a chunk of data to the hardware buffer to start the playback
@@ -131,13 +126,13 @@ class AudioLayer {
      * @param toCopy The size of the buffer
      * @return int  The number of bytes copied in the urgent buffer
      */
-    int putUrgent(void* buffer, int toCopy);
+    virtual int putUrgent(void* buffer, int toCopy) = 0; 
 
     /**
      * Query the capture device for number of bytes available in the hardware ring buffer
      * @return int The number of bytes available
      */
-    int canGetMic();
+    virtual int canGetMic() = 0;
 
     /**
      * Get data from the capture device
@@ -145,16 +140,7 @@ class AudioLayer {
      * @param toCopy The number of bytes to get
      * @return int The number of bytes acquired ( 0 if an error occured)
      */
-    int getMic(void * buffer, int toCopy);
-    
-    /**
-     * Concatenate two strings. Used to build a valid pcm device name. 
-     * @param plugin the alsa PCM name
-     * @param card the sound card number
-     * @param subdevice the subdevice number
-     * @return std::string the concatenated string
-     */
-    std::string buildDeviceTopo( std::string plugin, int card, int subdevice );
+    virtual int getMic(void * buffer, int toCopy) = 0;
     
     /**
      * Scan the sound card available on the system
@@ -164,7 +150,7 @@ class AudioLayer {
      *		   SFL_PCM_BOTH
      * @return std::vector<std::string> The vector containing the string description of the card
      */
-    std::vector<std::string> getSoundCardsInfo( int stream );
+    virtual std::vector<std::string> getSoundCardsInfo( int stream ) = 0;
 
     /**
      * Check if the given index corresponds to an existing sound card and supports the specified streaming mode
@@ -176,14 +162,20 @@ class AudioLayer {
      * @return bool True if it exists and supports the mode
      *		    false otherwise
      */
-    bool soundCardIndexExist( int card , int stream );
+    virtual bool soundCardIndexExist( int card , int stream ) = 0;
     
     /**
      * An index is associated with its string description
      * @param description The string description
      * @return	int	  Its index
      */
-    int soundCardGetIndex( std::string description );
+    virtual int soundCardGetIndex( std::string description ) = 0;
+
+    /**
+     * Get the current audio plugin.
+     * @return std::string  The name of the audio plugin
+     */
+    virtual std::string getAudioPlugin( void ) = 0; 
 
     /**
      * Write accessor to the error state
@@ -227,11 +219,6 @@ class AudioLayer {
      */
     unsigned int getFrameSize() { return _frameSize; }
 
-    /**
-     * Get the current audio plugin.
-     * @return std::string  The name of the audio plugin
-     */
-    std::string getAudioPlugin( void ) { return _audioPlugin; }
     /**
      * Get the current state. Conversation or not
      * @return bool true if playSamples has been called  
@@ -239,125 +226,26 @@ class AudioLayer {
      */
     bool getCurrentState( void ) { return _talk; }
 
-    /**
-     * Toggle echo testing on/off
-     */
-    void toggleEchoTesting();
-
-  private:
+  protected:
 
     /**
      * Drop the pending frames and close the capture device
-     * ALSA Library API
      */
-    void closeCaptureStream( void );
+    virtual void closeCaptureStream( void ) = 0;
 
     /**
      * Drop the pending frames and close the playback device
-     * ALSA Library API
-     */
-    void closePlaybackStream( void );
-
-    /**
-     * Fill the alsa internal ring buffer with chunks of data
-     */
-    void fillHWBuffer( void) ;
-
-    /**
-     * Callback used for asynchronous playback.
-     * Called when a certain amount of data is written ot the device
-     * @param pcm_callback  The callback pointer
-     */
-    static void AlsaCallBack( snd_async_handler_t* pcm_callback);
-
-    /**
-     * Callback used for asynchronous playback.
-     * Write tones buffer to the alsa internal ring buffer.
-     */
-    void playTones( void );
-
-    /**
-     * Open the specified device.
-     * ALSA Library API
-     * @param pcm_p The string name for the playback device
-     * @param pcm_c The string name for the capture device
-     * @param flag  To indicate which kind of stream you want to open
-     *		    SFL_PCM_CAPTURE
-     *		    SFL_PCM_PLAYBACK
-     *		    SFL_PCM_BOTH
-     * @return true if successful
-     *	       false otherwise
-     */
-    bool open_device( std::string pcm_p, std::string pcm_c, int flag); 
-
-    /**
-     * Copy a data buffer in the internal ring buffer
-     * ALSA Library API
-     * @param buffer The data to be copied
-     * @param length The size of the buffer
-     * @return int The number of frames actually copied
-     */
-    int write( void* buffer, int length);
-    
-    /**
-     * Read data from the internal ring buffer
-     * ALSA Library API
-     * @param buffer  The buffer to stock the read data
-     * @param toCopy  The number of bytes to get
-     * @return int The number of frames actually read
-     */
-    int read( void* buffer, int toCopy);
-    
-    /**
-     * Recover from XRUN state for capture
-     * ALSA Library API
-     */
-    void handle_xrun_capture( void );
-
-    /**
-     * Recover from XRUN state for playback
-     * ALSA Library API
      */
-    void handle_xrun_playback( void );
+    virtual void closePlaybackStream( void ) = 0;
 
     /** Augment coupling, reduce indirect access */
     ManagerImpl* _manager; 
 
-    /**
-     * Handles to manipulate playback stream
-     * ALSA Library API
-     */
-    snd_pcm_t* _PlaybackHandle;
-
-    /**
-     * Handles to manipulate capture stream
-     * ALSA Library API
-     */
-    snd_pcm_t* _CaptureHandle;
-    
-    /**
-     * Alsa parameter - Size of a period in the hardware ring buffer
-     */
-    snd_pcm_uframes_t _periodSize;
-
-    /**
-     * Handle on asynchronous event
-     */
-    snd_async_handler_t *_AsyncHandler;
-    
     /**
      * Urgent ring buffer used for ringtones
      */
     RingBuffer _urgentBuffer;
 
-    /**
-     * Volume is controlled by the application. Data buffer are modified here to adjust to the right volume selected by the user on the main interface
-     * @param buffer  The buffer to adjust
-     * @param len The number of bytes
-     * @param stream  The stream mode ( PLAYBACK - CAPTURE )
-     */
-    void * adjustVolume( void * , int , int);
-
     /**
      * Determine if both endpoints hang up.
      *	true if conversation is running
@@ -394,11 +282,6 @@ class AudioLayer {
      */	 		
     unsigned int _frameSize;
 
-    /**
-     * name of the alsa audio plugin used
-     */
-    std::string _audioPlugin;
-
     /**
      * Input channel (mic) should be 1 mono
      */
@@ -409,19 +292,6 @@ class AudioLayer {
      */
     unsigned int _outChannel; 
 
-    /**
-     * Default volume for incoming RTP and Urgent sounds.
-     */
-    unsigned short _defaultVolume; // 100
-
-    /**
-     * Echo testing or not
-     */
-    bool _echoTesting;
-
-    /** Vector to manage all soundcard index - description association of the system */
-    std::vector<HwIDPair> IDSoundCards;
-
    /** Contains the current error code */
     int _errorMessage;
 

src/audio/audiolayer-pulse.cpp → src/audio/pulselayer.cpp

 /*
- *  Copyright (C) 2005 Savoir-Faire Linux inc.
- *  Author: Yan Morin <yan.morin@savoirfairelinux.com>
- *  Author: Jerome Oufella <jerome.oufella@savoirfairelinux.com> 
+ *  Copyright (C) 2008 Savoir-Faire Linux inc.
  *  Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
  *
  *  This program is free software; you can redistribute it and/or modify
@@ -19,14 +17,8 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <stdio.h>
-#include <stdlib.h>
 
-#include <pulse/pulseaudio.h>
-
-#include "audiolayer-pulse.h"
-#include "../global.h"
-#include "../manager.h"
+#include "pulselayer.h"
 
 static pa_context *context = NULL;
 static pa_mainloop_api *mainloop_api = NULL;
@@ -38,20 +30,10 @@ static std::string stream_r = NULL;
 
 
 PulseLayer::PulseLayer(ManagerImpl* manager)
-  : _urgentRingBuffer(SIZEBUF)
-  , _mainSndRingBuffer(SIZEBUF)
-  , _micRingBuffer(SIZEBUF)
-  , _defaultVolume(PA_VOLUME_NORM)
-  , playback(NULL)  
-    , record(NULL)  
-  , _errorMessage("")
-    , _manager(manager)
+  : AudioLayer( manager )    
 {
-  _sampleRate = 8000;
-
-  _inChannel  = 1; // don't put in stereo
-  _outChannel = 1; // don't put in stereo
-  _echoTesting = false;
+  playback = NULL;   
+  record = NULL; 
 }
 
 // Destructor
@@ -63,6 +45,12 @@ PulseLayer::~PulseLayer (void)
   // pa_stream_disconnect();
 }
 
+void 
+PulseLayer::stream_state_callback( pa_stream* s, void* user_data )
+{
+  _debug("The state of the stream changed\n");
+}
+
 
   void
 PulseLayer::openDevice (int indexIn, int indexOut, int sampleRate, int frameSize) 
@@ -74,7 +62,7 @@ PulseLayer::openDevice (int indexIn, int indexOut, int sampleRate, int frameSize
   sample_spec.format = PA_SAMPLE_S16LE; 
   sample_spec.channels = 1; 
   channel_map.channels = 1; 
-
+  pa_stream_flags_t flag = PA_STREAM_START_CORKED ;  
 
   _debug(" Setting PulseLayer: device     in=%2d, out=%2d\n", indexIn, indexOut);
   _debug("                   : nb channel in=%2d, out=%2d\n", _inChannel, _outChannel);
@@ -101,24 +89,19 @@ PulseLayer::openDevice (int indexIn, int indexOut, int sampleRate, int frameSize
       pa_stream_set_state_callback(playback, stream_state_callback, NULL);
       // Transferring Data - Asynchronous Mode
       pa_stream_set_write_callback(playback, audioCallback, NULL);
-      pa_stream_connect_playback( playback, NULL , NULL , 0 , NULL, NULL );
+      pa_stream_connect_playback( playback, NULL , NULL , flag , NULL, NULL );
 
       break;
     case PA_CONTEXT_TERMINATED:
-      quit(0);
+      _debug("Context terminated\n");
       break;
     case PA_CONTEXT_FAILED:
     default:
-      _debug(" Error : %s" , pa_strerror(pa_context_errno(c)));
-      quit(1);
+      _debug(" Error : %s" , pa_strerror(pa_context_errno(context)));
+      exit(1);
   }
 }
 
-PulseLayer::stream_state_callback( void )
-{
-  _debug("The state of the stream changed\n");
-}
-
   int 
 PulseLayer::putMain(void* buffer, int toCopy)
 {
@@ -154,12 +137,9 @@ PulseLayer::isStreamStopped (void)
 {
 }
 
-void
-PulseLayer::toggleEchoTesting() {
-}
 
-  int 
-PulseLayer::audioCallback ()
+  void 
+PulseLayer::audioCallback ( pa_stream* s, size_t bytes, void* user_data )
 { 
   _debug("Audio callback: New data may be written to the stream\n");
   // pa_stream_write

src/audio/audiolayer-pulse.h → src/audio/pulselayer.h

@@ -17,22 +17,15 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#ifndef _AUDIO_LAYER_PULSE_H
-#define _AUDIO_LAYER_PULSE_H
+#ifndef _PULSE_LAYER_H
+#define _PULSE_LAYER_H
 
-#include <cc++/thread.h> // for ost::Mutex
-
-
-#include "../global.h"
-#include "ringbuffer.h"
-#include "audiodevice.h"
-
-#define FRAME_PER_BUFFER	160
+#include "audiolayer.h"
 
 class RingBuffer;
 class ManagerImpl;
 
-class PulseLayer {
+class PulseLayer : public AudioLayer {
   public:
     PulseLayer(ManagerImpl* manager);
     ~PulseLayer(void);
@@ -46,11 +39,16 @@ class PulseLayer {
     void openDevice(int, int, int, int);
     void startStream(void);
     void stopStream(void);
-		void sleep(int);
-		bool hasStream(void);
     bool isStreamActive(void);
     bool isStreamStopped(void);
 
+    /**
+     * Check if the capture is running
+     * @return true if the state of the capture handle equals SND_PCM_STATE_RUNNING
+     *	       false otherwise
+     */
+    bool isCaptureActive( void ) { return true; }
+
     void flushMain();
     int putMain(void* buffer, int toCopy);
     int putUrgent(void* buffer, int toCopy);
@@ -58,76 +56,55 @@ class PulseLayer {
     int getMic(void *, int);
     void flushMic();
 
-		int audioCallback ();
-
-
+    static void audioCallback ( pa_stream* s, size_t bytes, void* user_data );
 
-		void setErrorMessage(const std::string& error) { _errorMessage = error; }
-		std::string getErrorMessage() { return _errorMessage; }
+    static void stream_state_callback( pa_stream* s, void* user_data );	
 
     /**
-		 * Get the sample rate of PulseLayer
-		 * accessor only
+     * Scan the sound card available on the system
+     * @param stream To indicate whether we are looking for capture devices or playback devices
+     *		   SFL_PCM_CAPTURE
+     *		   SFL_PCM_PLAYBACK
+     *		   SFL_PCM_BOTH
+     * @return std::vector<std::string> The vector containing the string description of the card
      */
-		unsigned int getSampleRate() { return _sampleRate; }
-		unsigned int getFrameSize() { return _frameSize; }
+    std::vector<std::string> getSoundCardsInfo( int stream ) { 
+      std::vector<std::string> tmp;
+      return tmp; 
+    }
 
     /**
-		 * Toggle echo testing on/off
+     * Check if the given index corresponds to an existing sound card and supports the specified streaming mode
+     * @param card   An index
+     * @param stream  The stream mode
+     *		  SFL_PCM_CAPTURE
+     *		  SFL_PCM_PLAYBACK
+     *		  SFL_PCM_BOTH
+     * @return bool True if it exists and supports the mode
+     *		    false otherwise
      */
-		void toggleEchoTesting();
-
-	private:
-		void closeStream (void);
-		RingBuffer _urgentRingBuffer;
-		RingBuffer _mainSndRingBuffer;
-		RingBuffer _micRingBuffer;
-		ManagerImpl* _manager; // augment coupling, reduce indirect access
-		// a PulseLayer can't live without manager
-
-		pa_stream* playback;
-		pa_stream* record;
+    bool soundCardIndexExist( int card , int stream ) { return true; }
     
     /**
-		 * Sample Rate SFLphone should send sound data to the sound card 
-		 * The value can be set in the user config file- now: 44100HZ
+     * An index is associated with its string description
+     * @param description The string description
+     * @return	int	  Its index
      */
-		unsigned int _sampleRate;
+    int soundCardGetIndex( std::string description ) { return 0;}
 
     /**
- 		 * Length of the sound frame we capture or read in ms
- 		 * The value can be set in the user config file - now: 20ms
+     * Get the current audio plugin.
+     * @return std::string  The name of the audio plugin
      */
-		unsigned int _frameSize;
+    std::string getAudioPlugin( void ) { return ""; }
 
-		/**
-		 * Input channel (mic) should be 1 mono
-		 */
-		unsigned int _inChannel; // mic
-
-		/**
-		 * Output channel (stereo) should be 1 mono
-		 */
-		unsigned int _outChannel; // speaker
-
-		/**
-		 * Default volume for incoming RTP and Urgent sounds.
-		 */
-		//unsigned short _defaultVolume; // 100
-		pa_volume_t _defaultVolume;
-
-		/**
-		 * Echo testing or not
-		 */
-		bool _echoTesting;
+  private:
+    void closeStream (void);
 
-		std::string _errorMessage;
-		ost::Mutex _mutex;
+    pa_stream* playback;
+    pa_stream* record;
 
-		float *table_;
-		int tableSize_;
-		int leftPhase_;
 };
 
-#endif // _AUDIO_LAYER_PULSE_H_
+#endif // _PULSE_LAYER_H_
 

src/managerimpl.cpp

@@ -38,6 +38,8 @@
 #include "manager.h"
 #include "account.h"
 #include "audio/audiolayer.h"
+#include "audio/alsalayer.h"
+#include "audio/pulselayer.h"
 #include "audio/tonelist.h"
 
 #include "accountcreator.h" // create new account
@@ -1431,7 +1433,8 @@ ManagerImpl::getCurrentAudioOutputPlugin( void )
 ManagerImpl::initAudioDriver(void) 
 {
   _debugInit("AudioLayer Creation");
-  _audiodriver = new AudioLayer(this);
+  //_audiodriver = new AudioLayer(this);
+  _audiodriver = new AlsaLayer( this );
   if (_audiodriver == 0) {
     _debug("Init audio driver error\n");
   } else {