Expose the capture-side AudioProcessing object and allow it to be injected.
* Clean up the configuration code, including removing most of the weird defines. * Add a unit test. Review URL: https://webrtc-codereview.appspot.com/1152005 git-svn-id: http://webrtc.googlecode.com/svn/trunk@3605 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
330
webrtc/modules/audio_device/include/fake_audio_device.h
Normal file
330
webrtc/modules/audio_device/include/fake_audio_device.h
Normal file
@@ -0,0 +1,330 @@
|
||||
/*
|
||||
* Copyright (c) 2013 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.
|
||||
*/
|
||||
|
||||
#include "webrtc/modules/audio_device/include/audio_device.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
class FakeAudioDeviceModule : public AudioDeviceModule {
|
||||
public:
|
||||
FakeAudioDeviceModule() {}
|
||||
~FakeAudioDeviceModule() {}
|
||||
virtual int32_t AddRef() { return 0; }
|
||||
virtual int32_t Release() { return 0; }
|
||||
virtual int32_t RegisterEventObserver(AudioDeviceObserver* eventCallback) {
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t RegisterAudioCallback(AudioTransport* audioCallback) {
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t Init() { return 0; }
|
||||
virtual int32_t SpeakerIsAvailable(bool* available) {
|
||||
*available = true;
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t InitSpeaker() { return 0; }
|
||||
virtual int32_t SetPlayoutDevice(uint16_t index) { return 0; }
|
||||
virtual int32_t SetPlayoutDevice(WindowsDeviceType device) { return 0; }
|
||||
virtual int32_t SetStereoPlayout(bool enable) { return 0; }
|
||||
virtual int32_t StopPlayout() { return 0; }
|
||||
virtual int32_t MicrophoneIsAvailable(bool* available) {
|
||||
*available = true;
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t InitMicrophone() { return 0; }
|
||||
virtual int32_t SetRecordingDevice(uint16_t index) { return 0; }
|
||||
virtual int32_t SetRecordingDevice(WindowsDeviceType device) { return 0; }
|
||||
virtual int32_t SetStereoRecording(bool enable) { return 0; }
|
||||
virtual int32_t SetAGC(bool enable) { return 0; }
|
||||
virtual int32_t StopRecording() { return 0; }
|
||||
virtual int32_t TimeUntilNextProcess() { return 0; }
|
||||
virtual int32_t Process() { return 0; }
|
||||
virtual int32_t Terminate() { return 0; }
|
||||
|
||||
virtual int32_t ActiveAudioLayer(AudioLayer* audioLayer) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual ErrorCode LastError() const {
|
||||
assert(false);
|
||||
return kAdmErrNone;
|
||||
}
|
||||
virtual bool Initialized() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual int16_t PlayoutDevices() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int16_t RecordingDevices() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t PlayoutDeviceName(uint16_t index,
|
||||
char name[kAdmMaxDeviceNameSize],
|
||||
char guid[kAdmMaxGuidSize]) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t RecordingDeviceName(uint16_t index,
|
||||
char name[kAdmMaxDeviceNameSize],
|
||||
char guid[kAdmMaxGuidSize]) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t PlayoutIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t InitPlayout() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual bool PlayoutIsInitialized() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual int32_t RecordingIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t InitRecording() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual bool RecordingIsInitialized() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual int32_t StartPlayout() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual bool Playing() const {
|
||||
assert(false);
|
||||
return false;
|
||||
}
|
||||
virtual int32_t StartRecording() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual bool Recording() const {
|
||||
assert(false);
|
||||
return false;
|
||||
}
|
||||
virtual bool AGC() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual int32_t SetWaveOutVolume(uint16_t volumeLeft,
|
||||
uint16_t volumeRight) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t WaveOutVolume(uint16_t* volumeLeft,
|
||||
uint16_t* volumeRight) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual bool SpeakerIsInitialized() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual bool MicrophoneIsInitialized() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual int32_t SpeakerVolumeIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetSpeakerVolume(uint32_t volume) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SpeakerVolume(uint32_t* volume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MaxSpeakerVolume(uint32_t* maxVolume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MinSpeakerVolume(uint32_t* minVolume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SpeakerVolumeStepSize(uint16_t* stepSize) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneVolumeIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetMicrophoneVolume(uint32_t volume) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneVolume(uint32_t* volume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MaxMicrophoneVolume(uint32_t* maxVolume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MinMicrophoneVolume(uint32_t* minVolume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneVolumeStepSize(uint16_t* stepSize) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SpeakerMuteIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetSpeakerMute(bool enable) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SpeakerMute(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneMuteIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetMicrophoneMute(bool enable) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneMute(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneBoostIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetMicrophoneBoost(bool enable) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneBoost(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StereoPlayoutIsAvailable(bool* available) const {
|
||||
*available = false;
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StereoPlayout(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StereoRecordingIsAvailable(bool* available) const {
|
||||
*available = false;
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StereoRecording(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetRecordingChannel(const ChannelType channel) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t RecordingChannel(ChannelType* channel) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetPlayoutBuffer(const BufferType type,
|
||||
uint16_t sizeMS = 0) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t PlayoutBuffer(BufferType* type, uint16_t* sizeMS) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t PlayoutDelay(uint16_t* delayMS) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t RecordingDelay(uint16_t* delayMS) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t CPULoad(uint16_t* load) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StartRawOutputFileRecording(
|
||||
const char pcmFileNameUTF8[kAdmMaxFileNameSize]) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StopRawOutputFileRecording() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StartRawInputFileRecording(
|
||||
const char pcmFileNameUTF8[kAdmMaxFileNameSize]) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StopRawInputFileRecording() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetRecordingSampleRate(const uint32_t samplesPerSec) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t RecordingSampleRate(uint32_t* samplesPerSec) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetPlayoutSampleRate(const uint32_t samplesPerSec) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t PlayoutSampleRate(uint32_t* samplesPerSec) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t ResetAudioDevice() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetLoudspeakerStatus(bool enable) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t GetLoudspeakerStatus(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t EnableBuiltInAEC(bool enable) {
|
||||
assert(false);
|
||||
return -1;
|
||||
}
|
||||
virtual bool BuiltInAECIsEnabled() const {
|
||||
assert(false);
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace webrtc
|
@@ -40,6 +40,7 @@
|
||||
namespace webrtc {
|
||||
|
||||
class AudioDeviceModule;
|
||||
class AudioProcessing;
|
||||
|
||||
const int kVoEDefault = -1;
|
||||
|
||||
@@ -100,7 +101,7 @@ public:
|
||||
|
||||
// Releases the VoEBase sub-API and decreases an internal reference
|
||||
// counter. Returns the new reference count. This value should be zero
|
||||
// for all sub-API:s before the VoiceEngine object can be safely deleted.
|
||||
// for all sub-APIs before the VoiceEngine object can be safely deleted.
|
||||
virtual int Release() = 0;
|
||||
|
||||
// Installs the observer class to enable runtime error control and
|
||||
@@ -111,12 +112,21 @@ public:
|
||||
// and warning notifications.
|
||||
virtual int DeRegisterVoiceEngineObserver() = 0;
|
||||
|
||||
// Initiates all common parts of the VoiceEngine; e.g. all
|
||||
// Initializes all common parts of the VoiceEngine; e.g. all
|
||||
// encoders/decoders, the sound card and core receiving components.
|
||||
// This method also makes it possible to install a user-defined
|
||||
// external Audio Device Module (ADM) which implements all the audio
|
||||
// layer functionality in a separate (reference counted) module.
|
||||
virtual int Init(AudioDeviceModule* external_adm = NULL) = 0;
|
||||
// This method also makes it possible to install some user-defined external
|
||||
// modules:
|
||||
// - The Audio Device Module (ADM) which implements all the audio layer
|
||||
// functionality in a separate (reference counted) module.
|
||||
// - The AudioProcessing module handles capture-side processing. VoiceEngine
|
||||
// takes ownership of this object.
|
||||
// If NULL is passed for any of these, VoiceEngine will create its own.
|
||||
// TODO(ajm): Remove default NULLs.
|
||||
virtual int Init(AudioDeviceModule* external_adm = NULL,
|
||||
AudioProcessing* audioproc = NULL) = 0;
|
||||
|
||||
// Returns NULL before Init() is called.
|
||||
virtual AudioProcessing* audio_processing() = 0;
|
||||
|
||||
// Terminates all VoiceEngine functions and releses allocated resources.
|
||||
virtual int Terminate() = 0;
|
||||
@@ -180,7 +190,6 @@ public:
|
||||
// Gets the last VoiceEngine error code.
|
||||
virtual int LastError() = 0;
|
||||
|
||||
|
||||
// Stops or resumes playout and transmission on a temporary basis.
|
||||
virtual int SetOnHoldStatus(int channel, bool enable,
|
||||
OnHoldModes mode = kHoldSendAndPlay) = 0;
|
||||
|
@@ -29,7 +29,7 @@ SharedData::SharedData() :
|
||||
_channelManager(_gInstanceCounter),
|
||||
_engineStatistics(_gInstanceCounter),
|
||||
_audioDevicePtr(NULL),
|
||||
_audioProcessingModulePtr(NULL),
|
||||
audioproc_(NULL),
|
||||
_moduleProcessThreadPtr(ProcessThread::CreateProcessThread()),
|
||||
_externalRecording(false),
|
||||
_externalPlayout(false)
|
||||
@@ -56,7 +56,6 @@ SharedData::~SharedData()
|
||||
if (_audioDevicePtr) {
|
||||
_audioDevicePtr->Release();
|
||||
}
|
||||
AudioProcessing::Destroy(_audioProcessingModulePtr);
|
||||
delete _apiCritPtr;
|
||||
ProcessThread::DestroyProcessThread(_moduleProcessThreadPtr);
|
||||
Trace::ReturnTrace();
|
||||
@@ -72,10 +71,10 @@ void SharedData::set_audio_device(AudioDeviceModule* audio_device)
|
||||
_audioDevicePtr = audio_device;
|
||||
}
|
||||
|
||||
void SharedData::set_audio_processing(AudioProcessing* audio_processing) {
|
||||
if (_audioProcessingModulePtr)
|
||||
AudioProcessing::Destroy(_audioProcessingModulePtr);
|
||||
_audioProcessingModulePtr = audio_processing;
|
||||
void SharedData::set_audio_processing(AudioProcessing* audioproc) {
|
||||
audioproc_.reset(audioproc);
|
||||
_transmitMixerPtr->SetAudioProcessingModule(audioproc);
|
||||
_outputMixerPtr->SetAudioProcessingModule(audioproc);
|
||||
}
|
||||
|
||||
WebRtc_UWord16 SharedData::NumOfSendingChannels()
|
||||
|
@@ -11,14 +11,13 @@
|
||||
#ifndef WEBRTC_VOICE_ENGINE_SHARED_DATA_H
|
||||
#define WEBRTC_VOICE_ENGINE_SHARED_DATA_H
|
||||
|
||||
#include "voice_engine_defines.h"
|
||||
|
||||
#include "channel_manager.h"
|
||||
#include "statistics.h"
|
||||
#include "process_thread.h"
|
||||
|
||||
#include "audio_device.h"
|
||||
#include "audio_processing.h"
|
||||
#include "webrtc/modules/audio_device/include/audio_device.h"
|
||||
#include "webrtc/modules/audio_processing/include/audio_processing.h"
|
||||
#include "webrtc/modules/utility/interface/process_thread.h"
|
||||
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
|
||||
#include "webrtc/voice_engine/channel_manager.h"
|
||||
#include "webrtc/voice_engine/statistics.h"
|
||||
#include "webrtc/voice_engine/voice_engine_defines.h"
|
||||
|
||||
class ProcessThread;
|
||||
|
||||
@@ -39,7 +38,7 @@ public:
|
||||
ChannelManager& channel_manager() { return _channelManager; }
|
||||
AudioDeviceModule* audio_device() { return _audioDevicePtr; }
|
||||
void set_audio_device(AudioDeviceModule* audio_device);
|
||||
AudioProcessing* audio_processing() { return _audioProcessingModulePtr; }
|
||||
AudioProcessing* audio_processing() { return audioproc_.get(); }
|
||||
void set_audio_processing(AudioProcessing* audio_processing);
|
||||
TransmitMixer* transmit_mixer() { return _transmitMixerPtr; }
|
||||
OutputMixer* output_mixer() { return _outputMixerPtr; }
|
||||
@@ -72,7 +71,7 @@ protected:
|
||||
AudioDeviceModule* _audioDevicePtr;
|
||||
OutputMixer* _outputMixerPtr;
|
||||
TransmitMixer* _transmitMixerPtr;
|
||||
AudioProcessing* _audioProcessingModulePtr;
|
||||
scoped_ptr<AudioProcessing> audioproc_;
|
||||
ProcessThread* _moduleProcessThreadPtr;
|
||||
|
||||
bool _externalRecording;
|
||||
|
@@ -79,11 +79,10 @@ int VoEAudioProcessingImpl::SetNsStatus(bool enable, NsModes mode) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
NoiseSuppression::Level nsLevel(
|
||||
(NoiseSuppression::Level)WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE);
|
||||
NoiseSuppression::Level nsLevel = kDefaultNsMode;
|
||||
switch (mode) {
|
||||
case kNsDefault:
|
||||
nsLevel = (NoiseSuppression::Level)WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE;
|
||||
nsLevel = kDefaultNsMode;
|
||||
break;
|
||||
case kNsUnchanged:
|
||||
nsLevel = _shared->audio_processing()->noise_suppression()->level();
|
||||
@@ -134,14 +133,9 @@ int VoEAudioProcessingImpl::GetNsStatus(bool& enabled, NsModes& mode) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
bool enable(false);
|
||||
NoiseSuppression::Level nsLevel(
|
||||
(NoiseSuppression::Level)WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE);
|
||||
|
||||
enable = _shared->audio_processing()->noise_suppression()->is_enabled();
|
||||
nsLevel = _shared->audio_processing()->noise_suppression()->level();
|
||||
|
||||
enabled = enable;
|
||||
enabled = _shared->audio_processing()->noise_suppression()->is_enabled();
|
||||
NoiseSuppression::Level nsLevel =
|
||||
_shared->audio_processing()->noise_suppression()->level();
|
||||
|
||||
switch (nsLevel) {
|
||||
case NoiseSuppression::kLow:
|
||||
@@ -185,14 +179,13 @@ int VoEAudioProcessingImpl::SetAgcStatus(bool enable, AgcModes mode) {
|
||||
}
|
||||
#endif
|
||||
|
||||
GainControl::Mode agcMode(
|
||||
(GainControl::Mode)WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE);
|
||||
GainControl::Mode agcMode = kDefaultAgcMode;
|
||||
switch (mode) {
|
||||
case kAgcDefault:
|
||||
agcMode = (GainControl::Mode)WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE;
|
||||
agcMode = kDefaultAgcMode;
|
||||
break;
|
||||
case kAgcUnchanged:
|
||||
agcMode = _shared->audio_processing()->gain_control()->mode();;
|
||||
agcMode = _shared->audio_processing()->gain_control()->mode();
|
||||
break;
|
||||
case kAgcFixedDigital:
|
||||
agcMode = GainControl::kFixedDigital;
|
||||
@@ -244,14 +237,8 @@ int VoEAudioProcessingImpl::GetAgcStatus(bool& enabled, AgcModes& mode) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
bool enable(false);
|
||||
GainControl::Mode agcMode(
|
||||
(GainControl::Mode)WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE);
|
||||
|
||||
enable = _shared->audio_processing()->gain_control()->is_enabled();
|
||||
agcMode = _shared->audio_processing()->gain_control()->mode();
|
||||
|
||||
enabled = enable;
|
||||
enabled = _shared->audio_processing()->gain_control()->is_enabled();
|
||||
GainControl::Mode agcMode = _shared->audio_processing()->gain_control()->mode();
|
||||
|
||||
switch (agcMode) {
|
||||
case GainControl::kFixedDigital:
|
||||
|
@@ -330,7 +330,8 @@ int VoEBaseImpl::DeRegisterVoiceEngineObserver()
|
||||
return 0;
|
||||
}
|
||||
|
||||
int VoEBaseImpl::Init(AudioDeviceModule* external_adm)
|
||||
int VoEBaseImpl::Init(AudioDeviceModule* external_adm,
|
||||
AudioProcessing* audioproc)
|
||||
{
|
||||
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
||||
"Init(external_adm=0x%p)", external_adm);
|
||||
@@ -486,146 +487,73 @@ int VoEBaseImpl::Init(AudioDeviceModule* external_adm)
|
||||
"Init() failed to set mono/stereo recording mode");
|
||||
}
|
||||
|
||||
// APM initialization done after sound card since we need
|
||||
// to know if we support stereo recording or not.
|
||||
if (!audioproc) {
|
||||
audioproc = AudioProcessing::Create(VoEId(_shared->instance_id(), -1));
|
||||
if (!audioproc) {
|
||||
LOG(LS_ERROR) << "Failed to create AudioProcessing.";
|
||||
_shared->SetLastError(VE_NO_MEMORY);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
_shared->set_audio_processing(audioproc);
|
||||
|
||||
// Create the AudioProcessing Module if it does not exist.
|
||||
|
||||
if (_shared->audio_processing() == NULL)
|
||||
{
|
||||
_shared->set_audio_processing(AudioProcessing::Create(
|
||||
VoEId(_shared->instance_id(), -1)));
|
||||
if (_shared->audio_processing() == NULL)
|
||||
{
|
||||
_shared->SetLastError(VE_NO_MEMORY, kTraceCritical,
|
||||
"Init() failed to create the AP module");
|
||||
return -1;
|
||||
}
|
||||
// Ensure that mixers in both directions has access to the created APM
|
||||
_shared->transmit_mixer()->SetAudioProcessingModule(
|
||||
_shared->audio_processing());
|
||||
_shared->output_mixer()->SetAudioProcessingModule(
|
||||
_shared->audio_processing());
|
||||
|
||||
if (_shared->audio_processing()->echo_cancellation()->
|
||||
set_device_sample_rate_hz(
|
||||
kVoiceEngineAudioProcessingDeviceSampleRateHz))
|
||||
{
|
||||
_shared->SetLastError(VE_APM_ERROR, kTraceError,
|
||||
"Init() failed to set the device sample rate to 48K for AP "
|
||||
" module");
|
||||
return -1;
|
||||
}
|
||||
// Using 8 kHz as inital Fs. Might be changed already at first call.
|
||||
if (_shared->audio_processing()->set_sample_rate_hz(8000))
|
||||
{
|
||||
_shared->SetLastError(VE_APM_ERROR, kTraceError,
|
||||
"Init() failed to set the sample rate to 8K for AP module");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Assume mono until the audio frames are received from the capture
|
||||
// device, at which point this can be updated.
|
||||
if (_shared->audio_processing()->set_num_channels(1, 1) != 0)
|
||||
{
|
||||
_shared->SetLastError(VE_SOUNDCARD_ERROR, kTraceError,
|
||||
"Init() failed to set channels for the primary audio stream");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (_shared->audio_processing()->set_num_reverse_channels(1) != 0)
|
||||
{
|
||||
_shared->SetLastError(VE_SOUNDCARD_ERROR, kTraceError,
|
||||
"Init() failed to set channels for the primary audio stream");
|
||||
return -1;
|
||||
}
|
||||
// high-pass filter
|
||||
if (_shared->audio_processing()->high_pass_filter()->Enable(
|
||||
WEBRTC_VOICE_ENGINE_HP_DEFAULT_STATE) != 0)
|
||||
{
|
||||
_shared->SetLastError(VE_APM_ERROR, kTraceError,
|
||||
"Init() failed to set the high-pass filter for AP module");
|
||||
return -1;
|
||||
}
|
||||
// Echo Cancellation
|
||||
if (_shared->audio_processing()->echo_cancellation()->
|
||||
enable_drift_compensation(false) != 0)
|
||||
{
|
||||
_shared->SetLastError(VE_APM_ERROR, kTraceError,
|
||||
"Init() failed to set drift compensation for AP module");
|
||||
return -1;
|
||||
}
|
||||
if (_shared->audio_processing()->echo_cancellation()->Enable(
|
||||
WEBRTC_VOICE_ENGINE_EC_DEFAULT_STATE))
|
||||
{
|
||||
_shared->SetLastError(VE_APM_ERROR, kTraceError,
|
||||
"Init() failed to set echo cancellation state for AP module");
|
||||
return -1;
|
||||
}
|
||||
// Noise Reduction
|
||||
if (_shared->audio_processing()->noise_suppression()->set_level(
|
||||
(NoiseSuppression::Level) WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE)
|
||||
!= 0)
|
||||
{
|
||||
_shared->SetLastError(VE_APM_ERROR, kTraceError,
|
||||
"Init() failed to set noise reduction level for AP module");
|
||||
return -1;
|
||||
}
|
||||
if (_shared->audio_processing()->noise_suppression()->Enable(
|
||||
WEBRTC_VOICE_ENGINE_NS_DEFAULT_STATE) != 0)
|
||||
{
|
||||
_shared->SetLastError(VE_APM_ERROR, kTraceError,
|
||||
"Init() failed to set noise reduction state for AP module");
|
||||
return -1;
|
||||
}
|
||||
// Automatic Gain control
|
||||
if (_shared->audio_processing()->gain_control()->
|
||||
set_analog_level_limits(kMinVolumeLevel,kMaxVolumeLevel) != 0)
|
||||
{
|
||||
_shared->SetLastError(VE_APM_ERROR, kTraceError,
|
||||
"Init() failed to set AGC analog level for AP module");
|
||||
return -1;
|
||||
}
|
||||
if (_shared->audio_processing()->gain_control()->set_mode(
|
||||
(GainControl::Mode) WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE)
|
||||
!= 0)
|
||||
{
|
||||
_shared->SetLastError(VE_APM_ERROR, kTraceError,
|
||||
"Init() failed to set AGC mode for AP module");
|
||||
return -1;
|
||||
}
|
||||
if (_shared->audio_processing()->gain_control()->Enable(
|
||||
WEBRTC_VOICE_ENGINE_AGC_DEFAULT_STATE)
|
||||
!= 0)
|
||||
{
|
||||
_shared->SetLastError(VE_APM_ERROR, kTraceError,
|
||||
"Init() failed to set AGC state for AP module");
|
||||
return -1;
|
||||
}
|
||||
// VAD
|
||||
if (_shared->audio_processing()->voice_detection()->Enable(
|
||||
WEBRTC_VOICE_ENGINE_VAD_DEFAULT_STATE)
|
||||
!= 0)
|
||||
{
|
||||
_shared->SetLastError(VE_APM_ERROR, kTraceError,
|
||||
"Init() failed to set VAD state for AP module");
|
||||
return -1;
|
||||
}
|
||||
// Set the error state for any failures in this block.
|
||||
_shared->SetLastError(VE_APM_ERROR);
|
||||
if (audioproc->echo_cancellation()->set_device_sample_rate_hz(48000)) {
|
||||
LOG_FERR1(LS_ERROR, set_device_sample_rate_hz, 48000);
|
||||
return -1;
|
||||
}
|
||||
// Assume 16 kHz mono until the audio frames are received from the capture
|
||||
// device, at which point this can be updated.
|
||||
if (audioproc->set_sample_rate_hz(16000)) {
|
||||
LOG_FERR1(LS_ERROR, set_sample_rate_hz, 16000);
|
||||
return -1;
|
||||
}
|
||||
if (audioproc->set_num_channels(1, 1) != 0) {
|
||||
LOG_FERR2(LS_ERROR, set_num_channels, 1, 1);
|
||||
return -1;
|
||||
}
|
||||
if (audioproc->set_num_reverse_channels(1) != 0) {
|
||||
LOG_FERR1(LS_ERROR, set_num_reverse_channels, 1);
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Set default AGC mode for the ADM
|
||||
// Configure AudioProcessing components. All are disabled by default.
|
||||
if (audioproc->high_pass_filter()->Enable(true) != 0) {
|
||||
LOG_FERR1(LS_ERROR, high_pass_filter()->Enable, true);
|
||||
return -1;
|
||||
}
|
||||
if (audioproc->echo_cancellation()->enable_drift_compensation(false) != 0) {
|
||||
LOG_FERR1(LS_ERROR, enable_drift_compensation, false);
|
||||
return -1;
|
||||
}
|
||||
if (audioproc->noise_suppression()->set_level(kDefaultNsMode) != 0) {
|
||||
LOG_FERR1(LS_ERROR, noise_suppression()->set_level, kDefaultNsMode);
|
||||
return -1;
|
||||
}
|
||||
GainControl* agc = audioproc->gain_control();
|
||||
if (agc->set_analog_level_limits(kMinVolumeLevel, kMaxVolumeLevel) != 0) {
|
||||
LOG_FERR2(LS_ERROR, agc->set_analog_level_limits, kMinVolumeLevel,
|
||||
kMaxVolumeLevel);
|
||||
return -1;
|
||||
}
|
||||
if (agc->set_mode(kDefaultAgcMode) != 0) {
|
||||
LOG_FERR1(LS_ERROR, agc->set_mode, kDefaultAgcMode);
|
||||
return -1;
|
||||
}
|
||||
if (agc->Enable(kDefaultAgcState) != 0) {
|
||||
LOG_FERR1(LS_ERROR, agc->Enable, kDefaultAgcState);
|
||||
return -1;
|
||||
}
|
||||
_shared->SetLastError(0); // Clear error state.
|
||||
|
||||
#ifdef WEBRTC_VOICE_ENGINE_AGC
|
||||
bool enable(false);
|
||||
if (_shared->audio_processing()->gain_control()->mode()
|
||||
!= GainControl::kFixedDigital)
|
||||
{
|
||||
enable = _shared->audio_processing()->gain_control()->is_enabled();
|
||||
// Only set the AGC mode for the ADM when Adaptive AGC mode is selected
|
||||
if (_shared->audio_device()->SetAGC(enable) != 0)
|
||||
{
|
||||
_shared->SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR,
|
||||
kTraceError, "Init() failed to set default AGC mode in ADM 0");
|
||||
}
|
||||
bool agc_enabled = agc->mode() == GainControl::kAdaptiveAnalog &&
|
||||
agc->is_enabled();
|
||||
if (_shared->audio_device()->SetAGC(agc_enabled) != 0) {
|
||||
LOG_FERR1(LS_ERROR, audio_device()->SetAGC, agc_enabled);
|
||||
_shared->SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR);
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -1578,9 +1506,7 @@ WebRtc_Word32 VoEBaseImpl::TerminateInternal()
|
||||
}
|
||||
}
|
||||
|
||||
// Audio Device Module
|
||||
|
||||
if (_shared->audio_device() != NULL)
|
||||
if (_shared->audio_device())
|
||||
{
|
||||
if (_shared->audio_device()->StopPlayout() != 0)
|
||||
{
|
||||
@@ -1607,15 +1533,10 @@ WebRtc_Word32 VoEBaseImpl::TerminateInternal()
|
||||
_shared->SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR, kTraceError,
|
||||
"TerminateInternal() failed to terminate the ADM");
|
||||
}
|
||||
|
||||
_shared->set_audio_device(NULL);
|
||||
}
|
||||
|
||||
// AP module
|
||||
|
||||
if (_shared->audio_processing() != NULL)
|
||||
{
|
||||
_shared->transmit_mixer()->SetAudioProcessingModule(NULL);
|
||||
if (_shared->audio_processing()) {
|
||||
_shared->set_audio_processing(NULL);
|
||||
}
|
||||
|
||||
|
@@ -30,7 +30,11 @@ public:
|
||||
|
||||
virtual int DeRegisterVoiceEngineObserver();
|
||||
|
||||
virtual int Init(AudioDeviceModule* external_adm = NULL);
|
||||
virtual int Init(AudioDeviceModule* external_adm = NULL,
|
||||
AudioProcessing* audioproc = NULL);
|
||||
virtual AudioProcessing* audio_processing() {
|
||||
return _shared->audio_processing();
|
||||
}
|
||||
|
||||
virtual int Terminate();
|
||||
|
||||
@@ -79,7 +83,6 @@ public:
|
||||
|
||||
virtual int GetNetEQBGNMode(int channel, NetEqBgnModes& mode);
|
||||
|
||||
|
||||
virtual int SetOnHoldStatus(int channel,
|
||||
bool enable,
|
||||
OnHoldModes mode = kHoldSendAndPlay);
|
||||
|
50
webrtc/voice_engine/voe_base_unittest.cc
Normal file
50
webrtc/voice_engine/voe_base_unittest.cc
Normal file
@@ -0,0 +1,50 @@
|
||||
/*
|
||||
* Copyright (c) 2013 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.
|
||||
*/
|
||||
|
||||
#include "webrtc/voice_engine/include/voe_base.h"
|
||||
|
||||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
#include "webrtc/modules/audio_processing/include/audio_processing.h"
|
||||
#include "webrtc/modules/audio_device/include/fake_audio_device.h"
|
||||
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
class VoEBaseTest : public ::testing::Test {
|
||||
protected:
|
||||
VoEBaseTest() :
|
||||
voe_(VoiceEngine::Create()),
|
||||
base_(VoEBase::GetInterface(voe_)),
|
||||
adm_(new FakeAudioDeviceModule) {
|
||||
}
|
||||
|
||||
~VoEBaseTest() {
|
||||
base_->Release();
|
||||
VoiceEngine::Delete(voe_);
|
||||
}
|
||||
|
||||
VoiceEngine* voe_;
|
||||
VoEBase* base_;
|
||||
scoped_ptr<FakeAudioDeviceModule> adm_;
|
||||
};
|
||||
|
||||
TEST_F(VoEBaseTest, AcceptsAudioProcessingPtr) {
|
||||
AudioProcessing* audioproc = AudioProcessing::Create(0);
|
||||
EXPECT_EQ(0, base_->Init(adm_.get(), audioproc));
|
||||
EXPECT_EQ(audioproc, base_->audio_processing());
|
||||
}
|
||||
|
||||
TEST_F(VoEBaseTest, AudioProcessingCreatedAfterInit) {
|
||||
EXPECT_TRUE(base_->audio_processing() == NULL);
|
||||
EXPECT_EQ(0, base_->Init(adm_.get(), NULL));
|
||||
EXPECT_TRUE(base_->audio_processing() != NULL);
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
@@ -11,8 +11,7 @@
|
||||
#include "webrtc/voice_engine/include/voe_codec.h"
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
#include "webrtc/modules/audio_device/include/audio_device.h"
|
||||
#include "webrtc/modules/audio_device/include/audio_device_defines.h"
|
||||
#include "webrtc/modules/audio_device/include/fake_audio_device.h"
|
||||
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
|
||||
#include "webrtc/voice_engine/include/voe_base.h"
|
||||
#include "webrtc/voice_engine/include/voe_hardware.h"
|
||||
@@ -22,322 +21,6 @@ namespace webrtc {
|
||||
namespace voe {
|
||||
namespace {
|
||||
|
||||
|
||||
class FakeAudioDeviceModule : public AudioDeviceModule {
|
||||
public:
|
||||
FakeAudioDeviceModule() {}
|
||||
~FakeAudioDeviceModule() {}
|
||||
virtual int32_t AddRef() { return 0; }
|
||||
virtual int32_t Release() { return 0; }
|
||||
virtual int32_t RegisterEventObserver(AudioDeviceObserver* eventCallback) {
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t RegisterAudioCallback(AudioTransport* audioCallback) {
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t Init() { return 0; }
|
||||
virtual int32_t SpeakerIsAvailable(bool* available) {
|
||||
*available = true;
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t InitSpeaker() { return 0; }
|
||||
virtual int32_t SetPlayoutDevice(uint16_t index) { return 0; }
|
||||
virtual int32_t SetPlayoutDevice(WindowsDeviceType device) { return 0; }
|
||||
virtual int32_t SetStereoPlayout(bool enable) { return 0; }
|
||||
virtual int32_t StopPlayout() { return 0; }
|
||||
virtual int32_t MicrophoneIsAvailable(bool* available) {
|
||||
*available = true;
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t InitMicrophone() { return 0; }
|
||||
virtual int32_t SetRecordingDevice(uint16_t index) { return 0; }
|
||||
virtual int32_t SetRecordingDevice(WindowsDeviceType device) { return 0; }
|
||||
virtual int32_t SetStereoRecording(bool enable) { return 0; }
|
||||
virtual int32_t SetAGC(bool enable) { return 0; }
|
||||
virtual int32_t StopRecording() { return 0; }
|
||||
virtual int32_t TimeUntilNextProcess() { return 0; }
|
||||
virtual int32_t Process() { return 0; }
|
||||
virtual int32_t Terminate() { return 0; }
|
||||
|
||||
virtual int32_t ActiveAudioLayer(AudioLayer* audioLayer) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual ErrorCode LastError() const {
|
||||
assert(false);
|
||||
return kAdmErrNone;
|
||||
}
|
||||
virtual bool Initialized() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual int16_t PlayoutDevices() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int16_t RecordingDevices() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t PlayoutDeviceName(uint16_t index,
|
||||
char name[kAdmMaxDeviceNameSize],
|
||||
char guid[kAdmMaxGuidSize]) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t RecordingDeviceName(uint16_t index,
|
||||
char name[kAdmMaxDeviceNameSize],
|
||||
char guid[kAdmMaxGuidSize]) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t PlayoutIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t InitPlayout() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual bool PlayoutIsInitialized() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual int32_t RecordingIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t InitRecording() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual bool RecordingIsInitialized() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual int32_t StartPlayout() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual bool Playing() const {
|
||||
assert(false);
|
||||
return false;
|
||||
}
|
||||
virtual int32_t StartRecording() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual bool Recording() const {
|
||||
assert(false);
|
||||
return false;
|
||||
}
|
||||
virtual bool AGC() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual int32_t SetWaveOutVolume(uint16_t volumeLeft,
|
||||
uint16_t volumeRight) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t WaveOutVolume(uint16_t* volumeLeft,
|
||||
uint16_t* volumeRight) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual bool SpeakerIsInitialized() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual bool MicrophoneIsInitialized() const {
|
||||
assert(false);
|
||||
return true;
|
||||
}
|
||||
virtual int32_t SpeakerVolumeIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetSpeakerVolume(uint32_t volume) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SpeakerVolume(uint32_t* volume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MaxSpeakerVolume(uint32_t* maxVolume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MinSpeakerVolume(uint32_t* minVolume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SpeakerVolumeStepSize(uint16_t* stepSize) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneVolumeIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetMicrophoneVolume(uint32_t volume) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneVolume(uint32_t* volume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MaxMicrophoneVolume(uint32_t* maxVolume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MinMicrophoneVolume(uint32_t* minVolume) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneVolumeStepSize(uint16_t* stepSize) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SpeakerMuteIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetSpeakerMute(bool enable) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SpeakerMute(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneMuteIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetMicrophoneMute(bool enable) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneMute(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneBoostIsAvailable(bool* available) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetMicrophoneBoost(bool enable) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t MicrophoneBoost(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StereoPlayoutIsAvailable(bool* available) const {
|
||||
*available = false;
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StereoPlayout(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StereoRecordingIsAvailable(bool* available) const {
|
||||
*available = false;
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StereoRecording(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetRecordingChannel(const ChannelType channel) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t RecordingChannel(ChannelType* channel) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetPlayoutBuffer(const BufferType type,
|
||||
uint16_t sizeMS = 0) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t PlayoutBuffer(BufferType* type, uint16_t* sizeMS) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t PlayoutDelay(uint16_t* delayMS) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t RecordingDelay(uint16_t* delayMS) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t CPULoad(uint16_t* load) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StartRawOutputFileRecording(
|
||||
const char pcmFileNameUTF8[kAdmMaxFileNameSize]) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StopRawOutputFileRecording() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StartRawInputFileRecording(
|
||||
const char pcmFileNameUTF8[kAdmMaxFileNameSize]) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t StopRawInputFileRecording() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetRecordingSampleRate(const uint32_t samplesPerSec) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t RecordingSampleRate(uint32_t* samplesPerSec) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetPlayoutSampleRate(const uint32_t samplesPerSec) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t PlayoutSampleRate(uint32_t* samplesPerSec) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t ResetAudioDevice() {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t SetLoudspeakerStatus(bool enable) {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t GetLoudspeakerStatus(bool* enabled) const {
|
||||
assert(false);
|
||||
return 0;
|
||||
}
|
||||
virtual int32_t EnableBuiltInAEC(bool enable) {
|
||||
assert(false);
|
||||
return -1;
|
||||
}
|
||||
virtual bool BuiltInAECIsEnabled() const {
|
||||
assert(false);
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
class VoECodecTest : public ::testing::Test {
|
||||
protected:
|
||||
VoECodecTest()
|
||||
|
@@ -146,6 +146,7 @@
|
||||
'output_mixer_unittest.cc',
|
||||
'transmit_mixer_unittest.cc',
|
||||
'voe_audio_processing_unittest.cc',
|
||||
'voe_base_unittest.cc',
|
||||
'voe_codec_unittest.cc',
|
||||
],
|
||||
},
|
||||
|
@@ -18,6 +18,7 @@
|
||||
|
||||
#include "webrtc/common_types.h"
|
||||
#include "webrtc/engine_configurations.h"
|
||||
#include "webrtc/modules/audio_processing/include/audio_processing.h"
|
||||
#include "webrtc/system_wrappers/interface/logging.h"
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
@@ -77,7 +78,19 @@ enum { kVoiceEngineMaxSrtpTagAuthNullLength = 12 };
|
||||
enum { kVoiceEngineMaxSrtpKeyAuthNullLength = 256 };
|
||||
|
||||
// Audio processing
|
||||
enum { kVoiceEngineAudioProcessingDeviceSampleRateHz = 48000 };
|
||||
const NoiseSuppression::Level kDefaultNsMode = NoiseSuppression::kModerate;
|
||||
const GainControl::Mode kDefaultAgcMode =
|
||||
#if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
|
||||
GainControl::kAdaptiveDigital;
|
||||
#else
|
||||
GainControl::kAdaptiveAnalog;
|
||||
#endif
|
||||
const bool kDefaultAgcState =
|
||||
#if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
|
||||
false;
|
||||
#else
|
||||
true;
|
||||
#endif
|
||||
|
||||
// Codec
|
||||
// Min init target rate for iSAC-wb
|
||||
@@ -129,31 +142,15 @@ enum { kVoiceEngineMaxRtpExtensionId = 14 };
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
// TODO(andrew): we shouldn't be using the precompiler for this.
|
||||
// TODO(ajm): we shouldn't be using the precompiler for this.
|
||||
// Use enums or bools as appropriate.
|
||||
#define WEBRTC_AUDIO_PROCESSING_OFF false
|
||||
|
||||
#define WEBRTC_VOICE_ENGINE_HP_DEFAULT_STATE true
|
||||
// AudioProcessing HP is ON
|
||||
#define WEBRTC_VOICE_ENGINE_NS_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
// AudioProcessing NS off
|
||||
#define WEBRTC_VOICE_ENGINE_AGC_DEFAULT_STATE true
|
||||
// AudioProcessing AGC on
|
||||
#define WEBRTC_VOICE_ENGINE_EC_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
// AudioProcessing EC off
|
||||
#define WEBRTC_VOICE_ENGINE_VAD_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
// AudioProcessing off
|
||||
#define WEBRTC_VOICE_ENGINE_RX_AGC_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
#define WEBRTC_VOICE_ENGINE_RX_AGC_DEFAULT_STATE false
|
||||
// AudioProcessing RX AGC off
|
||||
#define WEBRTC_VOICE_ENGINE_RX_NS_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
#define WEBRTC_VOICE_ENGINE_RX_NS_DEFAULT_STATE false
|
||||
// AudioProcessing RX NS off
|
||||
#define WEBRTC_VOICE_ENGINE_RX_HP_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
#define WEBRTC_VOICE_ENGINE_RX_HP_DEFAULT_STATE false
|
||||
// AudioProcessing RX High Pass Filter off
|
||||
|
||||
#define WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE NoiseSuppression::kModerate
|
||||
// AudioProcessing NS moderate suppression
|
||||
#define WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE GainControl::kAdaptiveAnalog
|
||||
// AudioProcessing AGC analog digital combined
|
||||
#define WEBRTC_VOICE_ENGINE_RX_AGC_DEFAULT_MODE GainControl::kAdaptiveDigital
|
||||
// AudioProcessing AGC mode
|
||||
#define WEBRTC_VOICE_ENGINE_RX_NS_DEFAULT_MODE NoiseSuppression::kModerate
|
||||
@@ -346,22 +343,6 @@ inline int VoEChannelId(const int moduleId)
|
||||
#undef WEBRTC_CONFERENCING
|
||||
#undef WEBRTC_TYPING_DETECTION
|
||||
|
||||
// Default audio processing states
|
||||
#undef WEBRTC_VOICE_ENGINE_NS_DEFAULT_STATE
|
||||
#undef WEBRTC_VOICE_ENGINE_AGC_DEFAULT_STATE
|
||||
#undef WEBRTC_VOICE_ENGINE_EC_DEFAULT_STATE
|
||||
#define WEBRTC_VOICE_ENGINE_NS_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
#define WEBRTC_VOICE_ENGINE_AGC_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
#define WEBRTC_VOICE_ENGINE_EC_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
|
||||
// Default audio processing modes
|
||||
#undef WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE
|
||||
#undef WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE
|
||||
#define WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE \
|
||||
NoiseSuppression::kModerate
|
||||
#define WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE \
|
||||
GainControl::kAdaptiveDigital
|
||||
|
||||
#define ANDROID_NOT_SUPPORTED(stat) NOT_SUPPORTED(stat)
|
||||
|
||||
#else // LINUX PC
|
||||
@@ -444,20 +425,6 @@ inline int VoEChannelId(const int moduleId)
|
||||
#undef WEBRTC_CODEC_ISAC
|
||||
#undef WEBRTC_VOE_EXTERNAL_REC_AND_PLAYOUT
|
||||
|
||||
#undef WEBRTC_VOICE_ENGINE_NS_DEFAULT_STATE
|
||||
#undef WEBRTC_VOICE_ENGINE_AGC_DEFAULT_STATE
|
||||
#undef WEBRTC_VOICE_ENGINE_EC_DEFAULT_STATE
|
||||
#define WEBRTC_VOICE_ENGINE_NS_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
#define WEBRTC_VOICE_ENGINE_AGC_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
#define WEBRTC_VOICE_ENGINE_EC_DEFAULT_STATE WEBRTC_AUDIO_PROCESSING_OFF
|
||||
|
||||
#undef WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE
|
||||
#undef WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE
|
||||
#define WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE \
|
||||
NoiseSuppression::kModerate
|
||||
#define WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE \
|
||||
GainControl::kAdaptiveDigital
|
||||
|
||||
#define IPHONE_NOT_SUPPORTED(stat) NOT_SUPPORTED(stat)
|
||||
|
||||
#else // Non-iPhone
|
||||
|
Reference in New Issue
Block a user