generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove 'using namespace' from ViE autotest files.

Browse Source 
Review URL: http://webrtc-codereview.appspot.com/138017

git-svn-id: http://webrtc.googlecode.com/svn/trunk@534 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
mflodman@webrtc.org 2011-09-06 14:12:07 +00:00
parent ac75cab618
commit b69bb56741
17 changed files with 337 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/video_engine/main/test/AutoTest/interface/tb_interfaces.h
View File

@ -24,8 +24,6 @@
#include "vie_encryption.h"
#include "vie_defines.h"
//using namespace webrtc;
class tbInterfaces
{
public:

23
src/video_engine/main/test/AutoTest/interface/vie_autotest.h
View File

@ -37,8 +37,6 @@
#include <string>
#endif
using namespace webrtc;
class ViEAutoTest
{
public:
@ -54,7 +52,8 @@ public:
int ViECustomCall();
// general settings functions
bool GetVideoDevice(ViEBase* ptrViEBase, ViECapture* ptrViECapture,
bool GetVideoDevice(webrtc::ViEBase* ptrViEBase,
webrtc::ViECapture* ptrViECapture,
char* captureDeviceName, char* captureDeviceUniqueId);
bool GetIPAddress(char* IP);
#ifndef WEBRTC_ANDROID
@ -70,16 +69,20 @@ public:
// video settings functions
bool GetVideoPorts(int* txPort, int* rxPort);
bool GetVideoCodec(ViECodec* ptrViECodec, webrtc::VideoCodec& videoCodec);
bool GetVideoCodec(webrtc::ViECodec* ptrViECodec,
webrtc::VideoCodec& videoCodec);
// audio settings functions
bool GetAudioDevices(VoEBase* ptrVEBase, VoEHardware* ptrVEHardware,
bool GetAudioDevices(webrtc::VoEBase* ptrVEBase,
webrtc::VoEHardware* ptrVEHardware,
char* recordingDeviceName, int& recordingDeviceIndex,
char* playbackDeviceName, int& playbackDeviceIndex);
bool GetAudioDevices(VoEBase* ptrVEBase, VoEHardware* ptrVEHardware,
bool GetAudioDevices(webrtc::VoEBase* ptrVEBase,
webrtc::VoEHardware* ptrVEHardware,
int& recordingDeviceIndex, int& playbackDeviceIndex);
bool GetAudioPorts(int* txPort, int* rxPort);
bool GetAudioCodec(VoECodec* ptrVeCodec, CodecInst& audioCodec);
bool GetAudioCodec(webrtc::VoECodec* ptrVeCodec,
webrtc::CodecInst& audioCodec);
// vie_autotest_base.cc
int ViEBaseStandardTest();
@ -135,9 +138,9 @@ private:
void* _window1;
void* _window2;
VideoRenderType _renderType;
VideoRender* _vrm1;
VideoRender* _vrm2;
webrtc::VideoRenderType _renderType;
webrtc::VideoRender* _vrm1;
webrtc::VideoRender* _vrm2;
};
#endif // WEBRTC_VIDEO_ENGINE_MAIN_TEST_AUTOTEST_INTERFACE_VIE_AUTOTEST_H_

8
src/video_engine/main/test/AutoTest/interface/vie_autotest_main.h
View File

@ -13,22 +13,20 @@
#include <string>
using namespace std;
class ViEAutoTestMain
{
public:
ViEAutoTestMain();
bool BeginOSIndependentTesting();
bool GetAnswer(int index, string& answer);
bool GetAnswer(int index, std::string& answer);
int GetClassTestSelection();
bool GetNextAnswer(string& answer);
bool GetNextAnswer(std::string& answer);
bool IsUsingAnswerFile();
bool UseAnswerFile(const char* fileName);
private:
string _answers[1024];
std::string _answers[1024];
int _answersCount;
int _answersIndex;
bool _useAnswerFile;

52
src/video_engine/main/test/AutoTest/source/tb_external_transport.cc
View File

@ -35,21 +35,27 @@
#pragma warning(disable: 4355) // 'this' : used in base member initializer list
#endif
using namespace webrtc;
tbExternalTransport::tbExternalTransport(ViENetwork& vieNetwork) :
tbExternalTransport::tbExternalTransport(webrtc::ViENetwork& vieNetwork) :
_vieNetwork(vieNetwork),
_thread(*ThreadWrapper::CreateThread(ViEExternalTransportRun, this,
kHighPriority,
"AutotestTransport")),
_event(*EventWrapper::Create()),
_crit(*CriticalSectionWrapper::CreateCriticalSection()),
_statCrit(*CriticalSectionWrapper::CreateCriticalSection()),
_lossRate(0), _networkDelayMs(0), _rtpCount(0), _rtcpCount(0),
_dropCount(0), _rtpPackets(), _rtcpPackets(), _checkSSRC(false),
_lastSSRC(0), _checkSequenceNumber(0), _firstSequenceNumber(0)
_thread(*webrtc::ThreadWrapper::CreateThread(
ViEExternalTransportRun, this, webrtc::kHighPriority,
"AutotestTransport")),
_event(*webrtc::EventWrapper::Create()),
_crit(*webrtc::CriticalSectionWrapper::CreateCriticalSection()),
_statCrit(*webrtc::CriticalSectionWrapper::CreateCriticalSection()),
_lossRate(0),
_networkDelayMs(0),
_rtpCount(0),
_rtcpCount(0),
_dropCount(0),
_rtpPackets(),
_rtcpPackets(),
_checkSSRC(false),
_lastSSRC(0),
_checkSequenceNumber(0),
_firstSequenceNumber(0)
{
srand((int) TickTime::MicrosecondTimestamp());
srand((int) webrtc::TickTime::MicrosecondTimestamp());
unsigned int tId = 0;
_thread.Start(tId);
}
@ -117,21 +123,21 @@ int tbExternalTransport::SendRTCPPacket(int channel, const void *data, int len)
WebRtc_Word32 tbExternalTransport::SetPacketLoss(WebRtc_Word32 lossRate)
{
CriticalSectionScoped cs(_statCrit);
webrtc::CriticalSectionScoped cs(_statCrit);
_lossRate = lossRate;
return 0;
}
void tbExternalTransport::SetNetworkDelay(WebRtc_Word64 delayMs)
{
CriticalSectionScoped cs(_crit);
webrtc::CriticalSectionScoped cs(_crit);
_networkDelayMs = delayMs;
return;
}
void tbExternalTransport::ClearStats()
{
CriticalSectionScoped cs(_statCrit);
webrtc::CriticalSectionScoped cs(_statCrit);
_rtpCount = 0;
_dropCount = 0;
_rtcpCount = 0;
@ -142,7 +148,7 @@ void tbExternalTransport::GetStats(WebRtc_Word32& numRtpPackets,
WebRtc_Word32& numDroppedPackets,
WebRtc_Word32& numRtcpPackets)
{
CriticalSectionScoped cs(_statCrit);
webrtc::CriticalSectionScoped cs(_statCrit);
numRtpPackets = _rtpCount;
numDroppedPackets = _dropCount;
numRtcpPackets = _rtcpCount;
@ -151,24 +157,24 @@ void tbExternalTransport::GetStats(WebRtc_Word32& numRtpPackets,
void tbExternalTransport::EnableSSRCCheck()
{
CriticalSectionScoped cs(_statCrit);
webrtc::CriticalSectionScoped cs(_statCrit);
_checkSSRC = true;
}
unsigned int tbExternalTransport::ReceivedSSRC()
{
CriticalSectionScoped cs(_statCrit);
webrtc::CriticalSectionScoped cs(_statCrit);
return _lastSSRC;
}
void tbExternalTransport::EnableSequenceNumberCheck()
{
CriticalSectionScoped cs(_statCrit);
webrtc::CriticalSectionScoped cs(_statCrit);
_checkSequenceNumber = true;
}
unsigned short tbExternalTransport::GetFirstSequenceNumber()
{
CriticalSectionScoped cs(_statCrit);
webrtc::CriticalSectionScoped cs(_statCrit);
return _firstSequenceNumber;
}
@ -206,7 +212,7 @@ bool tbExternalTransport::ViEExternalTransportProcess()
if (packet)
{
{
CriticalSectionScoped cs(_statCrit);
webrtc::CriticalSectionScoped cs(_statCrit);
if (_checkSSRC)
{
_lastSSRC = ((packet->packetBuffer[8]) << 24);
@ -264,5 +270,5 @@ bool tbExternalTransport::ViEExternalTransportProcess()
WebRtc_Word64 tbExternalTransport::NowMs()
{
return TickTime::MillisecondTimestamp();
return webrtc::TickTime::MillisecondTimestamp();
}

23
src/video_engine/main/test/AutoTest/source/vie_autotest.cc
View File

@ -25,9 +25,11 @@ char* ViETest::_logStr = NULL;
ViEAutoTest::ViEAutoTest(void* window1, void* window2) :
_window1(window1),
_window2(window2),
_renderType(kRenderDefault),
_vrm1(VideoRender::CreateVideoRender(4561, window1, false, _renderType)),
_vrm2(VideoRender::CreateVideoRender(4562, window2, false, _renderType))
_renderType(webrtc::kRenderDefault),
_vrm1(webrtc::VideoRender::CreateVideoRender(
4561, window1, false, _renderType)),
_vrm2(webrtc::VideoRender::CreateVideoRender(
4562, window2, false, _renderType))
{
assert(_vrm1);
assert(_vrm2);
@ -37,9 +39,9 @@ ViEAutoTest::ViEAutoTest(void* window1, void* window2) :
ViEAutoTest::~ViEAutoTest()
{
VideoRender::DestroyVideoRender(_vrm1);
webrtc::VideoRender::DestroyVideoRender(_vrm1);
_vrm1 = NULL;
VideoRender::DestroyVideoRender(_vrm2);
webrtc::VideoRender::DestroyVideoRender(_vrm2);
_vrm2 = NULL;
ViETest::Terminate();
@ -110,7 +112,6 @@ int ViEAutoTest::ViEAPITest()
void ViEAutoTest::PrintVideoCodec(const webrtc::VideoCodec videoCodec)
{
using namespace std;
ViETest::Log("Video Codec Information:");
switch (videoCodec.codecType)
@ -142,15 +143,6 @@ void ViEAutoTest::PrintVideoCodec(const webrtc::VideoCodec videoCodec)
break;
}
//cout << "\tcodecSpecific: " << videoCodec.codecSpecific << endl;
//switch(videoCodec.codecSpecific)
//{
// webrtc::VideoCodecH263 H263;
// webrtc::VideoCodecVP8 VP8;
// webrtc::VideoCodecMPEG4 MPEG4;
// webrtc::VideoCodecGeneric Generic;
//}
ViETest::Log("\theight: %u", videoCodec.height);
ViETest::Log("\tmaxBitrate: %u", videoCodec.maxBitrate);
ViETest::Log("\tmaxFramerate: %u", videoCodec.maxFramerate);
@ -164,7 +156,6 @@ void ViEAutoTest::PrintVideoCodec(const webrtc::VideoCodec videoCodec)
void ViEAutoTest::PrintAudioCodec(const webrtc::CodecInst audioCodec)
{
using namespace std;
ViETest::Log("Audio Codec Information:");
ViETest::Log("\tchannels: %u", audioCodec.channels);
ViETest::Log("\t: %u", audioCodec.pacsize);

65
src/video_engine/main/test/AutoTest/source/vie_autotest_base.cc
View File

@ -32,8 +32,8 @@ int ViEAutoTest::ViEBaseStandardTest()
ViETest::Log("Starting a loopback call...");
VideoEngine* ptrViE = NULL;
ptrViE = VideoEngine::Create();
webrtc::VideoEngine* ptrViE = NULL;
ptrViE = webrtc::VideoEngine::Create();
numberOfErrors += ViETest::TestError(ptrViE != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -47,7 +47,7 @@ int ViEAutoTest::ViEBaseStandardTest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
#endif
ViEBase* ptrViEBase = ViEBase::GetInterface(ptrViE);
webrtc::ViEBase* ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViEBase != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -65,12 +65,12 @@ int ViEAutoTest::ViEBaseStandardTest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
ViECapture* ptrViECapture = ViECapture::GetInterface(ptrViE);
webrtc::ViECapture* ptrViECapture = webrtc::ViECapture::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViECapture != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
VideoCaptureModule* vcpm(NULL);
webrtc::VideoCaptureModule* vcpm(NULL);
const unsigned int KMaxDeviceNameLength = 128;
const unsigned int KMaxUniqueIdLength = 256;
@ -81,8 +81,8 @@ int ViEAutoTest::ViEBaseStandardTest()
bool captureDeviceSet = false;
int captureId = 0;
VideoCaptureModule::DeviceInfo* devInfo =
VideoCaptureModule::CreateDeviceInfo(0);
webrtc::VideoCaptureModule::DeviceInfo* devInfo =
webrtc::VideoCaptureModule::CreateDeviceInfo(0);
for (unsigned int captureIdx = 0;
captureIdx < devInfo->NumberOfDevices();
@ -95,7 +95,7 @@ int ViEAutoTest::ViEBaseStandardTest()
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
vcpm = VideoCaptureModule::Create(4571, uniqueId);
vcpm = webrtc::VideoCaptureModule::Create(4571, uniqueId);
numberOfErrors += ViETest::TestError(vcpm != NULL,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -110,11 +110,11 @@ int ViEAutoTest::ViEBaseStandardTest()
}
else
{
VideoCaptureModule::Destroy(vcpm);
webrtc::VideoCaptureModule::Destroy(vcpm);
vcpm = NULL;
}
}
VideoCaptureModule::DestroyDeviceInfo(devInfo);
webrtc::VideoCaptureModule::DestroyDeviceInfo(devInfo);
numberOfErrors+= ViETest::TestError(
captureDeviceSet,
@ -129,17 +129,19 @@ int ViEAutoTest::ViEBaseStandardTest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
ViERTP_RTCP* ptrViERtpRtcp = ViERTP_RTCP::GetInterface(ptrViE);
webrtc::ViERTP_RTCP* ptrViERtpRtcp =
webrtc::ViERTP_RTCP::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViE != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
error = ptrViERtpRtcp->SetRTCPStatus(videoChannel, kRtcpCompound_RFC4585);
error = ptrViERtpRtcp->SetRTCPStatus(videoChannel,
webrtc::kRtcpCompound_RFC4585);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ptrViERtpRtcp->SetKeyFrameRequestMethod(videoChannel,
kViEKeyFrameRequestPliRtcp);
error = ptrViERtpRtcp->SetKeyFrameRequestMethod(
videoChannel, webrtc::kViEKeyFrameRequestPliRtcp);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -147,7 +149,7 @@ int ViEAutoTest::ViEBaseStandardTest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
ViERender* ptrViERender = ViERender::GetInterface(ptrViE);
webrtc::ViERender* ptrViERender = webrtc::ViERender::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViERender != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -179,7 +181,7 @@ int ViEAutoTest::ViEBaseStandardTest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
ViECodec* ptrViECodec = ViECodec::GetInterface(ptrViE);
webrtc::ViECodec* ptrViECodec = webrtc::ViECodec::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViECodec != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -210,7 +212,8 @@ int ViEAutoTest::ViEBaseStandardTest()
__FUNCTION__, __LINE__);
}
ViENetwork* ptrViENetwork = ViENetwork::GetInterface(ptrViE);
webrtc::ViENetwork* ptrViENetwork =
webrtc::ViENetwork::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViENetwork != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -311,7 +314,7 @@ int ViEAutoTest::ViEBaseStandardTest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
VideoCaptureModule::Destroy(vcpm);
webrtc::VideoCaptureModule::Destroy(vcpm);
vcpm = NULL;
remainingInterfaces = ptrViECapture->Release();
@ -348,7 +351,7 @@ int ViEAutoTest::ViEBaseStandardTest()
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
bool deleted = VideoEngine::Delete(ptrViE);
bool deleted = webrtc::VideoEngine::Delete(ptrViE);
numberOfErrors += ViETest::TestError(deleted == true,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -403,14 +406,14 @@ int ViEAutoTest::ViEBaseAPITest()
int error = 0;
int numberOfErrors = 0;
VideoEngine* ptrViE = NULL;
ViEBase* ptrViEBase = NULL;
webrtc::VideoEngine* ptrViE = NULL;
webrtc::ViEBase* ptrViEBase = NULL;
// Get the ViEBase API
ptrViEBase = ViEBase::GetInterface(ptrViE);
ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViEBase == NULL);
ptrViE = VideoEngine::Create();
ptrViE = webrtc::VideoEngine::Create();
numberOfErrors += ViETest::TestError(ptrViE != NULL, "VideoEngine::Create");
#ifdef WEBRTC_ANDROID
@ -425,7 +428,7 @@ int ViEAutoTest::ViEBaseAPITest()
numberOfErrors += ViETest::TestError(error == 0, "SetTraceFile error");
#endif
ptrViEBase = ViEBase::GetInterface(ptrViE);
ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViEBase != NULL);
//***************************************************************
@ -478,16 +481,16 @@ int ViEAutoTest::ViEBaseAPITest()
__FUNCTION__, __LINE__);
// VoiceEngine
VoiceEngine* ptrVoE = NULL;
VoEBase* ptrVoEBase = NULL;
webrtc::VoiceEngine* ptrVoE = NULL;
webrtc::VoEBase* ptrVoEBase = NULL;
int audioChannel = -1;
ptrVoE = VoiceEngine::Create();
ptrVoE = webrtc::VoiceEngine::Create();
numberOfErrors += ViETest::TestError(ptrVoE != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
ptrVoEBase = VoEBase::GetInterface(ptrVoE);
ptrVoEBase = webrtc::VoEBase::GetInterface(ptrVoE);
numberOfErrors += ViETest::TestError(ptrVoEBase != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -530,7 +533,7 @@ int ViEAutoTest::ViEBaseAPITest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
ViEBase* ptrViEBase2 = ViEBase::GetInterface(ptrViE);
webrtc::ViEBase* ptrViEBase2 = webrtc::ViEBase::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViEBase2 != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -540,7 +543,7 @@ int ViEAutoTest::ViEBaseAPITest()
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
bool vieDeleted = VideoEngine::Delete(ptrViE);
bool vieDeleted = webrtc::VideoEngine::Delete(ptrViE);
numberOfErrors += ViETest::TestError(vieDeleted == false,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -550,7 +553,7 @@ int ViEAutoTest::ViEBaseAPITest()
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
vieDeleted = VideoEngine::Delete(ptrViE);
vieDeleted = webrtc::VideoEngine::Delete(ptrViE);
numberOfErrors += ViETest::TestError(vieDeleted == true,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);

126
src/video_engine/main/test/AutoTest/source/vie_autotest_capture.cc
View File

@ -30,26 +30,27 @@
#include "tb_video_channel.h"
#include "video_capture.h"
class CaptureObserver: public ViECaptureObserver
class CaptureObserver: public webrtc::ViECaptureObserver
{
public:
CaptureObserver() :
_brightness(Normal), _alarm(AlarmCleared), _frameRate(0)
{}
_brightness(webrtc::Normal),
_alarm(webrtc::AlarmCleared),
_frameRate(0) {}
virtual void BrightnessAlarm(const int captureId,
const Brightness brightness)
const webrtc::Brightness brightness)
{
_brightness = brightness;
switch (brightness)
{
case Normal:
case webrtc::Normal:
ViETest::Log(" BrightnessAlarm Normal");
break;
case Bright:
case webrtc::Bright:
ViETest::Log(" BrightnessAlarm Bright");
break;
case Dark:
case webrtc::Dark:
ViETest::Log(" BrightnessAlarm Dark");
break;
default:
@ -64,10 +65,11 @@ public:
_frameRate = frameRate;
}
virtual void NoPictureAlarm(const int captureId, const CaptureAlarm alarm)
virtual void NoPictureAlarm(const int captureId,
const webrtc::CaptureAlarm alarm)
{
_alarm = alarm;
if (alarm == AlarmRaised)
if (alarm == webrtc::AlarmRaised)
{
ViETest::Log("NoPictureAlarm CARaised.");
}
@ -77,12 +79,12 @@ public:
}
}
Brightness _brightness;
CaptureAlarm _alarm;
webrtc::Brightness _brightness;
webrtc::CaptureAlarm _alarm;
unsigned char _frameRate;
};
class CaptureEffectFilter: public ViEEffectFilter
class CaptureEffectFilter: public webrtc::ViEEffectFilter
{
public:
CaptureEffectFilter(unsigned int reqWidth, unsigned int reqHeight,
@ -135,8 +137,8 @@ int ViEAutoTest::ViECaptureStandardTest()
int error = 0;
tbInterfaces ViE("WebRTCViECapture_Standard", numberOfErrors);
VideoCaptureModule::DeviceInfo* devInfo =
VideoCaptureModule::CreateDeviceInfo(0);
webrtc::VideoCaptureModule::DeviceInfo* devInfo =
webrtc::VideoCaptureModule::CreateDeviceInfo(0);
int numberOfCaptureDevices = devInfo->NumberOfDevices();
ViETest::Log("Number of capture devices %d", numberOfCaptureDevices);
@ -145,7 +147,7 @@ int ViEAutoTest::ViECaptureStandardTest()
__LINE__);
int captureDeviceId[10];
VideoCaptureModule* vcpms[10];
webrtc::VideoCaptureModule* vcpms[10];
memset(vcpms, 0, sizeof(vcpms));
//Check capabilities
@ -186,7 +188,7 @@ int ViEAutoTest::ViECaptureStandardTest()
capIndex < numberOfCapabilities;
++capIndex)
{
VideoCaptureCapability capability;
webrtc::VideoCaptureCapability capability;
error = devInfo->GetCapability(deviceUniqueName, capIndex,
capability);
numberOfErrors += ViETest::TestError(error == 0,
@ -226,8 +228,8 @@ int ViEAutoTest::ViECaptureStandardTest()
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
VideoCaptureModule* vcpm = VideoCaptureModule::Create(deviceIndex,
deviceUniqueName);
webrtc::VideoCaptureModule* vcpm =
webrtc::VideoCaptureModule::Create(deviceIndex, deviceUniqueName);
numberOfErrors += ViETest::TestError(vcpm != NULL,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -238,7 +240,7 @@ int ViEAutoTest::ViECaptureStandardTest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
VideoCaptureCapability capability;
webrtc::VideoCaptureCapability capability;
error = devInfo->GetCapability(deviceUniqueName, 0, capability);
// Test that the camera select the closest capability to the selected
@ -256,7 +258,7 @@ int ViEAutoTest::ViECaptureStandardTest()
capability.height = capability.height - 2;
capability.width = capability.width - 2;
CaptureCapability vieCapability;
webrtc::CaptureCapability vieCapability;
vieCapability.width = capability.width;
vieCapability.height = capability.height;
vieCapability.codecType = capability.codecType;
@ -267,10 +269,10 @@ int ViEAutoTest::ViECaptureStandardTest()
vieCapability);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
TickTime startTime = TickTime::Now();
webrtc::TickTime startTime = webrtc::TickTime::Now();
while (filter._numberOfCapturedFrames < 10
&& (TickTime::Now() - startTime).Milliseconds() < 10000)
&& (webrtc::TickTime::Now() - startTime).Milliseconds() < 10000)
{
AutoTestSleep(100);
}
@ -321,7 +323,7 @@ int ViEAutoTest::ViECaptureStandardTest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
#endif
VideoCaptureModule::Destroy(vcpms[deviceIndex]);
webrtc::VideoCaptureModule::Destroy(vcpms[deviceIndex]);
}
#endif
if (numberOfErrors > 0)
@ -334,7 +336,7 @@ int ViEAutoTest::ViECaptureStandardTest()
ViETest::Log(" ");
return numberOfErrors;
}
VideoCaptureModule::DestroyDeviceInfo(devInfo);
webrtc::VideoCaptureModule::DestroyDeviceInfo(devInfo);
ViETest::Log(" ");
ViETest::Log(" ViECapture Standard Test PASSED!");
@ -381,8 +383,8 @@ int ViEAutoTest::ViECaptureAPITest()
WebRtc_UWord8 deviceUniqueName[512];
int captureId = 0;
VideoCaptureModule::DeviceInfo* devInfo =
VideoCaptureModule::CreateDeviceInfo(0);
webrtc::VideoCaptureModule::DeviceInfo* devInfo =
webrtc::VideoCaptureModule::CreateDeviceInfo(0);
numberOfErrors += ViETest::TestError(devInfo != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -393,7 +395,8 @@ int ViEAutoTest::ViECaptureAPITest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
VideoCaptureModule* vcpm = VideoCaptureModule::Create(0, deviceUniqueName);
webrtc::VideoCaptureModule* vcpm =
webrtc::VideoCaptureModule::Create(0, deviceUniqueName);
numberOfErrors += ViETest::TestError(vcpm != NULL, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -506,43 +509,43 @@ int ViEAutoTest::ViECaptureAPITest()
__FUNCTION__, __LINE__);
// Test GetOrientation
VideoCaptureRotation orientation;
webrtc::VideoCaptureRotation orientation;
WebRtc_UWord8 dummy_name[5];
error = devInfo->GetOrientation(dummy_name, orientation);
numberOfErrors += ViETest::TestError(error == -1, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
//Test SetRotation
error = ViE.ptrViECapture->SetRotateCapturedFrames(captureId,
RotateCapturedFrame_90);
error = ViE.ptrViECapture->SetRotateCapturedFrames(
captureId, webrtc::RotateCapturedFrame_90);
numberOfErrors += ViETest::TestError(error == -1, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError(ViE.LastError()
== kViECaptureDeviceDoesnNotExist, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError(
ViE.LastError() == kViECaptureDeviceDoesnNotExist,
"ERROR: %s at line %d", __FUNCTION__, __LINE__);
// Allocate capture device
error = ViE.ptrViECapture->AllocateCaptureDevice(*vcpm, captureId);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViECapture->SetRotateCapturedFrames(captureId,
RotateCapturedFrame_0);
error = ViE.ptrViECapture->SetRotateCapturedFrames(
captureId, webrtc::RotateCapturedFrame_0);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViECapture->SetRotateCapturedFrames(captureId,
RotateCapturedFrame_90);
error = ViE.ptrViECapture->SetRotateCapturedFrames(
captureId, webrtc::RotateCapturedFrame_90);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViECapture->SetRotateCapturedFrames(captureId,
RotateCapturedFrame_180);
error = ViE.ptrViECapture->SetRotateCapturedFrames(
captureId, webrtc::RotateCapturedFrame_180);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViECapture->SetRotateCapturedFrames(captureId,
RotateCapturedFrame_270);
error = ViE.ptrViECapture->SetRotateCapturedFrames(
captureId, webrtc::RotateCapturedFrame_270);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -551,8 +554,8 @@ int ViEAutoTest::ViECaptureAPITest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
VideoCaptureModule::DestroyDeviceInfo(devInfo);
VideoCaptureModule::Destroy(vcpm);
webrtc::VideoCaptureModule::DestroyDeviceInfo(devInfo);
webrtc::VideoCaptureModule::Destroy(vcpm);
//***************************************************************
// Testing finished. Tear down Video Engine
@ -596,11 +599,12 @@ int ViEAutoTest::ViECaptureExternalCaptureTest()
channel.StartReceive();
channel.StartSend();
VideoCaptureExternal* externalCapture;
webrtc::VideoCaptureExternal* externalCapture;
int captureId = 0;
// Allocate the external capture device
VideoCaptureModule* vcpm = VideoCaptureModule::Create(0, externalCapture);
webrtc::VideoCaptureModule* vcpm =
webrtc::VideoCaptureModule::Create(0, externalCapture);
numberOfErrors += ViETest::TestError(vcpm != NULL, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -675,10 +679,10 @@ int ViEAutoTest::ViECaptureExternalCaptureTest()
// }
int frameCount = 0;
VideoCaptureCapability capability;
webrtc::VideoCaptureCapability capability;
capability.width = 176;
capability.height = 144;
capability.rawType = kVideoI420;
capability.rawType = webrtc::kVideoI420;
ViETest::Log("Testing external capturing and frame rate callbacks.");
// TODO: Change when using a real file!
@ -688,17 +692,17 @@ int ViEAutoTest::ViECaptureExternalCaptureTest()
externalCapture->IncomingFrame(
videoFrame, videoFrameLength, capability,
TickTime::Now().MillisecondTimestamp());
webrtc::TickTime::Now().MillisecondTimestamp());
AutoTestSleep(33);
if (effectFilter._numberOfCapturedFrames > 2)
{
// make sure brigthness or no picture alarm has not been triggered
numberOfErrors += ViETest::TestError(observer._brightness == Normal,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError(
observer._alarm == AlarmCleared, "ERROR: %s at line %d",
observer._brightness == webrtc::Normal, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError(
observer._alarm == webrtc::AlarmCleared, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
}
frameCount++;
@ -718,10 +722,10 @@ int ViEAutoTest::ViECaptureExternalCaptureTest()
{
externalCapture->IncomingFrame(
videoFrame, videoFrameLength, capability,
TickTime::Now().MillisecondTimestamp());
webrtc::TickTime::Now().MillisecondTimestamp());
AutoTestSleep(33);
}
numberOfErrors += ViETest::TestError(observer._brightness == Bright,
numberOfErrors += ViETest::TestError(observer._brightness == webrtc::Bright,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -734,10 +738,10 @@ int ViEAutoTest::ViECaptureExternalCaptureTest()
{
externalCapture->IncomingFrame(
videoFrame, videoFrameLength, capability,
TickTime::Now().MillisecondTimestamp());
webrtc::TickTime::Now().MillisecondTimestamp());
AutoTestSleep(33);
}
numberOfErrors += ViETest::TestError(observer._brightness == Dark,
numberOfErrors += ViETest::TestError(observer._brightness == webrtc::Dark,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -755,19 +759,19 @@ int ViEAutoTest::ViECaptureExternalCaptureTest()
// Test no picture alarm
ViETest::Log("Testing NoPictureAlarm.");
AutoTestSleep(1050);
numberOfErrors += ViETest::TestError(observer._alarm == AlarmRaised,
numberOfErrors += ViETest::TestError(observer._alarm == webrtc::AlarmRaised,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
for (int frame = 0; frame < 10; ++frame)
{
externalCapture->IncomingFrame(
videoFrame, videoFrameLength, capability,
TickTime::Now().MillisecondTimestamp());
webrtc::TickTime::Now().MillisecondTimestamp());
AutoTestSleep(33);
}
numberOfErrors += ViETest::TestError(observer._alarm == AlarmCleared,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
numberOfErrors += ViETest::TestError(
observer._alarm == webrtc::AlarmCleared, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
delete videoFrame;

75
src/video_engine/main/test/AutoTest/source/vie_autotest_codec.cc
View File

@ -29,8 +29,8 @@
#include "vie_rtp_rtcp.h"
#include "voe_base.h"
class ViEAutotestCodecObserever: public ViEEncoderObserver,
public ViEDecoderObserver
class ViEAutotestCodecObserever: public webrtc::ViEEncoderObserver,
public webrtc::ViEDecoderObserver
{
public:
int incomingCodecCalled;
@ -96,7 +96,7 @@ public:
}
};
class ViEAutoTestEffectFilter: public ViEEffectFilter
class ViEAutoTestEffectFilter: public webrtc::ViEEffectFilter
{
public:
int numFrames;
@ -137,13 +137,13 @@ int ViEAutoTest::ViECodecStandardTest()
tbCaptureDevice captureDevice = tbCaptureDevice(interfaces, numberOfErrors);
int captureId = captureDevice.captureId;
VideoEngine* ptrViE = interfaces.ptrViE;
ViEBase* ptrViEBase = interfaces.ptrViEBase;
ViECapture* ptrViECapture = interfaces.ptrViECapture;
ViERender* ptrViERender = interfaces.ptrViERender;
ViECodec* ptrViECodec = interfaces.ptrViECodec;
ViERTP_RTCP* ptrViERtpRtcp = interfaces.ptrViERtpRtcp;
ViENetwork* ptrViENetwork = interfaces.ptrViENetwork;
webrtc::VideoEngine* ptrViE = interfaces.ptrViE;
webrtc::ViEBase* ptrViEBase = interfaces.ptrViEBase;
webrtc::ViECapture* ptrViECapture = interfaces.ptrViECapture;
webrtc::ViERender* ptrViERender = interfaces.ptrViERender;
webrtc::ViECodec* ptrViECodec = interfaces.ptrViECodec;
webrtc::ViERTP_RTCP* ptrViERtpRtcp = interfaces.ptrViERtpRtcp;
webrtc::ViENetwork* ptrViENetwork = interfaces.ptrViENetwork;
int videoChannel = -1;
error = ptrViEBase->CreateChannel(videoChannel);
@ -154,12 +154,13 @@ int ViEAutoTest::ViECodecStandardTest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ptrViERtpRtcp->SetRTCPStatus(videoChannel, kRtcpCompound_RFC4585);
error = ptrViERtpRtcp->SetRTCPStatus(videoChannel,
webrtc::kRtcpCompound_RFC4585);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ptrViERtpRtcp->SetKeyFrameRequestMethod(videoChannel,
kViEKeyFrameRequestPliRtcp);
error = ptrViERtpRtcp->SetKeyFrameRequestMethod(
videoChannel, webrtc::kViEKeyFrameRequestPliRtcp);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -204,7 +205,7 @@ int ViEAutoTest::ViECodecStandardTest()
videoCodec.width = 640;
videoCodec.height = 480;
}
if(videoCodec.codecType==kVideoCodecI420)
if(videoCodec.codecType == webrtc::kVideoCodecI420)
{
videoCodec.width=176;
videoCodec.height=144;
@ -251,7 +252,8 @@ int ViEAutoTest::ViECodecStandardTest()
// Make sure all codecs runs
//
{
ViEImageProcess* ptrViEImageProcess = ViEImageProcess::GetInterface(ptrViE);
webrtc::ViEImageProcess* ptrViEImageProcess =
webrtc::ViEImageProcess::GetInterface(ptrViE);
ViEAutotestCodecObserever codecObserver;
error = ptrViECodec->RegisterDecoderObserver(videoChannel,
codecObserver);
@ -269,8 +271,9 @@ int ViEAutoTest::ViECodecStandardTest()
__FUNCTION__, __LINE__);
if (videoCodec.codecType != webrtc::kVideoCodecMPEG4)
{
if(videoCodec.codecType==kVideoCodecI420) // Lower resolution to sockkets keep up.
if(videoCodec.codecType == webrtc::kVideoCodecI420)
{
// Lower resolution to sockkets keep up.
videoCodec.width=176;
videoCodec.height=144;
videoCodec.maxFramerate=15;
@ -300,7 +303,7 @@ int ViEAutoTest::ViECodecStandardTest()
int maxNumberOfRenderedFrames = videoCodec.maxFramerate
* KAutoTestSleepTimeMs / 1000;
if(videoCodec.codecType==kVideoCodecI420)
if(videoCodec.codecType == webrtc::kVideoCodecI420)
{
// Due to that I420 needs a huge bandwidht- rate control can set frame rate very low.
// This happen since we use the same channel as we just tested with vp8.
@ -463,12 +466,12 @@ int ViEAutoTest::ViECodecExtendedTest()
tbInterfaces interfaces = tbInterfaces("ViECodecExtendedTest",
numberOfErrors);
ViEBase* ptrViEBase = interfaces.ptrViEBase;
ViECapture* ptrViECapture = interfaces.ptrViECapture;
ViERender* ptrViERender = interfaces.ptrViERender;
ViECodec* ptrViECodec = interfaces.ptrViECodec;
ViERTP_RTCP* ptrViERtpRtcp = interfaces.ptrViERtpRtcp;
ViENetwork* ptrViENetwork = interfaces.ptrViENetwork;
webrtc::ViEBase* ptrViEBase = interfaces.ptrViEBase;
webrtc::ViECapture* ptrViECapture = interfaces.ptrViECapture;
webrtc::ViERender* ptrViERender = interfaces.ptrViERender;
webrtc::ViECodec* ptrViECodec = interfaces.ptrViECodec;
webrtc::ViERTP_RTCP* ptrViERtpRtcp = interfaces.ptrViERtpRtcp;
webrtc::ViENetwork* ptrViENetwork = interfaces.ptrViENetwork;
tbCaptureDevice captureDevice = tbCaptureDevice(interfaces,
numberOfErrors);
@ -484,13 +487,12 @@ int ViEAutoTest::ViECodecExtendedTest()
__FUNCTION__, __LINE__);
error = ptrViERtpRtcp->SetRTCPStatus(videoChannel,
kRtcpCompound_RFC4585);
webrtc::kRtcpCompound_RFC4585);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error
= ptrViERtpRtcp->SetKeyFrameRequestMethod(videoChannel,
kViEKeyFrameRequestPliRtcp);
error = ptrViERtpRtcp->SetKeyFrameRequestMethod(
videoChannel, webrtc::kViEKeyFrameRequestPliRtcp);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -635,9 +637,8 @@ int ViEAutoTest::ViECodecExtendedTest()
tbCapture.ConnectTo(videoChannel1);
error
= ViE.ptrViERtpRtcp->SetKeyFrameRequestMethod(
videoChannel1, kViEKeyFrameRequestPliRtcp);
error = ViE.ptrViERtpRtcp->SetKeyFrameRequestMethod(
videoChannel1, webrtc::kViEKeyFrameRequestPliRtcp);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -709,7 +710,7 @@ int ViEAutoTest::ViECodecExtendedTest()
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->SetKeyFrameRequestMethod(
videoChannel2, kViEKeyFrameRequestPliRtcp);
videoChannel2, webrtc::kViEKeyFrameRequestPliRtcp);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -794,7 +795,7 @@ int ViEAutoTest::ViECodecExtendedTest()
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->SetKeyFrameRequestMethod(
videoChannel3, kViEKeyFrameRequestPliRtcp);
videoChannel3, webrtc::kViEKeyFrameRequestPliRtcp);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -897,12 +898,12 @@ int ViEAutoTest::ViECodecAPITest()
int error = 0;
int numberOfErrors = 0;
VideoEngine* ptrViE = NULL;
ptrViE = VideoEngine::Create();
webrtc::VideoEngine* ptrViE = NULL;
ptrViE = webrtc::VideoEngine::Create();
numberOfErrors += ViETest::TestError(ptrViE != NULL, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
ViEBase* ptrViEBase = ViEBase::GetInterface(ptrViE);
webrtc::ViEBase* ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViEBase != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -916,7 +917,7 @@ int ViEAutoTest::ViECodecAPITest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
ViECodec* ptrViECodec = ViECodec::GetInterface(ptrViE);
webrtc::ViECodec* ptrViECodec = webrtc::ViECodec::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViECodec != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -992,7 +993,7 @@ int ViEAutoTest::ViECodecAPITest()
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
bool deleted = VideoEngine::Delete(ptrViE);
bool deleted = webrtc::VideoEngine::Delete(ptrViE);
numberOfErrors += ViETest::TestError(deleted == true,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);

53
src/video_engine/main/test/AutoTest/source/vie_autotest_custom_call.cc
View File

@ -33,12 +33,12 @@ int ViEAutoTest::ViECustomCall()
std::string str;
// VoE
VoiceEngine* ptrVE = VoiceEngine::Create();
webrtc::VoiceEngine* ptrVE = webrtc::VoiceEngine::Create();
numberOfErrors += ViETest::TestError(ptrVE != NULL, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
VoEBase* ptrVEBase = VoEBase::GetInterface(ptrVE);
numberOfErrors += ViETest::TestError(ptrVEBase != NULL,
webrtc::VoEBase* ptrVEBase = webrtc::VoEBase::GetInterface(ptrVE);
numberOfErrors += ViETest::TestError(ptrVEBase != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -46,29 +46,30 @@ int ViEAutoTest::ViECustomCall()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
VoECodec* ptrVECodec = VoECodec::GetInterface(ptrVE);
webrtc::VoECodec* ptrVECodec = webrtc::VoECodec::GetInterface(ptrVE);
numberOfErrors += ViETest::TestError(ptrVECodec != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
VoEHardware* ptrVEHardware = VoEHardware::GetInterface(ptrVE);
webrtc::VoEHardware* ptrVEHardware =
webrtc::VoEHardware::GetInterface(ptrVE);
numberOfErrors += ViETest::TestError(ptrVEHardware != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
VoEAudioProcessing* ptrVEAPM = VoEAudioProcessing::GetInterface(ptrVE);
webrtc::VoEAudioProcessing* ptrVEAPM =
webrtc::VoEAudioProcessing::GetInterface(ptrVE);
numberOfErrors += ViETest::TestError(ptrVEAPM != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
// ViE
VideoEngine* ptrViE = NULL;
ptrViE = VideoEngine::Create();
webrtc::VideoEngine* ptrViE = webrtc::VideoEngine::Create();
numberOfErrors += ViETest::TestError(ptrViE != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
ViEBase* ptrViEBase = ViEBase::GetInterface(ptrViE);
webrtc::ViEBase* ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViEBase != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -77,22 +78,24 @@ int ViEAutoTest::ViECustomCall()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
ViECapture* ptrViECapture = ViECapture::GetInterface(ptrViE);
webrtc::ViECapture* ptrViECapture =
webrtc::ViECapture::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViECapture != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
ViERender* ptrViERender = ViERender::GetInterface(ptrViE);
webrtc::ViERender* ptrViERender = webrtc::ViERender::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViERender != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
ViECodec* ptrViECodec = ViECodec::GetInterface(ptrViE);
webrtc::ViECodec* ptrViECodec = webrtc::ViECodec::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViECodec != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
ViENetwork* ptrViENetwork = ViENetwork::GetInterface(ptrViE);
webrtc::ViENetwork* ptrViENetwork =
webrtc::ViENetwork::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViENetwork != NULL,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
@ -237,12 +240,12 @@ int ViEAutoTest::ViECustomCall()
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ptrVEAPM->SetAgcStatus(true, kAgcDefault);
error = ptrVEAPM->SetAgcStatus(true, webrtc::kAgcDefault);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ptrVEAPM->SetNsStatus(true, kNsHighSuppression);
error = ptrVEAPM->SetNsStatus(true, webrtc::kNsHighSuppression);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -286,19 +289,20 @@ int ViEAutoTest::ViECustomCall()
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
ViERTP_RTCP* ptrViERtpRtcp = ViERTP_RTCP::GetInterface(ptrViE);
webrtc::ViERTP_RTCP* ptrViERtpRtcp =
webrtc::ViERTP_RTCP::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViE != NULL,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ptrViERtpRtcp->SetRTCPStatus(videoChannel,
kRtcpCompound_RFC4585);
webrtc::kRtcpCompound_RFC4585);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ptrViERtpRtcp->SetKeyFrameRequestMethod(
videoChannel, kViEKeyFrameRequestPliRtcp);
videoChannel, webrtc::kViEKeyFrameRequestPliRtcp);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -578,7 +582,7 @@ int ViEAutoTest::ViECustomCall()
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
bool deleted = VideoEngine::Delete(ptrViE);
bool deleted = webrtc::VideoEngine::Delete(ptrViE);
numberOfErrors += ViETest::TestError(deleted == true,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -591,8 +595,8 @@ int ViEAutoTest::ViECustomCall()
return numberOfErrors;
}
bool ViEAutoTest::GetVideoDevice(ViEBase* ptrViEBase,
ViECapture* ptrViECapture,
bool ViEAutoTest::GetVideoDevice(webrtc::ViEBase* ptrViEBase,
webrtc::ViECapture* ptrViECapture,
char* captureDeviceName,
char* captureDeviceUniqueId)
{
@ -673,8 +677,8 @@ bool ViEAutoTest::GetVideoDevice(ViEBase* ptrViEBase,
}
}
bool ViEAutoTest::GetAudioDevices(VoEBase* ptrVEBase,
VoEHardware* ptrVEHardware,
bool ViEAutoTest::GetAudioDevices(webrtc::VoEBase* ptrVEBase,
webrtc::VoEHardware* ptrVEHardware,
char* recordingDeviceName,
int& recordingDeviceIndex,
char* playbackDeviceName,
@ -926,7 +930,8 @@ bool ViEAutoTest::GetVideoPorts(int* txPort, int* rxPort)
assert(false);
return false;
}
bool ViEAutoTest::GetVideoCodec(ViECodec* ptrViECodec,
bool ViEAutoTest::GetVideoCodec(webrtc::ViECodec* ptrViECodec,
webrtc::VideoCodec& videoCodec)
{
int error = 0;

2
src/video_engine/main/test/AutoTest/source/vie_autotest_encryption.cc
View File

@ -21,7 +21,7 @@
#include "tb_interfaces.h"
#include "tb_video_channel.h"
class ViEAutotestEncryption: public Encryption
class ViEAutotestEncryption: public webrtc::Encryption
{
public:
ViEAutotestEncryption()

41
src/video_engine/main/test/AutoTest/source/vie_autotest_file.cc
View File

@ -21,10 +21,7 @@
#include "voe_codec.h"
// TODO: remove using ...
using namespace std;
class ViEAutotestFileObserver: public ViEFileObserver
class ViEAutotestFileObserver: public webrtc::ViEFileObserver
{
public:
ViEAutotestFileObserver() {};
@ -56,13 +53,13 @@ int ViEAutoTest::ViEFileStandardTest()
tbInterfaces interfaces = tbInterfaces("ViEFileStandardTest",
numberOfErrors);
VideoEngine* ptrViE = interfaces.ptrViE;
ViEBase* ptrViEBase = interfaces.ptrViEBase;
ViECapture* ptrViECapture = interfaces.ptrViECapture;
ViERender* ptrViERender = interfaces.ptrViERender;
ViECodec* ptrViECodec = interfaces.ptrViECodec;
ViERTP_RTCP* ptrViERtpRtcp = interfaces.ptrViERtpRtcp;
ViENetwork* ptrViENetwork = interfaces.ptrViENetwork;
webrtc::VideoEngine* ptrViE = interfaces.ptrViE;
webrtc::ViEBase* ptrViEBase = interfaces.ptrViEBase;
webrtc::ViECapture* ptrViECapture = interfaces.ptrViECapture;
webrtc::ViERender* ptrViERender = interfaces.ptrViERender;
webrtc::ViECodec* ptrViECodec = interfaces.ptrViECodec;
webrtc::ViERTP_RTCP* ptrViERtpRtcp = interfaces.ptrViERtpRtcp;
webrtc::ViENetwork* ptrViENetwork = interfaces.ptrViENetwork;
tbCaptureDevice captureDevice = tbCaptureDevice(interfaces,
numberOfErrors);
@ -82,14 +79,14 @@ int ViEAutoTest::ViEFileStandardTest()
__FUNCTION__, __LINE__);
error = ptrViERtpRtcp->SetRTCPStatus(videoChannel,
kRtcpCompound_RFC4585);
webrtc::kRtcpCompound_RFC4585);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR:%d %s at line %d",
ptrViEBase->LastError(),
__FUNCTION__, __LINE__);
error = ptrViERtpRtcp->SetKeyFrameRequestMethod(
videoChannel, kViEKeyFrameRequestPliRtcp);
videoChannel, webrtc::kViEKeyFrameRequestPliRtcp);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR:%d %s at line %d",
ptrViEBase->LastError(),
@ -204,14 +201,14 @@ int ViEAutoTest::ViEFileStandardTest()
ptrViEBase->LastError(),
__FUNCTION__, __LINE__);
ViEFile* ptrViEFile = ViEFile::GetInterface(ptrViE);
webrtc::ViEFile* ptrViEFile = webrtc::ViEFile::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR:%d %s at line %d",
ptrViEBase->LastError(),
__FUNCTION__, __LINE__);
VoiceEngine* ptrVEEngine = VoiceEngine::Create();
VoEBase* ptrVEBase = VoEBase::GetInterface(ptrVEEngine);
webrtc::VoiceEngine* ptrVEEngine = webrtc::VoiceEngine::Create();
webrtc::VoEBase* ptrVEBase = webrtc::VoEBase::GetInterface(ptrVEEngine);
ptrVEBase->Init();
int audioChannel = ptrVEBase->CreateChannel();
@ -256,9 +253,9 @@ int ViEAutoTest::ViEFileStandardTest()
const char outgoingVideo[1024] = VIE_TEST_FILES_ROOT "outgoingVideo.avi";
char snapshotRenderFileName[256] = VIE_TEST_FILES_ROOT "snapshotRenderer.jpg";
ViEPicture capturePicture;
ViEPicture renderPicture;
ViEPicture renderTimeoutPicture; // TODO: init with and image
webrtc::ViEPicture capturePicture;
webrtc::ViEPicture renderPicture;
webrtc::ViEPicture renderTimeoutPicture; // TODO: init with and image
ViEAutotestFileObserver fileObserver;
int fileId;
@ -272,7 +269,8 @@ int ViEAutoTest::ViEFileStandardTest()
error = ptrViEFile->StartRecordIncomingVideo(videoChannel,
incomingVideo,
NO_AUDIO, audioCodec2,
webrtc::NO_AUDIO,
audioCodec2,
videoCodec);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR:%d %s at line %d",
@ -393,7 +391,8 @@ int ViEAutoTest::ViEFileStandardTest()
"seconds", VIDEO_LENGTH);
error = ptrViEFile->StartRecordOutgoingVideo(videoChannel,
outgoingVideo,
NO_AUDIO, audioCodec2,
webrtc::NO_AUDIO,
audioCodec2,
videoCodec);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR:%d %s at line %d",

2
src/video_engine/main/test/AutoTest/source/vie_autotest_image_process.cc
View File

@ -21,7 +21,7 @@
#include "tb_video_channel.h"
#include "tb_capture_device.h"
class MyEffectFilter: public ViEEffectFilter
class MyEffectFilter: public webrtc::ViEEffectFilter
{
public:
MyEffectFilter() {}

28
src/video_engine/main/test/AutoTest/source/vie_autotest_loopback.cc
View File

@ -47,8 +47,8 @@ int VideoEngineSampleCode(void* window1, void* window2)
//
// Create a VideoEngine instance
//
VideoEngine* ptrViE = NULL;
ptrViE = VideoEngine::Create();
webrtc::VideoEngine* ptrViE = NULL;
ptrViE = webrtc::VideoEngine::Create();
if (ptrViE == NULL)
{
printf("ERROR in VideoEngine::Create\n");
@ -89,7 +89,7 @@ int VideoEngineSampleCode(void* window1, void* window2)
//
// Init VideoEngine and create a channel
//
ViEBase* ptrViEBase = ViEBase::GetInterface(ptrViE);
webrtc::ViEBase* ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE);
if (ptrViEBase == NULL)
{
printf("ERROR in ViEBase::GetInterface\n");
@ -114,7 +114,8 @@ int VideoEngineSampleCode(void* window1, void* window2)
//
// List available capture devices, allocate and connect.
//
ViECapture* ptrViECapture = ViECapture::GetInterface(ptrViE);
webrtc::ViECapture* ptrViECapture =
webrtc::ViECapture::GetInterface(ptrViE);
if (ptrViEBase == NULL)
{
printf("ERROR in ViECapture::GetInterface\n");
@ -191,22 +192,24 @@ int VideoEngineSampleCode(void* window1, void* window2)
//
// RTP/RTCP settings
//
ViERTP_RTCP* ptrViERtpRtcp = ViERTP_RTCP::GetInterface(ptrViE);
webrtc::ViERTP_RTCP* ptrViERtpRtcp =
webrtc::ViERTP_RTCP::GetInterface(ptrViE);
if (ptrViERtpRtcp == NULL)
{
printf("ERROR in ViERTP_RTCP::GetInterface\n");
return -1;
}
error = ptrViERtpRtcp->SetRTCPStatus(videoChannel, kRtcpCompound_RFC4585);
error = ptrViERtpRtcp->SetRTCPStatus(videoChannel,
webrtc::kRtcpCompound_RFC4585);
if (error == -1)
{
printf("ERROR in ViERTP_RTCP::SetRTCPStatus\n");
return -1;
}
error = ptrViERtpRtcp->SetKeyFrameRequestMethod(videoChannel,
kViEKeyFrameRequestPliRtcp);
error = ptrViERtpRtcp->SetKeyFrameRequestMethod(
videoChannel, webrtc::kViEKeyFrameRequestPliRtcp);
if (error == -1)
{
printf("ERROR in ViERTP_RTCP::SetKeyFrameRequestMethod\n");
@ -223,7 +226,7 @@ int VideoEngineSampleCode(void* window1, void* window2)
//
// Set up rendering
//
ViERender* ptrViERender = ViERender::GetInterface(ptrViE);
webrtc::ViERender* ptrViERender = webrtc::ViERender::GetInterface(ptrViE);
if (ptrViERender == NULL)
{
printf("ERROR in ViERender::GetInterface\n");
@ -263,7 +266,7 @@ int VideoEngineSampleCode(void* window1, void* window2)
//
// Setup codecs
//
ViECodec* ptrViECodec = ViECodec::GetInterface(ptrViE);
webrtc::ViECodec* ptrViECodec = webrtc::ViECodec::GetInterface(ptrViE);
if (ptrViECodec == NULL)
{
printf("ERROR in ViECodec::GetInterface\n");
@ -425,7 +428,8 @@ int VideoEngineSampleCode(void* window1, void* window2)
//
// Address settings
//
ViENetwork* ptrViENetwork = ViENetwork::GetInterface(ptrViE);
webrtc::ViENetwork* ptrViENetwork =
webrtc::ViENetwork::GetInterface(ptrViE);
if (ptrViENetwork == NULL)
{
printf("ERROR in ViENetwork::GetInterface\n");
@ -600,7 +604,7 @@ int VideoEngineSampleCode(void* window1, void* window2)
return -1;
}
bool deleted = VideoEngine::Delete(ptrViE);
bool deleted = webrtc::VideoEngine::Delete(ptrViE);
if (deleted == false)
{
printf("ERROR in VideoEngine::Delete\n");

2
src/video_engine/main/test/AutoTest/source/vie_autotest_main.cc
View File

@ -351,7 +351,7 @@ int ViEAutoTestMain::GetClassTestSelection()
return -1;
}
bool ViEAutoTestMain::GetAnswer(int index, string& answer)
bool ViEAutoTestMain::GetAnswer(int index, std::string& answer)
{
if (!_useAnswerFile || index > _answersCount)
{

8
src/video_engine/main/test/AutoTest/source/vie_autotest_network.cc
View File

@ -27,7 +27,7 @@
#endif
class ViEAutoTestNetworkObserver: public ViENetworkObserver
class ViEAutoTestNetworkObserver: public webrtc::ViENetworkObserver
{
public:
ViEAutoTestNetworkObserver()
@ -40,7 +40,7 @@ public:
{
}
virtual void PacketTimeout(const int videoChannel,
const ViEPacketTimeout timeout)
const webrtc::ViEPacketTimeout timeout)
{
}
};
@ -98,8 +98,8 @@ int ViEAutoTest::ViENetworkStandardTest()
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error= ViE.ptrViERtpRtcp->SetKeyFrameRequestMethod(tbChannel.videoChannel,
kViEKeyFrameRequestPliRtcp);
error= ViE.ptrViERtpRtcp->SetKeyFrameRequestMethod(
tbChannel.videoChannel, webrtc::kViEKeyFrameRequestPliRtcp);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);

27
src/video_engine/main/test/AutoTest/source/vie_autotest_render.cc
View File

@ -39,7 +39,7 @@
#elif defined(WEBRTC_MAC)
#endif
class ViEAutoTestExternalRenderer: public ExternalRenderer
class ViEAutoTestExternalRenderer: public webrtc::ExternalRenderer
{
public:
ViEAutoTestExternalRenderer() :
@ -169,9 +169,10 @@ int ViEAutoTest::ViERenderStandardTest()
__FUNCTION__, __LINE__);
// Destroy render module and create new in full screen mode
VideoRender::DestroyVideoRender(_vrm1);
webrtc::VideoRender::DestroyVideoRender(_vrm1);
_vrm1 = NULL;
_vrm1 = VideoRender::CreateVideoRender(4563, _window1, true, _renderType);
_vrm1 = webrtc::VideoRender::CreateVideoRender(
4563, _window1, true, _renderType);
numberOfErrors += ViETest::TestError(_vrm1, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -207,9 +208,10 @@ int ViEAutoTest::ViERenderStandardTest()
__FUNCTION__, __LINE__);
// Destroy full screen render module and create new in normal mode
VideoRender::DestroyVideoRender(_vrm1);
webrtc::VideoRender::DestroyVideoRender(_vrm1);
_vrm1 = NULL;
_vrm1 = VideoRender::CreateVideoRender(4561, _window1, false, _renderType);
_vrm1 = webrtc::VideoRender::CreateVideoRender(
4561, _window1, false, _renderType);
numberOfErrors += ViETest::TestError(_vrm1, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
#endif
@ -366,9 +368,10 @@ int ViEAutoTest::ViERenderExtendedTest()
__FUNCTION__, __LINE__);
// Destroy render module and create new in full screen mode
VideoRender::DestroyVideoRender(_vrm1);
webrtc::VideoRender::DestroyVideoRender(_vrm1);
_vrm1 = NULL;
_vrm1 = VideoRender::CreateVideoRender(4563, _window1, true, _renderType);
_vrm1 = webrtc::VideoRender::CreateVideoRender(
4563, _window1, true, _renderType);
numberOfErrors += ViETest::TestError(_vrm1, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -407,9 +410,10 @@ int ViEAutoTest::ViERenderExtendedTest()
__FUNCTION__, __LINE__);
// Destroy full screen render module and create new for external rendering
VideoRender::DestroyVideoRender(_vrm1);
webrtc::VideoRender::DestroyVideoRender(_vrm1);
_vrm1 = NULL;
_vrm1 = VideoRender::CreateVideoRender(4564, NULL, false, _renderType);
_vrm1 = webrtc::VideoRender::CreateVideoRender(4564, NULL, false,
_renderType);
numberOfErrors += ViETest::TestError(_vrm1, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -442,9 +446,10 @@ int ViEAutoTest::ViERenderExtendedTest()
// Destroy render module for external rendering and create new in normal
// mode
VideoRender::DestroyVideoRender(_vrm1);
webrtc::VideoRender::DestroyVideoRender(_vrm1);
_vrm1 = NULL;
_vrm1 = VideoRender::CreateVideoRender(4561, _window1, false, _renderType);
_vrm1 = webrtc::VideoRender::CreateVideoRender(4561, _window1, false,
_renderType);
numberOfErrors += ViETest::TestError(_vrm1, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);

118
src/video_engine/main/test/AutoTest/source/vie_autotest_rtp_rtcp.cc
View File

@ -22,7 +22,7 @@
#include "tb_interfaces.h"
#include "tb_video_channel.h"
class ViERtpObserver: public ViERTPObserver
class ViERtpObserver: public webrtc::ViERTPObserver
{
public:
ViERtpObserver()
@ -42,7 +42,7 @@ public:
}
};
class ViERtcpObserver: public ViERTCPObserver
class ViERtcpObserver: public webrtc::ViERTCPObserver
{
public:
int _channel;
@ -161,10 +161,10 @@ int ViEAutoTest::ViERtpRtcpStandardTest()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
char returnCName[ViERTP_RTCP::KMaxRTCPCNameLength];
memset(returnCName, 0, ViERTP_RTCP::KMaxRTCPCNameLength);
error
= ViE.ptrViERtpRtcp->GetRTCPCName(tbChannel.videoChannel, returnCName);
char returnCName[webrtc::ViERTP_RTCP::KMaxRTCPCNameLength];
memset(returnCName, 0, webrtc::ViERTP_RTCP::KMaxRTCPCNameLength);
error = ViE.ptrViERtpRtcp->GetRTCPCName(tbChannel.videoChannel,
returnCName);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError((strcmp(sendCName, returnCName) == 0),
@ -177,8 +177,8 @@ int ViEAutoTest::ViERtpRtcpStandardTest()
AutoTestSleep(1000);
char remoteCName[ViERTP_RTCP::KMaxRTCPCNameLength];
memset(remoteCName, 0, ViERTP_RTCP::KMaxRTCPCNameLength);
char remoteCName[webrtc::ViERTP_RTCP::KMaxRTCPCNameLength];
memset(remoteCName, 0, webrtc::ViERTP_RTCP::KMaxRTCPCNameLength);
error = ViE.ptrViERtpRtcp->GetRemoteRTCPCName(tbChannel.videoChannel,
remoteCName);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
@ -364,11 +364,11 @@ int ViEAutoTest::ViERtpRtcpStandardTest()
#endif
error = ViE.ptrViERtpRtcp->StartRTPDump(tbChannel.videoChannel, inDumpName,
kRtpIncoming);
webrtc::kRtpIncoming);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->StartRTPDump(tbChannel.videoChannel,
outDumpName, kRtpOutgoing);
outDumpName, webrtc::kRtpOutgoing);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -384,12 +384,12 @@ int ViEAutoTest::ViERtpRtcpStandardTest()
AutoTestSleep(1000);
error
= ViE.ptrViERtpRtcp->StopRTPDump(tbChannel.videoChannel, kRtpIncoming);
error = ViE.ptrViERtpRtcp->StopRTPDump(tbChannel.videoChannel,
webrtc::kRtpIncoming);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error
= ViE.ptrViERtpRtcp->StopRTPDump(tbChannel.videoChannel, kRtpOutgoing);
error = ViE.ptrViERtpRtcp->StopRTPDump(tbChannel.videoChannel,
webrtc::kRtpOutgoing);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -578,44 +578,45 @@ int ViEAutoTest::ViERtpRtcpAPITest()
//
// Check different RTCP modes
//
ViERTCPMode rtcpMode = kRtcpNone;
webrtc::ViERTCPMode rtcpMode = webrtc::kRtcpNone;
error = ViE.ptrViERtpRtcp->GetRTCPStatus(tbChannel.videoChannel, rtcpMode);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError(rtcpMode == kRtcpCompound_RFC4585,
numberOfErrors += ViETest::TestError(
rtcpMode == webrtc::kRtcpCompound_RFC4585,
"ERROR: %s at line %d", __FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->SetRTCPStatus(tbChannel.videoChannel,
webrtc::kRtcpCompound_RFC4585);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->GetRTCPStatus(tbChannel.videoChannel, rtcpMode);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError(
rtcpMode == webrtc::kRtcpCompound_RFC4585,
"ERROR: %s at line %d", __FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->SetRTCPStatus(tbChannel.videoChannel,
webrtc::kRtcpNonCompound_RFC5506);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->GetRTCPStatus(tbChannel.videoChannel, rtcpMode);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError(
rtcpMode == webrtc::kRtcpNonCompound_RFC5506, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->SetRTCPStatus(tbChannel.videoChannel,
webrtc::kRtcpNone);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->GetRTCPStatus(tbChannel.videoChannel, rtcpMode);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError(rtcpMode == webrtc::kRtcpNone,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
error = ViE.ptrViERtpRtcp->SetRTCPStatus(tbChannel.videoChannel,
kRtcpCompound_RFC4585);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->GetRTCPStatus(tbChannel.videoChannel, rtcpMode);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError(rtcpMode == kRtcpCompound_RFC4585,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
error = ViE.ptrViERtpRtcp->SetRTCPStatus(tbChannel.videoChannel,
kRtcpNonCompound_RFC5506);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->GetRTCPStatus(tbChannel.videoChannel, rtcpMode);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError(rtcpMode == kRtcpNonCompound_RFC5506,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
error = ViE.ptrViERtpRtcp->SetRTCPStatus(tbChannel.videoChannel, kRtcpNone);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->GetRTCPStatus(tbChannel.videoChannel, rtcpMode);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
numberOfErrors += ViETest::TestError(rtcpMode == kRtcpNone,
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
error = ViE.ptrViERtpRtcp->SetRTCPStatus(tbChannel.videoChannel,
kRtcpCompound_RFC4585);
webrtc::kRtcpCompound_RFC4585);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -718,7 +719,7 @@ int ViEAutoTest::ViERtpRtcpAPITest()
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->SetRTCPStatus(tbChannel.videoChannel,
kRtcpCompound_RFC4585);
webrtc::kRtcpCompound_RFC4585);
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
tbChannel.StopSend();
@ -813,38 +814,39 @@ int ViEAutoTest::ViERtpRtcpAPITest()
const char* dumpName = "DumpFileName.rtp";
#endif
error = ViE.ptrViERtpRtcp->StartRTPDump(tbChannel.videoChannel,
dumpName, kRtpIncoming);
dumpName, webrtc::kRtpIncoming);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->StopRTPDump(tbChannel.videoChannel,
kRtpIncoming);
webrtc::kRtpIncoming);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->StopRTPDump(tbChannel.videoChannel,
kRtpIncoming);
webrtc::kRtpIncoming);
numberOfErrors += ViETest::TestError(error == -1,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->StartRTPDump(tbChannel.videoChannel,
dumpName, kRtpOutgoing);
dumpName, webrtc::kRtpOutgoing);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->StopRTPDump(tbChannel.videoChannel,
kRtpOutgoing);
webrtc::kRtpOutgoing);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->StopRTPDump(tbChannel.videoChannel,
kRtpOutgoing);
webrtc::kRtpOutgoing);
numberOfErrors += ViETest::TestError(error == -1,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->StartRTPDump(tbChannel.videoChannel,
dumpName, (RTPDirections) 3);
dumpName,
(webrtc::RTPDirections) 3);
numberOfErrors += ViETest::TestError(error == -1,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -902,22 +904,22 @@ int ViEAutoTest::ViERtpRtcpAPITest()
//
{
error = ViE.ptrViERtpRtcp->SetKeyFrameRequestMethod(
tbChannel.videoChannel, kViEKeyFrameRequestPliRtcp);
tbChannel.videoChannel, webrtc::kViEKeyFrameRequestPliRtcp);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->SetKeyFrameRequestMethod(
tbChannel.videoChannel, kViEKeyFrameRequestPliRtcp);
tbChannel.videoChannel, webrtc::kViEKeyFrameRequestPliRtcp);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->SetKeyFrameRequestMethod(
tbChannel.videoChannel, kViEKeyFrameRequestNone);
tbChannel.videoChannel, webrtc::kViEKeyFrameRequestNone);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ViE.ptrViERtpRtcp->SetKeyFrameRequestMethod(
tbChannel.videoChannel, kViEKeyFrameRequestNone);
tbChannel.videoChannel, webrtc::kViEKeyFrameRequestNone);
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);