src/third_party/webrtc/voice_engine/transmit_mixer.h

   1 /*
   2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #ifndef WEBRTC_VOICE_ENGINE_TRANSMIT_MIXER_H
  12 #define WEBRTC_VOICE_ENGINE_TRANSMIT_MIXER_H
  13
  14 #include "webrtc/common_audio/resampler/include/push_resampler.h"
  15 #include "webrtc/common_types.h"
  16 #include "webrtc/modules/interface/module_common_types.h"
  17 #include "webrtc/modules/utility/interface/file_player.h"
  18 #include "webrtc/modules/utility/interface/file_recorder.h"
  19 #include "webrtc/voice_engine/include/voe_base.h"
  20 #include "webrtc/voice_engine/level_indicator.h"
  21 #include "webrtc/voice_engine/monitor_module.h"
  22 #include "webrtc/voice_engine/voice_engine_defines.h"
  23
  24 namespace webrtc {
  25
  26 class AudioProcessing;
  27 class ProcessThread;
  28 class VoEExternalMedia;
  29 class VoEMediaProcess;
  30
  31 namespace voe {
  32
  33 class ChannelManager;
  34 class MixedAudio;
  35 class Statistics;
  36
  37 class TransmitMixer : public MonitorObserver,
  38                       public FileCallback
  39
  40 {
  41 public:
  42     static int32_t Create(TransmitMixer*& mixer, uint32_t instanceId);
  43
  44     static void Destroy(TransmitMixer*& mixer);
  45
  46     int32_t SetEngineInformation(ProcessThread& processThread,
  47                                  Statistics& engineStatistics,
  48                                  ChannelManager& channelManager);
  49
  50     int32_t SetAudioProcessingModule(
  51         AudioProcessing* audioProcessingModule);
  52
  53     int32_t PrepareDemux(const void* audioSamples,
  54                          uint32_t nSamples,
  55                          uint8_t  nChannels,
  56                          uint32_t samplesPerSec,
  57                          uint16_t totalDelayMS,
  58                          int32_t  clockDrift,
  59                          uint16_t currentMicLevel,
  60                          bool keyPressed);
  61
  62
  63     int32_t DemuxAndMix();
  64     // Used by the Chrome to pass the recording data to the specific VoE
  65     // channels for demux.
  66     void DemuxAndMix(const int voe_channels[], int number_of_voe_channels);
  67
  68     int32_t EncodeAndSend();
  69     // Used by the Chrome to pass the recording data to the specific VoE
  70     // channels for encoding and sending to the network.
  71     void EncodeAndSend(const int voe_channels[], int number_of_voe_channels);
  72
  73     // Must be called on the same thread as PrepareDemux().
  74     uint32_t CaptureLevel() const;
  75
  76     int32_t StopSend();
  77
  78     // VoEDtmf
  79     void UpdateMuteMicrophoneTime(uint32_t lengthMs);
  80
  81     // VoEExternalMedia
  82     int RegisterExternalMediaProcessing(VoEMediaProcess* object,
  83                                         ProcessingTypes type);
  84     int DeRegisterExternalMediaProcessing(ProcessingTypes type);
  85
  86     int GetMixingFrequency();
  87
  88     // VoEVolumeControl
  89     int SetMute(bool enable);
  90
  91     bool Mute() const;
  92
  93     int8_t AudioLevel() const;
  94
  95     int16_t AudioLevelFullRange() const;
  96
  97     bool IsRecordingCall();
  98
  99     bool IsRecordingMic();
 100
 101     int StartPlayingFileAsMicrophone(const char* fileName,
 102                                      bool loop,
 103                                      FileFormats format,
 104                                      int startPosition,
 105                                      float volumeScaling,
 106                                      int stopPosition,
 107                                      const CodecInst* codecInst);
 108
 109     int StartPlayingFileAsMicrophone(InStream* stream,
 110                                      FileFormats format,
 111                                      int startPosition,
 112                                      float volumeScaling,
 113                                      int stopPosition,
 114                                      const CodecInst* codecInst);
 115
 116     int StopPlayingFileAsMicrophone();
 117
 118     int IsPlayingFileAsMicrophone() const;
 119
 120     int ScaleFileAsMicrophonePlayout(float scale);
 121
 122     int StartRecordingMicrophone(const char* fileName,
 123                                  const CodecInst* codecInst);
 124
 125     int StartRecordingMicrophone(OutStream* stream,
 126                                  const CodecInst* codecInst);
 127
 128     int StopRecordingMicrophone();
 129
 130     int StartRecordingCall(const char* fileName, const CodecInst* codecInst);
 131
 132     int StartRecordingCall(OutStream* stream, const CodecInst* codecInst);
 133
 134     int StopRecordingCall();
 135
 136     void SetMixWithMicStatus(bool mix);
 137
 138     int32_t RegisterVoiceEngineObserver(VoiceEngineObserver& observer);
 139
 140     virtual ~TransmitMixer();
 141
 142     // MonitorObserver
 143     void OnPeriodicProcess();
 144
 145
 146     // FileCallback
 147     void PlayNotification(int32_t id,
 148                           uint32_t durationMs);
 149
 150     void RecordNotification(int32_t id,
 151                             uint32_t durationMs);
 152
 153     void PlayFileEnded(int32_t id);
 154
 155     void RecordFileEnded(int32_t id);
 156
 157 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
 158     // Typing detection
 159     int TimeSinceLastTyping(int &seconds);
 160     int SetTypingDetectionParameters(int timeWindow,
 161                                      int costPerTyping,
 162                                      int reportingThreshold,
 163                                      int penaltyDecay,
 164                                      int typeEventDelay);
 165 #endif
 166
 167   void EnableStereoChannelSwapping(bool enable);
 168   bool IsStereoChannelSwappingEnabled();
 169
 170 private:
 171     TransmitMixer(uint32_t instanceId);
 172
 173     // Gets the maximum sample rate and number of channels over all currently
 174     // sending codecs.
 175     void GetSendCodecInfo(int* max_sample_rate, int* max_channels);
 176
 177     int GenerateAudioFrame(const int16_t audioSamples[],
 178                            int nSamples,
 179                            int nChannels,
 180                            int samplesPerSec);
 181     int32_t RecordAudioToFile(uint32_t mixingFrequency);
 182
 183     int32_t MixOrReplaceAudioWithFile(
 184         int mixingFrequency);
 185
 186     void ProcessAudio(int delay_ms, int clock_drift, int current_mic_level);
 187
 188 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
 189     int TypingDetection(bool keyPressed);
 190 #endif
 191
 192     // uses
 193     Statistics* _engineStatisticsPtr;
 194     ChannelManager* _channelManagerPtr;
 195     AudioProcessing* audioproc_;
 196     VoiceEngineObserver* _voiceEngineObserverPtr;
 197     ProcessThread* _processThreadPtr;
 198
 199     // owns
 200     MonitorModule _monitorModule;
 201     AudioFrame _audioFrame;
 202     PushResampler resampler_;  // ADM sample rate -> mixing rate
 203     FilePlayer* _filePlayerPtr;
 204     FileRecorder* _fileRecorderPtr;
 205     FileRecorder* _fileCallRecorderPtr;
 206     int _filePlayerId;
 207     int _fileRecorderId;
 208     int _fileCallRecorderId;
 209     bool _filePlaying;
 210     bool _fileRecording;
 211     bool _fileCallRecording;
 212     voe::AudioLevel _audioLevel;
 213     // protect file instances and their variables in MixedParticipants()
 214     CriticalSectionWrapper& _critSect;
 215     CriticalSectionWrapper& _callbackCritSect;
 216
 217 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
 218     int32_t _timeActive;
 219     int32_t _timeSinceLastTyping;
 220     int32_t _penaltyCounter;
 221     bool _typingNoiseWarningPending;
 222     bool _typingNoiseDetected;
 223
 224     // Tunable treshold values
 225     int _timeWindow; // nr of10ms slots accepted to count as a hit.
 226     int _costPerTyping; // Penalty added for a typing + activity coincide.
 227     int _reportingThreshold; // Threshold for _penaltyCounter.
 228     int _penaltyDecay; // How much we reduce _penaltyCounter every 10 ms.
 229     int _typeEventDelay; // How old typing events we allow
 230
 231 #endif
 232     bool _saturationWarning;
 233
 234     int _instanceId;
 235     bool _mixFileWithMicrophone;
 236     uint32_t _captureLevel;
 237     VoEMediaProcess* external_postproc_ptr_;
 238     VoEMediaProcess* external_preproc_ptr_;
 239     bool _mute;
 240     int32_t _remainingMuteMicTimeMs;
 241     bool stereo_codec_;
 242     bool swap_stereo_channels_;
 243 };
 244
 245 }  // namespace voe
 246
 247 }  // namespace webrtc
 248
 249 #endif  // WEBRTC_VOICE_ENGINE_TRANSMIT_MIXER_H