jamosdev
/
rhubarb-lip-sync
mirror of https://github.com/DanielSWolf/rhubarb-lip-sync.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
rhubarb-lip-sync/lib/webrtc-8d2248ff/webrtc/media/engine/fakewebrtcvoiceengine.h

594 lines
21 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/gunit.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/fakewebrtccommon.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;
class FakeAudioProcessing : public webrtc::AudioProcessing {
public:
FakeAudioProcessing() : experimental_ns_enabled_(false) {}
WEBRTC_STUB(Initialize, ())
WEBRTC_STUB(Initialize, (
int input_sample_rate_hz,
int output_sample_rate_hz,
int reverse_sample_rate_hz,
webrtc::AudioProcessing::ChannelLayout input_layout,
webrtc::AudioProcessing::ChannelLayout output_layout,
webrtc::AudioProcessing::ChannelLayout reverse_layout));
WEBRTC_STUB(Initialize, (
const webrtc::ProcessingConfig& processing_config));
WEBRTC_VOID_FUNC(SetExtraOptions, (const webrtc::Config& config)) {
experimental_ns_enabled_ = config.Get<webrtc::ExperimentalNs>().enabled;
}
WEBRTC_STUB_CONST(proc_sample_rate_hz, ());
WEBRTC_STUB_CONST(proc_split_sample_rate_hz, ());
size_t num_input_channels() const override { return 0; }
size_t num_proc_channels() const override { return 0; }
size_t num_output_channels() const override { return 0; }
size_t num_reverse_channels() const override { return 0; }
WEBRTC_VOID_STUB(set_output_will_be_muted, (bool muted));
WEBRTC_STUB(ProcessStream, (webrtc::AudioFrame* frame));
WEBRTC_STUB(ProcessStream, (
const float* const* src,
size_t samples_per_channel,
int input_sample_rate_hz,
webrtc::AudioProcessing::ChannelLayout input_layout,
int output_sample_rate_hz,
webrtc::AudioProcessing::ChannelLayout output_layout,
float* const* dest));
WEBRTC_STUB(ProcessStream,
(const float* const* src,
const webrtc::StreamConfig& input_config,
const webrtc::StreamConfig& output_config,
float* const* dest));
WEBRTC_STUB(ProcessReverseStream, (webrtc::AudioFrame * frame));
WEBRTC_STUB(AnalyzeReverseStream, (
const float* const* data,
size_t samples_per_channel,
int sample_rate_hz,
webrtc::AudioProcessing::ChannelLayout layout));
WEBRTC_STUB(ProcessReverseStream,
(const float* const* src,
const webrtc::StreamConfig& reverse_input_config,
const webrtc::StreamConfig& reverse_output_config,
float* const* dest));
WEBRTC_STUB(set_stream_delay_ms, (int delay));
WEBRTC_STUB_CONST(stream_delay_ms, ());
WEBRTC_BOOL_STUB_CONST(was_stream_delay_set, ());
WEBRTC_VOID_STUB(set_stream_key_pressed, (bool key_pressed));
WEBRTC_VOID_STUB(set_delay_offset_ms, (int offset));
WEBRTC_STUB_CONST(delay_offset_ms, ());
WEBRTC_STUB(StartDebugRecording,
(const char filename[kMaxFilenameSize], int64_t max_size_bytes));
WEBRTC_STUB(StartDebugRecording, (FILE * handle, int64_t max_size_bytes));
WEBRTC_STUB(StopDebugRecording, ());
WEBRTC_VOID_STUB(UpdateHistogramsOnCallEnd, ());
webrtc::EchoCancellation* echo_cancellation() const override { return NULL; }
webrtc::EchoControlMobile* echo_control_mobile() const override {
return NULL;
}
webrtc::GainControl* gain_control() const override { return NULL; }
webrtc::HighPassFilter* high_pass_filter() const override { return NULL; }
webrtc::LevelEstimator* level_estimator() const override { return NULL; }
webrtc::NoiseSuppression* noise_suppression() const override { return NULL; }
webrtc::VoiceDetection* voice_detection() const override { return NULL; }
bool experimental_ns_enabled() {
return experimental_ns_enabled_;
}
private:
bool experimental_ns_enabled_;
};
class FakeWebRtcVoiceEngine
: public webrtc::VoEAudioProcessing,
public webrtc::VoEBase, public webrtc::VoECodec,
public webrtc::VoEHardware,
public webrtc::VoEVolumeControl {
public:
struct Channel {
Channel() {
memset(&send_codec, 0, sizeof(send_codec));
}
bool playout = false;
bool vad = false;
bool codec_fec = false;
int max_encoding_bandwidth = 0;
bool opus_dtx = false;
int cn8_type = 13;
int cn16_type = 105;
int associate_send_channel = -1;
std::vector<webrtc::CodecInst> recv_codecs;
webrtc::CodecInst send_codec;
int neteq_capacity = -1;
bool neteq_fast_accelerate = false;
};
FakeWebRtcVoiceEngine() {
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()); }
bool GetPlayout(int channel) {
return channels_[channel]->playout;
}
bool GetVAD(int channel) {
return channels_[channel]->vad;
}
bool GetOpusDtx(int channel) {
return channels_[channel]->opus_dtx;
}
bool GetCodecFEC(int channel) {
return channels_[channel]->codec_fec;
}
int GetMaxEncodingBandwidth(int channel) {
return channels_[channel]->max_encoding_bandwidth;
}
int GetSendCNPayloadType(int channel, bool wideband) {
return (wideband) ?
channels_[channel]->cn16_type :
channels_[channel]->cn8_type;
}
void set_playout_fail_channel(int channel) {
playout_fail_channel_ = channel;
}
void set_fail_create_channel(bool fail_create_channel) {
fail_create_channel_ = fail_create_channel;
}
int AddChannel(const webrtc::Config& 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());
if (config.Get<webrtc::NetEqCapacityConfig>().enabled) {
ch->neteq_capacity = config.Get<webrtc::NetEqCapacityConfig>().capacity;
}
ch->neteq_fast_accelerate =
config.Get<webrtc::NetEqFastAccelerate>().enabled;
channels_[++last_channel_] = ch;
return last_channel_;
}
int GetNumSetSendCodecs() const { return num_set_send_codecs_; }
int GetAssociateSendChannel(int channel) {
return channels_[channel]->associate_send_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 &audio_processing_;
}
webrtc::AudioDeviceModule* audio_device_module() override {
return nullptr;
}
WEBRTC_FUNC(CreateChannel, ()) {
webrtc::Config empty_config;
return AddChannel(empty_config);
}
WEBRTC_FUNC(CreateChannel, (const webrtc::Config& config)) {
return AddChannel(config);
}
WEBRTC_FUNC(DeleteChannel, (int channel)) {
WEBRTC_CHECK_CHANNEL(channel);
for (const auto& ch : channels_) {
if (ch.second->associate_send_channel == channel) {
ch.second->associate_send_channel = -1;
}
}
delete channels_[channel];
channels_.erase(channel);
return 0;
}
WEBRTC_STUB(StartReceive, (int channel));
WEBRTC_FUNC(StartPlayout, (int channel)) {
if (playout_fail_channel_ != channel) {
WEBRTC_CHECK_CHANNEL(channel);
channels_[channel]->playout = true;
return 0;
} else {
// When playout_fail_channel_ == channel, fail the StartPlayout on this
// channel.
return -1;
}
}
WEBRTC_STUB(StartSend, (int channel));
WEBRTC_STUB(StopReceive, (int channel));
WEBRTC_FUNC(StopPlayout, (int channel)) {
WEBRTC_CHECK_CHANNEL(channel);
channels_[channel]->playout = false;
return 0;
}
WEBRTC_STUB(StopSend, (int channel));
WEBRTC_STUB(GetVersion, (char version[1024]));
WEBRTC_STUB(LastError, ());
WEBRTC_FUNC(AssociateSendChannel, (int channel,
int accociate_send_channel)) {
WEBRTC_CHECK_CHANNEL(channel);
channels_[channel]->associate_send_channel = accociate_send_channel;
return 0;
}
webrtc::RtcEventLog* GetEventLog() override { return nullptr; }
// webrtc::VoECodec
WEBRTC_STUB(NumOfCodecs, ());
WEBRTC_STUB(GetCodec, (int index, webrtc::CodecInst& codec));
WEBRTC_FUNC(SetSendCodec, (int channel, const webrtc::CodecInst& codec)) {
WEBRTC_CHECK_CHANNEL(channel);
// To match the behavior of the real implementation.
if (_stricmp(codec.plname, "telephone-event") == 0 ||
_stricmp(codec.plname, "audio/telephone-event") == 0 ||
_stricmp(codec.plname, "CN") == 0 ||
_stricmp(codec.plname, "red") == 0) {
return -1;
}
channels_[channel]->send_codec = codec;
++num_set_send_codecs_;
return 0;
}
WEBRTC_FUNC(GetSendCodec, (int channel, webrtc::CodecInst& codec)) {
WEBRTC_CHECK_CHANNEL(channel);
codec = channels_[channel]->send_codec;
return 0;
}
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];
if (ch->playout)
return -1; // Channel is in use.
// 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_FUNC(SetSendCNPayloadType, (int channel, int type,
webrtc::PayloadFrequencies frequency)) {
WEBRTC_CHECK_CHANNEL(channel);
if (frequency == webrtc::kFreq8000Hz) {
channels_[channel]->cn8_type = type;
} else if (frequency == webrtc::kFreq16000Hz) {
channels_[channel]->cn16_type = type;
}
return 0;
}
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_FUNC(SetVADStatus, (int channel, bool enable, webrtc::VadModes mode,
bool disableDTX)) {
WEBRTC_CHECK_CHANNEL(channel);
if (channels_[channel]->send_codec.channels == 2) {
// Replicating VoE behavior; VAD cannot be enabled for stereo.
return -1;
}
channels_[channel]->vad = enable;
return 0;
}
WEBRTC_STUB(GetVADStatus, (int channel, bool& enabled,
webrtc::VadModes& mode, bool& disabledDTX));
WEBRTC_FUNC(SetFECStatus, (int channel, bool enable)) {
WEBRTC_CHECK_CHANNEL(channel);
if (_stricmp(channels_[channel]->send_codec.plname, "opus") != 0) {
// Return -1 if current send codec is not Opus.
// TODO(minyue): Excludes other codecs if they support inband FEC.
return -1;
}
channels_[channel]->codec_fec = enable;
return 0;
}
WEBRTC_FUNC(GetFECStatus, (int channel, bool& enable)) {
WEBRTC_CHECK_CHANNEL(channel);
enable = channels_[channel]->codec_fec;
return 0;
}
WEBRTC_FUNC(SetOpusMaxPlaybackRate, (int channel, int frequency_hz)) {
WEBRTC_CHECK_CHANNEL(channel);
if (_stricmp(channels_[channel]->send_codec.plname, "opus") != 0) {
// Return -1 if current send codec is not Opus.
return -1;
}
if (frequency_hz <= 8000)
channels_[channel]->max_encoding_bandwidth = kOpusBandwidthNb;
else if (frequency_hz <= 12000)
channels_[channel]->max_encoding_bandwidth = kOpusBandwidthMb;
else if (frequency_hz <= 16000)
channels_[channel]->max_encoding_bandwidth = kOpusBandwidthWb;
else if (frequency_hz <= 24000)
channels_[channel]->max_encoding_bandwidth = kOpusBandwidthSwb;
else
channels_[channel]->max_encoding_bandwidth = kOpusBandwidthFb;
return 0;
}
WEBRTC_FUNC(SetOpusDtx, (int channel, bool enable_dtx)) {
WEBRTC_CHECK_CHANNEL(channel);
if (_stricmp(channels_[channel]->send_codec.plname, "opus") != 0) {
// Return -1 if current send codec is not Opus.
return -1;
}
channels_[channel]->opus_dtx = enable_dtx;
return 0;
}
// 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(SetRxNsStatus, (int channel, bool enable, webrtc::NsModes mode));
WEBRTC_STUB(GetRxNsStatus, (int channel, bool& enabled,
webrtc::NsModes& mode));
WEBRTC_STUB(SetRxAgcStatus, (int channel, bool enable,
webrtc::AgcModes mode));
WEBRTC_STUB(GetRxAgcStatus, (int channel, bool& enabled,
webrtc::AgcModes& mode));
WEBRTC_STUB(SetRxAgcConfig, (int channel, webrtc::AgcConfig config));
WEBRTC_STUB(GetRxAgcConfig, (int channel, webrtc::AgcConfig& config));
WEBRTC_STUB(RegisterRxVadObserver, (int, webrtc::VoERxVadCallback&));
WEBRTC_STUB(DeRegisterRxVadObserver, (int channel));
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;
}
int 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;
int num_set_send_codecs_ = 0; // how many times we call SetSendCodec().
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_;
int playout_fail_channel_ = -1;
FakeAudioProcessing audio_processing_;
};
} // namespace cricket
#endif // WEBRTC_MEDIA_ENGINE_FAKEWEBRTCVOICEENGINE_H_
Reference in New Issue View Git Blame Copy Permalink