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
26namespace webrtc {
27
28class AudioProcessing;
29class ProcessThread;
30class VoEExternalMedia;
31class VoEMediaProcess;
32
33namespace voe {
34
35class ChannelManager;
36class MixedAudio;
37class Statistics;
38
39class TransmitMixer : public MonitorObserver,
40                      public FileCallback {
41public:
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
168private:
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