blob: 1e5f98a7401f2cba4fc3c80f047fdc892bd57be8 [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 <stdio.h>
#include <string.h>
#include <math.h>
#include "engine_configurations.h"
#if defined(_WIN32)
#include <conio.h> // exists only on windows
#include <tchar.h>
#endif
#include "voe_standard_test.h"
#if defined (_ENABLE_VISUAL_LEAK_DETECTOR_) && defined(_DEBUG) && \
defined(_WIN32) && !defined(_INSTRUMENTATION_TESTING_)
#include "vld.h"
#endif
#ifdef MAC_IPHONE
#include "../../source/voice_engine_defines.h" // defines build macros
#else
#include "../../source/voice_engine_defines.h" // defines build macros
#endif
#include "automated_mode.h"
#include "critical_section_wrapper.h"
#include "event_wrapper.h"
#include "thread_wrapper.h"
#ifdef _TEST_NETEQ_STATS_
#include "../../interface/voe_neteq_stats.h" // Not available in delivery folder
#endif
#include "voe_extended_test.h"
#include "voe_stress_test.h"
#include "voe_unit_test.h"
#include "voe_cpu_test.h"
using namespace webrtc;
namespace voetest {
#ifdef MAC_IPHONE
// Defined in iPhone specific test file
int GetDocumentsDir(char* buf, int bufLen);
char* GetFilename(char* filename);
const char* GetFilename(const char* filename);
int GetResource(char* resource, char* dest, int destLen);
char* GetResource(char* resource);
const char* GetResource(const char* resource);
// #ifdef MAC_IPHONE
#elif defined(WEBRTC_ANDROID)
char filenameStr[2][256];
int currentStr = 0;
char* GetFilename(char* filename) {
currentStr = !currentStr;
sprintf(filenameStr[currentStr], "/sdcard/%s", filename);
return filenameStr[currentStr];
}
const char* GetFilename(const char* filename) {
currentStr = !currentStr;
sprintf(filenameStr[currentStr], "/sdcard/%s", filename);
return filenameStr[currentStr];
}
int GetResource(char* resource, char* dest, int destLen) {
currentStr = !currentStr;
sprintf(filenameStr[currentStr], "/sdcard/%s", resource);
strncpy(dest, filenameStr[currentStr], destLen-1);
return 0;
}
char* GetResource(char* resource) {
currentStr = !currentStr;
sprintf(filenameStr[currentStr], "/sdcard/%s", resource);
return filenameStr[currentStr];
}
const char* GetResource(const char* resource) {
currentStr = !currentStr;
sprintf(filenameStr[currentStr], "/sdcard/%s", resource);
return filenameStr[currentStr];
}
#else
char filenameStr[2][256];
int currentStr = 0;
char* GetFilename(char* filename) {
currentStr = !currentStr;
sprintf(filenameStr[currentStr], "/tmp/%s", filename);
return filenameStr[currentStr];
}
const char* GetFilename(const char* filename) {
currentStr = !currentStr;
sprintf(filenameStr[currentStr], "/tmp/%s", filename);
return filenameStr[currentStr];
}
int GetResource(char* resource, char* dest, int destLen) {
currentStr = !currentStr;
sprintf(filenameStr[currentStr], "/tmp/%s", resource);
strncpy(dest, filenameStr[currentStr], destLen - 1);
return 0;
}
char* GetResource(char* resource) {
currentStr = !currentStr;
sprintf(filenameStr[currentStr], "/tmp/%s", resource);
return filenameStr[currentStr];
}
const char* GetResource(const char* resource) {
currentStr = !currentStr;
sprintf(filenameStr[currentStr], "/tmp/%s", resource);
return filenameStr[currentStr];
}
#endif
#if !defined(MAC_IPHONE)
const char* summaryFilename = "/tmp/VoiceEngineSummary.txt";
#endif
// For iPhone the summary filename is created in createSummary
int dummy = 0; // Dummy used in different functions to avoid warnings
TestRtpObserver::TestRtpObserver() {
Reset();
}
TestRtpObserver::~TestRtpObserver() {
}
void TestRtpObserver::Reset() {
for (int i = 0; i < 2; i++) {
ssrc_[i] = 0;
csrc_[i][0] = 0;
csrc_[i][1] = 0;
added_[i][0] = false;
added_[i][1] = false;
size_[i] = 0;
}
}
void TestRtpObserver::OnIncomingCSRCChanged(const int channel,
const unsigned int CSRC,
const bool added) {
char msg[128];
sprintf(msg, "=> OnIncomingCSRCChanged(channel=%d, CSRC=%u, added=%d)\n",
channel, CSRC, added);
TEST_LOG("%s", msg);
if (channel > 1)
return; // Not enough memory.
csrc_[channel][size_[channel]] = CSRC;
added_[channel][size_[channel]] = added;
size_[channel]++;
if (size_[channel] == 2)
size_[channel] = 0;
}
void TestRtpObserver::OnIncomingSSRCChanged(const int channel,
const unsigned int SSRC) {
char msg[128];
sprintf(msg, "\n=> OnIncomingSSRCChanged(channel=%d, SSRC=%u)\n", channel,
SSRC);
TEST_LOG("%s", msg);
ssrc_[channel] = SSRC;
}
void MyDeadOrAlive::OnPeriodicDeadOrAlive(const int /*channel*/,
const bool alive) {
if (alive) {
TEST_LOG("ALIVE\n");
} else {
TEST_LOG("DEAD\n");
}
fflush(NULL);
}
#ifdef WEBRTC_VOICE_ENGINE_EXTERNAL_MEDIA_API
void MyMedia::Process(const int channel,
const ProcessingTypes type,
WebRtc_Word16 audio_10ms[],
const int length,
const int samplingFreqHz,
const bool stereo) {
for (int i = 0; i < length; i++) {
if (!stereo) {
audio_10ms[i] = (WebRtc_Word16) (audio_10ms[i] *
sin(2.0 * 3.14 * f * 400.0 / samplingFreqHz));
} else {
// interleaved stereo
audio_10ms[2 * i] = (WebRtc_Word16) (audio_10ms[2 * i] *
sin(2.0 * 3.14 * f * 400.0 / samplingFreqHz));
audio_10ms[2 * i + 1] = (WebRtc_Word16) (audio_10ms[2 * i + 1] *
sin(2.0 * 3.14 * f * 400.0 / samplingFreqHz));
}
f++;
}
}
#endif
MyMedia mobj;
FakeExternalTransport::FakeExternalTransport(VoENetwork* ptr)
: my_network_(ptr),
thread_(NULL),
lock_(NULL),
event_(NULL),
length_(0),
channel_(0),
delay_is_enabled_(0),
delay_time_in_ms_(0) {
const char* threadName = "external_thread";
lock_ = CriticalSectionWrapper::CreateCriticalSection();
event_ = EventWrapper::Create();
thread_ = ThreadWrapper::CreateThread(Run, this, kHighPriority, threadName);
if (thread_) {
unsigned int id;
thread_->Start(id);
}
}
FakeExternalTransport::~FakeExternalTransport() {
if (thread_) {
thread_->SetNotAlive();
event_->Set();
if (thread_->Stop()) {
delete thread_;
thread_ = NULL;
delete event_;
event_ = NULL;
delete lock_;
lock_ = NULL;
}
}
}
bool FakeExternalTransport::Run(void* ptr) {
return static_cast<FakeExternalTransport*> (ptr)->Process();
}
bool FakeExternalTransport::Process() {
switch (event_->Wait(500)) {
case kEventSignaled:
lock_->Enter();
my_network_->ReceivedRTPPacket(channel_, packet_buffer_, length_);
lock_->Leave();
return true;
case kEventTimeout:
return true;
case kEventError:
break;
}
return true;
}
int FakeExternalTransport::SendPacket(int channel, const void *data, int len) {
lock_->Enter();
if (len < 1612) {
memcpy(packet_buffer_, (const unsigned char*) data, len);
length_ = len;
channel_ = channel;
}
lock_->Leave();
event_->Set(); // triggers ReceivedRTPPacket() from worker thread
return len;
}
int FakeExternalTransport::SendRTCPPacket(int channel, const void *data, int len) {
if (delay_is_enabled_) {
Sleep(delay_time_in_ms_);
}
my_network_->ReceivedRTCPPacket(channel, data, len);
return len;
}
void FakeExternalTransport::SetDelayStatus(bool enable, unsigned int delayInMs) {
delay_is_enabled_ = enable;
delay_time_in_ms_ = delayInMs;
}
ErrorObserver::ErrorObserver() {
code = -1;
}
void ErrorObserver::CallbackOnError(const int channel, const int errCode) {
code = errCode;
#ifndef _INSTRUMENTATION_TESTING_
TEST_LOG("\n************************\n");
TEST_LOG(" RUNTIME ERROR: %d \n", errCode);
TEST_LOG("************************\n");
#endif
}
void MyTraceCallback::Print(const TraceLevel level,
const char *traceString,
const int length) {
if (traceString) {
char* tmp = new char[length];
memcpy(tmp, traceString, length);
TEST_LOG("%s", tmp);
TEST_LOG("\n");
delete[] tmp;
}
}
void RtcpAppHandler::OnApplicationDataReceived(
const int /*channel*/, const unsigned char sub_type,
const unsigned int name, const unsigned char* data,
const unsigned short length_in_bytes) {
length_in_bytes_ = length_in_bytes;
memcpy(data_, &data[0], length_in_bytes);
sub_type_ = sub_type;
name_ = name;
}
void RtcpAppHandler::Reset() {
length_in_bytes_ = 0;
memset(data_, 0, sizeof(data_));
sub_type_ = 0;
name_ = 0;
}
void my_encryption::encrypt(int, unsigned char * in_data,
unsigned char * out_data,
int bytes_in,
int * bytes_out) {
int i;
for (i = 0; i < bytes_in; i++)
out_data[i] = ~in_data[i];
*bytes_out = bytes_in + 2; // length is increased by 2
}
void my_encryption::decrypt(int, unsigned char * in_data,
unsigned char * out_data,
int bytes_in,
int * bytes_out) {
int i;
for (i = 0; i < bytes_in; i++)
out_data[i] = ~in_data[i];
*bytes_out = bytes_in - 2; // length is decreased by 2
}
void my_encryption::encrypt_rtcp(int,
unsigned char * in_data,
unsigned char * out_data,
int bytes_in,
int * bytes_out) {
int i;
for (i = 0; i < bytes_in; i++)
out_data[i] = ~in_data[i];
*bytes_out = bytes_in + 2;
}
void my_encryption::decrypt_rtcp(int, unsigned char * in_data,
unsigned char * out_data,
int bytes_in,
int * bytes_out) {
int i;
for (i = 0; i < bytes_in; i++)
out_data[i] = ~in_data[i];
*bytes_out = bytes_in + 2;
}
void SubAPIManager::DisplayStatus() const {
TEST_LOG("Supported sub APIs:\n\n");
if (_base)
TEST_LOG(" Base\n");
if (_callReport)
TEST_LOG(" CallReport\n");
if (_codec)
TEST_LOG(" Codec\n");
if (_dtmf)
TEST_LOG(" Dtmf\n");
if (_encryption)
TEST_LOG(" Encryption\n");
if (_externalMedia)
TEST_LOG(" ExternalMedia\n");
if (_file)
TEST_LOG(" File\n");
if (_hardware)
TEST_LOG(" Hardware\n");
if (_netEqStats)
TEST_LOG(" NetEqStats\n");
if (_network)
TEST_LOG(" Network\n");
if (_rtp_rtcp)
TEST_LOG(" RTP_RTCP\n");
if (_videoSync)
TEST_LOG(" VideoSync\n");
if (_volumeControl)
TEST_LOG(" VolumeControl\n");
if (_apm)
TEST_LOG(" AudioProcessing\n");
ANL();
TEST_LOG("Excluded sub APIs:\n\n");
if (!_base)
TEST_LOG(" Base\n");
if (!_callReport)
TEST_LOG(" CallReport\n");
if (!_codec)
TEST_LOG(" Codec\n");
if (!_dtmf)
TEST_LOG(" Dtmf\n");
if (!_encryption)
TEST_LOG(" Encryption\n");
if (!_externalMedia)
TEST_LOG(" ExternamMedia\n");
if (!_file)
TEST_LOG(" File\n");
if (!_hardware)
TEST_LOG(" Hardware\n");
if (!_netEqStats)
TEST_LOG(" NetEqStats\n");
if (!_network)
TEST_LOG(" Network\n");
if (!_rtp_rtcp)
TEST_LOG(" RTP_RTCP\n");
if (!_videoSync)
TEST_LOG(" VideoSync\n");
if (!_volumeControl)
TEST_LOG(" VolumeControl\n");
if (!_apm)
TEST_LOG(" AudioProcessing\n");
ANL();
}
bool SubAPIManager::GetExtendedMenuSelection(ExtendedSelection& sel) {
printf("------------------------------------------------\n");
printf("Select extended test\n\n");
printf(" (0) None\n");
printf("- - - - - - - - - - - - - - - - - - - - - - - - \n");
printf(" (1) Base");
if (_base)
printf("\n");
else
printf(" (NA)\n");
printf(" (2) CallReport");
if (_callReport)
printf("\n");
else
printf(" (NA)\n");
printf(" (3) Codec");
if (_codec)
printf("\n");
else
printf(" (NA)\n");
printf(" (4) Dtmf");
if (_dtmf)
printf("\n");
else
printf(" (NA)\n");
printf(" (5) Encryption");
if (_encryption)
printf("\n");
else
printf(" (NA)\n");
printf(" (6) VoEExternalMedia");
if (_externalMedia)
printf("\n");
else
printf(" (NA)\n");
printf(" (7) File");
if (_file)
printf("\n");
else
printf(" (NA)\n");
printf(" (8) Mixing");
if (_file)
printf("\n");
else
printf(" (NA)\n");
printf(" (9) Hardware");
if (_hardware)
printf("\n");
else
printf(" (NA)\n");
printf(" (10) NetEqStats");
if (_netEqStats)
printf("\n");
else
printf(" (NA)\n");
printf(" (11) Network");
if (_network)
printf("\n");
else
printf(" (NA)\n");
printf(" (12) RTP_RTCP");
if (_rtp_rtcp)
printf("\n");
else
printf(" (NA)\n");
printf(" (13) VideoSync");
if (_videoSync)
printf("\n");
else
printf(" (NA)\n");
printf(" (14) VolumeControl");
if (_volumeControl)
printf("\n");
else
printf(" (NA)\n");
printf(" (15) AudioProcessing");
if (_apm)
printf("\n");
else
printf(" (NA)\n");
printf("\n: ");
ExtendedSelection xsel(XSEL_Invalid);
int selection(0);
dummy = scanf("%d", &selection);
switch (selection) {
case 0:
xsel = XSEL_None;
break;
case 1:
if (_base)
xsel = XSEL_Base;
break;
case 2:
if (_callReport)
xsel = XSEL_CallReport;
break;
case 3:
if (_codec)
xsel = XSEL_Codec;
break;
case 4:
if (_dtmf)
xsel = XSEL_DTMF;
break;
case 5:
if (_encryption)
xsel = XSEL_Encryption;
break;
case 6:
if (_externalMedia)
xsel = XSEL_ExternalMedia;
break;
case 7:
if (_file)
xsel = XSEL_File;
break;
case 8:
if (_file)
xsel = XSEL_Mixing;
break;
case 9:
if (_hardware)
xsel = XSEL_Hardware;
break;
case 10:
if (_netEqStats)
xsel = XSEL_NetEqStats;
break;
case 11:
if (_network)
xsel = XSEL_Network;
break;
case 12:
if (_rtp_rtcp)
xsel = XSEL_RTP_RTCP;
break;
case 13:
if (_videoSync)
xsel = XSEL_VideoSync;
break;
case 14:
if (_volumeControl)
xsel = XSEL_VolumeControl;
break;
case 15:
if (_apm)
xsel = XSEL_AudioProcessing;
break;
default:
xsel = XSEL_Invalid;
break;
}
if (xsel == XSEL_Invalid)
printf("Invalid selection!\n");
sel = xsel;
_xsel = xsel;
return (xsel != XSEL_Invalid);
}
VoETestManager::VoETestManager()
: initialized_(false),
voice_engine_(NULL),
voe_base_(0),
voe_call_report_(0),
voe_codec_(0),
voe_dtmf_(0),
voe_encrypt_(0),
voe_xmedia_(0),
voe_file_(0),
voe_hardware_(0),
voe_network_(0),
#ifdef _TEST_NETEQ_STATS_
voe_neteq_stats_(NULL),
#endif
voe_rtp_rtcp_(0),
voe_vsync_(0),
voe_volume_control_(0),
voe_apm_(0)
{
}
VoETestManager::~VoETestManager() {
}
bool VoETestManager::Init() {
if (initialized_)
return true;
if (VoiceEngine::SetTraceFile(NULL) != -1) {
// should not be possible to call a Trace method before the VoE is
// created
TEST_LOG("\nError at line: %i (VoiceEngine::SetTraceFile()"
"should fail)!\n", __LINE__);
return false;
}
voice_engine_ = VoiceEngine::Create();
if (!voice_engine_) {
TEST_LOG("Failed to create VoiceEngine\n");
return false;
}
return true;
}
void VoETestManager::GetInterfaces() {
if (voice_engine_) {
voe_base_ = VoEBase::GetInterface(voice_engine_);
voe_codec_ = VoECodec::GetInterface(voice_engine_);
voe_volume_control_ = VoEVolumeControl::GetInterface(voice_engine_);
voe_dtmf_ = VoEDtmf::GetInterface(voice_engine_);
voe_rtp_rtcp_ = VoERTP_RTCP::GetInterface(voice_engine_);
voe_apm_ = VoEAudioProcessing::GetInterface(voice_engine_);
voe_network_ = VoENetwork::GetInterface(voice_engine_);
voe_file_ = VoEFile::GetInterface(voice_engine_);
#ifdef _TEST_VIDEO_SYNC_
voe_vsync_ = VoEVideoSync::GetInterface(voice_engine_);
#endif
voe_encrypt_ = VoEEncryption::GetInterface(voice_engine_);
voe_hardware_ = VoEHardware::GetInterface(voice_engine_);
// Set the audio layer to use in all tests
if (voe_hardware_) {
int res = voe_hardware_->SetAudioDeviceLayer(TESTED_AUDIO_LAYER);
if (res < 0) {
printf("\nERROR: failed to set audio layer to use in "
"testing\n");
} else {
printf("\nAudio layer %d will be used in testing\n",
TESTED_AUDIO_LAYER);
}
}
#ifdef _TEST_XMEDIA_
voe_xmedia_ = VoEExternalMedia::GetInterface(voice_engine_);
#endif
#ifdef _TEST_CALL_REPORT_
voe_call_report_ = VoECallReport::GetInterface(voice_engine_);
#endif
#ifdef _TEST_NETEQ_STATS_
voe_neteq_stats_ = VoENetEqStats::GetInterface(voice_engine_);
#endif
}
}
int VoETestManager::ReleaseInterfaces() {
int err(0), remInt(1), j(0);
bool releaseOK(true);
if (voe_base_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_base_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d base interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
// try to release one addition time (should fail)
TEST_MUSTPASS(-1 != voe_base_->Release());
err = voe_base_->LastError();
// it is considered safe to delete even if Release has been called
// too many times
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
if (voe_codec_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_codec_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d codec interfaces"
" (should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_codec_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
if (voe_volume_control_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_volume_control_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d volume interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_volume_control_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
if (voe_dtmf_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_dtmf_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d dtmf interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_dtmf_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
if (voe_rtp_rtcp_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_rtp_rtcp_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d rtp/rtcp interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_rtp_rtcp_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
if (voe_apm_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_apm_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d apm interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_apm_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
if (voe_network_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_network_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d network interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_network_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
if (voe_file_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_file_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d file interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_file_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
#ifdef _TEST_VIDEO_SYNC_
if (voe_vsync_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_vsync_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d video sync interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_vsync_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
#endif
if (voe_encrypt_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_encrypt_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d encryption interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_encrypt_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
if (voe_hardware_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_hardware_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d hardware interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_hardware_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
#ifdef _TEST_XMEDIA_
if (voe_xmedia_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_xmedia_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d external media interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_xmedia_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
#endif
#ifdef _TEST_CALL_REPORT_
if (voe_call_report_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_call_report_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d call report interfaces"
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_call_report_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
#endif
#ifdef _TEST_NETEQ_STATS_
if (voe_neteq_stats_) {
for (remInt = 1, j = 0; remInt > 0; j++)
TEST_MUSTPASS(-1 == (remInt = voe_neteq_stats_->Release()));
if (j > 1) {
TEST_LOG("\n\n*** Error: released %d neteq stat interfaces "
"(should only be 1) \n", j);
releaseOK = false;
}
TEST_MUSTPASS(-1 != voe_neteq_stats_->Release());
err = voe_base_->LastError();
TEST_MUSTPASS(err != VE_INTERFACE_NOT_FOUND);
}
#endif
if (false == VoiceEngine::Delete(voice_engine_)) {
TEST_LOG("\n\nVoiceEngine::Delete() failed. \n");
releaseOK = false;
}
if (VoiceEngine::SetTraceFile(NULL) != -1) {
TEST_LOG("\nError at line: %i (VoiceEngine::SetTraceFile()"
"should fail)!\n", __LINE__);
}
return (releaseOK == true) ? 0 : -1;
}
int VoETestManager::SetUp(ErrorObserver* error_observer) {
char char_buffer[1024];
TEST_MUSTPASS(voe_base_->Init());
#if defined(WEBRTC_ANDROID)
TEST_MUSTPASS(voe_hardware_->SetLoudspeakerStatus(false));
#endif
TEST_MUSTPASS(voe_base_->RegisterVoiceEngineObserver(*error_observer));
TEST_LOG("Get version \n");
TEST_MUSTPASS(voe_base_->GetVersion(char_buffer));
TEST_LOG("--------------------\n%s\n--------------------\n", char_buffer);
TEST_LOG("Create channel \n");
int nChannels = voe_base_->MaxNumOfChannels();
TEST_MUSTPASS(!(nChannels > 0));
TEST_LOG("Max number of channels = %d \n", nChannels);
TEST_MUSTPASS(voe_base_->CreateChannel());
return 0;
}
int VoETestManager::TestStartStreaming(FakeExternalTransport& channel0_transport) {
TEST_LOG("\n\n+++ Starting streaming +++\n\n");
#ifdef WEBRTC_EXTERNAL_TRANSPORT
TEST_LOG("Enabling external transport \n");
TEST_MUSTPASS(voe_network_->RegisterExternalTransport(0, channel0_transport));
#else
TEST_LOG("Setting send and receive parameters \n");
TEST_MUSTPASS(voe_base_->SetSendDestination(0, 8000, "127.0.0.1"));
// No IP specified => "0.0.0.0" will be stored.
TEST_MUSTPASS(voe_base_->SetLocalReceiver(0,8000));
CodecInst Jing_inst;
Jing_inst.channels = 1;
Jing_inst.pacsize = 160;
Jing_inst.plfreq = 8000;
Jing_inst.pltype = 0;
Jing_inst.rate = 64000;
strcpy(Jing_inst.plname, "PCMU");
TEST_MUSTPASS(voe_codec_->SetSendCodec(0, Jing_inst));
int port = -1;
int src_port = -1;
int rtcp_port = -1;
char ip_address[64] = { 0 };
strcpy(ip_address, "10.10.10.10");
TEST_MUSTPASS(voe_base_->GetSendDestination(0, port, ip_address, src_port,
rtcp_port));
TEST_MUSTPASS(8000 != port);
TEST_MUSTPASS(8000 != src_port);
TEST_MUSTPASS(8001 != rtcp_port);
TEST_MUSTPASS(_stricmp(ip_address, "127.0.0.1"));
port = -1;
rtcp_port = -1;
TEST_MUSTPASS(voe_base_->GetLocalReceiver(0, port, rtcp_port, ip_address));
TEST_MUSTPASS(8000 != port);
TEST_MUSTPASS(8001 != rtcp_port);
TEST_MUSTPASS(_stricmp(ip_address, "0.0.0.0"));
#endif
return 0;
}
int VoETestManager::TestStartPlaying() {
TEST_LOG("Start listening, playout and sending \n");
TEST_MUSTPASS(voe_base_->StartReceive(0));
TEST_MUSTPASS(voe_base_->StartPlayout(0));
TEST_MUSTPASS(voe_base_->StartSend(0));
// Run in full duplex.
TEST_LOG("You should now hear yourself, running default codec (PCMU)\n");
SLEEP(2000);
if (voe_file_) {
TEST_LOG("Start playing a file as microphone, so you don't need to"
" speak all the time\n");
TEST_MUSTPASS(voe_file_->StartPlayingFileAsMicrophone(0,
AudioFilename(),
true,
true));
SLEEP(1000);
}
return 0;
}
int VoETestManager::DoStandardTest() {
// Ensure we have all input files:
TEST_MUSTPASS(!strcmp("", AudioFilename()));
TEST_LOG("\n\n+++ Base tests +++\n\n");
ErrorObserver error_observer;
if (SetUp(&error_observer) != 0) return -1;
voe_network_->SetSourceFilter(0, 0);
FakeExternalTransport channel0_transport(voe_network_);
if (TestStartStreaming(channel0_transport) != 0) return -1;
if (TestStartPlaying() != 0) return -1;
///////
// AudioProcessing
#ifdef _TEST_AUDIO_PROCESSING_
TEST_LOG("\n\n+++ AudioProcessing tests +++\n\n");
#ifdef WEBRTC_VOICE_ENGINE_AGC
bool test;
TEST_LOG("AGC calls\n");
#if (defined(MAC_IPHONE) || defined(WEBRTC_ANDROID))
TEST_LOG("Must be OFF by default\n");
test = true;
AgcModes agcMode = kAgcAdaptiveAnalog;
TEST_MUSTPASS(voe_apm_->GetAgcStatus(test, agcMode));
TEST_MUSTPASS(test);
TEST_MUSTPASS(kAgcAdaptiveDigital != agcMode);
#else
TEST_LOG("Must be ON by default\n");
test = false;
AgcModes agcMode = kAgcAdaptiveAnalog;
TEST_MUSTPASS(voe_apm_->GetAgcStatus(test, agcMode));
TEST_MUSTPASS(!test);
TEST_MUSTPASS(kAgcAdaptiveAnalog != agcMode);
TEST_LOG("Turn off AGC\n");
// must set value in first call!
TEST_MUSTPASS(voe_apm_->SetAgcStatus(false, kAgcDefault));
TEST_LOG("Should be OFF now\n");
TEST_MUSTPASS(voe_apm_->GetAgcStatus(test, agcMode));
TEST_MUSTPASS(test);
TEST_MUSTPASS(kAgcAdaptiveAnalog != agcMode);
#endif // #if (defined(MAC_IPHONE) || defined(WEBRTC_ANDROID))
TEST_LOG("Turn ON AGC\n");
#if (defined(MAC_IPHONE) || defined(WEBRTC_ANDROID))
TEST_MUSTPASS(voe_apm_->SetAgcStatus(true, kAgcAdaptiveDigital));
#else
TEST_MUSTPASS(voe_apm_->SetAgcStatus(true));
#endif
TEST_LOG("Should be ON now\n");
TEST_MUSTPASS(voe_apm_->GetAgcStatus(test, agcMode));
TEST_MUSTPASS(!test);
#if (defined(MAC_IPHONE) || defined(WEBRTC_ANDROID))
TEST_MUSTPASS(kAgcAdaptiveDigital != agcMode);
#else
TEST_MUSTPASS(kAgcAdaptiveAnalog != agcMode);
#endif
#if (defined(MAC_IPHONE) || defined(WEBRTC_ANDROID))
TEST_LOG("Testing Type settings\n");
// Should fail
TEST_MUSTPASS(!voe_apm_->SetAgcStatus(true, kAgcAdaptiveAnalog));
// Should fail
TEST_MUSTPASS(voe_apm_->SetAgcStatus(true, kAgcFixedDigital));
// Should fail
TEST_MUSTPASS(voe_apm_->SetAgcStatus(true, kAgcAdaptiveDigital));
TEST_LOG("Turn off AGC\n");
TEST_MUSTPASS(voe_apm_->SetAgcStatus(false));
TEST_LOG("Should be OFF now\n");
TEST_MUSTPASS(voe_apm_->GetAgcStatus(test, agcMode));
TEST_MUSTPASS(test);
TEST_MUSTPASS(kAgcAdaptiveDigital != agcMode);
#else
TEST_LOG("Testing Mode settings\n");
TEST_MUSTPASS(voe_apm_->SetAgcStatus(true, kAgcFixedDigital));
TEST_MUSTPASS(voe_apm_->GetAgcStatus(test, agcMode));
TEST_MUSTPASS(kAgcFixedDigital != agcMode);
TEST_MUSTPASS(voe_apm_->SetAgcStatus(true, kAgcAdaptiveDigital));
TEST_MUSTPASS(voe_apm_->GetAgcStatus(test, agcMode));
TEST_MUSTPASS(kAgcAdaptiveDigital != agcMode);
TEST_MUSTPASS(voe_apm_->SetAgcStatus(true, kAgcAdaptiveAnalog));
TEST_MUSTPASS(voe_apm_->GetAgcStatus(test, agcMode));
TEST_MUSTPASS(kAgcAdaptiveAnalog != agcMode);
#endif // #if (defined(MAC_IPHONE) || defined(WEBRTC_ANDROID))
TEST_LOG("rxAGC calls\n");
// Note the following test is not tested in iphone, android and wince,
// you may run into issue
bool rxAGCTemp(false);
AgcModes rxAGCModeTemp(kAgcAdaptiveAnalog);
// Store current state
TEST_MUSTPASS(voe_apm_->GetAgcStatus(rxAGCTemp, rxAGCModeTemp));
TEST_LOG("Turn off near-end AGC\n");
TEST_MUSTPASS(voe_apm_->SetAgcStatus(false));
TEST_LOG("rxAGC Must be OFF by default\n");
test = true;
AgcModes rxAGCMode = kAgcAdaptiveDigital;
TEST_MUSTPASS(voe_apm_->GetRxAgcStatus(0, test, agcMode));
TEST_MUSTPASS(test);
TEST_MUSTPASS(kAgcAdaptiveDigital != rxAGCMode);
TEST_LOG("Turn off rxAGC\n");
// must set value in first call!
TEST_MUSTPASS(voe_apm_->SetRxAgcStatus(0, false, kAgcDefault));
TEST_LOG("Should be OFF now\n");
TEST_MUSTPASS(voe_apm_->GetRxAgcStatus(0, test, agcMode));
TEST_MUSTPASS(test);
TEST_MUSTPASS(kAgcAdaptiveDigital != rxAGCMode);
TEST_LOG("Turn ON AGC\n");
TEST_MUSTPASS(voe_apm_->SetRxAgcStatus(0, true));
TEST_LOG("Should be ON now\n");
TEST_MUSTPASS(voe_apm_->GetRxAgcStatus(0, test, agcMode));
TEST_MUSTPASS(!test);
TEST_MUSTPASS(kAgcAdaptiveDigital != agcMode);
TEST_LOG("Testing Type settings\n");
// Should fail
TEST_MUSTPASS(!voe_apm_->SetRxAgcStatus(0, true, kAgcAdaptiveAnalog));
TEST_MUSTPASS(voe_apm_->SetRxAgcStatus(0, true, kAgcFixedDigital));
TEST_MUSTPASS(voe_apm_->GetRxAgcStatus(0, test, agcMode));
TEST_MUSTPASS(kAgcFixedDigital != agcMode);
TEST_MUSTPASS(voe_apm_->SetRxAgcStatus(0, true, kAgcAdaptiveDigital));
TEST_MUSTPASS(voe_apm_->GetRxAgcStatus(0, test, agcMode));
TEST_MUSTPASS(kAgcAdaptiveDigital != agcMode);
TEST_LOG("Turn off AGC\n");
TEST_MUSTPASS(voe_apm_->SetRxAgcStatus(0, false));
TEST_LOG("Should be OFF now\n");
TEST_MUSTPASS(voe_apm_->GetRxAgcStatus(0, test, agcMode));
TEST_MUSTPASS(test);
TEST_MUSTPASS(kAgcAdaptiveDigital != agcMode);
// recover the old AGC mode
TEST_MUSTPASS(voe_apm_->SetAgcStatus(rxAGCTemp, rxAGCModeTemp));
#else
TEST_LOG("Skipping AGC tests - WEBRTC_VOICE_ENGINE_AGC not defined \n");
#endif // #ifdef WEBRTC_VOICE_ENGINE_AGC
#ifdef WEBRTC_VOICE_ENGINE_ECHO
TEST_LOG("EC calls\n");
TEST_LOG("Must be OFF by default\n");
#if (defined(MAC_IPHONE) || defined(WEBRTC_ANDROID))
const EcModes ecModeDefault = kEcAecm;
#else
const EcModes ecModeDefault = kEcAec;
#endif
test = true;
EcModes ecMode = kEcAec;
AecmModes aecmMode = kAecmSpeakerphone;
bool enabledCNG(false);
TEST_MUSTPASS(voe_apm_->GetEcStatus(test, ecMode));
TEST_MUSTPASS(test);
TEST_MUSTPASS(ecModeDefault != ecMode);
TEST_MUSTPASS(voe_apm_->GetAecmMode(aecmMode, enabledCNG));
TEST_LOG("default AECM: mode=%d CNG: mode=%d\n", aecmMode, enabledCNG);
TEST_MUSTPASS(kAecmSpeakerphone != aecmMode);
TEST_MUSTPASS(enabledCNG != true);
TEST_MUSTPASS(voe_apm_->SetAecmMode(kAecmQuietEarpieceOrHeadset, false));
TEST_MUSTPASS(voe_apm_->GetAecmMode(aecmMode, enabledCNG));
TEST_LOG("change AECM to mode=%d CNG to false\n", aecmMode);
TEST_MUSTPASS(aecmMode != kAecmQuietEarpieceOrHeadset);
TEST_MUSTPASS(enabledCNG != false);
TEST_LOG("Turn ON EC\n");
TEST_MUSTPASS(voe_apm_->SetEcStatus(true, ecModeDefault));
TEST_LOG("Should be ON now\n");
TEST_MUSTPASS(voe_apm_->GetEcStatus(test, ecMode));
TEST_MUSTPASS(!test);
TEST_MUSTPASS(ecModeDefault != ecMode);
#if (!defined(MAC_IPHONE) && !defined(WEBRTC_ANDROID))
TEST_MUSTPASS(voe_apm_->SetEcStatus(true, kEcAec));
TEST_MUSTPASS(voe_apm_->GetEcStatus(test, ecMode));
TEST_MUSTPASS(kEcAec != ecMode);
TEST_MUSTPASS(voe_apm_->SetEcStatus(true, kEcConference));
TEST_MUSTPASS(voe_apm_->GetEcStatus(test, ecMode));
TEST_MUSTPASS(kEcAec != ecMode);
// the samplefreq for AudioProcessing is 32k, so it wont work to
// activate AECM
TEST_MUSTPASS(voe_apm_->SetEcStatus(true, kEcAecm));
TEST_MUSTPASS(voe_apm_->GetEcStatus(test, ecMode));
TEST_MUSTPASS(kEcAecm != ecMode);
#endif
// set kEcAecm mode
TEST_LOG("Testing AECM Mode settings\n");
TEST_MUSTPASS(voe_apm_->SetEcStatus(true, kEcAecm));
TEST_MUSTPASS(voe_apm_->GetEcStatus(test, ecMode));
TEST_LOG("EC: enabled=%d, ECmode=%d\n", test, ecMode);
TEST_MUSTPASS(test != true);
TEST_MUSTPASS(ecMode != kEcAecm);
// AECM mode, get and set
TEST_MUSTPASS(voe_apm_->GetAecmMode(aecmMode, enabledCNG));
TEST_MUSTPASS(aecmMode != kAecmQuietEarpieceOrHeadset);
TEST_MUSTPASS(enabledCNG != false);
TEST_MUSTPASS(voe_apm_->SetAecmMode(kAecmEarpiece, true));
TEST_MUSTPASS(voe_apm_->GetAecmMode(aecmMode, enabledCNG));
TEST_LOG("AECM: mode=%d CNG: mode=%d\n", aecmMode, enabledCNG);
TEST_MUSTPASS(aecmMode != kAecmEarpiece);
TEST_MUSTPASS(enabledCNG != true);
TEST_MUSTPASS(voe_apm_->SetAecmMode(kAecmEarpiece, false));
TEST_MUSTPASS(voe_apm_->GetAecmMode(aecmMode, enabledCNG));
TEST_LOG("AECM: mode=%d CNG: mode=%d\n", aecmMode, enabledCNG);
TEST_MUSTPASS(aecmMode != kAecmEarpiece);
TEST_MUSTPASS(enabledCNG != false);
TEST_MUSTPASS(voe_apm_->SetAecmMode(kAecmLoudEarpiece, true));
TEST_MUSTPASS(voe_apm_->GetAecmMode(aecmMode, enabledCNG));
TEST_LOG("AECM: mode=%d CNG: mode=%d\n", aecmMode, enabledCNG);
TEST_MUSTPASS(aecmMode != kAecmLoudEarpiece);
TEST_MUSTPASS(enabledCNG != true);
TEST_MUSTPASS(voe_apm_->SetAecmMode(kAecmSpeakerphone, false));
TEST_MUSTPASS(voe_apm_->GetAecmMode(aecmMode, enabledCNG));
TEST_LOG("AECM: mode=%d CNG: mode=%d\n", aecmMode, enabledCNG);
TEST_MUSTPASS(aecmMode != kAecmSpeakerphone);
TEST_MUSTPASS(enabledCNG != false);
TEST_MUSTPASS(voe_apm_->SetAecmMode(kAecmLoudSpeakerphone, true));
TEST_MUSTPASS(voe_apm_->GetAecmMode(aecmMode, enabledCNG));
TEST_LOG("AECM: mode=%d CNG: mode=%d\n", aecmMode, enabledCNG);
TEST_MUSTPASS(aecmMode != kAecmLoudSpeakerphone);
TEST_MUSTPASS(enabledCNG != true);
TEST_LOG("Turn OFF AEC\n");
TEST_MUSTPASS(voe_apm_->SetEcStatus(false));
TEST_LOG("Should be OFF now\n");
TEST_MUSTPASS(voe_apm_->GetEcStatus(test, ecMode));
TEST_MUSTPASS(test);
#else
TEST_LOG("Skipping echo cancellation tests -"
" WEBRTC_VOICE_ENGINE_ECHO not defined \n");
#endif // #ifdef WEBRTC_VOICE_ENGINE_ECHO
#ifdef WEBRTC_VOICE_ENGINE_NR
TEST_LOG("NS calls\n");
TEST_LOG("Must be OFF by default\n");
NsModes nsModeDefault = kNsModerateSuppression;
test = true;
NsModes nsMode = kNsVeryHighSuppression;
TEST_MUSTPASS(voe_apm_->GetNsStatus(test, nsMode));
TEST_MUSTPASS(test);
TEST_MUSTPASS(nsModeDefault != nsMode);
TEST_LOG("Turn ON NS\n");
TEST_MUSTPASS(voe_apm_->SetNsStatus(true));
TEST_LOG("Should be ON now\n");
TEST_MUSTPASS(voe_apm_->GetNsStatus(test, nsMode));
TEST_MUSTPASS(!test);
TEST_MUSTPASS(nsModeDefault != nsMode);
TEST_LOG("Testing Mode settings\n");
TEST_MUSTPASS(voe_apm_->SetNsStatus(true, kNsLowSuppression));
TEST_MUSTPASS(voe_apm_->GetNsStatus(test, nsMode));
TEST_MUSTPASS(kNsLowSuppression != nsMode);
TEST_MUSTPASS(voe_apm_->SetNsStatus(true, kNsModerateSuppression));
TEST_MUSTPASS(voe_apm_->GetNsStatus(test, nsMode));
TEST_MUSTPASS(kNsModerateSuppression != nsMode);
TEST_MUSTPASS(voe_apm_->SetNsStatus(true, kNsHighSuppression));
TEST_MUSTPASS(voe_apm_->GetNsStatus(test, nsMode));
TEST_MUSTPASS(kNsHighSuppression != nsMode);
TEST_MUSTPASS(voe_apm_->SetNsStatus(true, kNsVeryHighSuppression));
TEST_MUSTPASS(voe_apm_->GetNsStatus(test, nsMode));
TEST_MUSTPASS(kNsVeryHighSuppression != nsMode);
TEST_MUSTPASS(voe_apm_->SetNsStatus(true, kNsConference));
TEST_MUSTPASS(voe_apm_->GetNsStatus(test, nsMode));
TEST_MUSTPASS(kNsHighSuppression != nsMode);
TEST_MUSTPASS(voe_apm_->SetNsStatus(true, kNsDefault));
TEST_MUSTPASS(voe_apm_->GetNsStatus(test, nsMode));
TEST_MUSTPASS(nsModeDefault != nsMode);
TEST_LOG("Turn OFF NS\n");
TEST_MUSTPASS(voe_apm_->SetNsStatus(false));
TEST_LOG("Should be OFF now\n");
TEST_MUSTPASS(voe_apm_->GetNsStatus(test, nsMode));
TEST_MUSTPASS(test);
TEST_LOG("rxNS calls\n");
TEST_LOG("rxNS Must be OFF by default\n");
TEST_MUSTPASS(voe_apm_->GetRxNsStatus(0, test, nsMode));
TEST_MUSTPASS(test);
TEST_MUSTPASS(nsModeDefault != nsMode);
TEST_LOG("Turn ON rxNS\n");
TEST_MUSTPASS(voe_apm_->SetRxNsStatus(0, true));
TEST_LOG("Should be ON now\n");
TEST_MUSTPASS(voe_apm_->GetRxNsStatus(0, test, nsMode));
TEST_MUSTPASS(!test);
TEST_MUSTPASS(nsModeDefault != nsMode);
TEST_LOG("Testing Mode settings\n");
TEST_MUSTPASS(voe_apm_->SetRxNsStatus(0, true, kNsLowSuppression));
TEST_MUSTPASS(voe_apm_->GetRxNsStatus(0, test, nsMode));
TEST_MUSTPASS(kNsLowSuppression != nsMode);
TEST_MUSTPASS(voe_apm_->SetRxNsStatus(0, true, kNsModerateSuppression));
TEST_MUSTPASS(voe_apm_->GetRxNsStatus(0, test, nsMode));
TEST_MUSTPASS(kNsModerateSuppression != nsMode);
TEST_MUSTPASS(voe_apm_->SetRxNsStatus(0, true, kNsHighSuppression));
TEST_MUSTPASS(voe_apm_->GetRxNsStatus(0, test, nsMode));
TEST_MUSTPASS(kNsHighSuppression != nsMode);
TEST_MUSTPASS(voe_apm_->SetRxNsStatus(0, true, kNsVeryHighSuppression));
TEST_MUSTPASS(voe_apm_->GetRxNsStatus(0, test, nsMode));
TEST_MUSTPASS(kNsVeryHighSuppression != nsMode);
TEST_MUSTPASS(voe_apm_->SetRxNsStatus(0, true, kNsConference));
TEST_MUSTPASS(voe_apm_->GetRxNsStatus(0, test, nsMode));
TEST_MUSTPASS(kNsHighSuppression != nsMode);
TEST_MUSTPASS(voe_apm_->SetRxNsStatus(0, true, kNsDefault));
TEST_MUSTPASS(voe_apm_->GetRxNsStatus(0, test, nsMode));
TEST_MUSTPASS(nsModeDefault != nsMode);
TEST_LOG("Turn OFF NS\n");
TEST_MUSTPASS(voe_apm_->SetRxNsStatus(0, false));
TEST_LOG("Should be OFF now\n");
TEST_MUSTPASS(voe_apm_->GetRxNsStatus(0, test, nsMode));
TEST_MUSTPASS(test);
#else
TEST_LOG("Skipping NS tests - WEBRTC_VOICE_ENGINE_NR not defined \n");
#endif // #ifdef WEBRTC_VOICE_ENGINE_NR
#if (!defined(MAC_IPHONE) && !defined(WEBRTC_ANDROID) && \
defined(WEBRTC_VOICE_ENGINE_NR))
#ifdef WEBRTC_VOICE_ENGINE_ECHO
bool enabled = false;
TEST_LOG("EC Metrics calls\n");
TEST_MUSTPASS(voe_apm_->GetEcMetricsStatus(enabled)); // check default
TEST_MUSTPASS(enabled != false);
TEST_MUSTPASS(voe_apm_->SetEcMetricsStatus(true)); // enable EC metrics
// must enable AEC to get valid echo metrics
TEST_MUSTPASS(voe_apm_->SetEcStatus(true, kEcAec));
TEST_MUSTPASS(voe_apm_->GetEcMetricsStatus(enabled));
TEST_MUSTPASS(enabled != true);
TEST_LOG("Speak into microphone and check metrics for 10 seconds...\n");
int ERL, ERLE, RERL, A_NLP;
int delay_median = 0;
int delay_std = 0;
for (int t = 0; t < 5; t++) {
SLEEP(2000);
TEST_MUSTPASS(voe_apm_->GetEchoMetrics(ERL, ERLE, RERL, A_NLP));
TEST_MUSTPASS(voe_apm_->GetEcDelayMetrics(delay_median, delay_std));
TEST_LOG(" Echo : ERL=%5d, ERLE=%5d, RERL=%5d, A_NLP=%5d [dB], "
" delay median=%3d, delay std=%3d [ms]\n", ERL, ERLE, RERL, A_NLP,
delay_median, delay_std);
}
TEST_MUSTPASS(voe_apm_->SetEcMetricsStatus(false)); // disable echo metrics
#else
TEST_LOG("Skipping Echo Control metrics tests -"
" WEBRTC_VOICE_ENGINE_ECHO not defined \n");
#endif // #ifdef WEBRTC_VOICE_ENGINE_ECHO
#else
TEST_LOG("Skipping apm metrics tests - MAC_IPHONE/WEBRTC_ANDROID defined \n");
#endif // #if (!defined(MAC_IPHONE) && !d...
// VAD/DTX indication
TEST_LOG("Get voice activity indication \n");
if (voe_codec_) {
bool v = true, dummy2;
VadModes dummy1;
TEST_MUSTPASS(voe_codec_->GetVADStatus(0, v, dummy1, dummy2));
TEST_MUSTPASS(v); // Make sure VAD is disabled
}
TEST_MUSTPASS(1 != voe_apm_->VoiceActivityIndicator(0));
if (voe_codec_ && voe_volume_control_) {
TEST_LOG("RX VAD detections may vary depending on current signal"
" and mic input \n");
#if !defined(WEBRTC_ANDROID) && !defined(MAC_IPHONE)
RxCallback rxc;
TEST_MUSTPASS(voe_apm_->RegisterRxVadObserver(0, rxc));
#endif
TEST_MUSTPASS(voe_codec_->SetVADStatus(0, true));
TEST_MUSTPASS(voe_volume_control_->SetInputMute(0, true));
if (voe_file_) {
TEST_MUSTPASS(voe_file_->StopPlayingFileAsMicrophone(0));
}
SLEEP(500); // After sleeping we should have detected silence
TEST_MUSTPASS(0 != voe_apm_->VoiceActivityIndicator(0));
#if !defined(WEBRTC_ANDROID) && !defined(MAC_IPHONE)
TEST_MUSTPASS(0 != rxc._vadDecision);
#endif
if (voe_file_) {
TEST_LOG("Start playing a file as microphone again \n");
TEST_MUSTPASS(voe_file_->StartPlayingFileAsMicrophone(
0, AudioFilename(), true, true));
} else {
TEST_LOG("==> Make sure you talk into the microphone \n");
}
TEST_MUSTPASS(voe_codec_->SetVADStatus(0, false));
TEST_MUSTPASS(voe_volume_control_->SetInputMute(0, false));
SLEEP(500); // Sleep time selected by looking in mic play file, after
// sleep we should have detected voice
TEST_MUSTPASS(1 != voe_apm_->VoiceActivityIndicator(0));
#if !defined(WEBRTC_ANDROID) && !defined(MAC_IPHONE)
TEST_MUSTPASS(1 != rxc._vadDecision);
TEST_LOG("Disabling RX VAD detection, make sure you see no "
"detections\n");
TEST_MUSTPASS(voe_apm_->DeRegisterRxVadObserver(0));
SLEEP(2000);
#endif
} else {
TEST_LOG("Skipping voice activity indicator tests - codec and"
" volume APIs not available \n");
}
#else
TEST_LOG("\n\n+++ AudioProcessing tests NOT ENABLED +++\n");
#endif // #ifdef _TEST_AUDIO_PROCESSING_
////////
// File
#ifdef _TEST_FILE_
TEST_LOG("\n\n+++ File tests +++\n\n");
// test of UTF8 using swedish letters åäö
char fileName[64];
fileName[0] = (char) 0xc3;
fileName[1] = (char) 0xa5;
fileName[2] = (char) 0xc3;
fileName[3] = (char) 0xa4;
fileName[4] = (char) 0xc3;
fileName[5] = (char) 0xb6;
fileName[6] = '.';
fileName[7] = 'p';
fileName[8] = 'c';
fileName[9] = 'm';
fileName[10] = 0;
// test of UTF8 using japanese Hirigana "ぁあ"letter small A and letter A
/* fileName[0] = (char)0xe3;
fileName[1] = (char)0x81;
fileName[2] = (char)0x81;
fileName[3] = (char)0xe3;
fileName[4] = (char)0x81;
fileName[5] = (char)0x82;
fileName[6] = '.';
fileName[7] = 'p';
fileName[8] = 'c';
fileName[9] = 'm';
fileName[10] = 0;
*/
// Part of the cyrillic alpabet
// Ф Х Ѡ Ц Ч Ш Щ Ъ ЪІ Ь Ѣ
const char* recName = GetFilename(fileName);
// Generated with
#if _WIN32
/* char tempFileNameUTF8[200];
int err = WideCharToMultiByte(CP_UTF8,0,L"åäö", -1, tempFileNameUTF8,
sizeof(tempFileNameUTF8), NULL, NULL);
*/
#endif
//Stop the current file
TEST_LOG("Stop playing file as microphone \n");
TEST_MUSTPASS(voe_file_->StopPlayingFileAsMicrophone(0));
TEST_LOG("==> Talk into the microphone \n");
SLEEP(1000);
TEST_LOG("Record mic for 3 seconds in PCM format\n");
TEST_MUSTPASS(voe_file_->StartRecordingMicrophone(recName));
SLEEP(3000);
TEST_MUSTPASS(voe_file_->StopRecordingMicrophone());
TEST_LOG("Play out the recorded file...\n");
TEST_MUSTPASS(voe_file_->StartPlayingFileLocally(0, recName));
SLEEP(2000);
#ifndef _INSTRUMENTATION_TESTING_
TEST_LOG("After 2 seconds we should still be playing\n");
TEST_MUSTPASS(!voe_file_->IsPlayingFileLocally(0));
#endif
TEST_LOG("Set scaling\n");
TEST_MUSTPASS(voe_file_->ScaleLocalFilePlayout(0,(float)0.11));
SLEEP(1100);
TEST_LOG("After 3.1 seconds we should NOT be playing\n");
TEST_MUSTPASS(voe_file_->IsPlayingFileLocally(0));
CodecInst codec;
TEST_LOG("Record speaker for 3 seconds to wav file\n");
memset(&codec, 0, sizeof(CodecInst));
strcpy(codec.plname, "pcmu");
codec.plfreq = 8000;
codec.channels = 1;
codec.pacsize = 160;
codec.pltype = 0;
codec.rate = 64000;
TEST_MUSTPASS(voe_file_->StartRecordingPlayout(0,recName,&codec));
SLEEP(3000);
TEST_MUSTPASS(voe_file_->StopRecordingPlayout(0));
TEST_LOG("Play file as mic, looping for 3 seconds\n");
TEST_MUSTPASS(voe_file_->StartPlayingFileAsMicrophone(0,
recName,
1,
0,
kFileFormatWavFile));
SLEEP(3000);
TEST_LOG("After 3 seconds we should still be playing\n");
TEST_MUSTPASS(!voe_file_->IsPlayingFileAsMicrophone(0));
SLEEP(600);
TEST_LOG("After 3.6 seconds we should still be playing\n");
TEST_MUSTPASS(!voe_file_->IsPlayingFileAsMicrophone(0));
TEST_LOG("Set scaling\n");
TEST_MUSTPASS(voe_file_->ScaleFileAsMicrophonePlayout(0,(float)0.11));
SLEEP(200);
TEST_LOG("Stop playing file as microphone\n");
TEST_MUSTPASS(voe_file_->StopPlayingFileAsMicrophone(0));
TEST_LOG("==> Start playing a file as microphone again \n");
TEST_MUSTPASS(voe_file_->StartPlayingFileAsMicrophone(0, AudioFilename(),
true, true));
#else
TEST_LOG("\n\n+++ File tests NOT ENABLED +++\n");
#endif // #ifdef _TEST_FILE_
#ifdef _XTENDED_TEST_FILE_
// Create unique trace files for this test
TEST_MUSTPASS(voe_base_->SetTraceFileName(GetFilename("VoEFile_trace.txt")));
TEST_MUSTPASS(voe_base_->SetDebugTraceFileName(GetFilename(
"VoEFile_trace_debug.txt")));
// turn off default AGC during these tests
TEST_MUSTPASS(voe_apm_->SetAgcStatus(false));
int res = xtend.TestFile(voe_file_);
#ifndef MAC_IPHONE
TEST_MUSTPASS(voe_apm_->SetAgcStatus(true)); // restore AGC state
#endif
TEST_MUSTPASS(voe_base_->Terminate());
return res;
#endif
////////////
// Network
#ifdef _TEST_NETWORK_
TEST_LOG("\n\n+++ Network tests +++\n\n");
#ifndef WEBRTC_EXTERNAL_TRANSPORT
int sourceRtpPort = 1234;
int sourceRtcpPort = 1235;
int filterPort = -1;
int filterPortRTCP = -1;
char sourceIp[32] = "127.0.0.1";
char filterIp[64] = { 0 };
SLEEP(200); // Make sure we have received packets
TEST_MUSTPASS(voe_network_->GetSourceInfo(0,
sourceRtpPort,
sourceRtcpPort,
sourceIp));
TEST_LOG("sourceIp = %s, sourceRtpPort = %d, sourceRtcpPort = %d\n",
sourceIp, sourceRtpPort, sourceRtcpPort);
TEST_MUSTPASS(8000 != sourceRtpPort);
TEST_MUSTPASS(8001 != sourceRtcpPort);
TEST_MUSTPASS(voe_network_->GetSourceFilter(0,
filterPort,
filterPortRTCP,
filterIp));
TEST_MUSTPASS(0 != filterPort);
TEST_MUSTPASS(0 != filterPortRTCP);
TEST_MUSTPASS(_stricmp(filterIp, ""));
TEST_LOG("Set filter port to %d => should hear audio\n", sourceRtpPort);
TEST_MUSTPASS(voe_network_->SetSourceFilter(0,
sourceRtpPort,
sourceRtcpPort,
"0.0.0.0"));
TEST_MUSTPASS(voe_network_->GetSourceFilter(0,
filterPort,
filterPortRTCP,
filterIp));
TEST_MUSTPASS(sourceRtpPort != filterPort);
TEST_MUSTPASS(sourceRtcpPort != filterPortRTCP);
TEST_MUSTPASS(_stricmp(filterIp, "0.0.0.0"));
SLEEP(1000);
TEST_LOG("Set filter port to %d => should *not* hear audio\n",
sourceRtpPort + 10);
TEST_MUSTPASS(voe_network_->SetSourceFilter(0, sourceRtpPort+10));
TEST_MUSTPASS(voe_network_->GetSourceFilter(0,
filterPort,
filterPortRTCP,
filterIp));
TEST_MUSTPASS(sourceRtpPort+10 != filterPort);
SLEEP(1000);
TEST_LOG("Disable port filter => should hear audio again\n");
TEST_MUSTPASS(voe_network_->SetSourceFilter(0, 0));
SLEEP(1000);
if (voe_rtp_rtcp_) {
TEST_MUSTPASS(voe_rtp_rtcp_->SetRTCP_CNAME(0, "Tomas"));
}
TEST_LOG("Set filter IP to %s => should hear audio\n", sourceIp);
TEST_MUSTPASS(voe_network_->SetSourceFilter(0, 0, sourceRtcpPort+10,
sourceIp));
TEST_MUSTPASS(voe_network_->GetSourceFilter(0,
filterPort,
filterPortRTCP,
filterIp));
TEST_MUSTPASS(_stricmp(filterIp, sourceIp));
SLEEP(1000);
TEST_LOG("Set filter IP to 10.10.10.10 => should *not* hear audio\n");
TEST_MUSTPASS(voe_network_->SetSourceFilter(0, 0, sourceRtcpPort+10,
"10.10.10.10"));
TEST_MUSTPASS(voe_network_->GetSourceFilter(0, filterPort, filterPort,
filterIp));
TEST_MUSTPASS(_stricmp(filterIp, "10.10.10.10"));
SLEEP(1000);
TEST_LOG("Disable IP filter => should hear audio again\n");
TEST_MUSTPASS(voe_network_->SetSourceFilter(0, 0, sourceRtcpPort+10,
"0.0.0.0"));
SLEEP(1000);
TEST_LOG("Set filter IP to 10.10.10.10 => should *not* hear audio\n");
TEST_MUSTPASS(voe_network_->SetSourceFilter(0, 0, sourceRtcpPort+10,
"10.10.10.10"));
SLEEP(1000);
if (voe_rtp_rtcp_) {
char tmpStr[64];
SLEEP(2000);
TEST_LOG("Checking RTCP port filter with CNAME...\n");
TEST_MUSTPASS(voe_rtp_rtcp_->GetRemoteRTCP_CNAME(0, tmpStr));
TEST_MUSTPASS(!_stricmp("Tomas", tmpStr));
TEST_MUSTPASS(voe_rtp_rtcp_->SetRTCP_CNAME(0, "Niklas"));
} else {
TEST_LOG("Skipping RTCP port filter test since there is no RTP/RTCP "
"interface!\n");
}
TEST_LOG("Disable IP filter => should hear audio again\n");
TEST_MUSTPASS(voe_network_->SetSourceFilter(0, 0, 0, NULL));
TEST_MUSTPASS(voe_network_->GetSourceFilter(0, filterPort, filterPortRTCP,
filterIp));
TEST_MUSTPASS(_stricmp(filterIp, ""));
SLEEP(1000);
TEST_LOG("Wait 2 seconds for packet timeout...\n");
TEST_LOG("You should see runtime error %d\n", VE_RECEIVE_PACKET_TIMEOUT);
TEST_MUSTPASS(voe_base_->StopSend(0));
TEST_MUSTPASS(voe_network_->SetPacketTimeoutNotification(0, true, 2));
SLEEP(3000);
#if !defined(_INSTRUMENTATION_TESTING_)
TEST_LOG("error_observer.code is %d\n", error_observer.code);
TEST_MUSTPASS(error_observer.code != VE_RECEIVE_PACKET_TIMEOUT);
#endif
error_observer.code = -1;
TEST_MUSTPASS(voe_base_->StartSend(0));
if (voe_file_) {
TEST_LOG("Start playing a file as microphone again \n");
TEST_MUSTPASS(voe_file_->StartPlayingFileAsMicrophone(0,
AudioFilename(),
true,
true));
}
TEST_LOG("You should see runtime error %d\n", VE_PACKET_RECEIPT_RESTARTED);
SLEEP(1000);
#if !defined(_INSTRUMENTATION_TESTING_)
TEST_MUSTPASS(error_observer.code != VE_PACKET_RECEIPT_RESTARTED);
#endif
#if !defined(_INSTRUMENTATION_TESTING_)
TEST_LOG("Disabling observer, no runtime error should be seen...\n");
TEST_MUSTPASS(voe_base_->DeRegisterVoiceEngineObserver());
error_observer.code = -1;
TEST_MUSTPASS(voe_base_->StopSend(0));
TEST_MUSTPASS(voe_network_->SetPacketTimeoutNotification(0, true, 2));
SLEEP(2500);
TEST_MUSTPASS(error_observer.code != -1);
// disable notifications to avoid additional 8082 callbacks
TEST_MUSTPASS(voe_network_->SetPacketTimeoutNotification(0, false, 2));
TEST_MUSTPASS(voe_base_->StartSend(0));
if (voe_file_) {
TEST_LOG("Start playing a file as microphone again \n");
TEST_MUSTPASS(voe_file_->StartPlayingFileAsMicrophone(0,
AudioFilename(),
true,
true));
}
SLEEP(1000);
/// TEST_MUSTPASS(obs.code != -1);
TEST_LOG("Enabling observer again\n");
TEST_MUSTPASS(voe_base_->RegisterVoiceEngineObserver(error_observer));
#endif
TEST_LOG("Enable dead-or-alive callbacks for 4 seconds (dT=1sec)...\n");
TEST_LOG("You should see ALIVE messages\n");
MyDeadOrAlive dead_or_alive_observer;
TEST_MUSTPASS(voe_network_->RegisterDeadOrAliveObserver(
0, dead_or_alive_observer));
TEST_MUSTPASS(voe_network_->SetPeriodicDeadOrAliveStatus(0, true, 1));
SLEEP(4000);
// stop sending and flush dead-or-alive states
if (voe_rtp_rtcp_) {
TEST_MUSTPASS(voe_rtp_rtcp_->SetRTCPStatus(0, false));
}
TEST_MUSTPASS(voe_base_->StopSend(0));
SLEEP(500);
TEST_LOG("Disable sending for 4 seconds (dT=1sec)...\n");
TEST_LOG("You should see DEAD messages (one ALIVE message might"
" sneak in if you are unlucky)\n");
SLEEP(4000);
TEST_LOG("Disable dead-or-alive callbacks.\n");
TEST_MUSTPASS(voe_network_->SetPeriodicDeadOrAliveStatus(0, false));
TEST_LOG("Enabling external transport\n");
TEST_MUSTPASS(voe_base_->StopReceive(0));
// recreate the channel to ensure that we can switch from transport
// to external transport
TEST_MUSTPASS(voe_base_->DeleteChannel(0));
TEST_MUSTPASS(voe_base_->CreateChannel());
TEST_MUSTPASS(voe_network_->RegisterExternalTransport(0, channel0_transport));
TEST_MUSTPASS(voe_base_->StartReceive(0));
TEST_MUSTPASS(voe_base_->StartSend(0));
TEST_MUSTPASS(voe_base_->StartPlayout(0));
if (voe_file_) {
TEST_LOG("Start playing a file as microphone again using"
" external transport\n");
TEST_MUSTPASS(voe_file_->StartPlayingFileAsMicrophone(0,
AudioFilename(),
true,
true));
}
SLEEP(4000);
TEST_LOG("Disabling external transport\n");
TEST_MUSTPASS(voe_base_->StopSend(0));
TEST_MUSTPASS(voe_base_->StopPlayout(0));
TEST_MUSTPASS(voe_base_->StopReceive(0));
TEST_MUSTPASS(voe_network_->DeRegisterExternalTransport(0));
TEST_MUSTPASS(voe_base_->SetSendDestination(0, 8000, "127.0.0.1"));
TEST_MUSTPASS(voe_base_->SetLocalReceiver(0, 8000));
TEST_MUSTPASS(voe_base_->StartReceive(0));
TEST_MUSTPASS(voe_base_->StartSend(0));
TEST_MUSTPASS(voe_base_->StartPlayout(0));
if (voe_file_) {
TEST_LOG("Start playing a file as microphone again using transport\n");
TEST_MUSTPASS(voe_file_->StartPlayingFileAsMicrophone(0,
AudioFilename(),
true,
true));
}
SLEEP(2000);
#else
TEST_LOG("Skipping network tests - "
"WEBRTC_EXTERNAL_TRANSPORT is defined \n");
#endif // #ifndef WEBRTC_EXTERNAL_TRANSPORT
#else
TEST_LOG("\n\n+++ Network tests NOT ENABLED +++\n");
#endif // #ifdef _TEST_NETWORK_
///////////////
// CallReport
#ifdef _TEST_CALL_REPORT_
TEST_LOG("\n\n+++ CallReport tests +++\n\n");
#if (defined(WEBRTC_VOICE_ENGINE_ECHO) && defined(WEBRTC_VOICE_ENGINE_NR))
TEST(ResetCallReportStatistics);ANL();
TEST_MUSTPASS(!voe_call_report_->ResetCallReportStatistics(-2));
TEST_MUSTPASS(!voe_call_report_->ResetCallReportStatistics(1));
TEST_MUSTPASS(voe_call_report_->ResetCallReportStatistics(0));
TEST_MUSTPASS(voe_call_report_->ResetCallReportStatistics(-1));
bool onOff;
TEST_MUSTPASS(voe_apm_->GetEcMetricsStatus(onOff));
TEST_MUSTPASS(onOff != false);
TEST_MUSTPASS(voe_apm_->SetEcMetricsStatus(true));
SLEEP(3000);
EchoStatistics echo;
TEST(GetEchoMetricSummary);ANL();
// all outputs will be -100 in loopback (skip further tests)
TEST_MUSTPASS(voe_call_report_->GetEchoMetricSummary(echo));
StatVal delays;
TEST(GetRoundTripTimeSummary);ANL();
voe_rtp_rtcp_->SetRTCPStatus(0, false);
// All values should be -1 since RTCP is off
TEST_MUSTPASS(voe_call_report_->GetRoundTripTimeSummary(0, delays));
TEST_MUSTPASS(delays.min != -1);
TEST_MUSTPASS(delays.max != -1);
TEST_MUSTPASS(delays.average != -1);
voe_rtp_rtcp_->SetRTCPStatus(0, true);
SLEEP(5000); // gives time for RTCP
TEST_MUSTPASS(voe_call_report_->GetRoundTripTimeSummary(0, delays));
TEST_MUSTPASS(delays.min == -1);
TEST_MUSTPASS(delays.max == -1);
TEST_MUSTPASS(delays.average == -1);
voe_rtp_rtcp_->SetRTCPStatus(0, false);
int nDead = 0;
int nAlive = 0;
// -1 will be returned since dead-or-alive is not active
TEST(GetDeadOrAliveSummary);ANL();
TEST_MUSTPASS(voe_call_report_->GetDeadOrAliveSummary(0, nDead,
nAlive) != -1);
// we don't need these callbacks any longer
TEST_MUSTPASS(voe_network_->DeRegisterDeadOrAliveObserver(0));
TEST_MUSTPASS(voe_network_->SetPeriodicDeadOrAliveStatus(0, true, 1));
SLEEP(2000);
// All results should be >= 0 since dead-or-alive is active
TEST_MUSTPASS(voe_call_report_->GetDeadOrAliveSummary(0, nDead, nAlive));
TEST_MUSTPASS(nDead == -1);TEST_MUSTPASS(nAlive == -1)
TEST_MUSTPASS(voe_network_->SetPeriodicDeadOrAliveStatus(0, false));
TEST(WriteReportToFile);ANL();
TEST_MUSTPASS(!voe_call_report_->WriteReportToFile(NULL));
TEST_MUSTPASS(voe_call_report_->WriteReportToFile("call_report.txt"));
#else
TEST_LOG("Skipping CallReport tests since both EC and NS are required\n");
#endif
#else
TEST_LOG("\n\n+++ CallReport tests NOT ENABLED +++\n");
#endif // #ifdef _TEST_CALL_REPORT_
//////////////
// Video Sync
#ifdef _TEST_VIDEO_SYNC_
TEST_LOG("\n\n+++ Video sync tests +++\n\n");
unsigned int val;
TEST_MUSTPASS(voe_vsync_->GetPlayoutTimestamp(0, val));
TEST_LOG("Playout timestamp = %lu\n", (long unsigned int) val);
TEST_LOG("Init timestamp and sequence number manually\n");
TEST_MUSTPASS(!voe_vsync_->SetInitTimestamp(0, 12345));
TEST_MUSTPASS(!voe_vsync_->SetInitSequenceNumber(0, 123));
TEST_MUSTPASS(voe_base_->StopSend(0));
TEST_MUSTPASS(voe_vsync_->SetInitTimestamp(0, 12345));
TEST_MUSTPASS(voe_vsync_->SetInitSequenceNumber(0, 123));
TEST_MUSTPASS(voe_base_->StartSend(0));
if (voe_file_) {
TEST_LOG("Start playing a file as microphone again \n");
TEST_MUSTPASS(voe_file_->StartPlayingFileAsMicrophone(0,
AudioFilename(),
true,
true));
}
SLEEP(3000);
TEST_LOG("Check delay estimates during 15 seconds, verify that "
"they stabilize during this time\n");
int valInt = -1;
for (int i = 0; i < 15; i++) {
TEST_MUSTPASS(voe_vsync_->GetDelayEstimate(0, valInt));
TEST_LOG("Delay estimate = %d ms\n", valInt);
#if defined(MAC_IPHONE)
TEST_MUSTPASS(valInt <= 30);
#else
TEST_MUSTPASS(valInt <= 45); // 45=20+25 => can't be this low
#endif
SLEEP(1000);
}
TEST_LOG("Setting NetEQ min delay to 500 milliseconds and repeat "
"the test above\n");
TEST_MUSTPASS(voe_vsync_->SetMinimumPlayoutDelay(0, 500));
for (int i = 0; i < 15; i++) {
TEST_MUSTPASS(voe_vsync_->GetDelayEstimate(0, valInt));
TEST_LOG("Delay estimate = %d ms\n", valInt);
TEST_MUSTPASS(valInt <= 45);
SLEEP(1000);
}
TEST_LOG("Setting NetEQ min delay to 0 milliseconds and repeat"
" the test above\n");
TEST_MUSTPASS(voe_vsync_->SetMinimumPlayoutDelay(0, 0));
for (int i = 0; i < 15; i++) {
TEST_MUSTPASS(voe_vsync_->GetDelayEstimate(0, valInt));
TEST_LOG("Delay estimate = %d ms\n", valInt);
TEST_MUSTPASS(valInt <= 45);
SLEEP(1000);
}
#if (defined (_WIN32) || (defined(WEBRTC_LINUX)) && !defined(WEBRTC_ANDROID))
valInt = -1;
TEST_MUSTPASS(voe_vsync_->GetPlayoutBufferSize(valInt));
TEST_LOG("Soundcard buffer size = %d ms\n", valInt);
#endif
#else
TEST_LOG("\n\n+++ Video sync tests NOT ENABLED +++\n");
#endif // #ifdef _TEST_VIDEO_SYNC_
//////////////
// Encryption
#ifdef _TEST_ENCRYPT_
TEST_LOG("\n\n+++ Encryption tests +++\n\n");
#ifdef WEBRTC_SRTP
TEST_LOG("SRTP tests:\n");
unsigned char encrKey[30] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
TEST_LOG("Enable SRTP encryption and decryption, you should still hear"
" the voice\n");
TEST_MUSTPASS(voe_encrypt_->EnableSRTPSend(0,
kCipherAes128CounterMode,
30,
kAuthHmacSha1,
20, 4, kEncryptionAndAuthentication, encrKey));
TEST_MUSTPASS(voe_encrypt_->EnableSRTPReceive(0,
kCipherAes128CounterMode,
30,
kAuthHmacSha1,
20, 4, kEncryptionAndAuthentication, encrKey));
SLEEP(2000);
TEST_LOG("Disabling decryption, you should hear nothing or garbage\n");
TEST_MUSTPASS(voe_encrypt_->DisableSRTPReceive(0));
SLEEP(2000);
TEST_LOG("Enable decryption again, you should hear the voice again\n");
TEST_MUSTPASS(voe_encrypt_->EnableSRTPReceive(0,
kCipherAes128CounterMode,
30,
kAuthHmacSha1,
20, 4, kEncryptionAndAuthentication, encrKey));
SLEEP(2000);
TEST_LOG("Disabling encryption and enabling decryption, you should"
" hear nothing\n");
TEST_MUSTPASS(voe_encrypt_->DisableSRTPSend(0));
SLEEP(2000);
TEST_LOG("Back to normal\n");
// both SRTP sides are now inactive
TEST_MUSTPASS(voe_encrypt_->DisableSRTPReceive(0));
SLEEP(2000);
TEST_LOG("Enable SRTP and SRTCP encryption and decryption,"
" you should still hear the voice\n");
TEST_MUSTPASS(voe_encrypt_->EnableSRTPSend(0,
kCipherAes128CounterMode,
30,
kAuthHmacSha1,
20, 4, kEncryptionAndAuthentication, encrKey, true));
TEST_MUSTPASS(voe_encrypt_->EnableSRTPReceive(0,
kCipherAes128CounterMode,
30,
kAuthHmacSha1,
20, 4, kEncryptionAndAuthentication, encrKey, true));
SLEEP(2000);
TEST_LOG("Back to normal\n");
TEST_MUSTPASS(voe_encrypt_->DisableSRTPSend(0));
// both SRTP sides are now inactive
TEST_MUSTPASS(voe_encrypt_->DisableSRTPReceive(0));
SLEEP(2000);
#else
TEST_LOG("Skipping SRTP tests - WEBRTC_SRTP not defined \n");
#endif // #ifdef WEBRTC_SRTP
TEST_LOG("\nExternal encryption tests:\n");
my_encryption * encObj = new my_encryption;
TEST_MUSTPASS(voe_encrypt_->RegisterExternalEncryption(0, *encObj));
TEST_LOG("Encryption enabled but you should still hear the voice\n");
SLEEP(2000);
TEST_LOG("Removing encryption object and deleting it\n");
TEST_MUSTPASS(voe_encrypt_->DeRegisterExternalEncryption(0));
delete encObj;
SLEEP(2000);
#else
TEST_LOG("\n\n+++ Encryption tests NOT ENABLED +++\n");
#endif // #ifdef _TEST_ENCRYPT_
//////////////////
// External media
#ifdef _TEST_XMEDIA_
TEST_LOG("\n\n+++ External media tests +++\n\n");
#ifdef WEBRTC_VOE_EXTERNAL_REC_AND_PLAYOUT
TEST_LOG("Stop playing file as microphone \n");
TEST_LOG("==> Talk into the microphone \n");
TEST_MUSTPASS(voe_file_->StopPlayingFileAsMicrophone(0));
TEST_LOG("Enabling external playout\n");
TEST_MUSTPASS(voe_base_->StopSend(0));
TEST_MUSTPASS(voe_base_->StopPlayout(0));
TEST_MUSTPASS(voe_xmedia_->SetExternalPlayoutStatus(true));
TEST_MUSTPASS(voe_base_->StartPlayout(0));
TEST_MUSTPASS(voe_base_->StartSend(0));
TEST_LOG("Writing 2 secs of play data to vector\n");
int getLen;
WebRtc_Word16 speechData[32000];
for (int i = 0; i < 200; i++) {
TEST_MUSTPASS(voe_xmedia_->ExternalPlayoutGetData(speechData+i*160,
16000,
100,
getLen));
TEST_MUSTPASS(160 != getLen);
SLEEP(10);
}
TEST_LOG("Disabling external playout\n");
TEST_MUSTPASS(voe_base_->StopSend(0));
TEST_MUSTPASS(voe_base_->StopPlayout(0));
TEST_MUSTPASS(voe_xmedia_->SetExternalPlayoutStatus(false));
TEST_MUSTPASS(voe_base_->StartPlayout(0));
TEST_LOG("Enabling external recording\n");
TEST_MUSTPASS(voe_xmedia_->SetExternalRecordingStatus(true));
TEST_MUSTPASS(voe_base_->StartSend(0));
TEST_LOG("Inserting record data from vector\n");
for (int i = 0; i < 200; i++) {
TEST_MUSTPASS(voe_xmedia_->ExternalRecordingInsertData(speechData+i*160,
160,
16000,
20));
SLEEP(10);
}
TEST_LOG("Disabling external recording\n");
TEST_MUSTPASS(voe_base_->StopSend(0));
TEST_MUSTPASS(voe_xmedia_->SetExternalRecordingStatus(false));
TEST_MUSTPASS(voe_base_->StartSend(0));
TEST_LOG("==> Start playing a file as microphone again \n");
TEST_MUSTPASS(voe_file_->StartPlayingFileAsMicrophone(0, AudioFilename(),
true, true));
#else
TEST_LOG("Skipping external rec and playout tests - \
WEBRTC_VOE_EXTERNAL_REC_AND_PLAYOUT not defined \n");
#endif // WEBRTC_VOE_EXTERNAL_REC_AND_PLAYOUT
TEST_LOG("Enabling playout external media processing => "
"played audio should now be affected \n");
TEST_MUSTPASS(voe_xmedia_->RegisterExternalMediaProcessing(
-1, kPlaybackAllChannelsMixed, mobj));
SLEEP(2000);
TEST_LOG("Back to normal again \n");
TEST_MUSTPASS(voe_xmedia_->DeRegisterExternalMediaProcessing(
-1, kPlaybackAllChannelsMixed));
SLEEP(2000);
// Note that we must do per channel here because PlayFileAsMicrophone
// is only done on ch 0.
TEST_LOG("Enabling recording external media processing => "
"played audio should now be affected \n");
TEST_MUSTPASS(voe_xmedia_->RegisterExternalMediaProcessing(
0, kRecordingPerChannel, mobj));
SLEEP(2000);
TEST_LOG("Back to normal again \n");
TEST_MUSTPASS(voe_xmedia_->DeRegisterExternalMediaProcessing(
0, kRecordingPerChannel));
SLEEP(2000);
TEST_LOG("Enabling recording external media processing => "
"speak and make sure that voice is affected \n");
TEST_MUSTPASS(voe_xmedia_->RegisterExternalMediaProcessing(
-1, kRecordingAllChannelsMixed, mobj));
SLEEP(2000);
TEST_LOG("Back to normal again \n");
TEST_MUSTPASS(voe_xmedia_->DeRegisterExternalMediaProcessing(
-1, kRecordingAllChannelsMixed));
SLEEP(2000);
#else
TEST_LOG("\n\n+++ External media tests NOT ENABLED +++\n");
#endif // #ifdef _TEST_XMEDIA_
/////////////////////
// NetEQ statistics
#ifdef _TEST_NETEQ_STATS_
TEST_LOG("\n\n+++ NetEQ statistics tests +++\n\n");
#ifdef WEBRTC_VOICE_ENGINE_NETEQ_STATS_API
NetworkStatistics nStats;
TEST_MUSTPASS(voe_neteq_stats_->GetNetworkStatistics(0, nStats));
TEST_LOG("\nNetwork statistics: \n");
TEST_LOG(" currentAccelerateRate = %hu \n",
nStats.currentAccelerateRate);
TEST_LOG(" currentBufferSize = %hu \n",
nStats.currentBufferSize);
TEST_LOG(" currentDiscardRate = %hu \n",
nStats.currentDiscardRate);
TEST_LOG(" currentExpandRate = %hu \n",
nStats.currentExpandRate);
TEST_LOG(" currentPacketLossRate = %hu \n",
nStats.currentPacketLossRate);
TEST_LOG(" currentPreemptiveRate = %hu \n",
nStats.currentPreemptiveRate);
TEST_LOG(" preferredBufferSize = %hu \n",
nStats.preferredBufferSize);
TEST_LOG(" jitterPeaksFound = %i \n",
nStats.jitterPeaksFound);
TEST_LOG(" clockDriftPPM = %i \n",
nStats.clockDriftPPM);
TEST_LOG(" meanWaitingTimeMs = %i \n",
nStats.meanWaitingTimeMs);
TEST_LOG(" medianWaitingTimeMs = %i \n",
nStats.medianWaitingTimeMs);
TEST_LOG(" minWaitingTimeMs = %i \n",
nStats.minWaitingTimeMs);
TEST_LOG(" maxWaitingTimeMs = %i \n",
nStats.maxWaitingTimeMs);
#else
TEST_LOG("Skipping NetEQ statistics tests - "
"WEBRTC_VOICE_ENGINE_NETEQ_STATS_API not defined \n");
#endif // #ifdef WEBRTC_VOICE_ENGINE_NETEQ_STATS_API
#else
TEST_LOG("\n\n+++ NetEQ statistics tests NOT ENABLED +++\n");
#endif // #ifdef _TEST_NETEQ_STATS_
//////////////////
// Stop streaming
TEST_LOG("\n\n+++ Stop streaming +++\n\n");
TEST_LOG("Stop playout, sending and listening \n");
TEST_MUSTPASS(voe_base_->StopPlayout(0));
TEST_MUSTPASS(voe_base_->StopSend(0));
TEST_MUSTPASS(voe_base_->StopReceive(0));
// Exit:
TEST_LOG("Delete channel and terminate VE \n");
TEST_MUSTPASS(voe_base_->DeleteChannel(0));
TEST_MUSTPASS(voe_base_->Terminate());
return 0;
}
int runAutoTest(TestType testType, ExtendedSelection extendedSel) {
SubAPIManager apiMgr;
apiMgr.DisplayStatus();
////////////////////////////////////
// Create VoiceEngine and sub API:s
voetest::VoETestManager tm;
if (!tm.Init()) {
return -1;
}
tm.GetInterfaces();
//////////////////////
// Run standard tests
int mainRet(-1);
if (testType == Standard) {
mainRet = tm.DoStandardTest();
////////////////////////////////
// Create configuration summary
TEST_LOG("\n\n+++ Creating configuration summary file +++\n");
createSummary(tm.VoiceEnginePtr());
} else if (testType == Extended) {
VoEExtendedTest xtend(tm);
mainRet = 0;
while (extendedSel != XSEL_None) {
if (extendedSel == XSEL_Base || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestBase()) == -1)
break;
xtend.TestPassed("Base");
}
if (extendedSel == XSEL_CallReport || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestCallReport()) == -1)
break;
xtend.TestPassed("CallReport");
}
if (extendedSel == XSEL_Codec || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestCodec()) == -1)
break;
xtend.TestPassed("Codec");
}
if (extendedSel == XSEL_DTMF || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestDtmf()) == -1)
break;
xtend.TestPassed("Dtmf");
}
if (extendedSel == XSEL_Encryption || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestEncryption()) == -1)
break;
xtend.TestPassed("Encryption");
}
if (extendedSel == XSEL_ExternalMedia || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestExternalMedia()) == -1)
break;
xtend.TestPassed("ExternalMedia");
}
if (extendedSel == XSEL_File || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestFile()) == -1)
break;
xtend.TestPassed("File");
}
if (extendedSel == XSEL_Mixing || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestMixing()) == -1)
break;
xtend.TestPassed("Mixing");
}
if (extendedSel == XSEL_Hardware || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestHardware()) == -1)
break;
xtend.TestPassed("Hardware");
}
if (extendedSel == XSEL_NetEqStats || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestNetEqStats()) == -1)
break;
xtend.TestPassed("NetEqStats");
}
if (extendedSel == XSEL_Network || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestNetwork()) == -1)
break;
xtend.TestPassed("Network");
}
if (extendedSel == XSEL_RTP_RTCP || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestRTP_RTCP()) == -1)
break;
xtend.TestPassed("RTP_RTCP");
}
if (extendedSel == XSEL_VideoSync || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestVideoSync()) == -1)
break;
xtend.TestPassed("VideoSync");
}
if (extendedSel == XSEL_VolumeControl || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestVolumeControl()) == -1)
break;
xtend.TestPassed("VolumeControl");
}
if (extendedSel == XSEL_AudioProcessing || extendedSel == XSEL_All) {
if ((mainRet = xtend.TestAPM()) == -1)
break;
xtend.TestPassed("AudioProcessing");
}
apiMgr.GetExtendedMenuSelection(extendedSel);
} // while (extendedSel != XSEL_None)
} else if (testType == Stress) {
VoEStressTest stressTest(tm);
mainRet = stressTest.DoTest();
} else if (testType == Unit) {
VoEUnitTest unitTest(tm);
mainRet = unitTest.DoTest();
} else if (testType == CPU) {
VoECpuTest cpuTest(tm);
mainRet = cpuTest.DoTest();
} else {
// Should never end up here
TEST_LOG("INVALID SELECTION \n");
}
//////////////////
// Release/Delete
int releaseOK = tm.ReleaseInterfaces();
if ((0 == mainRet) && (releaseOK != -1)) {
TEST_LOG("\n\n*** All tests passed *** \n\n");
} else {
TEST_LOG("\n\n*** Test failed! *** \n");
}
return 0;
}
void createSummary(VoiceEngine* ve) {
int len;
char str[256];
#ifdef MAC_IPHONE
char summaryFilename[256];
GetDocumentsDir(summaryFilename, 256);
strcat(summaryFilename, "/summary.txt");
#endif
VoEBase* voe_base_ = VoEBase::GetInterface(ve);
FILE* stream = fopen(summaryFilename, "wt");
sprintf(str, "WebRTc VoiceEngine ");
#if defined(_WIN32)
strcat(str, "Win");
#elif defined(WEBRTC_LINUX) && defined(WEBRTC_TARGET_PC) && \
!defined(WEBRTC_ANDROID)
strcat(str, "Linux");
#elif defined(WEBRTC_MAC) && !defined(MAC_IPHONE)
strcat(str, "Mac");
#elif defined(WEBRTC_ANDROID)
strcat(str, "Android");
#elif defined(MAC_IPHONE)
strcat(str, "iPhone");
#endif
// Add for other platforms as needed
fprintf(stream, "%s\n", str);
len = (int) strlen(str);
for (int i = 0; i < len; i++) {
fprintf(stream, "=");
}
fprintf(stream, "\n\n");
char version[1024];
char veVersion[24];
voe_base_->GetVersion(version);
// find first NL <=> end of VoiceEngine version string
int pos = (int) strcspn(version, "\n");
strncpy(veVersion, version, pos);
veVersion[pos] = '\0';
sprintf(str, "Version: %s\n", veVersion);
fprintf(stream, "%s\n", str);
sprintf(str, "Build date & time: %s\n", BUILDDATE " " BUILDTIME);
fprintf(stream, "%s\n", str);
strcpy(str, "G.711 A-law");
fprintf(stream, "\nSupported codecs: %s\n", str);
strcpy(str, " G.711 mu-law");
fprintf(stream, "%s\n", str);
#ifdef WEBRTC_CODEC_EG711
strcpy(str, " Enhanced G.711 A-law");
fprintf(stream, "%s\n", str);
strcpy(str, " Enhanced G.711 mu-law");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_IPCMWB
strcpy(str, " iPCM-wb");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_ILBC
strcpy(str, " iLBC");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_ISAC
strcpy(str, " iSAC");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_ISACLC
strcpy(str, " iSAC-LC");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_G722
strcpy(str, " G.722");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_G722_1
strcpy(str, " G.722.1");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_G722_1C
strcpy(str, " G.722.1C");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_G723
strcpy(str, " G.723");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_G726
strcpy(str, " G.726");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_G729
strcpy(str, " G.729");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_G729_1
strcpy(str, " G.729.1");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_GSMFR
strcpy(str, " GSM-FR");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_GSMAMR
strcpy(str, " AMR");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_GSMAMRWB
strcpy(str, " AMR-WB");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_GSMEFR
strcpy(str, " GSM-EFR");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_SPEEX
strcpy(str, " Speex");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_SILK
strcpy(str, " Silk");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_CODEC_PCM16
strcpy(str, " L16");
fprintf(stream, "%s\n", str);
#endif
#ifdef NETEQFIX_VOXWARE_SC3
strcpy(str, " Voxware SC3");
fprintf(stream, "%s\n", str);
#endif
// Always included
strcpy(str, " AVT (RFC2833)");
fprintf(stream, "%s\n", str);
#ifdef WEBRTC_CODEC_RED
strcpy(str, " RED (forward error correction)");
fprintf(stream, "%s\n", str);
#endif
fprintf(stream, "\nEcho Control: ");
#ifdef WEBRTC_VOICE_ENGINE_ECHO
fprintf(stream, "Yes\n");
#else
fprintf(stream, "No\n");
#endif
fprintf(stream, "\nAutomatic Gain Control: ");
#ifdef WEBRTC_VOICE_ENGINE_AGC
fprintf(stream, "Yes\n");
#else
fprintf(stream, "No\n");
#endif
fprintf(stream, "\nNoise Reduction: ");
#ifdef WEBRTC_VOICE_ENGINE_NR
fprintf(stream, "Yes\n");
#else
fprintf(stream, "No\n");
#endif
fprintf(stream, "\nSRTP: ");
#ifdef WEBRTC_SRTP
fprintf(stream, "Yes\n");
#else
fprintf(stream, "No\n");
#endif
fprintf(stream, "\nExternal transport only: ");
#ifdef WEBRTC_EXTERNAL_TRANSPORT
fprintf(stream, "Yes\n");
#else
fprintf(stream, "No\n");
#endif
fprintf(stream, "\nTelephone event detection: ");
#ifdef WEBRTC_DTMF_DETECTION
fprintf(stream, "Yes\n");
#else
fprintf(stream, "No\n");
#endif
strcpy(str, "VoEBase");
fprintf(stream, "\nSupported sub-APIs: %s\n", str);
#ifdef WEBRTC_VOICE_ENGINE_CODEC_API
strcpy(str, " VoECodec");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_DTMF_API
strcpy(str, " VoEDtmf");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_FILE_API
strcpy(str, " VoEFile");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_HARDWARE_API
strcpy(str, " VoEHardware");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_NETWORK_API
strcpy(str, " VoENetwork");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_RTP_RTCP_API
strcpy(str, " VoERTP_RTCP");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_VOLUME_CONTROL_API
strcpy(str, " VoEVolumeControl");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_AUDIO_PROCESSING_API
strcpy(str, " VoEAudioProcessing");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_EXTERNAL_MEDIA_API
strcpy(str, " VoeExternalMedia");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_NETEQ_STATS_API
strcpy(str, " VoENetEqStats");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_ENCRYPTION_API
strcpy(str, " VoEEncryption");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_CALL_REPORT_API
strcpy(str, " VoECallReport");
fprintf(stream, "%s\n", str);
#endif
#ifdef WEBRTC_VOICE_ENGINE_VIDEO_SYNC_API
strcpy(str, " VoEVideoSync");
fprintf(stream, "%s\n", str);
#endif
fclose(stream);
voe_base_->Release();
}
/*********Knowledge Base******************/
//An example for creating threads and calling VE API's from that thread.
// Using thread. A generic API/Class for all platforms.
#ifdef THEADTEST // find first NL <=> end of VoiceEngine version string
//Definition of Thread Class
class ThreadTest
{
public:
ThreadTest(
VoEBase* voe_base_);
~ThreadTest()
{
delete _myThread;
}
void Stop();
private:
static bool StartSend(
void* obj);
bool StartSend();
ThreadWrapper* _myThread;
VoEBase* _base;
bool _stopped;
};
//Main function from where StartSend is invoked as a seperate thread.
ThreadTest::ThreadTest(
VoEBase* voe_base_)
:
_stopped(false),
_base(voe_base_)
{
//Thread Creation
_myThread = ThreadWrapper::CreateThread(StartSend, this, kLowPriority);
unsigned int id = 0;
//Starting the thread
_myThread->Start(id);
}
//Calls the StartSend. This is to avoid the static declaration issue.
bool
ThreadTest::StartSend(
void* obj)
{
return ((ThreadTest*)obj)->StartSend();
}
bool
ThreadTest::StartSend()
{
_myThread->SetNotAlive(); //Ensures this function is called only once.
_base->StartSend(0);
return true;
}
void ThreadTest::Stop()
{
_stopped = true;
}
// Use the following to invoke ThreatTest from the main function.
// ThreadTest* threadtest = new ThreadTest(voe_base_);
#endif
// An example to create a thread and call VE API's call from that thread.
// Specific to Windows Platform
#ifdef THREAD_TEST_WINDOWS
//Thread Declaration. Need to be added in the class controlling/dictating
// the main code.
/**
private:
static unsigned int WINAPI StartSend(void* obj);
unsigned int WINAPI StartSend();
**/
//Thread Definition
unsigned int WINAPI mainTest::StartSend(void *obj)
{
return ((mainTest*)obj)->StartSend();
}
unsigned int WINAPI mainTest::StartSend()
{
//base
voe_base_->StartSend(0);
// TEST_MUSTPASS(voe_base_->StartSend(0));
TEST_LOG("hi hi hi");
return 0;
}
//Thread invoking. From the main code
/*****
unsigned int threadID=0;
if ((HANDLE)_beginthreadex(NULL,
0,
StartSend,
(void*)this,
0,
&threadID) == NULL)
return false;
****/
#endif
} // namespace voetest
int RunInManualMode(int argc, char** argv) {
using namespace voetest;
SubAPIManager apiMgr;
apiMgr.DisplayStatus();
printf("----------------------------\n");
printf("Select type of test\n\n");
printf(" (0) Quit\n");
printf(" (1) Standard test\n");
printf(" (2) Extended test(s)...\n");
printf(" (3) Stress test(s)...\n");
printf(" (4) Unit test(s)...\n");
printf(" (5) CPU & memory reference test [Windows]...\n");
printf("\n: ");
int selection(0);
dummy = scanf("%d", &selection);
ExtendedSelection extendedSel(XSEL_Invalid);
enum TestType testType(Invalid);
switch (selection) {
case 0:
return 0;
case 1:
testType = Standard;
break;
case 2:
testType = Extended;
while (!apiMgr.GetExtendedMenuSelection(extendedSel))
continue;
break;
case 3:
testType = Stress;
break;
case 4:
testType = Unit;
break;
case 5:
testType = CPU;
break;
default:
TEST_LOG("Invalid selection!\n");
return 0;
}
if (testType == Standard) {
TEST_LOG("\n\n+++ Running gtest-rewritten standard tests first +++\n\n");
// Run the automated tests too in standard mode since we are gradually
// rewriting the standard test to be automated. Running this will give
// the standard suite the same completeness.
RunInAutomatedMode(argc, argv);
}
// Function that can be called from other entry functions.
return runAutoTest(testType, extendedSel);
}
// ----------------------------------------------------------------------------
// main
// ----------------------------------------------------------------------------
#if !defined(MAC_IPHONE)
int main(int argc, char** argv) {
if (argc > 1 && std::string(argv[1]) == "--automated") {
// This function is defined in automated_mode.cc to avoid macro clashes
// with googletest (for instance the ASSERT_TRUE macro).
return RunInAutomatedMode(argc, argv);
}
return RunInManualMode(argc, argv);
}
#endif //#if !defined(MAC_IPHONE)