Home | History | Annotate | Download | only in voice_engine
      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/audio_processing/typing_detection.h"
     17 #include "webrtc/modules/interface/module_common_types.h"
     18 #include "webrtc/modules/utility/interface/file_player.h"
     19 #include "webrtc/modules/utility/interface/file_recorder.h"
     20 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
     21 #include "webrtc/voice_engine/include/voe_base.h"
     22 #include "webrtc/voice_engine/level_indicator.h"
     23 #include "webrtc/voice_engine/monitor_module.h"
     24 #include "webrtc/voice_engine/voice_engine_defines.h"
     25 
     26 namespace webrtc {
     27 
     28 class AudioProcessing;
     29 class ProcessThread;
     30 class VoEExternalMedia;
     31 class VoEMediaProcess;
     32 
     33 namespace voe {
     34 
     35 class ChannelManager;
     36 class MixedAudio;
     37 class Statistics;
     38 
     39 class TransmitMixer : public MonitorObserver,
     40                       public FileCallback {
     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 StartRecordingMicrophone(const char* fileName,
    121                                  const CodecInst* codecInst);
    122 
    123     int StartRecordingMicrophone(OutStream* stream,
    124                                  const CodecInst* codecInst);
    125 
    126     int StopRecordingMicrophone();
    127 
    128     int StartRecordingCall(const char* fileName, const CodecInst* codecInst);
    129 
    130     int StartRecordingCall(OutStream* stream, const CodecInst* codecInst);
    131 
    132     int StopRecordingCall();
    133 
    134     void SetMixWithMicStatus(bool mix);
    135 
    136     int32_t RegisterVoiceEngineObserver(VoiceEngineObserver& observer);
    137 
    138     virtual ~TransmitMixer();
    139 
    140     // MonitorObserver
    141     void OnPeriodicProcess();
    142 
    143 
    144     // FileCallback
    145     void PlayNotification(int32_t id,
    146                           uint32_t durationMs);
    147 
    148     void RecordNotification(int32_t id,
    149                             uint32_t durationMs);
    150 
    151     void PlayFileEnded(int32_t id);
    152 
    153     void RecordFileEnded(int32_t id);
    154 
    155 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
    156     // Typing detection
    157     int TimeSinceLastTyping(int &seconds);
    158     int SetTypingDetectionParameters(int timeWindow,
    159                                      int costPerTyping,
    160                                      int reportingThreshold,
    161                                      int penaltyDecay,
    162                                      int typeEventDelay);
    163 #endif
    164 
    165   void EnableStereoChannelSwapping(bool enable);
    166   bool IsStereoChannelSwappingEnabled();
    167 
    168 private:
    169     TransmitMixer(uint32_t instanceId);
    170 
    171     // Gets the maximum sample rate and number of channels over all currently
    172     // sending codecs.
    173     void GetSendCodecInfo(int* max_sample_rate, int* max_channels);
    174 
    175     void GenerateAudioFrame(const int16_t audioSamples[],
    176                             int nSamples,
    177                             int nChannels,
    178                             int samplesPerSec);
    179     int32_t RecordAudioToFile(uint32_t mixingFrequency);
    180 
    181     int32_t MixOrReplaceAudioWithFile(
    182         int mixingFrequency);
    183 
    184     void ProcessAudio(int delay_ms, int clock_drift, int current_mic_level,
    185                       bool key_pressed);
    186 
    187 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
    188     void TypingDetection(bool keyPressed);
    189 #endif
    190 
    191     // uses
    192     Statistics* _engineStatisticsPtr;
    193     ChannelManager* _channelManagerPtr;
    194     AudioProcessing* audioproc_;
    195     VoiceEngineObserver* _voiceEngineObserverPtr;
    196     ProcessThread* _processThreadPtr;
    197 
    198     // owns
    199     MonitorModule _monitorModule;
    200     AudioFrame _audioFrame;
    201     PushResampler<int16_t> resampler_;  // ADM sample rate -> mixing rate
    202     FilePlayer* _filePlayerPtr;
    203     FileRecorder* _fileRecorderPtr;
    204     FileRecorder* _fileCallRecorderPtr;
    205     int _filePlayerId;
    206     int _fileRecorderId;
    207     int _fileCallRecorderId;
    208     bool _filePlaying;
    209     bool _fileRecording;
    210     bool _fileCallRecording;
    211     voe::AudioLevel _audioLevel;
    212     // protect file instances and their variables in MixedParticipants()
    213     CriticalSectionWrapper& _critSect;
    214     CriticalSectionWrapper& _callbackCritSect;
    215 
    216 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
    217     webrtc::TypingDetection _typingDetection;
    218     bool _typingNoiseWarningPending;
    219     bool _typingNoiseDetected;
    220 #endif
    221     bool _saturationWarning;
    222 
    223     int _instanceId;
    224     bool _mixFileWithMicrophone;
    225     uint32_t _captureLevel;
    226     VoEMediaProcess* external_postproc_ptr_;
    227     VoEMediaProcess* external_preproc_ptr_;
    228     bool _mute;
    229     int32_t _remainingMuteMicTimeMs;
    230     bool stereo_codec_;
    231     bool swap_stereo_channels_;
    232     scoped_ptr<int16_t[]> mono_buffer_;
    233 };
    234 
    235 }  // namespace voe
    236 
    237 }  // namespace webrtc
    238 
    239 #endif  // WEBRTC_VOICE_ENGINE_TRANSMIT_MIXER_H
    240