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