MpCallFlowGraph.h

Go to the documentation of this file.

//
// Copyright (C) 2006-2016 SIPez LLC.  All rights reserved.
//
// Copyright (C) 2004-2009 SIPfoundry Inc.
// Licensed by SIPfoundry under the LGPL license.
//
// Copyright (C) 2004-2006 Pingtel Corp.  All rights reserved.
// Licensed to SIPfoundry under a Contributor Agreement.
//
// $$


#ifndef _MpCallFlowGraph_h_
#define _MpCallFlowGraph_h_

#include <rtcp/RtcpConfig.h>

// SYSTEM INCLUDES

// APPLICATION INCLUDES
#include <mp/MpMisc.h>
#include <mp/MpFlowGraphBase.h>
#include <mp/StreamDefs.h>
#include <mp/MpStreamMsg.h>
#include <os/OsProtectEvent.h>
#include <mp/MprRecorder.h>
#include <os/OsSocket.h>

// DEFINES
#define DEBUG_POSTPONE
#undef DEBUG_POSTPONE

#define DOING_ECHO_CANCELATION
#define SPEEX_ECHO_CANCELATION

// Disable Speex AEC if Speex is not available
#ifndef HAVE_SPEEX // [
#  undef SPEEX_ECHO_CANCELATION
#endif // !HAVE_SPEEX ]

// Make sure that at least one canceler enabled if AEC enabled at all.
// And make sure that all cancelers disabled if AEC is disabled.
#ifdef DOING_ECHO_CANCELATION // [
#  ifndef SPEEX_ECHO_CANCELATION // [
//#     define SIPX_ECHO_CANCELATION
// $$$ Ipse: sipX AEC is not working now!
#     undef DOING_ECHO_CANCELATION
#  endif // !SPEEX_ECHO_CANCELATION ]
#else // DOING_ECHO_CANCELATION ][
#  undef SPEEX_ECHO_CANCELATION
#  undef SIPX_ECHO_CANCELATION
#endif // DOING_ECHO_CANCELATION ]

// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
typedef enum FLOWGRAPH_AEC_MODE
{
    FLOWGRAPH_AEC_DISABLED,
    FLOWGRAPH_AEC_SUPPRESS,
    FLOWGRAPH_AEC_CANCEL,
    FLOWGRAPH_AEC_CANCEL_AUTO
} FLOWGRAPH_AEC_MODE ;

// FORWARD DECLARATIONS
class MprBridge;
class MprFromStream;
class MprFromFile;
class MprFromMic;
class MprEchoSuppress;
class MprSpeexEchoCancel;
class MprSpeexPreprocess;
class MprMixer;
class MprSplitter;
class MprToSpkr;
class MprToneGen;
class SdpCodec;
class MpRtpInputConnection;
class MpRtpOutputConnection;
class MprEncode;
class MprDecode;

class MpCallFlowGraph : public MpFlowGraphBase
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:

   typedef enum
   {
      TONE_TO_SPKR = 0x1,   
      TONE_TO_NET  = 0x2    
   } ToneOptions;

   enum RecorderChoice {
#ifndef DISABLE_LOCAL_AUDIO // [
      RECORDER_MIC = 0,
      RECORDER_ECHO_OUT,
      RECORDER_ECHO_IN8,
#ifdef HIGH_SAMPLERATE_AUDIO // [
      RECORDER_MIC32K,
      RECORDER_SPKR32K,
      RECORDER_ECHO_IN32,
#endif // HIGH_SAMPLERATE_AUDIO ]
#endif // DISABLE_LOCAL_AUDIO ]
      RECORDER_SPKR,
      RECORDER_CALL,    
      MAX_RECORDERS = 10
   };

/* ============================ CREATORS ================================== */


   MpCallFlowGraph(const char* pLocale = "",
                   int samplesPerFrame=0,
                   int samplesPerSec=0,
                   OsMsgDispatcher *pNotifDispatcher= NULL);

   virtual
   ~MpCallFlowGraph();


/* ============================ MANIPULATORS ============================== */


   void startTone(int toneId, int toneOptions);

   void stopTone(void);

   int closeRecorders(void);

   OsStatus Record(int ms,
            const char* playFilename, 
            const char* baseName,     
            const char* endName,      
            int recorderMask);

   OsStatus recordMic(int ms, MpAudioSample* pAudioBuf, int bufferSize);

   OsStatus recordMic(int ms,
                      int silenceLength,
                      const char* fileName) ;

   OsStatus record(int timeMS,
                   int silenceLength,
                   const char* micName = NULL,
                   const char* echoOutName = NULL,
                   const char* spkrName = NULL,
                   const char* mic32Name = NULL,
                   const char* spkr32Name = NULL,
                   const char* echoIn8Name = NULL,
                   const char* echoIn32Name = NULL,
                   const char* playName = NULL,
                   const char* callName = NULL,
                   int toneOptions = 0,
                   int repeat = 0,
                   MprRecorder::RecordFileFormat format = MprRecorder::RAW_PCM_16);

   UtlBoolean setupRecorder(RecorderChoice which, const char* audioFileName,
                  int time, int silenceLength,
                  MprRecorder::RecordFileFormat format = MprRecorder::RAW_PCM_16);

   OsStatus playBuffer(char* audioBuf,
                  unsigned long bufSize,
                  uint32_t inRate,
                  int type,
                  UtlBoolean repeat,
                  int toneOptions,
                  OsProtectedEvent* event = NULL,
                  UtlBoolean autoStopOnFinish = TRUE);
   OsStatus playFile( const char* audioFileName 
                    , UtlBoolean repeat 
                    , int toneOptions   
                    , UtlBoolean autoStopOnFinish = TRUE);
   OsStatus pauseFile();

   OsStatus resumeFile();

   void stopFile(UtlBoolean closeFile);
   void startSendRtp(OsSocket& rRtpSocket, OsSocket& rRtcpSocket,
                     MpConnectionID connID=1, SdpCodec* pPrimaryCodec = NULL,
                     SdpCodec* pDtmfCodec = NULL);

   void stopSendRtp(MpConnectionID connID=1);

   void startReceiveRtp(SdpCodec* pCodecs[], int numCodecs,
                        OsSocket& rRtpSocket, OsSocket& rRtcpSocket,
                        MpConnectionID connID=1);

   void stopReceiveRtp(MpConnectionID connID=1);

   virtual OsStatus gainFocus(void);
   virtual OsStatus loseFocus(void);
   OsStatus postNotification(const MpResNotificationMsg& msg);

   MpConnectionID createConnection(int maxRtpStreams = 1,
                                   UtlBoolean isMcast = FALSE);

   UtlBoolean unmuteInput(MpConnectionID connID);

   UtlBoolean unmuteOutput(MpConnectionID connID);

   UtlBoolean muteInput(MpConnectionID connID);

   UtlBoolean muteOutput(MpConnectionID connID);

   OsStatus deleteConnection(MpConnectionID connID);


   static UtlBoolean setInbandDTMF(UtlBoolean bEnable);

   static UtlBoolean setAECMode(FLOWGRAPH_AEC_MODE mode);
   static UtlBoolean setAGC(UtlBoolean bEnable);
   static UtlBoolean setAudioNoiseReduction(UtlBoolean bEnable);
/* ============================ ACCESSORS ================================= */


   virtual MpFlowGraphBase::FlowGraphType getType();


/* ============================ INQUIRY =================================== */


   UtlBoolean isCodecSupported(SdpCodec& rCodec);

/* ============================ CALLBACKS ================================= */

/* //////////////////////////// PROTECTED ///////////////////////////////// */
protected:

/* //////////////////////////// PRIVATE /////////////////////////////////// */
private:

   typedef enum {
      START_PLAY_NONE = 0,
      START_PLAY_FILE,
      START_PLAY_SPKR
   } PlayStart;

   static UtlBoolean sbSendInBandDTMF ;
   static UtlBoolean sbEnableAEC ;
   static UtlBoolean sbEnableAGC ;
   static UtlBoolean sbEnableNoiseReduction ;

   enum { MAX_CONNECTIONS = 10 };

   MprBridge*    mpBridge;
   MprFromFile*  mpFromFile;
#ifndef DISABLE_STREAM_PLAYER
   MprFromStream*  mpFromStream;
#endif
#ifndef DISABLE_LOCAL_AUDIO // [
   MprFromMic*   mpFromMic;
   MprSplitter*  mpMicSplitter;
   MprRecorder* mpBufferRecorder;
#  ifdef HAVE_SPEEX // [
      MprSpeexPreprocess* mpSpeexPreProcess;
#  endif // HAVE_SPEEX ]
#  if defined (SPEEX_ECHO_CANCELATION)
      MprSpeexEchoCancel* mpEchoCancel;
#  elif defined (SIPX_ECHO_CANCELATION)
      MprEchoSuppress*    mpEchoCancel;
#  endif
      MprToSpkr*    mpToSpkr;
#endif // DISABLE_LOCAL_AUDIO ]
   MprMixer*     mpTFsMicMixer;
   MprMixer*     mpTFsBridgeMixer;
   MprMixer*     mpCallrecMixer;
   MprSplitter*  mpMicCallrecSplitter;
   MprSplitter*  mpSpeakerCallrecSplitter;
   MprSplitter*  mpToneFileSplitter;
   MprToneGen*   mpToneGen;
   OsBSem        mConnTableLock;
   UtlBoolean    mToneIsGlobal;
   MpRtpInputConnection* mpInputConnections[MAX_CONNECTIONS];
   int           mNumRtpStreams[MAX_CONNECTIONS];
   UtlBoolean    mIsMcastConnection[MAX_CONNECTIONS];
   MprDecode**   mpDecoders[MAX_CONNECTIONS];
   MprMixer*     mpMcastMixer[MAX_CONNECTIONS];
   MpRtpOutputConnection* mpOutputConnections[MAX_CONNECTIONS];
   MprEncode*    mpEncoders[MAX_CONNECTIONS];
   UtlBoolean    mToneGenDefocused; 

   MprRecorder* mpRecorders[MAX_RECORDERS];

   virtual UtlBoolean handleMessage(OsMsg& rMsg);
   UtlBoolean handleRemoveConnection(MpFlowGraphMsg& rMsg);
   UtlBoolean handleStartPlay(MpFlowGraphMsg& rMsg);
   UtlBoolean handleStartRecord(MpFlowGraphMsg& rMsg);
   UtlBoolean handleStopRecord(MpFlowGraphMsg& rMsg);
   UtlBoolean handleStartTone(MpFlowGraphMsg& rMsg);
   UtlBoolean handleStopToneOrPlay(void);
   UtlBoolean handleOnMprRecorderEnabled(const UtlString &resourceName);
   UtlBoolean handleOnMprRecorderDisabled(const UtlString &resourceName);
#ifdef DEBUG_POSTPONE /* [ */
   void postPone(int ms);
#endif /* DEBUG_POSTPONE ] */

#ifndef DISABLE_STREAM_PLAYER
   UtlBoolean handleStreamRealizeUrl(MpStreamMsg& rMsg);
   UtlBoolean handleStreamRealizeBuffer(MpStreamMsg& rMsg);
   UtlBoolean handleStreamPrefetch(MpStreamMsg& rMsg);
   UtlBoolean handleStreamPlay(MpStreamMsg& rMsg);
   UtlBoolean handleStreamRewind(MpStreamMsg& rMsg);
   UtlBoolean handleStreamPause(MpStreamMsg& rMsg);
   UtlBoolean handleStreamStop(MpStreamMsg& rMsg);
   UtlBoolean handleStreamDestroy(MpStreamMsg& rMsg);
#endif // DISABLE_STREAM_PLAYER

   MpCallFlowGraph(const MpCallFlowGraph& rMpCallFlowGraph);

   MpCallFlowGraph& operator=(const MpCallFlowGraph& rhs);

};

/* ============================ INLINE METHODS ============================ */

#endif  // _MpCallFlowGraph_h_