MprRecorder.h

Go to the documentation of this file.

//  
// Copyright (C) 2006-2019 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 _MprRecorder_h_
#define _MprRecorder_h_

// SYSTEM INCLUDES
#ifdef _VXWORKS /* [ */
#   include <ioLib.h>
#endif /* _VXWORKS ] */

#if defined(_WIN32) && !defined(WINCE) /* [ */
#   include <io.h>
#endif /* _WIN32 ] */

// APPLICATION INCLUDES
#include "os/OsMutex.h"
#include "mp/MpResourceMsg.h"
#include "mp/MpAudioResource.h"
#include "utl/CircularBufferPtr.h"
#include "os/OsProtectEvent.h"

// DEFINES
// Note: only tested with 1-4 channels
#ifndef MAXIMUM_RECORDER_CHANNELS
#  define MAXIMUM_RECORDER_CHANNELS 4
#endif

// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS

// FORWARD DECLARATIONS
class MpEncoderBase;
class MpResamplerBase;
struct SipxOpusWriteObject;
struct OpusHead;

class MprRecorder : public MpAudioResource
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:

   typedef enum {
      UNINITIALIZED_FORMAT = -1,
      RAW_PCM_16 = 0,

      // WAV codec codes:
      WAV_PCM_16 = 1,
      WAV_ALAW = 6,
      WAV_MULAW = 7,
      WAV_GSM = 49, // 0x31

      // Ogg codecs:
      OGG_OPUS = 501
   } RecordFileFormat;

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


   MprRecorder(const UtlString& rName);

   virtual
   ~MprRecorder();


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


   static OsStatus startFile(const UtlString& namedResource, 
                             OsMsgQ& fgQ,
                             const char *filename,
                             RecordFileFormat recFormat,
                             int time = 0,
                             int silenceLength = -1,
                             UtlBoolean append = FALSE,
                             int numChannels = 1);
   static OsStatus startBuffer(const UtlString& namedResource, 
                               OsMsgQ& fgQ,
                               MpAudioSample *pBuffer,
                               int bufferSize,
                               int time = 0,
                               int silenceLength = -1,
                               int numChannels = 1);
   static OsStatus pause(const UtlString& namedResource, OsMsgQ& flowgraphQueue);
   static OsStatus resume(const UtlString& namedResource, OsMsgQ& flowgraphQueue);
   static OsStatus startCircularBuffer(const UtlString& namedResource, 
                                       OsMsgQ& fgQ,
                                       CircularBufferPtr & buffer,
                                       RecordFileFormat recordingFormat,
                                       unsigned long recordingBufferNotificationWatermark,
                                       int numChannels = 1);
   static OsStatus stop(const UtlString& namedResource, OsMsgQ& fgQ);

   static OsStatus validateOpusHeader(int inFileFd, OpusHead& opusHeader);

/* ============================ ACCESSORS ================================= */



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

   static int getMaximumRecoderChannels();

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

   typedef enum
   {
      MPRM_START_FILE = MpResourceMsg::MPRM_EXTERNAL_MESSAGE_START,
      MPRM_START_BUFFER,
      MPRM_PAUSE,
      MPRM_RESUME,
      MPRM_START_CIRCULAR_BUFFER,
      MPRM_STOP
   } AddlMsgTypes;

   typedef enum
   {
      FINISHED_AUTO,   
      FINISHED_MANUAL, 
      FINISHED_ERROR   
   } FinishCause;

   typedef enum
   {
      STATE_IDLE,      
      STATE_RECORDING, 
      STATE_PAUSED    
          
   } State;

   typedef enum
   {
      TO_UNDEFINED = -1,
      TO_FILE,           
      TO_BUFFER,         
      TO_CIRCULAR_BUFFER 
   } RecordDestination;

   typedef enum
   {
       NO_INTERLACE,
       PRE_ENCODE_INTERLACE,
       POST_ENCODE_INTERLACE
   } SampleInterlaceStage;

   State mState;            
   RecordDestination mRecordDestination; 
   int mChannels;
   int mFramesToRecord;
   int mNumFramesProcessed;
   int mSamplesRecorded;
   int mConsecutiveInactive;
   int mSilenceLength;


   int mFileDescriptor;     
   RecordFileFormat mRecFormat; 



   MpAudioSample *mpBuffer; 
   int mBufferSize;         


   MpEncoderBase* mpEncoder; 
   int mEncodedFrames;      
   int mLastEncodedFrameSize;

   void* mpOpusEncoder;
   void* mpOpusComments;
   struct SipxOpusWriteObject* mpOpusStreamObject;

   SampleInterlaceStage mWhenToInterlace;

   MpResamplerBase* mpResampler; 

   

   CircularBufferPtr * mpCircularBuffer;
   unsigned long mRecordingBufferNotificationWatermark;

   int mSamplesPerLastFrame; 
   int mSamplesPerSecond;    

   virtual UtlBoolean doProcessFrame(MpBufPtr inBufs[],
                                    MpBufPtr outBufs[],
                                    int inBufsSize,
                                    int outBufsSize,
                                    UtlBoolean isEnabled,
                                    int samplesPerFrame,
                                    int samplesPerSecond);

   UtlBoolean handleStartFile(int file, 
                              RecordFileFormat recFormat, 
                              int time,
                              int silenceLength,
                              UtlBoolean append,
                              int numChannels);
   UtlBoolean handleStartBuffer(MpAudioSample *pBuffer, int bufferSize, int time,
                                int silenceLength, int numChannels);

   UtlBoolean handleStartCircularBuffer(CircularBufferPtr * buffer, 
                                        RecordFileFormat recordingFormat,
                                        unsigned long recordingBufferNotificationWatermark,
                                        int numChannels);

   UtlBoolean handleStop();

   virtual UtlBoolean handleDisable();

   virtual UtlBoolean handleMessage(MpResourceMsg& rMsg);

   void startRecording(int time, int silenceLength);

   UtlBoolean finish(FinishCause cause);

   void closeFile(const char* fromWhereLabel);

   typedef int (MprRecorder::*WriteMethod)(const char * channelBuffers[], int);

   inline int writeFileSilence(int numSamples);

   inline int writeSamples(const MpAudioSample *pBuffer[], int numSamples, WriteMethod writeMethod);

   inline int writeBufferSilence(int numSamples);

   inline int writeCircularBufferSilence(int numSamples);

   inline int writeBufferSpeech(const MpAudioSample *pBuffer, int numSamples);

   static UtlBoolean writeWaveHeader(int handle, RecordFileFormat format, 
                                     uint32_t samplesPerSecond = 8000,
                                     int16_t numChannels = 1);

   static OsStatus readWaveHeader(int fileHandle,
                                  RecordFileFormat& format,
                                  uint16_t& samplesPerSecond,
                                  uint16_t& channels);
   static UtlBoolean updateWaveHeaderLengths(int handle, RecordFileFormat format);

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

   MprRecorder(const MprRecorder& rMprRecorder);

   MprRecorder& operator=(const MprRecorder& rhs);

   int writeFile(const char* channelData[], int dataSize);
   int writeCircularBuffer(const char* channelData[], int dataSize);
   void notifyCircularBufferWatermark();
   void createEncoder(const char * mimeSubtype, unsigned int codecSampleRate);
   void prepareEncoder(RecordFileFormat recFormat, unsigned int & codecSampleRate);
   OsStatus createOpusEncoder(int channels,
                              const char* artist, 
                              const char* title);
   void deleteOpusEncoder();
   void trimSilenceFromEndOfRecording();

   static int16_t getBytesPerSample(RecordFileFormat format);
   static int interlaceSamples(const char* samplesArrays[], int samplesPerChannel, int bytesPerSample, int channels, char* interlacedChannelSamplesArray, int interlacedArrayMaximum);
};

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

#endif  // _MprRecorder_h_