zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
07fbb2bc94b5de469481a43d0e65e352ee6a78d1
platform-external-webrtc/webrtc/media/engine/fakewebrtcvoiceengine.h
solenberg 7602aabdc0 Remove usage of VoEBase::AssociateSendChannel() from WVoMC. 
- Functionality now implemented in AudioReceiveStream and Call.
- Added some missing function to MockChannelProxy.

BUG=webrtc:4690

Review-Url: https://codereview.webrtc.org/2461523002
Cr-Commit-Position: refs/heads/master@{#15072}
2016-11-14 19:30:16 +00:00

363 lines
13 KiB
C++
Raw Blame History

/*
* Copyright (c) 2010 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_MEDIA_ENGINE_FAKEWEBRTCVOICEENGINE_H_
#define WEBRTC_MEDIA_ENGINE_FAKEWEBRTCVOICEENGINE_H_
#include <list>
#include <map>
#include <vector>
#include "webrtc/base/basictypes.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/stringutils.h"
#include "webrtc/config.h"
#include "webrtc/media/base/codec.h"
#include "webrtc/media/base/rtputils.h"
#include "webrtc/media/engine/webrtcvoe.h"
#include "webrtc/modules/audio_coding/acm2/rent_a_codec.h"
#include "webrtc/modules/audio_processing/include/audio_processing.h"
namespace cricket {
static const int kOpusBandwidthNb = 4000;
static const int kOpusBandwidthMb = 6000;
static const int kOpusBandwidthWb = 8000;
static const int kOpusBandwidthSwb = 12000;
static const int kOpusBandwidthFb = 20000;
#define WEBRTC_CHECK_CHANNEL(channel) \
if (channels_.find(channel) == channels_.end()) return -1;
#define WEBRTC_STUB(method, args) \
int method args override { return 0; }
#define WEBRTC_STUB_CONST(method, args) \
int method args const override { return 0; }
#define WEBRTC_BOOL_STUB(method, args) \
bool method args override { return true; }
#define WEBRTC_VOID_STUB(method, args) \
void method args override {}
#define WEBRTC_FUNC(method, args) int method args override
class FakeWebRtcVoiceEngine
: public webrtc::VoEAudioProcessing,
public webrtc::VoEBase, public webrtc::VoECodec,
public webrtc::VoEHardware,
public webrtc::VoEVolumeControl {
public:
struct Channel {
std::vector<webrtc::CodecInst> recv_codecs;
size_t neteq_capacity = 0;
bool neteq_fast_accelerate = false;
};
explicit FakeWebRtcVoiceEngine(webrtc::AudioProcessing* apm) : apm_(apm) {
memset(&agc_config_, 0, sizeof(agc_config_));
}
~FakeWebRtcVoiceEngine() override {
RTC_CHECK(channels_.empty());
}
bool ec_metrics_enabled() const { return ec_metrics_enabled_; }
bool IsInited() const { return inited_; }
int GetLastChannel() const { return last_channel_; }
int GetNumChannels() const { return static_cast<int>(channels_.size()); }
void set_fail_create_channel(bool fail_create_channel) {
fail_create_channel_ = fail_create_channel;
}
WEBRTC_STUB(Release, ());
// webrtc::VoEBase
WEBRTC_STUB(RegisterVoiceEngineObserver, (
webrtc::VoiceEngineObserver& observer));
WEBRTC_STUB(DeRegisterVoiceEngineObserver, ());
WEBRTC_FUNC(Init,
(webrtc::AudioDeviceModule* adm,
webrtc::AudioProcessing* audioproc,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
decoder_factory)) {
inited_ = true;
return 0;
}
WEBRTC_FUNC(Terminate, ()) {
inited_ = false;
return 0;
}
webrtc::AudioProcessing* audio_processing() override {
return apm_;
}
webrtc::AudioDeviceModule* audio_device_module() override {
return nullptr;
}
WEBRTC_FUNC(CreateChannel, ()) {
return CreateChannel(webrtc::VoEBase::ChannelConfig());
}
WEBRTC_FUNC(CreateChannel, (const webrtc::VoEBase::ChannelConfig& config)) {
if (fail_create_channel_) {
return -1;
}
Channel* ch = new Channel();
auto db = webrtc::acm2::RentACodec::Database();
ch->recv_codecs.assign(db.begin(), db.end());
ch->neteq_capacity = config.acm_config.neteq_config.max_packets_in_buffer;
ch->neteq_fast_accelerate =
config.acm_config.neteq_config.enable_fast_accelerate;
channels_[++last_channel_] = ch;
return last_channel_;
}
WEBRTC_FUNC(DeleteChannel, (int channel)) {
WEBRTC_CHECK_CHANNEL(channel);
delete channels_[channel];
channels_.erase(channel);
return 0;
}
WEBRTC_STUB(StartReceive, (int channel));
WEBRTC_STUB(StartPlayout, (int channel));
WEBRTC_STUB(StartSend, (int channel));
WEBRTC_STUB(StopReceive, (int channel));
WEBRTC_STUB(StopPlayout, (int channel));
WEBRTC_STUB(StopSend, (int channel));
WEBRTC_STUB(GetVersion, (char version[1024]));
WEBRTC_STUB(LastError, ());
WEBRTC_STUB(AssociateSendChannel, (int channel,
int accociate_send_channel));
// webrtc::VoECodec
WEBRTC_STUB(NumOfCodecs, ());
WEBRTC_STUB(GetCodec, (int index, webrtc::CodecInst& codec));
WEBRTC_STUB(SetSendCodec, (int channel, const webrtc::CodecInst& codec));
WEBRTC_STUB(GetSendCodec, (int channel, webrtc::CodecInst& codec));
WEBRTC_STUB(SetBitRate, (int channel, int bitrate_bps));
WEBRTC_STUB(GetRecCodec, (int channel, webrtc::CodecInst& codec));
WEBRTC_FUNC(SetRecPayloadType, (int channel,
const webrtc::CodecInst& codec)) {
WEBRTC_CHECK_CHANNEL(channel);
Channel* ch = channels_[channel];
// Check if something else already has this slot.
if (codec.pltype != -1) {
for (std::vector<webrtc::CodecInst>::iterator it =
ch->recv_codecs.begin(); it != ch->recv_codecs.end(); ++it) {
if (it->pltype == codec.pltype &&
_stricmp(it->plname, codec.plname) != 0) {
return -1;
}
}
}
// Otherwise try to find this codec and update its payload type.
int result = -1; // not found
for (std::vector<webrtc::CodecInst>::iterator it = ch->recv_codecs.begin();
it != ch->recv_codecs.end(); ++it) {
if (strcmp(it->plname, codec.plname) == 0 &&
it->plfreq == codec.plfreq &&
it->channels == codec.channels) {
it->pltype = codec.pltype;
result = 0;
}
}
return result;
}
WEBRTC_STUB(SetSendCNPayloadType, (int channel, int type,
webrtc::PayloadFrequencies frequency));
WEBRTC_FUNC(GetRecPayloadType, (int channel, webrtc::CodecInst& codec)) {
WEBRTC_CHECK_CHANNEL(channel);
Channel* ch = channels_[channel];
for (std::vector<webrtc::CodecInst>::iterator it = ch->recv_codecs.begin();
it != ch->recv_codecs.end(); ++it) {
if (strcmp(it->plname, codec.plname) == 0 &&
it->plfreq == codec.plfreq &&
it->channels == codec.channels &&
it->pltype != -1) {
codec.pltype = it->pltype;
return 0;
}
}
return -1; // not found
}
WEBRTC_STUB(SetVADStatus, (int channel, bool enable, webrtc::VadModes mode,
bool disableDTX));
WEBRTC_STUB(GetVADStatus, (int channel, bool& enabled,
webrtc::VadModes& mode, bool& disabledDTX));
WEBRTC_STUB(SetFECStatus, (int channel, bool enable));
WEBRTC_STUB(GetFECStatus, (int channel, bool& enable));
WEBRTC_STUB(SetOpusMaxPlaybackRate, (int channel, int frequency_hz));
WEBRTC_STUB(SetOpusDtx, (int channel, bool enable_dtx));
// webrtc::VoEHardware
WEBRTC_STUB(GetNumOfRecordingDevices, (int& num));
WEBRTC_STUB(GetNumOfPlayoutDevices, (int& num));
WEBRTC_STUB(GetRecordingDeviceName, (int i, char* name, char* guid));
WEBRTC_STUB(GetPlayoutDeviceName, (int i, char* name, char* guid));
WEBRTC_STUB(SetRecordingDevice, (int, webrtc::StereoChannel));
WEBRTC_STUB(SetPlayoutDevice, (int));
WEBRTC_STUB(SetAudioDeviceLayer, (webrtc::AudioLayers));
WEBRTC_STUB(GetAudioDeviceLayer, (webrtc::AudioLayers&));
WEBRTC_STUB(SetRecordingSampleRate, (unsigned int samples_per_sec));
WEBRTC_STUB_CONST(RecordingSampleRate, (unsigned int* samples_per_sec));
WEBRTC_STUB(SetPlayoutSampleRate, (unsigned int samples_per_sec));
WEBRTC_STUB_CONST(PlayoutSampleRate, (unsigned int* samples_per_sec));
WEBRTC_STUB(EnableBuiltInAEC, (bool enable));
bool BuiltInAECIsAvailable() const override { return false; }
WEBRTC_STUB(EnableBuiltInAGC, (bool enable));
bool BuiltInAGCIsAvailable() const override { return false; }
WEBRTC_STUB(EnableBuiltInNS, (bool enable));
bool BuiltInNSIsAvailable() const override { return false; }
// webrtc::VoEVolumeControl
WEBRTC_STUB(SetSpeakerVolume, (unsigned int));
WEBRTC_STUB(GetSpeakerVolume, (unsigned int&));
WEBRTC_STUB(SetMicVolume, (unsigned int));
WEBRTC_STUB(GetMicVolume, (unsigned int&));
WEBRTC_STUB(SetInputMute, (int, bool));
WEBRTC_STUB(GetInputMute, (int, bool&));
WEBRTC_STUB(GetSpeechInputLevel, (unsigned int&));
WEBRTC_STUB(GetSpeechOutputLevel, (int, unsigned int&));
WEBRTC_STUB(GetSpeechInputLevelFullRange, (unsigned int&));
WEBRTC_STUB(GetSpeechOutputLevelFullRange, (int, unsigned int&));
WEBRTC_STUB(SetChannelOutputVolumeScaling, (int channel, float scale));
WEBRTC_STUB(GetChannelOutputVolumeScaling, (int channel, float& scale));
WEBRTC_STUB(SetOutputVolumePan, (int channel, float left, float right));
WEBRTC_STUB(GetOutputVolumePan, (int channel, float& left, float& right));
// webrtc::VoEAudioProcessing
WEBRTC_FUNC(SetNsStatus, (bool enable, webrtc::NsModes mode)) {
ns_enabled_ = enable;
ns_mode_ = mode;
return 0;
}
WEBRTC_FUNC(GetNsStatus, (bool& enabled, webrtc::NsModes& mode)) {
enabled = ns_enabled_;
mode = ns_mode_;
return 0;
}
WEBRTC_FUNC(SetAgcStatus, (bool enable, webrtc::AgcModes mode)) {
agc_enabled_ = enable;
agc_mode_ = mode;
return 0;
}
WEBRTC_FUNC(GetAgcStatus, (bool& enabled, webrtc::AgcModes& mode)) {
enabled = agc_enabled_;
mode = agc_mode_;
return 0;
}
WEBRTC_FUNC(SetAgcConfig, (webrtc::AgcConfig config)) {
agc_config_ = config;
return 0;
}
WEBRTC_FUNC(GetAgcConfig, (webrtc::AgcConfig& config)) {
config = agc_config_;
return 0;
}
WEBRTC_FUNC(SetEcStatus, (bool enable, webrtc::EcModes mode)) {
ec_enabled_ = enable;
ec_mode_ = mode;
return 0;
}
WEBRTC_FUNC(GetEcStatus, (bool& enabled, webrtc::EcModes& mode)) {
enabled = ec_enabled_;
mode = ec_mode_;
return 0;
}
WEBRTC_STUB(EnableDriftCompensation, (bool enable))
WEBRTC_BOOL_STUB(DriftCompensationEnabled, ())
WEBRTC_VOID_STUB(SetDelayOffsetMs, (int offset))
WEBRTC_STUB(DelayOffsetMs, ());
WEBRTC_FUNC(SetAecmMode, (webrtc::AecmModes mode, bool enableCNG)) {
aecm_mode_ = mode;
cng_enabled_ = enableCNG;
return 0;
}
WEBRTC_FUNC(GetAecmMode, (webrtc::AecmModes& mode, bool& enabledCNG)) {
mode = aecm_mode_;
enabledCNG = cng_enabled_;
return 0;
}
WEBRTC_STUB(VoiceActivityIndicator, (int channel));
WEBRTC_FUNC(SetEcMetricsStatus, (bool enable)) {
ec_metrics_enabled_ = enable;
return 0;
}
WEBRTC_STUB(GetEcMetricsStatus, (bool& enabled));
WEBRTC_STUB(GetEchoMetrics, (int& ERL, int& ERLE, int& RERL, int& A_NLP));
WEBRTC_STUB(GetEcDelayMetrics, (int& delay_median, int& delay_std,
float& fraction_poor_delays));
WEBRTC_STUB(StartDebugRecording, (const char* fileNameUTF8));
WEBRTC_STUB(StartDebugRecording, (FILE* handle));
WEBRTC_STUB(StopDebugRecording, ());
WEBRTC_FUNC(SetTypingDetectionStatus, (bool enable)) {
typing_detection_enabled_ = enable;
return 0;
}
WEBRTC_FUNC(GetTypingDetectionStatus, (bool& enabled)) {
enabled = typing_detection_enabled_;
return 0;
}
WEBRTC_STUB(TimeSinceLastTyping, (int& seconds));
WEBRTC_STUB(SetTypingDetectionParameters, (int timeWindow,
int costPerTyping,
int reportingThreshold,
int penaltyDecay,
int typeEventDelay));
int EnableHighPassFilter(bool enable) override {
highpass_filter_enabled_ = enable;
return 0;
}
bool IsHighPassFilterEnabled() override {
return highpass_filter_enabled_;
}
bool IsStereoChannelSwappingEnabled() override {
return stereo_swapping_enabled_;
}
void EnableStereoChannelSwapping(bool enable) override {
stereo_swapping_enabled_ = enable;
}
size_t GetNetEqCapacity() const {
auto ch = channels_.find(last_channel_);
ASSERT(ch != channels_.end());
return ch->second->neteq_capacity;
}
bool GetNetEqFastAccelerate() const {
auto ch = channels_.find(last_channel_);
ASSERT(ch != channels_.end());
return ch->second->neteq_fast_accelerate;
}
private:
bool inited_ = false;
int last_channel_ = -1;
std::map<int, Channel*> channels_;
bool fail_create_channel_ = false;
bool ec_enabled_ = false;
bool ec_metrics_enabled_ = false;
bool cng_enabled_ = false;
bool ns_enabled_ = false;
bool agc_enabled_ = false;
bool highpass_filter_enabled_ = false;
bool stereo_swapping_enabled_ = false;
bool typing_detection_enabled_ = false;
webrtc::EcModes ec_mode_ = webrtc::kEcDefault;
webrtc::AecmModes aecm_mode_ = webrtc::kAecmSpeakerphone;
webrtc::NsModes ns_mode_ = webrtc::kNsDefault;
webrtc::AgcModes agc_mode_ = webrtc::kAgcDefault;
webrtc::AgcConfig agc_config_;
webrtc::AudioProcessing* apm_ = nullptr;
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(FakeWebRtcVoiceEngine);
};
} // namespace cricket
#endif // WEBRTC_MEDIA_ENGINE_FAKEWEBRTCVOICEENGINE_H_
Reference in New Issue View Git Blame Copy Permalink