zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Replace FakeAudioProcessing in WVoE unittest with MockAudioProcessing.

Browse Source 
- Update MockAudioProcessing to current APM interface.
- Replace calls to VoEAudioProcessing::Start/StopAecDump with direct calls on APM.
- Add AudioProcessing* in WVoE, get it from VoE, so we can call directly on APM.

BUG=webrtc:4690

Review-Url: https://codereview.webrtc.org/2446143002
Cr-Commit-Position: refs/heads/master@{#14786}
This commit is contained in:
solenberg
2016-10-26 05:12:24 -07:00
committed by Commit bot
parent 16b6d6dc5b
commit 059fb4480b
6 changed files with 358 additions and 491 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
webrtc/media/engine/fakewebrtcvoiceengine.h
View File

@ -45,99 +45,11 @@ static const int kOpusBandwidthFb = 20000;
#define WEBRTC_BOOL_STUB(method, args) \
bool method args override { return true; }
#define WEBRTC_BOOL_STUB_CONST(method, args) \
bool method args const override { return true; }
#define WEBRTC_VOID_STUB(method, args) \
void method args override {}
#define WEBRTC_FUNC(method, args) int method args override
#define WEBRTC_VOID_FUNC(method, args) void method args override
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_STUB(ApplyConfig, (const AudioProcessing::Config& 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(StartDebugRecording, (FILE * handle));
WEBRTC_STUB(StartDebugRecordingForPlatformFile, (rtc::PlatformFile handle));
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,
@ -151,7 +63,7 @@ class FakeWebRtcVoiceEngine
bool neteq_fast_accelerate = false;
};
FakeWebRtcVoiceEngine() {
explicit FakeWebRtcVoiceEngine(webrtc::AudioProcessing* apm) : apm_(apm) {
memset(&agc_config_, 0, sizeof(agc_config_));
}
~FakeWebRtcVoiceEngine() override {
@ -190,7 +102,7 @@ class FakeWebRtcVoiceEngine
return 0;
}
webrtc::AudioProcessing* audio_processing() override {
return &audio_processing_;
return apm_;
}
webrtc::AudioDeviceModule* audio_device_module() override {
return nullptr;
@ -344,7 +256,6 @@ class FakeWebRtcVoiceEngine
mode = ns_mode_;
return 0;
}
WEBRTC_FUNC(SetAgcStatus, (bool enable, webrtc::AgcModes mode)) {
agc_enabled_ = enable;
agc_mode_ = mode;
@ -355,7 +266,6 @@ class FakeWebRtcVoiceEngine
mode = agc_mode_;
return 0;
}
WEBRTC_FUNC(SetAgcConfig, (webrtc::AgcConfig config)) {
agc_config_ = config;
return 0;
@ -397,11 +307,9 @@ class FakeWebRtcVoiceEngine
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;
@ -410,7 +318,6 @@ class FakeWebRtcVoiceEngine
enabled = typing_detection_enabled_;
return 0;
}
WEBRTC_STUB(TimeSinceLastTyping, (int& seconds));
WEBRTC_STUB(SetTypingDetectionParameters, (int timeWindow,
int costPerTyping,
@ -459,7 +366,9 @@ class FakeWebRtcVoiceEngine
webrtc::NsModes ns_mode_ = webrtc::kNsDefault;
webrtc::AgcModes agc_mode_ = webrtc::kAgcDefault;
webrtc::AgcConfig agc_config_;
FakeAudioProcessing audio_processing_;
webrtc::AudioProcessing* apm_ = nullptr;
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(FakeWebRtcVoiceEngine);
};
} // namespace cricket

39
webrtc/media/engine/webrtcvoiceengine.cc
View File

@ -553,6 +553,9 @@ WebRtcVoiceEngine::WebRtcVoiceEngine(
}
RTC_DCHECK(adm_);
apm_ = voe_wrapper_->base()->audio_processing();
RTC_DCHECK(apm_);
// Save the default AGC configuration settings. This must happen before
// calling ApplyOptions or the default will be overwritten.
int error = voe_wrapper_->processing()->GetAgcConfig(default_agc_config_);
@ -877,13 +880,8 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
}
}
// We check audioproc for the benefit of tests, since FakeWebRtcVoiceEngine
// returns NULL on audio_processing().
webrtc::AudioProcessing* audioproc = voe_wrapper_->base()->audio_processing();
if (audioproc) {
audioproc->SetExtraOptions(config);
audioproc->ApplyConfig(apm_config);
}
apm()->SetExtraOptions(config);
apm()->ApplyConfig(apm_config);
if (options.recording_sample_rate) {
LOG(LS_INFO) << "Recording sample rate is "
@ -916,10 +914,8 @@ void WebRtcVoiceEngine::SetDefaultDevices() {
LOG_RTCERR1(SetRecordingDevice, in_id);
ret = false;
}
webrtc::AudioProcessing* ap = voe()->base()->audio_processing();
if (ap) {
ap->Initialize();
}
apm()->Initialize();
if (voe_wrapper_->hw()->SetPlayoutDevice(out_id) == -1) {
LOG_RTCERR1(SetPlayoutDevice, out_id);
@ -1040,8 +1036,7 @@ bool WebRtcVoiceEngine::StartAecDump(rtc::PlatformFile file,
return false;
}
StopAecDump();
if (voe_wrapper_->base()->audio_processing()->StartDebugRecording(
aec_dump_file_stream, max_size_bytes) !=
if (apm()->StartDebugRecording(aec_dump_file_stream, max_size_bytes) !=
webrtc::AudioProcessing::kNoError) {
LOG_RTCERR0(StartDebugRecording);
fclose(aec_dump_file_stream);
@ -1055,8 +1050,8 @@ void WebRtcVoiceEngine::StartAecDump(const std::string& filename) {
RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
if (!is_dumping_aec_) {
// Start dumping AEC when we are not dumping.
if (voe_wrapper_->base()->audio_processing()->StartDebugRecording(
filename.c_str(), -1) != webrtc::AudioProcessing::kNoError) {
if (apm()->StartDebugRecording(filename.c_str(), -1) !=
webrtc::AudioProcessing::kNoError) {
LOG_RTCERR1(StartDebugRecording, filename.c_str());
} else {
is_dumping_aec_ = true;
@ -1068,8 +1063,7 @@ void WebRtcVoiceEngine::StopAecDump() {
RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
if (is_dumping_aec_) {
// Stop dumping AEC when we are dumping.
if (voe_wrapper_->base()->audio_processing()->StopDebugRecording() !=
webrtc::AudioProcessing::kNoError) {
if (apm()->StopDebugRecording() != webrtc::AudioProcessing::kNoError) {
LOG_RTCERR0(StopDebugRecording);
}
is_dumping_aec_ = false;
@ -1087,6 +1081,12 @@ webrtc::AudioDeviceModule* WebRtcVoiceEngine::adm() {
return adm_;
}
webrtc::AudioProcessing* WebRtcVoiceEngine::apm() {
RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
RTC_DCHECK(apm_);
return apm_;
}
AudioCodecs WebRtcVoiceEngine::CollectRecvCodecs() const {
PayloadTypeMapper mapper;
AudioCodecs out;
@ -2378,11 +2378,8 @@ bool WebRtcVoiceMediaChannel::MuteStream(uint32_t ssrc, bool muted) {
for (const auto& kv : send_streams_) {
all_muted = all_muted && kv.second->muted();
}
engine()->apm()->set_output_will_be_muted(all_muted);
webrtc::AudioProcessing* ap = engine()->voe()->base()->audio_processing();
if (ap) {
ap->set_output_will_be_muted(all_muted);
}
return true;
}

3
webrtc/media/engine/webrtcvoiceengine.h
View File

@ -101,6 +101,7 @@ class WebRtcVoiceEngine final : public webrtc::TraceCallback {
void StartAecDump(const std::string& filename);
int CreateVoEChannel();
webrtc::AudioDeviceModule* adm();
webrtc::AudioProcessing* apm();
AudioCodecs CollectRecvCodecs() const;
@ -110,6 +111,8 @@ class WebRtcVoiceEngine final : public webrtc::TraceCallback {
// The audio device manager.
rtc::scoped_refptr<webrtc::AudioDeviceModule> adm_;
rtc::scoped_refptr<webrtc::AudioDecoderFactory> decoder_factory_;
// Reference to the APM, owned by VoE.
webrtc::AudioProcessing* apm_ = nullptr;
// The primary instance of WebRtc VoiceEngine.
std::unique_ptr<VoEWrapper> voe_wrapper_;
rtc::scoped_refptr<webrtc::AudioState> audio_state_;

368
webrtc/media/engine/webrtcvoiceengine_unittest.cc
View File

File diff suppressed because it is too large Load Diff

2
webrtc/modules/audio_processing/agc/agc_manager_direct_unittest.cc
View File

@ -92,7 +92,7 @@ class AgcManagerDirectTest : public ::testing::Test {
}
MockAgc* agc_;
MockGainControl gctrl_;
test::MockGainControl gctrl_;
TestVolumeCallbacks volume_;
AgcManagerDirect manager_;
test::TraceToStderr trace_to_stderr;

294
webrtc/modules/audio_processing/include/mock_audio_processing.h
View File

@ -14,257 +14,174 @@
#include <memory>
#include "webrtc/modules/audio_processing/include/audio_processing.h"
#include "webrtc/test/gmock.h"
namespace webrtc {
namespace test {
class MockEchoCancellation : public EchoCancellation {
public:
MOCK_METHOD1(Enable,
int(bool enable));
MOCK_CONST_METHOD0(is_enabled,
bool());
MOCK_METHOD1(enable_drift_compensation,
int(bool enable));
MOCK_CONST_METHOD0(is_drift_compensation_enabled,
bool());
MOCK_METHOD1(set_stream_drift_samples,
void(int drift));
MOCK_CONST_METHOD0(stream_drift_samples,
int());
MOCK_METHOD1(set_suppression_level,
int(SuppressionLevel level));
MOCK_CONST_METHOD0(suppression_level,
SuppressionLevel());
MOCK_CONST_METHOD0(stream_has_echo,
bool());
MOCK_METHOD1(enable_metrics,
int(bool enable));
MOCK_CONST_METHOD0(are_metrics_enabled,
bool());
MOCK_METHOD1(GetMetrics,
int(Metrics* metrics));
MOCK_METHOD1(enable_delay_logging,
int(bool enable));
MOCK_CONST_METHOD0(is_delay_logging_enabled,
bool());
MOCK_METHOD2(GetDelayMetrics,
int(int* median, int* std));
MOCK_METHOD3(GetDelayMetrics,
int(int* median, int* std, float* fraction_poor_delays));
MOCK_CONST_METHOD0(aec_core,
struct AecCore*());
virtual ~MockEchoCancellation() {}
MOCK_METHOD1(Enable, int(bool enable));
MOCK_CONST_METHOD0(is_enabled, bool());
MOCK_METHOD1(enable_drift_compensation, int(bool enable));
MOCK_CONST_METHOD0(is_drift_compensation_enabled, bool());
MOCK_METHOD1(set_stream_drift_samples, void(int drift));
MOCK_CONST_METHOD0(stream_drift_samples, int());
MOCK_METHOD1(set_suppression_level, int(SuppressionLevel level));
MOCK_CONST_METHOD0(suppression_level, SuppressionLevel());
MOCK_CONST_METHOD0(stream_has_echo, bool());
MOCK_METHOD1(enable_metrics, int(bool enable));
MOCK_CONST_METHOD0(are_metrics_enabled, bool());
MOCK_METHOD1(GetMetrics, int(Metrics* metrics));
MOCK_METHOD1(enable_delay_logging, int(bool enable));
MOCK_CONST_METHOD0(is_delay_logging_enabled, bool());
MOCK_METHOD2(GetDelayMetrics, int(int* median, int* std));
MOCK_METHOD3(GetDelayMetrics, int(int* median, int* std,
float* fraction_poor_delays));
MOCK_CONST_METHOD0(aec_core, struct AecCore*());
};
class MockEchoControlMobile : public EchoControlMobile {
public:
MOCK_METHOD1(Enable,
int(bool enable));
MOCK_CONST_METHOD0(is_enabled,
bool());
MOCK_METHOD1(set_routing_mode,
int(RoutingMode mode));
MOCK_CONST_METHOD0(routing_mode,
RoutingMode());
MOCK_METHOD1(enable_comfort_noise,
int(bool enable));
MOCK_CONST_METHOD0(is_comfort_noise_enabled,
bool());
MOCK_METHOD2(SetEchoPath,
int(const void* echo_path, size_t size_bytes));
MOCK_CONST_METHOD2(GetEchoPath,
int(void* echo_path, size_t size_bytes));
virtual ~MockEchoControlMobile() {}
MOCK_METHOD1(Enable, int(bool enable));
MOCK_CONST_METHOD0(is_enabled, bool());
MOCK_METHOD1(set_routing_mode, int(RoutingMode mode));
MOCK_CONST_METHOD0(routing_mode, RoutingMode());
MOCK_METHOD1(enable_comfort_noise, int(bool enable));
MOCK_CONST_METHOD0(is_comfort_noise_enabled, bool());
MOCK_METHOD2(SetEchoPath, int(const void* echo_path, size_t size_bytes));
MOCK_CONST_METHOD2(GetEchoPath, int(void* echo_path, size_t size_bytes));
};
class MockGainControl : public GainControl {
public:
MOCK_METHOD1(Enable,
int(bool enable));
MOCK_CONST_METHOD0(is_enabled,
bool());
MOCK_METHOD1(set_stream_analog_level,
int(int level));
MOCK_METHOD0(stream_analog_level,
int());
MOCK_METHOD1(set_mode,
int(Mode mode));
MOCK_CONST_METHOD0(mode,
Mode());
MOCK_METHOD1(set_target_level_dbfs,
int(int level));
MOCK_CONST_METHOD0(target_level_dbfs,
int());
MOCK_METHOD1(set_compression_gain_db,
int(int gain));
MOCK_CONST_METHOD0(compression_gain_db,
int());
MOCK_METHOD1(enable_limiter,
int(bool enable));
MOCK_CONST_METHOD0(is_limiter_enabled,
bool());
MOCK_METHOD2(set_analog_level_limits,
int(int minimum, int maximum));
MOCK_CONST_METHOD0(analog_level_minimum,
int());
MOCK_CONST_METHOD0(analog_level_maximum,
int());
MOCK_CONST_METHOD0(stream_is_saturated,
bool());
virtual ~MockGainControl() {}
MOCK_METHOD1(Enable, int(bool enable));
MOCK_CONST_METHOD0(is_enabled, bool());
MOCK_METHOD1(set_stream_analog_level, int(int level));
MOCK_METHOD0(stream_analog_level, int());
MOCK_METHOD1(set_mode, int(Mode mode));
MOCK_CONST_METHOD0(mode, Mode());
MOCK_METHOD1(set_target_level_dbfs, int(int level));
MOCK_CONST_METHOD0(target_level_dbfs, int());
MOCK_METHOD1(set_compression_gain_db, int(int gain));
MOCK_CONST_METHOD0(compression_gain_db, int());
MOCK_METHOD1(enable_limiter, int(bool enable));
MOCK_CONST_METHOD0(is_limiter_enabled, bool());
MOCK_METHOD2(set_analog_level_limits, int(int minimum, int maximum));
MOCK_CONST_METHOD0(analog_level_minimum, int());
MOCK_CONST_METHOD0(analog_level_maximum, int());
MOCK_CONST_METHOD0(stream_is_saturated, bool());
};
class MockHighPassFilter : public HighPassFilter {
public:
MOCK_METHOD1(Enable,
int(bool enable));
MOCK_CONST_METHOD0(is_enabled,
bool());
virtual ~MockHighPassFilter() {}
MOCK_METHOD1(Enable, int(bool enable));
MOCK_CONST_METHOD0(is_enabled, bool());
};
class MockLevelEstimator : public LevelEstimator {
public:
MOCK_METHOD1(Enable,
int(bool enable));
MOCK_CONST_METHOD0(is_enabled,
bool());
MOCK_METHOD0(RMS,
int());
virtual ~MockLevelEstimator() {}
MOCK_METHOD1(Enable, int(bool enable));
MOCK_CONST_METHOD0(is_enabled, bool());
MOCK_METHOD0(RMS, int());
};
class MockNoiseSuppression : public NoiseSuppression {
public:
MOCK_METHOD1(Enable,
int(bool enable));
MOCK_CONST_METHOD0(is_enabled,
bool());
MOCK_METHOD1(set_level,
int(Level level));
MOCK_CONST_METHOD0(level,
Level());
MOCK_CONST_METHOD0(speech_probability,
float());
virtual ~MockNoiseSuppression() {}
MOCK_METHOD1(Enable, int(bool enable));
MOCK_CONST_METHOD0(is_enabled, bool());
MOCK_METHOD1(set_level, int(Level level));
MOCK_CONST_METHOD0(level, Level());
MOCK_CONST_METHOD0(speech_probability, float());
MOCK_METHOD0(NoiseEstimate, std::vector<float>());
};
class MockVoiceDetection : public VoiceDetection {
public:
MOCK_METHOD1(Enable,
int(bool enable));
MOCK_CONST_METHOD0(is_enabled,
bool());
MOCK_CONST_METHOD0(stream_has_voice,
bool());
MOCK_METHOD1(set_stream_has_voice,
int(bool has_voice));
MOCK_METHOD1(set_likelihood,
int(Likelihood likelihood));
MOCK_CONST_METHOD0(likelihood,
Likelihood());
MOCK_METHOD1(set_frame_size_ms,
int(int size));
MOCK_CONST_METHOD0(frame_size_ms,
int());
virtual ~MockVoiceDetection() {}
MOCK_METHOD1(Enable, int(bool enable));
MOCK_CONST_METHOD0(is_enabled, bool());
MOCK_CONST_METHOD0(stream_has_voice, bool());
MOCK_METHOD1(set_stream_has_voice, int(bool has_voice));
MOCK_METHOD1(set_likelihood, int(Likelihood likelihood));
MOCK_CONST_METHOD0(likelihood, Likelihood());
MOCK_METHOD1(set_frame_size_ms, int(int size));
MOCK_CONST_METHOD0(frame_size_ms, int());
};
class MockAudioProcessing : public AudioProcessing {
public:
MockAudioProcessing()
: echo_cancellation_(new MockEchoCancellation),
echo_control_mobile_(new MockEchoControlMobile),
gain_control_(new MockGainControl),
high_pass_filter_(new MockHighPassFilter),
level_estimator_(new MockLevelEstimator),
noise_suppression_(new MockNoiseSuppression),
voice_detection_(new MockVoiceDetection) {
: echo_cancellation_(new testing::NiceMock<MockEchoCancellation>()),
echo_control_mobile_(new testing::NiceMock<MockEchoControlMobile>()),
gain_control_(new testing::NiceMock<MockGainControl>()),
high_pass_filter_(new testing::NiceMock<MockHighPassFilter>()),
level_estimator_(new testing::NiceMock<MockLevelEstimator>()),
noise_suppression_(new testing::NiceMock<MockNoiseSuppression>()),
voice_detection_(new testing::NiceMock<MockVoiceDetection>()) {
}
virtual ~MockAudioProcessing() {
}
virtual ~MockAudioProcessing() {}
MOCK_METHOD0(Initialize,
int());
MOCK_METHOD6(Initialize,
int(int capture_input_sample_rate_hz,
MOCK_METHOD0(Initialize, int());
MOCK_METHOD6(Initialize, int(int capture_input_sample_rate_hz,
int capture_output_sample_rate_hz,
int render_sample_rate_hz,
ChannelLayout capture_input_layout,
ChannelLayout capture_output_layout,
ChannelLayout render_input_layout));
MOCK_METHOD1(Initialize,
int(const ProcessingConfig& processing_config));
MOCK_METHOD1(Initialize, int(const ProcessingConfig& processing_config));
MOCK_METHOD1(ApplyConfig, void(const Config& config));
MOCK_METHOD1(SetExtraOptions, void(const webrtc::Config& config));
MOCK_METHOD1(set_sample_rate_hz,
int(int rate));
MOCK_CONST_METHOD0(input_sample_rate_hz,
int());
MOCK_CONST_METHOD0(sample_rate_hz,
int());
MOCK_CONST_METHOD0(proc_sample_rate_hz,
int());
MOCK_CONST_METHOD0(proc_split_sample_rate_hz,
int());
MOCK_CONST_METHOD0(num_input_channels,
size_t());
MOCK_CONST_METHOD0(num_output_channels,
size_t());
MOCK_CONST_METHOD0(num_reverse_channels,
size_t());
MOCK_METHOD1(set_output_will_be_muted,
void(bool muted));
MOCK_CONST_METHOD0(output_will_be_muted,
bool());
MOCK_METHOD1(ProcessStream,
int(AudioFrame* frame));
MOCK_METHOD7(ProcessStream,
int(const float* const* src,
MOCK_CONST_METHOD0(proc_sample_rate_hz, int());
MOCK_CONST_METHOD0(proc_split_sample_rate_hz, int());
MOCK_CONST_METHOD0(num_input_channels, size_t());
MOCK_CONST_METHOD0(num_proc_channels, size_t());
MOCK_CONST_METHOD0(num_output_channels, size_t());
MOCK_CONST_METHOD0(num_reverse_channels, size_t());
MOCK_METHOD1(set_output_will_be_muted, void(bool muted));
MOCK_METHOD1(ProcessStream, int(AudioFrame* frame));
MOCK_METHOD7(ProcessStream, int(const float* const* src,
size_t samples_per_channel,
int input_sample_rate_hz,
ChannelLayout input_layout,
int output_sample_rate_hz,
ChannelLayout output_layout,
float* const* dest));
MOCK_METHOD4(ProcessStream,
int(const float* const* src,
MOCK_METHOD4(ProcessStream, int(const float* const* src,
const StreamConfig& input_config,
const StreamConfig& output_config,
float* const* dest));
MOCK_METHOD1(AnalyzeReverseStream,
int(AudioFrame* frame));
MOCK_METHOD1(ProcessReverseStream, int(AudioFrame* frame));
MOCK_METHOD4(AnalyzeReverseStream,
int(const float* const* data,
MOCK_METHOD4(AnalyzeReverseStream, int(const float* const* data,
size_t samples_per_channel,
int sample_rate_hz,
ChannelLayout layout));
MOCK_METHOD4(ProcessReverseStream,
int(const float* const* src,
MOCK_METHOD4(ProcessReverseStream, int(const float* const* src,
const StreamConfig& input_config,
const StreamConfig& output_config,
float* const* dest));
MOCK_METHOD1(set_stream_delay_ms,
int(int delay));
MOCK_CONST_METHOD0(stream_delay_ms,
int());
MOCK_CONST_METHOD0(was_stream_delay_set,
bool());
MOCK_METHOD1(set_stream_key_pressed,
void(bool key_pressed));
MOCK_CONST_METHOD0(stream_key_pressed,
bool());
MOCK_METHOD1(set_delay_offset_ms,
void(int offset));
MOCK_CONST_METHOD0(delay_offset_ms,
int());
MOCK_METHOD2(StartDebugRecording,
int(const char filename[kMaxFilenameSize],
MOCK_METHOD1(set_stream_delay_ms, int(int delay));
MOCK_CONST_METHOD0(stream_delay_ms, int());
MOCK_CONST_METHOD0(was_stream_delay_set, bool());
MOCK_METHOD1(set_stream_key_pressed, void(bool key_pressed));
MOCK_METHOD1(set_delay_offset_ms, void(int offset));
MOCK_CONST_METHOD0(delay_offset_ms, int());
MOCK_METHOD2(StartDebugRecording, int(const char filename[kMaxFilenameSize],
int64_t max_log_size_bytes));
MOCK_METHOD2(StartDebugRecording,
int(FILE* handle, int64_t max_log_size_bytes));
MOCK_METHOD1(StartDebugRecording,
int (FILE* handle));
MOCK_METHOD1(StartDebugRecording,
MOCK_METHOD2(StartDebugRecording, int(FILE* handle,
int64_t max_log_size_bytes));
MOCK_METHOD1(StartDebugRecording, int (FILE* handle));
MOCK_METHOD1(StartDebugRecordingForPlatformFile,
int(rtc::PlatformFile handle));
MOCK_METHOD0(StopDebugRecording,
int());
MOCK_METHOD0(StopDebugRecording, int());
MOCK_METHOD0(UpdateHistogramsOnCallEnd, void());
virtual MockEchoCancellation* echo_cancellation() const {
return echo_cancellation_.get();
@ -298,6 +215,7 @@ class MockAudioProcessing : public AudioProcessing {
std::unique_ptr<MockVoiceDetection> voice_detection_;
};
} // namespace test
} // namespace webrtc
#endif // WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_MOCK_AUDIO_PROCESSING_H_