blob: 65ac21f53662a5cd1e3bf78c66e77e3eb513e648 [file] [log] [blame]
/*
* Copyright (c) 2011 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 "voe_base_impl.h"
#include "audio_coding_module.h"
#include "audio_device_impl.h"
#include "audio_processing.h"
#include "channel.h"
#include "critical_section_wrapper.h"
#include "file_wrapper.h"
#include "output_mixer.h"
#include "signal_processing_library.h"
#include "trace.h"
#include "transmit_mixer.h"
#include "utility.h"
#include "voe_errors.h"
#include "voice_engine_impl.h"
#if (defined(_WIN32) && defined(_DLL) && (_MSC_VER == 1400))
// Fix for VS 2005 MD/MDd link problem
#include <stdio.h>
extern "C"
{ FILE _iob[3] = { __iob_func()[0], __iob_func()[1], __iob_func()[2]}; }
#endif
namespace webrtc
{
VoEBase* VoEBase::GetInterface(VoiceEngine* voiceEngine)
{
if (NULL == voiceEngine)
{
return NULL;
}
VoiceEngineImpl* s = reinterpret_cast<VoiceEngineImpl*> (voiceEngine);
VoEBaseImpl* d = s;
(*d)++;
return (d);
}
VoEBaseImpl::VoEBaseImpl() :
_voiceEngineObserverPtr(NULL),
_callbackCritSect(*CriticalSectionWrapper::CreateCriticalSection()),
_voiceEngineObserver(false), _oldVoEMicLevel(0), _oldMicLevel(0)
{
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl() - ctor");
}
VoEBaseImpl::~VoEBaseImpl()
{
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
"~VoEBaseImpl() - dtor");
TerminateInternal();
delete &_callbackCritSect;
}
int VoEBaseImpl::Release()
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::Release()");
(*this)--;
int refCount = GetCount();
if (refCount < 0)
{
Reset();
_engineStatistics.SetLastError(VE_INTERFACE_NOT_FOUND, kTraceWarning);
return (-1);
}
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl reference counter = %d", refCount);
return (refCount);
}
void VoEBaseImpl::OnErrorIsReported(const ErrorCode error)
{
CriticalSectionScoped cs(_callbackCritSect);
if (_voiceEngineObserver)
{
if (_voiceEngineObserverPtr)
{
int errCode(0);
if (error == AudioDeviceObserver::kRecordingError)
{
errCode = VE_RUNTIME_REC_ERROR;
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::OnErrorIsReported() => "
"VE_RUNTIME_REC_ERROR");
}
else if (error == AudioDeviceObserver::kPlayoutError)
{
errCode = VE_RUNTIME_PLAY_ERROR;
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::OnErrorIsReported() => "
"VE_RUNTIME_PLAY_ERROR");
}
// Deliver callback (-1 <=> no channel dependency)
_voiceEngineObserverPtr->CallbackOnError(-1, errCode);
}
}
}
void VoEBaseImpl::OnWarningIsReported(const WarningCode warning)
{
CriticalSectionScoped cs(_callbackCritSect);
if (_voiceEngineObserver)
{
if (_voiceEngineObserverPtr)
{
int warningCode(0);
if (warning == AudioDeviceObserver::kRecordingWarning)
{
warningCode = VE_RUNTIME_REC_WARNING;
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::OnErrorIsReported() => "
"VE_RUNTIME_REC_WARNING");
}
else if (warning == AudioDeviceObserver::kPlayoutWarning)
{
warningCode = VE_RUNTIME_PLAY_WARNING;
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::OnErrorIsReported() => "
"VE_RUNTIME_PLAY_WARNING");
}
// Deliver callback (-1 <=> no channel dependency)
_voiceEngineObserverPtr->CallbackOnError(-1, warningCode);
}
}
}
WebRtc_Word32 VoEBaseImpl::RecordedDataIsAvailable(
const WebRtc_Word8* audioSamples,
const WebRtc_UWord32 nSamples,
const WebRtc_UWord8 nBytesPerSample,
const WebRtc_UWord8 nChannels,
const WebRtc_UWord32 samplesPerSec,
const WebRtc_UWord32 totalDelayMS,
const WebRtc_Word32 clockDrift,
const WebRtc_UWord32 currentMicLevel,
WebRtc_UWord32& newMicLevel)
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::RecordedDataIsAvailable(nSamples=%u, "
"nBytesPerSample=%u, nChannels=%u, samplesPerSec=%u, "
"totalDelayMS=%u, clockDrift=%d, currentMicLevel=%u)",
nSamples, nBytesPerSample, nChannels, samplesPerSec,
totalDelayMS, clockDrift, currentMicLevel);
assert(_transmitMixerPtr != NULL);
assert(_audioDevicePtr != NULL);
bool isAnalogAGC(false);
WebRtc_UWord32 maxVolume(0);
WebRtc_UWord16 currentVoEMicLevel(0);
WebRtc_UWord32 newVoEMicLevel(0);
if (_audioProcessingModulePtr
&& (_audioProcessingModulePtr->gain_control()->mode()
== GainControl::kAdaptiveAnalog))
{
isAnalogAGC = true;
}
// Will only deal with the volume in adaptive analog mode
if (isAnalogAGC)
{
// Scale from ADM to VoE level range
if (_audioDevicePtr->MaxMicrophoneVolume(&maxVolume) == 0)
{
if (0 != maxVolume)
{
currentVoEMicLevel = (WebRtc_UWord16) ((currentMicLevel
* kMaxVolumeLevel + (int) (maxVolume / 2))
/ (maxVolume));
}
}
// We learned that on certain systems (e.g Linux) the currentVoEMicLevel
// can be greater than the maxVolumeLevel therefore
// we are going to cap the currentVoEMicLevel to the maxVolumeLevel
// if it turns out that the currentVoEMicLevel is indeed greater
// than the maxVolumeLevel
if (currentVoEMicLevel > kMaxVolumeLevel)
{
currentVoEMicLevel = kMaxVolumeLevel;
}
}
// Keep track if the MicLevel has been changed by the AGC, if not,
// use the old value AGC returns to let AGC continue its trend,
// so eventually the AGC is able to change the mic level. This handles
// issues with truncation introduced by the scaling.
if (_oldMicLevel == currentMicLevel)
{
currentVoEMicLevel = (WebRtc_UWord16) _oldVoEMicLevel;
}
// Perform channel-independent operations
// (APM, mix with file, record to file, mute, etc.)
_transmitMixerPtr->PrepareDemux(audioSamples, nSamples, nChannels,
samplesPerSec,
(WebRtc_UWord16) totalDelayMS, clockDrift,
currentVoEMicLevel);
// Copy the audio frame to each sending channel and perform
// channel-dependent operations (file mixing, mute, etc.) to prepare
// for encoding.
_transmitMixerPtr->DemuxAndMix();
// Do the encoding and packetize+transmit the RTP packet when encoding
// is done.
_transmitMixerPtr->EncodeAndSend();
// Will only deal with the volume in adaptive analog mode
if (isAnalogAGC)
{
// Scale from VoE to ADM level range
newVoEMicLevel = _transmitMixerPtr->CaptureLevel();
if (newVoEMicLevel != currentVoEMicLevel)
{
// Add (kMaxVolumeLevel/2) to round the value
newMicLevel = (WebRtc_UWord32) ((newVoEMicLevel * maxVolume
+ (int) (kMaxVolumeLevel / 2)) / (kMaxVolumeLevel));
}
else
{
// Pass zero if the level is unchanged
newMicLevel = 0;
}
// Keep track of the value AGC returns
_oldVoEMicLevel = newVoEMicLevel;
_oldMicLevel = currentMicLevel;
}
return 0;
}
WebRtc_Word32 VoEBaseImpl::NeedMorePlayData(
const WebRtc_UWord32 nSamples,
const WebRtc_UWord8 nBytesPerSample,
const WebRtc_UWord8 nChannels,
const WebRtc_UWord32 samplesPerSec,
WebRtc_Word8* audioSamples,
WebRtc_UWord32& nSamplesOut)
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::NeedMorePlayData(nSamples=%u, "
"nBytesPerSample=%d, nChannels=%d, samplesPerSec=%u)",
nSamples, nBytesPerSample, nChannels, samplesPerSec);
assert(_outputMixerPtr != NULL);
AudioFrame audioFrame;
// Perform mixing of all active participants (channel-based mixing)
_outputMixerPtr->MixActiveChannels();
// Additional operations on the combined signal
_outputMixerPtr->DoOperationsOnCombinedSignal();
// Retrieve the final output mix (resampled to match the ADM)
_outputMixerPtr->GetMixedAudio(samplesPerSec, nChannels, audioFrame);
assert(nSamples == audioFrame._payloadDataLengthInSamples);
assert(samplesPerSec ==
static_cast<WebRtc_UWord32>(audioFrame._frequencyInHz));
// Deliver audio (PCM) samples to the ADM
memcpy(
(WebRtc_Word16*) audioSamples,
(const WebRtc_Word16*) audioFrame._payloadData,
sizeof(WebRtc_Word16) * (audioFrame._payloadDataLengthInSamples
* audioFrame._audioChannel));
nSamplesOut = audioFrame._payloadDataLengthInSamples;
return 0;
}
int VoEBaseImpl::RegisterVoiceEngineObserver(VoiceEngineObserver& observer)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"RegisterVoiceEngineObserver(observer=0x%d)", &observer);
CriticalSectionScoped cs(_callbackCritSect);
if (_voiceEngineObserverPtr)
{
_engineStatistics.SetLastError(VE_INVALID_OPERATION, kTraceError,
"RegisterVoiceEngineObserver() observer"
" already enabled");
return -1;
}
// Register the observer in all active channels
voe::ScopedChannel sc(_channelManager);
void* iterator(NULL);
voe::Channel* channelPtr = sc.GetFirstChannel(iterator);
while (channelPtr != NULL)
{
channelPtr->RegisterVoiceEngineObserver(observer);
channelPtr = sc.GetNextChannel(iterator);
}
_transmitMixerPtr->RegisterVoiceEngineObserver(observer);
_voiceEngineObserverPtr = &observer;
_voiceEngineObserver = true;
return 0;
}
int VoEBaseImpl::DeRegisterVoiceEngineObserver()
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"DeRegisterVoiceEngineObserver()");
CriticalSectionScoped cs(_callbackCritSect);
if (!_voiceEngineObserverPtr)
{
_engineStatistics.SetLastError(VE_INVALID_OPERATION, kTraceError,
"DeRegisterVoiceEngineObserver() observer already disabled");
return 0;
}
_voiceEngineObserver = false;
_voiceEngineObserverPtr = NULL;
// Deregister the observer in all active channels
voe::ScopedChannel sc(_channelManager);
void* iterator(NULL);
voe::Channel* channelPtr = sc.GetFirstChannel(iterator);
while (channelPtr != NULL)
{
channelPtr->DeRegisterVoiceEngineObserver();
channelPtr = sc.GetNextChannel(iterator);
}
return 0;
}
int VoEBaseImpl::Init(AudioDeviceModule* external_adm)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"Init(external_adm=0x%p)", external_adm);
CriticalSectionScoped cs(*_apiCritPtr);
if (_engineStatistics.Initialized())
{
return 0;
}
if (_moduleProcessThreadPtr)
{
if (_moduleProcessThreadPtr->Start() != 0)
{
_engineStatistics.SetLastError(VE_THREAD_ERROR, kTraceError,
"Init() failed to start module process thread");
return -1;
}
}
// Create an internal ADM if the user has not added an external
// ADM implementation as input to Init().
if (external_adm == NULL)
{
// Create the internal ADM implementation.
_audioDevicePtr = AudioDeviceModuleImpl::Create(
VoEId(_instanceId, -1), _audioDeviceLayer);
if (_audioDevicePtr == NULL)
{
_engineStatistics.SetLastError(VE_NO_MEMORY, kTraceCritical,
"Init() failed to create the ADM");
return -1;
}
}
else
{
// Use the already existing external ADM implementation.
_audioDevicePtr = external_adm;
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
"An external ADM implementation will be used in VoiceEngine");
}
// Increase the reference counter for both external and internal usage.
_audioDevicePtr->AddRef();
// Register the ADM to the process thread, which will drive the error
// callback mechanism
if (_moduleProcessThreadPtr->RegisterModule(_audioDevicePtr) != 0)
{
_engineStatistics.SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR,
kTraceError,
"Init() failed to register the ADM");
return -1;
}
bool available(false);
// --------------------
// Reinitialize the ADM
// Register the AudioObserver implementation
_audioDevicePtr->RegisterEventObserver(this);
// Register the AudioTransport implementation
_audioDevicePtr->RegisterAudioCallback(this);
// ADM initialization
if (_audioDevicePtr->Init() != 0)
{
_engineStatistics.SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR,
kTraceError,
"Init() failed to initialize the ADM");
return -1;
}
// Initialize the default speaker
if (_audioDevicePtr->SetPlayoutDevice(WEBRTC_VOICE_ENGINE_DEFAULT_DEVICE)
!= 0)
{
_engineStatistics.SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR, kTraceInfo,
"Init() failed to set the default output device");
}
if (_audioDevicePtr->SpeakerIsAvailable(&available) != 0)
{
_engineStatistics.SetLastError(VE_CANNOT_ACCESS_SPEAKER_VOL, kTraceInfo,
"Init() failed to check speaker availability, trying to "
"initialize speaker anyway");
}
else if (!available)
{
_engineStatistics.SetLastError(VE_CANNOT_ACCESS_SPEAKER_VOL, kTraceInfo,
"Init() speaker not available, trying to initialize speaker "
"anyway");
}
if (_audioDevicePtr->InitSpeaker() != 0)
{
_engineStatistics.SetLastError(VE_CANNOT_ACCESS_SPEAKER_VOL, kTraceInfo,
"Init() failed to initialize the speaker");
}
// Initialize the default microphone
if (_audioDevicePtr->SetRecordingDevice(WEBRTC_VOICE_ENGINE_DEFAULT_DEVICE)
!= 0)
{
_engineStatistics.SetLastError(VE_SOUNDCARD_ERROR, kTraceInfo,
"Init() failed to set the default input device");
}
if (_audioDevicePtr->MicrophoneIsAvailable(&available) != 0)
{
_engineStatistics.SetLastError(VE_CANNOT_ACCESS_MIC_VOL, kTraceInfo,
"Init() failed to check microphone availability, trying to "
"initialize microphone anyway");
}
else if (!available)
{
_engineStatistics.SetLastError(VE_CANNOT_ACCESS_MIC_VOL, kTraceInfo,
"Init() microphone not available, trying to initialize "
"microphone anyway");
}
if (_audioDevicePtr->InitMicrophone() != 0)
{
_engineStatistics.SetLastError(VE_CANNOT_ACCESS_MIC_VOL, kTraceInfo,
"Init() failed to initialize the microphone");
}
// Set number of channels
_audioDevicePtr->StereoPlayoutIsAvailable(&available);
if (_audioDevicePtr->SetStereoPlayout(available) != 0)
{
_engineStatistics.SetLastError(VE_SOUNDCARD_ERROR, kTraceWarning,
"Init() failed to set mono/stereo playout mode");
}
// TODO(andrew): These functions don't tell us whether stereo recording
// is truly available. We simply set the AudioProcessing input to stereo
// here, because we have to wait until receiving the first frame to
// determine the actual number of channels anyway.
//
// These functions may be changed; tracked here:
// http://code.google.com/p/webrtc/issues/detail?id=204
_audioDevicePtr->StereoRecordingIsAvailable(&available);
if (_audioDevicePtr->SetStereoRecording(available) != 0)
{
_engineStatistics.SetLastError(VE_SOUNDCARD_ERROR, kTraceWarning,
"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.
// Create the AudioProcessing Module if it does not exist.
if (_audioProcessingModulePtr == NULL)
{
_audioProcessingModulePtr = AudioProcessing::Create(
VoEId(_instanceId, -1));
if (_audioProcessingModulePtr == NULL)
{
_engineStatistics.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
_transmitMixerPtr->SetAudioProcessingModule(_audioProcessingModulePtr);
_outputMixerPtr->SetAudioProcessingModule(_audioProcessingModulePtr);
if (_audioProcessingModulePtr->echo_cancellation()->
set_device_sample_rate_hz(
kVoiceEngineAudioProcessingDeviceSampleRateHz))
{
_engineStatistics.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 (_audioProcessingModulePtr->set_sample_rate_hz(8000))
{
_engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
"Init() failed to set the sample rate to 8K for AP module");
return -1;
}
// Assume mono output until a send codec is set, and stereo input until
// we receive the first captured frame. We set stereo input here to
// avoid triggering a possible error in SetSendCodec when a stereo
// codec is selected.
if (_audioProcessingModulePtr->set_num_channels(2, 1) != 0)
{
_engineStatistics.SetLastError(VE_SOUNDCARD_ERROR, kTraceError,
"Init() failed to set channels for the primary audio stream");
return -1;
}
if (_audioProcessingModulePtr->set_num_reverse_channels(1) != 0)
{
_engineStatistics.SetLastError(VE_SOUNDCARD_ERROR, kTraceError,
"Init() failed to set channels for the primary audio stream");
return -1;
}
// high-pass filter
if (_audioProcessingModulePtr->high_pass_filter()->Enable(
WEBRTC_VOICE_ENGINE_HP_DEFAULT_STATE) != 0)
{
_engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
"Init() failed to set the high-pass filter for AP module");
return -1;
}
// Echo Cancellation
if (_audioProcessingModulePtr->echo_cancellation()->
enable_drift_compensation(false) != 0)
{
_engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
"Init() failed to set drift compensation for AP module");
return -1;
}
if (_audioProcessingModulePtr->echo_cancellation()->Enable(
WEBRTC_VOICE_ENGINE_EC_DEFAULT_STATE))
{
_engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
"Init() failed to set echo cancellation state for AP module");
return -1;
}
// Noise Reduction
if (_audioProcessingModulePtr->noise_suppression()->set_level(
(NoiseSuppression::Level) WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE)
!= 0)
{
_engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
"Init() failed to set noise reduction level for AP module");
return -1;
}
if (_audioProcessingModulePtr->noise_suppression()->Enable(
WEBRTC_VOICE_ENGINE_NS_DEFAULT_STATE) != 0)
{
_engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
"Init() failed to set noise reduction state for AP module");
return -1;
}
// Automatic Gain control
if (_audioProcessingModulePtr->gain_control()->set_analog_level_limits(
kMinVolumeLevel,kMaxVolumeLevel) != 0)
{
_engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
"Init() failed to set AGC analog level for AP module");
return -1;
}
if (_audioProcessingModulePtr->gain_control()->set_mode(
(GainControl::Mode) WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE)
!= 0)
{
_engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
"Init() failed to set AGC mode for AP module");
return -1;
}
if (_audioProcessingModulePtr->gain_control()->Enable(
WEBRTC_VOICE_ENGINE_AGC_DEFAULT_STATE)
!= 0)
{
_engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
"Init() failed to set AGC state for AP module");
return -1;
}
// VAD
if (_audioProcessingModulePtr->voice_detection()->Enable(
WEBRTC_VOICE_ENGINE_VAD_DEFAULT_STATE)
!= 0)
{
_engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
"Init() failed to set VAD state for AP module");
return -1;
}
}
// Set default AGC mode for the ADM
#ifdef WEBRTC_VOICE_ENGINE_AGC
bool enable(false);
if (_audioProcessingModulePtr->gain_control()->mode()
!= GainControl::kFixedDigital)
{
enable = _audioProcessingModulePtr->gain_control()->is_enabled();
// Only set the AGC mode for the ADM when Adaptive AGC mode is selected
if (_audioDevicePtr->SetAGC(enable) != 0)
{
_engineStatistics.SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR,
kTraceError, "Init() failed to set default AGC mode in ADM 0");
}
}
#endif
return _engineStatistics.SetInitialized();
}
int VoEBaseImpl::Terminate()
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"Terminate()");
CriticalSectionScoped cs(*_apiCritPtr);
return TerminateInternal();
}
int VoEBaseImpl::MaxNumOfChannels()
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"MaxNumOfChannels()");
WebRtc_Word32 maxNumOfChannels = _channelManager.MaxNumOfChannels();
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
"MaxNumOfChannels() => %d", maxNumOfChannels);
return (maxNumOfChannels);
}
int VoEBaseImpl::CreateChannel()
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"CreateChannel()");
CriticalSectionScoped cs(*_apiCritPtr);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
WebRtc_Word32 channelId = -1;
if (!_channelManager.CreateChannel(channelId))
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_CREATED, kTraceError,
"CreateChannel() failed to allocate "
"memory for channel");
return -1;
}
bool destroyChannel(false);
{
voe::ScopedChannel sc(_channelManager, channelId);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_CREATED, kTraceError,
"CreateChannel() failed to allocate"
" memory for channel");
return -1;
}
else if (channelPtr->SetEngineInformation(_engineStatistics,
*_outputMixerPtr,
*_transmitMixerPtr,
*_moduleProcessThreadPtr,
*_audioDevicePtr,
_voiceEngineObserverPtr,
&_callbackCritSect) != 0)
{
destroyChannel = true;
_engineStatistics.SetLastError(VE_CHANNEL_NOT_CREATED, kTraceError,
"CreateChannel() failed to "
"associate engine and channel."
" Destroying channel.");
}
else if (channelPtr->Init() != 0)
{
destroyChannel = true;
_engineStatistics.SetLastError(VE_CHANNEL_NOT_CREATED, kTraceError,
"CreateChannel() failed to "
"initialize channel. Destroying"
" channel.");
}
}
if (destroyChannel)
{
_channelManager.DestroyChannel(channelId);
return -1;
}
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
"CreateChannel() => %d", channelId);
return channelId;
}
int VoEBaseImpl::DeleteChannel(int channel)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"DeleteChannel(channel=%d)", channel);
CriticalSectionScoped cs(*_apiCritPtr);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
{
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"DeleteChannel() failed to locate "
"channel");
return -1;
}
}
if (_channelManager.DestroyChannel(channel) != 0)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"DeleteChannel() failed to destroy "
"channel");
return -1;
}
if (StopSend() != 0)
{
return -1;
}
if (StopPlayout() != 0)
{
return -1;
}
return 0;
}
int VoEBaseImpl::SetLocalReceiver(int channel, int port, int RTCPport,
const char ipAddr[64],
const char multiCastAddr[64])
{
// Inititialize local receive sockets (RTP and RTCP).
//
// The sockets are always first closed and then created again by this
// function call. The created sockets are by default also used for
// transmission (unless source port is set in SetSendDestination).
//
// Note that, sockets can also be created automatically if a user calls
// SetSendDestination and StartSend without having called SetLocalReceiver
// first. The sockets are then created at the first packet transmission.
CriticalSectionScoped cs(*_apiCritPtr);
if (ipAddr == NULL && multiCastAddr == NULL)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"SetLocalReceiver(channel=%d, port=%d, RTCPport=%d)",
channel, port, RTCPport);
}
else if (ipAddr != NULL && multiCastAddr == NULL)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"SetLocalReceiver(channel=%d, port=%d, RTCPport=%d, "
"ipAddr=%s)", channel, port, RTCPport, ipAddr);
}
else if (ipAddr == NULL && multiCastAddr != NULL)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"SetLocalReceiver(channel=%d, port=%d, RTCPport=%d, "
"multiCastAddr=%s)", channel, port, RTCPport,
multiCastAddr);
}
else
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"SetLocalReceiver(channel=%d, port=%d, RTCPport=%d, "
"ipAddr=%s, multiCastAddr=%s)", channel, port,
RTCPport, ipAddr, multiCastAddr);
}
#ifndef WEBRTC_EXTERNAL_TRANSPORT
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
if ((port < 0) || (port > 65535))
{
_engineStatistics.SetLastError(VE_INVALID_PORT_NMBR, kTraceError,
"SetLocalReceiver() invalid RTP port");
return -1;
}
if (((RTCPport != kVoEDefault) && (RTCPport < 0)) || ((RTCPport
!= kVoEDefault) && (RTCPport > 65535)))
{
_engineStatistics.SetLastError(VE_INVALID_PORT_NMBR, kTraceError,
"SetLocalReceiver() invalid RTCP port");
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"SetLocalReceiver() failed to locate "
"channel");
return -1;
}
// Cast RTCP port. In the RTP module 0 corresponds to RTP port + 1 in
// the module, which is the default.
WebRtc_UWord16 rtcpPortUW16(0);
if (RTCPport != kVoEDefault)
{
rtcpPortUW16 = static_cast<WebRtc_UWord16> (RTCPport);
}
return channelPtr->SetLocalReceiver(port, rtcpPortUW16, ipAddr,
multiCastAddr);
#else
_engineStatistics.SetLastError(VE_EXTERNAL_TRANSPORT_ENABLED,
kTraceWarning,
"SetLocalReceiver() VoE is built for "
"external transport");
return -1;
#endif
}
int VoEBaseImpl::GetLocalReceiver(int channel, int& port, int& RTCPport,
char ipAddr[64])
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"GetLocalReceiver(channel=%d, ipAddr[]=?)", channel);
#ifndef WEBRTC_EXTERNAL_TRANSPORT
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"SetLocalReceiver() failed to locate "
"channel");
return -1;
}
WebRtc_Word32 ret = channelPtr->GetLocalReceiver(port, RTCPport, ipAddr);
if (ipAddr != NULL)
{
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
"GetLocalReceiver() => port=%d, RTCPport=%d, ipAddr=%s",
port, RTCPport, ipAddr);
}
else
{
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
"GetLocalReceiver() => port=%d, RTCPport=%d", port,
RTCPport);
}
return ret;
#else
_engineStatistics.SetLastError(VE_EXTERNAL_TRANSPORT_ENABLED,
kTraceWarning,
"SetLocalReceiver() VoE is built for "
"external transport");
return -1;
#endif
}
int VoEBaseImpl::SetSendDestination(int channel, int port, const char* ipaddr,
int sourcePort, int RTCPport)
{
WEBRTC_TRACE(
kTraceApiCall,
kTraceVoice,
VoEId(_instanceId, -1),
"SetSendDestination(channel=%d, port=%d, ipaddr=%s,"
"sourcePort=%d, RTCPport=%d)",
channel, port, ipaddr, sourcePort, RTCPport);
CriticalSectionScoped cs(*_apiCritPtr);
#ifndef WEBRTC_EXTERNAL_TRANSPORT
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"SetSendDestination() failed to locate "
"channel");
return -1;
}
if ((port < 0) || (port > 65535))
{
_engineStatistics.SetLastError(VE_INVALID_PORT_NMBR, kTraceError,
"SetSendDestination() invalid RTP port");
return -1;
}
if (((RTCPport != kVoEDefault) && (RTCPport < 0)) || ((RTCPport
!= kVoEDefault) && (RTCPport > 65535)))
{
_engineStatistics.SetLastError(VE_INVALID_PORT_NMBR, kTraceError,
"SetSendDestination() invalid RTCP "
"port");
return -1;
}
if (((sourcePort != kVoEDefault) && (sourcePort < 0)) || ((sourcePort
!= kVoEDefault) && (sourcePort > 65535)))
{
_engineStatistics.SetLastError(VE_INVALID_PORT_NMBR, kTraceError,
"SetSendDestination() invalid source "
"port");
return -1;
}
// Cast RTCP port. In the RTP module 0 corresponds to RTP port + 1 in the
// module, which is the default.
WebRtc_UWord16 rtcpPortUW16(0);
if (RTCPport != kVoEDefault)
{
rtcpPortUW16 = static_cast<WebRtc_UWord16> (RTCPport);
WEBRTC_TRACE(
kTraceInfo,
kTraceVoice,
VoEId(_instanceId, channel),
"SetSendDestination() non default RTCP port %u will be "
"utilized",
rtcpPortUW16);
}
return channelPtr->SetSendDestination(port, ipaddr, sourcePort,
rtcpPortUW16);
#else
_engineStatistics.SetLastError(VE_EXTERNAL_TRANSPORT_ENABLED,
kTraceWarning,
"SetSendDestination() VoE is built for "
"external transport");
return -1;
#endif
}
int VoEBaseImpl::GetSendDestination(int channel, int& port, char ipAddr[64],
int& sourcePort, int& RTCPport)
{
WEBRTC_TRACE(
kTraceApiCall,
kTraceVoice,
VoEId(_instanceId, -1),
"GetSendDestination(channel=%d, ipAddr[]=?, sourcePort=?,"
"RTCPport=?)",
channel);
#ifndef WEBRTC_EXTERNAL_TRANSPORT
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"GetSendDestination() failed to locate "
"channel");
return -1;
}
WebRtc_Word32 ret = channelPtr->GetSendDestination(port, ipAddr,
sourcePort, RTCPport);
if (ipAddr != NULL)
{
WEBRTC_TRACE(
kTraceStateInfo,
kTraceVoice,
VoEId(_instanceId, -1),
"GetSendDestination() => port=%d, RTCPport=%d, ipAddr=%s, "
"sourcePort=%d, RTCPport=%d",
port, RTCPport, ipAddr, sourcePort, RTCPport);
}
else
{
WEBRTC_TRACE(
kTraceStateInfo,
kTraceVoice,
VoEId(_instanceId, -1),
"GetSendDestination() => port=%d, RTCPport=%d, "
"sourcePort=%d, RTCPport=%d",
port, RTCPport, sourcePort, RTCPport);
}
return ret;
#else
_engineStatistics.SetLastError(VE_EXTERNAL_TRANSPORT_ENABLED,
kTraceWarning,
"GetSendDestination() VoE is built for "
"external transport");
return -1;
#endif
}
int VoEBaseImpl::StartReceive(int channel)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"StartReceive(channel=%d)", channel);
CriticalSectionScoped cs(*_apiCritPtr);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"StartReceive() failed to locate "
"channel");
return -1;
}
return channelPtr->StartReceiving();
}
int VoEBaseImpl::StopReceive(int channel)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"StopListen(channel=%d)", channel);
CriticalSectionScoped cs(*_apiCritPtr);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"SetLocalReceiver() failed to locate "
"channel");
return -1;
}
return channelPtr->StopReceiving();
}
int VoEBaseImpl::StartPlayout(int channel)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"StartPlayout(channel=%d)", channel);
CriticalSectionScoped cs(*_apiCritPtr);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"StartPlayout() failed to locate "
"channel");
return -1;
}
if (channelPtr->Playing())
{
return 0;
}
if (StartPlayout() != 0)
{
_engineStatistics.SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR,
kTraceError,
"StartPlayout() failed to start "
"playout");
return -1;
}
return channelPtr->StartPlayout();
}
int VoEBaseImpl::StopPlayout(int channel)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"StopPlayout(channel=%d)", channel);
CriticalSectionScoped cs(*_apiCritPtr);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"StopPlayout() failed to locate "
"channel");
return -1;
}
if (channelPtr->StopPlayout() != 0)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
"StopPlayout() failed to stop playout for channel %d",
channel);
}
return StopPlayout();
}
int VoEBaseImpl::StartSend(int channel)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"StartSend(channel=%d)", channel);
CriticalSectionScoped cs(*_apiCritPtr);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"StartSend() failed to locate channel");
return -1;
}
if (channelPtr->Sending())
{
return 0;
}
#ifndef WEBRTC_EXTERNAL_TRANSPORT
if (!channelPtr->ExternalTransport()
&& !channelPtr->SendSocketsInitialized())
{
_engineStatistics.SetLastError(VE_DESTINATION_NOT_INITED, kTraceError,
"StartSend() must set send destination "
"first");
return -1;
}
#endif
if (StartSend() != 0)
{
_engineStatistics.SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR,
kTraceError,
"StartSend() failed to start recording");
return -1;
}
return channelPtr->StartSend();
}
int VoEBaseImpl::StopSend(int channel)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"StopSend(channel=%d)", channel);
CriticalSectionScoped cs(*_apiCritPtr);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"StopSend() failed to locate channel");
return -1;
}
if (channelPtr->StopSend() != 0)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
"StopSend() failed to stop sending for channel %d",
channel);
}
return StopSend();
}
int VoEBaseImpl::GetVersion(char version[1024])
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"GetVersion(version=?)");
assert(kVoiceEngineVersionMaxMessageSize == 1024);
if (version == NULL)
{
_engineStatistics.SetLastError(VE_INVALID_ARGUMENT, kTraceError);
return (-1);
}
char versionBuf[kVoiceEngineVersionMaxMessageSize];
char* versionPtr = versionBuf;
WebRtc_Word32 len = 0;
WebRtc_Word32 accLen = 0;
len = AddVoEVersion(versionPtr);
if (len == -1)
{
return -1;
}
versionPtr += len;
accLen += len;
assert(accLen < kVoiceEngineVersionMaxMessageSize);
len = AddBuildInfo(versionPtr);
if (len == -1)
{
return -1;
}
versionPtr += len;
accLen += len;
assert(accLen < kVoiceEngineVersionMaxMessageSize);
#ifdef WEBRTC_EXTERNAL_TRANSPORT
len = AddExternalTransportBuild(versionPtr);
if (len == -1)
{
return -1;
}
versionPtr += len;
accLen += len;
assert(accLen < kVoiceEngineVersionMaxMessageSize);
#endif
#ifdef WEBRTC_VOE_EXTERNAL_REC_AND_PLAYOUT
len = AddExternalRecAndPlayoutBuild(versionPtr);
if (len == -1)
{
return -1;
}
versionPtr += len;
accLen += len;
assert(accLen < kVoiceEngineVersionMaxMessageSize);
#endif
memcpy(version, versionBuf, accLen);
version[accLen] = '\0';
// to avoid the truncation in the trace, split the string into parts
char partOfVersion[256];
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
"GetVersion() =>");
for (int partStart = 0; partStart < accLen;)
{
memset(partOfVersion, 0, sizeof(partOfVersion));
int partEnd = partStart + 180;
while (version[partEnd] != '\n' && version[partEnd] != '\0')
{
partEnd--;
}
if (partEnd < accLen)
{
memcpy(partOfVersion, &version[partStart], partEnd - partStart);
}
else
{
memcpy(partOfVersion, &version[partStart], accLen - partStart);
}
partStart = partEnd;
WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
"%s", partOfVersion);
}
return 0;
}
WebRtc_Word32 VoEBaseImpl::AddBuildInfo(char* str) const
{
return sprintf(str, "Build: %s\n", BUILDINFO);
}
WebRtc_Word32 VoEBaseImpl::AddVoEVersion(char* str) const
{
return sprintf(str, "VoiceEngine 4.1.0\n");
}
#ifdef WEBRTC_EXTERNAL_TRANSPORT
WebRtc_Word32 VoEBaseImpl::AddExternalTransportBuild(char* str) const
{
return sprintf(str, "External transport build\n");
}
#endif
#ifdef WEBRTC_VOE_EXTERNAL_REC_AND_PLAYOUT
WebRtc_Word32 VoEBaseImpl::AddExternalRecAndPlayoutBuild(char* str) const
{
return sprintf(str, "External recording and playout build\n");
}
#endif
int VoEBaseImpl::LastError()
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"LastError()");
return (_engineStatistics.LastError());
}
int VoEBaseImpl::SetNetEQPlayoutMode(int channel, NetEqModes mode)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"SetNetEQPlayoutMode(channel=%i, mode=%i)", channel, mode);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"SetNetEQPlayoutMode() failed to locate"
" channel");
return -1;
}
return channelPtr->SetNetEQPlayoutMode(mode);
}
int VoEBaseImpl::GetNetEQPlayoutMode(int channel, NetEqModes& mode)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"GetNetEQPlayoutMode(channel=%i, mode=?)", channel);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"GetNetEQPlayoutMode() failed to locate"
" channel");
return -1;
}
return channelPtr->GetNetEQPlayoutMode(mode);
}
int VoEBaseImpl::SetNetEQBGNMode(int channel, NetEqBgnModes mode)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"SetNetEQBGNMode(channel=%i, mode=%i)", channel, mode);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"SetNetEQBGNMode() failed to locate "
"channel");
return -1;
}
return channelPtr->SetNetEQBGNMode(mode);
}
int VoEBaseImpl::GetNetEQBGNMode(int channel, NetEqBgnModes& mode)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"GetNetEQBGNMode(channel=%i, mode=?)", channel);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"GetNetEQBGNMode() failed to locate "
"channel");
return -1;
}
return channelPtr->GetNetEQBGNMode(mode);
}
int VoEBaseImpl::SetOnHoldStatus(int channel, bool enable, OnHoldModes mode)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"SetOnHoldStatus(channel=%d, enable=%d, mode=%d)", channel,
enable, mode);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"SetOnHoldStatus() failed to locate "
"channel");
return -1;
}
return channelPtr->SetOnHoldStatus(enable, mode);
}
int VoEBaseImpl::GetOnHoldStatus(int channel, bool& enabled, OnHoldModes& mode)
{
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
"GetOnHoldStatus(channel=%d, enabled=?, mode=?)", channel);
if (!_engineStatistics.Initialized())
{
_engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
return -1;
}
voe::ScopedChannel sc(_channelManager, channel);
voe::Channel* channelPtr = sc.ChannelPtr();
if (channelPtr == NULL)
{
_engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
"GetOnHoldStatus() failed to locate "
"channel");
return -1;
}
return channelPtr->GetOnHoldStatus(enabled, mode);
}
WebRtc_Word32 VoEBaseImpl::StartPlayout()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::StartPlayout()");
if (_audioDevicePtr->Playing())
{
return 0;
}
if (!_externalPlayout)
{
if (_audioDevicePtr->InitPlayout() != 0)
{
WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1),
"StartPlayout() failed to initialize playout");
return -1;
}
if (_audioDevicePtr->StartPlayout() != 0)
{
WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1),
"StartPlayout() failed to start playout");
return -1;
}
}
return 0;
}
WebRtc_Word32 VoEBaseImpl::StopPlayout()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::StopPlayout()");
WebRtc_Word32 numOfChannels = _channelManager.NumOfChannels();
if (numOfChannels <= 0)
{
return 0;
}
WebRtc_UWord16 nChannelsPlaying(0);
WebRtc_Word32* channelsArray = new WebRtc_Word32[numOfChannels];
// Get number of playing channels
_channelManager.GetChannelIds(channelsArray, numOfChannels);
for (int i = 0; i < numOfChannels; i++)
{
voe::ScopedChannel sc(_channelManager, channelsArray[i]);
voe::Channel* chPtr = sc.ChannelPtr();
if (chPtr)
{
if (chPtr->Playing())
{
nChannelsPlaying++;
}
}
}
delete[] channelsArray;
// Stop audio-device playing if no channel is playing out
if (nChannelsPlaying == 0)
{
if (_audioDevicePtr->StopPlayout() != 0)
{
_engineStatistics.SetLastError(VE_CANNOT_STOP_PLAYOUT, kTraceError,
"StopPlayout() failed to stop "
"playout");
return -1;
}
}
return 0;
}
WebRtc_Word32 VoEBaseImpl::StartSend()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::StartSend()");
if (_audioDevicePtr->Recording())
{
return 0;
}
if (!_externalRecording)
{
if (_audioDevicePtr->InitRecording() != 0)
{
WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1),
"StartSend() failed to initialize recording");
return -1;
}
if (_audioDevicePtr->StartRecording() != 0)
{
WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1),
"StartSend() failed to start recording");
return -1;
}
}
return 0;
}
WebRtc_Word32 VoEBaseImpl::StopSend()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::StopSend()");
if ((NumOfSendingChannels() == 0) && !_transmitMixerPtr->IsRecordingMic())
{
// Stop audio-device recording if no channel is recording
if (_audioDevicePtr->StopRecording() != 0)
{
_engineStatistics.SetLastError(VE_CANNOT_STOP_RECORDING,
kTraceError,
"StopSend() failed to stop "
"recording");
return -1;
}
_transmitMixerPtr->StopSend();
}
return 0;
}
WebRtc_Word32 VoEBaseImpl::TerminateInternal()
{
WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
"VoEBaseImpl::TerminateInternal()");
// Delete any remaining channel objects
WebRtc_Word32 numOfChannels = _channelManager.NumOfChannels();
if (numOfChannels > 0)
{
WebRtc_Word32* channelsArray = new WebRtc_Word32[numOfChannels];
_channelManager.GetChannelIds(channelsArray, numOfChannels);
for (int i = 0; i < numOfChannels; i++)
{
DeleteChannel(channelsArray[i]);
}
delete[] channelsArray;
}
if (_moduleProcessThreadPtr)
{
if (_audioDevicePtr)
{
if (_moduleProcessThreadPtr->DeRegisterModule(_audioDevicePtr) != 0)
{
_engineStatistics.SetLastError(VE_THREAD_ERROR, kTraceError,
"TerminateInternal() failed to "
"deregister ADM");
}
}
if (_moduleProcessThreadPtr->Stop() != 0)
{
_engineStatistics.SetLastError(VE_THREAD_ERROR, kTraceError,
"TerminateInternal() failed to stop "
"module process thread");
}
}
// Audio Device Module
if (_audioDevicePtr != NULL)
{
if (_audioDevicePtr->StopPlayout() != 0)
{
_engineStatistics.SetLastError(VE_SOUNDCARD_ERROR, kTraceWarning,
"TerminateInternal() failed to stop "
"playout");
}
if (_audioDevicePtr->StopRecording() != 0)
{
_engineStatistics.SetLastError(VE_SOUNDCARD_ERROR, kTraceWarning,
"TerminateInternal() failed to stop "
"recording");
}
_audioDevicePtr->RegisterEventObserver(NULL);
_audioDevicePtr->RegisterAudioCallback(NULL);
if (_audioDevicePtr->Terminate() != 0)
{
_engineStatistics.SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR,
kTraceError,
"TerminateInternal() failed to "
"terminate the ADM");
}
_audioDevicePtr->Release();
_audioDevicePtr = NULL;
}
// AP module
if (_audioProcessingModulePtr != NULL)
{
_transmitMixerPtr->SetAudioProcessingModule(NULL);
AudioProcessing::Destroy(_audioProcessingModulePtr);
_audioProcessingModulePtr = NULL;
}
return _engineStatistics.SetUnInitialized();
}
} // namespace webrtc