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

File handling in vie_auto_test now uses fileutils so input and output file end up in a good place.

Browse Source 
BUG=
TEST=

Review URL: http://webrtc-codereview.appspot.com/301003

git-svn-id: http://webrtc.googlecode.com/svn/trunk@1103 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
phoglund@webrtc.org 2011-12-05 15:27:04 +00:00
parent 82d91ae6cf
commit 23e1c0a0b1
16 changed files with 170 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
DEPS
View File

@ -14,7 +14,7 @@ vars = {
# External resources like video and audio files used for testing purposes.
# Downloaded on demand when needed.
"webrtc_resources_revision": "2",
"webrtc_resources_revision": "3",
}
# NOTE: Prefer revision numbers to tags for svn deps.

104
src/video_engine/test/auto_test/automated/vie_comparison_test.cc
View File

@ -8,26 +8,23 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include <cstdio>
#include "gflags/gflags.h"
#include "gtest/gtest.h"
#include "testsupport/metrics/video_metrics.h"
#include "vie_autotest.h"
#include "vie_autotest_window_manager_interface.h"
#include "vie_comparison_tests.h"
#include "vie_integration_test_base.h"
#include "vie_to_file_renderer.h"
#include "vie_window_creator.h"
#include "testsupport/metrics/video_metrics.h"
namespace {
// These flags are checked upon running the test.
DEFINE_string(i420_test_video_path, "", "Path to an i420-coded raw video file"
" to use for the test. This file is fed into the fake camera"
" and will therefore be what the camera 'sees'.");
DEFINE_int32(i420_test_video_width, 0, "The width of the provided video.");
DEFINE_int32(i420_test_video_height, 0, "The height of the provided video.");
// The input file must be QCIF since I420 gets scaled to that in the tests
// (it is so bandwidth-heavy we have no choice). Our comparison algorithms
// wouldn't like scaling, so this will work when we compare with the original.
const std::string input_file = ViETest::GetResultOutputPath() +
"resources/paris_qcif.yuv";
const int input_width = 176;
const int input_height = 144;
class ViEComparisonTest: public testing::Test {
public:
@ -35,16 +32,21 @@ class ViEComparisonTest: public testing::Test {
std::string test_case_name =
::testing::UnitTest::GetInstance()->current_test_info()->name();
std::string local_preview_filename = test_case_name + "-local-preview.yuv";
std::string remote_filename = test_case_name + "-remote.yuv";
std::string output_path = ViETest::GetResultOutputPath();
std::string local_preview_filename =
test_case_name + "-local-preview.yuv";
std::string remote_filename =
test_case_name + "-remote.yuv";
if (!local_file_renderer_.PrepareForRendering(local_preview_filename)) {
FAIL() << "Could not open output file " << local_preview_filename <<
" for writing.";
if (!local_file_renderer_.PrepareForRendering(output_path,
local_preview_filename)) {
FAIL() << "Could not open output file " << output_path <<
local_preview_filename << " for writing.";
}
if (!remote_file_renderer_.PrepareForRendering(remote_filename)) {
FAIL() << "Could not open output file " << remote_filename <<
" for writing.";
if (!remote_file_renderer_.PrepareForRendering(output_path,
remote_filename)) {
FAIL() << "Could not open output file " << output_path <<
remote_filename << " for writing.";
}
}
@ -73,41 +75,34 @@ class ViEComparisonTest: public testing::Test {
};
TEST_F(ViEComparisonTest, RunsBaseStandardTestWithoutErrors) {
tests_.TestCallSetup(FLAGS_i420_test_video_path,
FLAGS_i420_test_video_width,
FLAGS_i420_test_video_height,
&local_file_renderer_,
&remote_file_renderer_);
ASSERT_TRUE(tests_.TestCallSetup(input_file, input_width, input_height,
&local_file_renderer_,
&remote_file_renderer_));
QualityMetricsResult psnr_result;
int psnr_error = PsnrFromFiles(
FLAGS_i420_test_video_path.c_str(),
remote_file_renderer_.output_filename().c_str(),
FLAGS_i420_test_video_width,
FLAGS_i420_test_video_height,
&psnr_result);
input_file.c_str(), remote_file_renderer_.GetFullOutputPath().c_str(),
input_width, input_height, &psnr_result);
ASSERT_EQ(0, psnr_error) << "The PSNR routine failed - output files missing?";
ASSERT_GT(psnr_result.average, 25); // That is, we want at least 25 dB
ASSERT_GT(psnr_result.average, 28); // That is, we want at least 28 dB
QualityMetricsResult ssim_result;
int ssim_error = SsimFromFiles(
FLAGS_i420_test_video_path.c_str(),
remote_file_renderer_.output_filename().c_str(),
FLAGS_i420_test_video_width,
FLAGS_i420_test_video_height,
&ssim_result);
input_file.c_str(), remote_file_renderer_.GetFullOutputPath().c_str(),
input_width, input_height, &ssim_result);
ASSERT_EQ(0, ssim_error) << "The SSIM routine failed - output files missing?";
ASSERT_GT(ssim_result.average, 0.85f); // 1 = perfect, -1 = terrible
ASSERT_GT(ssim_result.average, 0.95f); // 1 = perfect, -1 = terrible
ViETest::Log("Results: PSNR %f SSIM %f",
psnr_result.average, ssim_result.average);
}
TEST_F(ViEComparisonTest, RunsCodecTestWithoutErrors) {
tests_.TestCodecs(FLAGS_i420_test_video_path,
FLAGS_i420_test_video_width,
FLAGS_i420_test_video_height,
&local_file_renderer_,
&remote_file_renderer_);
ASSERT_TRUE(tests_.TestCodecs(input_file, input_width, input_height,
&local_file_renderer_,
&remote_file_renderer_));
// We compare the local and remote here instead of with the original.
// The reason is that it is hard to say when the three consecutive tests
@ -115,28 +110,27 @@ TEST_F(ViEComparisonTest, RunsCodecTestWithoutErrors) {
// original to get a fair comparison.
QualityMetricsResult psnr_result;
int psnr_error = PsnrFromFiles(
local_file_renderer_.output_filename().c_str(),
remote_file_renderer_.output_filename().c_str(),
FLAGS_i420_test_video_width,
FLAGS_i420_test_video_height,
&psnr_result);
input_file.c_str(),
remote_file_renderer_.GetFullOutputPath().c_str(),
input_width, input_height, &psnr_result);
ASSERT_EQ(0, psnr_error) << "The PSNR routine failed - output files missing?";
// This test includes VP8 which is a bit lossy. According to Wikipedia between
// 20-25 is considered OK for transmission codecs and we seem to be getting
// like 21 so 20 seems like a good threshold value here.
// TODO(phoglund): This value should be higher. Investigate why the remote
// file turns out 6 seconds shorter than the local file (frame dropping?...)
EXPECT_GT(psnr_result.average, 20);
QualityMetricsResult ssim_result;
int ssim_error = SsimFromFiles(
local_file_renderer_.output_filename().c_str(),
remote_file_renderer_.output_filename().c_str(),
FLAGS_i420_test_video_width,
FLAGS_i420_test_video_height,
&ssim_result);
local_file_renderer_.GetFullOutputPath().c_str(),
remote_file_renderer_.GetFullOutputPath().c_str(),
input_width, input_height, &ssim_result);
// TODO(phoglund): This value should also be higher.
ASSERT_EQ(0, ssim_error) << "The SSIM routine failed - output files missing?";
EXPECT_GT(ssim_result.average, 0.8f); // 1 = perfect, -1 = terrible
EXPECT_GT(ssim_result.average, 0.7f); // 1 = perfect, -1 = terrible
ViETest::Log("Results: PSNR %f SSIM %f",
psnr_result.average, ssim_result.average);
}
} // namespace

2
src/video_engine/test/auto_test/automated/vie_standard_integration_test.cc
View File

@ -64,7 +64,7 @@ TEST_F(ViEStandardIntegrationTest, RunsRenderTestWithoutErrors) {
tests_->ViERenderStandardTest();
}
TEST_F(ViEStandardIntegrationTest, RunsRtpRctpTestWithoutErrors) {
TEST_F(ViEStandardIntegrationTest, RunsRtpRtcpTestWithoutErrors) {
tests_->ViERtpRtcpStandardTest();
}

24
src/video_engine/test/auto_test/helpers/vie_to_file_renderer.cc
View File

@ -20,16 +20,18 @@ ViEToFileRenderer::~ViEToFileRenderer() {
}
bool ViEToFileRenderer::PrepareForRendering(
const std::string& output_path,
const std::string& output_filename) {
assert(output_file_ == NULL);
output_file_ = std::fopen(output_filename.c_str(), "wb");
output_file_ = std::fopen((output_path + output_filename).c_str(), "wb");
if (output_file_ == NULL) {
return false;
}
output_filename_ = output_filename;
output_path_ = output_path;
return true;
}
@ -41,30 +43,34 @@ void ViEToFileRenderer::StopRendering() {
bool ViEToFileRenderer::SaveOutputFile(const std::string& prefix) {
assert(output_file_ == NULL && output_filename_ != "");
if (std::rename(output_filename_.c_str(),
(prefix + output_filename_).c_str()) != 0) {
if (std::rename((output_path_ + output_filename_).c_str(),
(output_path_ + prefix + output_filename_).c_str()) != 0) {
std::perror("Failed to rename output file");
return false;
}
// Forget about the file
output_filename_ = "";
ForgetOutputFile();
return true;
}
bool ViEToFileRenderer::DeleteOutputFile() {
assert(output_file_ == NULL && output_filename_ != "");
if (std::remove(output_filename_.c_str()) != 0) {
if (std::remove((output_path_ + output_filename_).c_str()) != 0) {
std::perror("Failed to delete output file");
return false;
}
output_filename_ = "";
ForgetOutputFile();
return true;
}
const std::string& ViEToFileRenderer::output_filename() const {
std::string ViEToFileRenderer::GetFullOutputPath() const {
assert(output_file_ != NULL);
return output_filename_;
return output_path_ + output_filename_;
}
void ViEToFileRenderer::ForgetOutputFile() {
output_filename_ = "";
output_path_ = "";
}
int ViEToFileRenderer::DeliverFrame(unsigned char *buffer,

8
src/video_engine/test/auto_test/helpers/vie_to_file_renderer.h
View File

@ -23,7 +23,8 @@ class ViEToFileRenderer: public webrtc::ExternalRenderer {
virtual ~ViEToFileRenderer();
// Returns false if we fail opening the output filename for writing.
bool PrepareForRendering(const std::string& output_filename);
bool PrepareForRendering(const std::string& output_path,
const std::string& output_filename);
// Closes the output file.
void StopRendering();
@ -45,10 +46,13 @@ class ViEToFileRenderer: public webrtc::ExternalRenderer {
int DeliverFrame(unsigned char* buffer, int buffer_size,
unsigned int time_stamp);
const std::string& output_filename() const;
std::string GetFullOutputPath() const;
private:
void ForgetOutputFile();
std::FILE* output_file_;
std::string output_path_;
std::string output_filename_;
};

11
src/video_engine/test/auto_test/interface/vie_autotest_defines.h
View File

@ -19,6 +19,7 @@
#include <cassert>
#include <stdarg.h>
#include <stdio.h>
#include <string>
#include "engine_configurations.h"
#include "gtest/gtest.h"
@ -27,7 +28,6 @@
#include <windows.h>
#elif defined (WEBRTC_ANDROID)
#include <android/log.h>
#include <string>
#elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
#include <string.h>
#include <time.h>
@ -148,7 +148,7 @@ class ViETest {
#endif
}
// Deprecated(qhogpat): Prefer to use googletest macros in all cases
// Deprecated(phoglund): Prefer to use googletest macros in all cases
// except the custom call case.
static int TestError(bool expr, const char* fmt, ...) {
if (!expr) {
@ -168,6 +168,13 @@ class ViETest {
return 0;
}
// Returns a suitable path to write trace and result files to.
// You should always use this when you want to write output files.
// The returned path is guaranteed to end with a path separator.
// This function may be run at any time during the program's execution.
// Implemented in vie_autotest.cc
static std::string GetResultOutputPath();
private:
static void AssertError(const char* message) {
#ifdef VIE_ASSERT_ERROR

11
src/video_engine/test/auto_test/interface/vie_comparison_tests.h
View File

@ -31,16 +31,19 @@ class ViEToFileRenderer;
// input is restarted between stages.
class ViEComparisonTests {
public:
// Test a typical simple call setup.
void TestCallSetup(
// Test a typical simple call setup. Returns false if the input file
// could not be opened; reports errors using googletest macros otherwise.
bool TestCallSetup(
const std::string& i420_test_video_path,
int width,
int height,
ViEToFileRenderer* local_file_renderer,
ViEToFileRenderer* remote_file_renderer);
// Tries testing the I420 and VP8 codecs in turn.
void TestCodecs(
// Tries testing the I420 and VP8 codecs in turn. Returns false if the
// input file could not be opened; reports errors using googletest macros
// otherwise.
bool TestCodecs(
const std::string& i420_video_file,
int width,
int height,

2
src/video_engine/test/auto_test/primitives/base_primitives.cc
View File

@ -59,8 +59,6 @@ void TestI420CallSetup(webrtc::ViECodec* codec_interface,
// Call started.
ViETest::Log("Call started");
ViETest::Log("You should see a local preview from camera %s"
" in window 1 and the remote video in window 2.", device_name);
AutoTestSleep(KAutoTestSleepTimeMs);

15
src/video_engine/test/auto_test/source/tb_interfaces.cc
View File

@ -12,21 +12,16 @@
#include "gtest/gtest.h"
TbInterfaces::TbInterfaces(const char* testName) {
char traceFile[256] = "";
TbInterfaces::TbInterfaces(const char* test_name) {
std::string trace_file_path =
(ViETest::GetResultOutputPath() + test_name) + "_trace.txt";
#ifdef WEBRTC_ANDROID
strcat(traceFile,"/sdcard/");
#endif
strcat(traceFile, testName);
strcat(traceFile, "_trace.txt");
ViETest::Log("Creating ViE Interfaces for test %s\n", testName);
ViETest::Log("Creating ViE Interfaces for test %s\n", test_name);
video_engine = webrtc::VideoEngine::Create();
EXPECT_TRUE(video_engine != NULL);
EXPECT_EQ(0, video_engine->SetTraceFile(traceFile));
EXPECT_EQ(0, video_engine->SetTraceFile(trace_file_path.c_str()));
EXPECT_EQ(0, video_engine->SetTraceFilter(webrtc::kTraceAll));
base = webrtc::ViEBase::GetInterface(video_engine);

18
src/video_engine/test/auto_test/source/vie_autotest.cc
View File

@ -12,16 +12,28 @@
// vie_autotest.cc
//
#include "vie_autotest_defines.h"
#include "vie_autotest.h"
#include <stdio.h>
#include "video_render.h"
#include "engine_configurations.h"
#include "testsupport/fileutils.h"
#include "video_render.h"
#include "vie_autotest_defines.h"
// ViETest implementation
FILE* ViETest::log_file_ = NULL;
char* ViETest::log_str_ = NULL;
std::string ViETest::GetResultOutputPath() {
#ifdef WEBRTC_ANDROID
return "/sdcard/";
#else
return webrtc::test::OutputPath();
#endif
}
// ViEAutoTest implementation
ViEAutoTest::ViEAutoTest(void* window1, void* window2) :
_window1(window1),
_window2(window2),

11
src/video_engine/test/auto_test/source/vie_autotest_base.cc
View File

@ -71,6 +71,8 @@ void ViEAutoTest::ViEBaseStandardTest() {
// ***************************************************************
// Run the actual test:
// ***************************************************************
ViETest::Log("You should shortly see a local preview from camera %s"
" in window 1 and the remote video in window 2.", device_name);
::TestI420CallSetup(interfaces.codec, interfaces.video_engine,
base_interface, interfaces.network, video_channel,
device_name);
@ -124,12 +126,9 @@ void ViEAutoTest::ViEBaseAPITest() {
webrtc::VideoEngine* ptrViE = webrtc::VideoEngine::Create();
EXPECT_TRUE(NULL != ptrViE);
#ifdef WEBRTC_ANDROID
EXPECT_EQ(0,
video_engine->SetTraceFile("/sdcard/WebRTC/ViEBaseAPI_trace.txt"));
#else
EXPECT_EQ(0, ptrViE->SetTraceFile("ViEBaseAPI_trace.txt"));
#endif
std::string trace_file_path =
ViETest::GetResultOutputPath() + "ViEBaseAPI_trace.txt";
EXPECT_EQ(0, ptrViE->SetTraceFile(trace_file_path.c_str()));
ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE);
EXPECT_TRUE(NULL != ptrViEBase);

48
src/video_engine/test/auto_test/source/vie_autotest_custom_call.cc
View File

@ -13,11 +13,11 @@
*
*/
#include "vie_autotest_defines.h"
#include "vie_autotest.h"
#include <iostream>
#include "vie_autotest.h"
#include "vie_autotest_defines.h"
#define VCM_RED_PAYLOAD_TYPE 96
#define VCM_ULPFEC_PAYLOAD_TYPE 97
#define DEFAULT_SEND_IP "127.0.0.1"
@ -169,7 +169,7 @@ int ViEAutoTest::ViECustomCall()
"ERROR: %s at line %d", __FUNCTION__,
__LINE__);
webrtc::VoEHardware* ptrVEHardware =
webrtc::VoEHardware* ptrVEHardware =
webrtc::VoEHardware::GetInterface(ptrVE);
numberOfErrors += ViETest::TestError(ptrVEHardware != NULL,
"ERROR: %s at line %d", __FUNCTION__,
@ -196,7 +196,7 @@ int ViEAutoTest::ViECustomCall()
numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
__FUNCTION__, __LINE__);
webrtc::ViECapture* ptrViECapture =
webrtc::ViECapture* ptrViECapture =
webrtc::ViECapture::GetInterface(ptrViE);
numberOfErrors += ViETest::TestError(ptrViECapture != NULL,
"ERROR: %s at line %d", __FUNCTION__,
@ -367,7 +367,9 @@ int ViEAutoTest::ViECustomCall()
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
error = ptrViE->SetTraceFile("ViECustomCall_trace.txt");
std::string trace_file =
ViETest::GetResultOutputPath() + "ViECustomCall_trace.txt";
error = ptrViE->SetTraceFile(trace_file.c_str());
numberOfErrors += ViETest::TestError(error == 0,
"ERROR: %s at line %d",
__FUNCTION__, __LINE__);
@ -504,7 +506,7 @@ int ViEAutoTest::ViECustomCall()
ViEAutotestEncoderObserver* codecEncoderObserver = NULL;
ViEAutotestDecoderObserver* codecDecoderObserver = NULL;
//***************************************************************
// Engine ready. Wait for input
//***************************************************************
@ -540,14 +542,14 @@ int ViEAutoTest::ViECustomCall()
std::cout << " 5. Record Incoming Call" << std::endl;
std::cout << " 6. Record Outgoing Call" << std::endl;
std::cout << " 7. Play File on Video Channel"
<< "(Assumes you recorded incoming & outgoing call)"
<< "(Assumes you recorded incoming & outgoing call)"
<< std::endl;
std::cout << " 8. Change Video Protection Method" << std::endl;
std::cout << " 9. Toggle Encoder Observer" << std::endl;
std::cout << " 10. Toggle Decoder Observer" << std::endl;
std::cout << " 11. Print Call Information" << std::endl;
std::cout << " 12. Print Call Statistics" << std::endl;
std::cout << " 13. Toggle Image Scaling "
std::cout << " 13. Toggle Image Scaling "
<< "(Warning high CPU usage when enabled)"
<< std::endl;
std::cout << "What do you want to do? ";
@ -566,7 +568,7 @@ int ViEAutoTest::ViECustomCall()
modify_call = false;
break;
case 1:
// Change video Codec
// Change video Codec
SetVideoCodecType(ptrViECodec, videoSendCodec);
SetVideoCodecSize(ptrViECodec, videoSendCodec);
SetVideoCodecBitrate(ptrViECodec, videoSendCodec);
@ -679,7 +681,7 @@ int ViEAutoTest::ViECustomCall()
break;
case 5:
// Record the incoming call
std::cout << "Start Recording Incoming Video "
std::cout << "Start Recording Incoming Video "
<< DEFAULT_INCOMING_FILE_NAME << std::endl;
error = ptrViEFile->StartRecordIncomingVideo(
videoChannel, DEFAULT_INCOMING_FILE_NAME,
@ -695,7 +697,7 @@ int ViEAutoTest::ViECustomCall()
break;
case 6:
// Record the outgoing call
std::cout << "Start Recording Outgoing Video "
std::cout << "Start Recording Outgoing Video "
<< DEFAULT_OUTGOING_FILE_NAME << std::endl;
error = ptrViEFile->StartRecordOutgoingVideo(
videoChannel, DEFAULT_OUTGOING_FILE_NAME,
@ -715,7 +717,7 @@ int ViEAutoTest::ViECustomCall()
std::cout << "Available files to play" << std::endl;
std::cout << " 0. " << DEFAULT_INCOMING_FILE_NAME << std::endl;
std::cout << " 1. " << DEFAULT_OUTGOING_FILE_NAME << std::endl;
std::cout << "Press enter for default ("
std::cout << "Press enter for default ("
<< DEFAULT_INCOMING_FILE_NAME << "): ";
std::getline(std::cin, str);
file_selection = atoi(str.c_str());
@ -725,7 +727,7 @@ int ViEAutoTest::ViECustomCall()
"ERROR:%d %s at line %d",
ptrViEBase->LastError(),
__FUNCTION__, __LINE__);
if (file_selection == 1)
if (file_selection == 1)
error = ptrViEFile->StartPlayFile(DEFAULT_OUTGOING_FILE_NAME,
fileId, true);
else
@ -742,7 +744,7 @@ int ViEAutoTest::ViECustomCall()
ptrViEBase->LastError(),
__FUNCTION__, __LINE__);
std::cout << std::endl;
std::cout << "Start sending the file that is played in a loop "
std::cout << "Start sending the file that is played in a loop "
<< std::endl;
error = ptrViEFile->SendFileOnChannel(fileId, videoChannel);
numberOfErrors += ViETest::TestError(error == 0,
@ -782,7 +784,7 @@ int ViEAutoTest::ViECustomCall()
SetVideoProtection(ptrViECodec, ptrViERtpRtcp,
videoChannel, protectionMethod);
modify_call = true;
break;
break;
case 9:
// Toggle Encoder Observer
if (!codecEncoderObserver) {
@ -835,7 +837,7 @@ int ViEAutoTest::ViECustomCall()
audioCodec, audioTxPort,
audioRxPort, protectionMethod);
PrintVideoStreamInformation(ptrViECodec,
videoChannel);
videoChannel);
modify_call = true;
break;
case 12:
@ -864,7 +866,7 @@ int ViEAutoTest::ViECustomCall()
modify_call = true;
break;
default:
// invalid selection, shows options menu again
// invalid selection, shows options menu again
std::cout << "Invalid selection. Select Again." << std::endl;
break;
}
@ -1420,7 +1422,7 @@ bool GetAudioCodec(webrtc::VoECodec* ptrVeCodec,
std::cout << "ERROR: Code = " << error << " Invalid selection"
<< std::endl;
continue;
}
}
return true;
}
}
@ -1548,7 +1550,7 @@ bool SetVideoCodecResolution(webrtc::ViECodec* ptrViECodec,
std::getline(std::cin, str);
sizeOption = atoi(str.c_str());
switch (sizeOption) {
case 1:
videoCodec.width = 128;
@ -1667,8 +1669,8 @@ bool SetVideoCodecMaxFramerate(webrtc::ViECodec* ptrViECodec,
}
return true;
}
// GetVideoProtection only prints the prompt to get a number
// that SetVideoProtection method uses
// GetVideoProtection only prints the prompt to get a number
// that SetVideoProtection method uses
// 0 = None
// 1 = FEC
// 2 = NACK
@ -1676,7 +1678,7 @@ bool SetVideoCodecMaxFramerate(webrtc::ViECodec* ptrViECodec,
// Default = DEFAULT_VIDEO_PROTECTION METHOD
int GetVideoProtection() {
int protectionMethod = DEFAULT_VIDEO_PROTECTION_METHOD;
std::cout << "Available Video Protection Method." << std::endl;
std::cout << " 0. None" << std::endl;
std::cout << " 1. FEC" << std::endl;

24
src/video_engine/test/auto_test/source/vie_autotest_loopback.cc
View File

@ -14,16 +14,18 @@
// This code is also used as sample code for ViE 3.0
//
#include "vie_autotest_defines.h"
#include "vie_autotest.h"
// ===================================================================
//
// BEGIN: VideoEngine 3.0 Sample Code
//
#include <iostream>
#include "common_types.h"
#include "tb_external_transport.h"
#include "voe_base.h"
#include "vie_autotest_defines.h"
#include "vie_autotest.h"
#include "vie_base.h"
#include "vie_capture.h"
#include "vie_codec.h"
@ -31,8 +33,6 @@
#include "vie_render.h"
#include "vie_rtp_rtcp.h"
#include <iostream>
#include "tb_external_transport.h"
#define VCM_RED_PAYLOAD_TYPE 96
#define VCM_ULPFEC_PAYLOAD_TYPE 97
@ -62,22 +62,14 @@ int VideoEngineSampleCode(void* window1, void* window2)
return -1;
}
#ifdef WEBRTC_ANDROID
error = ptrViE->SetTraceFile("/sdcard/ViELoopbackCall_trace.txt");
std::string trace_file =
ViETest::GetResultOutputPath() + "ViELoopbackCall_trace.txt";
error = ptrViE->SetTraceFile(trace_file.c_str());
if (error == -1)
{
printf("ERROR in VideoEngine::SetTraceFile\n");
return -1;
}
#else
error = ptrViE->SetTraceFile("ViELoopbackCall_trace.txt");
if (error == -1)
{
printf("ERROR in VideoEngine::SetTraceFile\n");
return -1;
}
#endif
//
// Init VideoEngine and create a channel

25
src/video_engine/test/auto_test/source/vie_autotest_rtp_rtcp.cc
View File

@ -13,14 +13,13 @@
//
#include <iostream>
#include "vie_autotest_defines.h"
#include "vie_autotest.h"
#include "engine_configurations.h"
#include "tb_capture_device.h"
#include "tb_external_transport.h"
#include "tb_interfaces.h"
#include "tb_video_channel.h"
#include "vie_autotest.h"
#include "vie_autotest_defines.h"
class ViERtpObserver: public webrtc::ViERTPObserver
{
@ -325,18 +324,14 @@ void ViEAutoTest::ViERtpRtcpStandardTest()
ViETest::Log("Testing RTP dump...\n");
#ifdef WEBRTC_ANDROID
const char* inDumpName = "/sdcard/IncomingRTPDump.rtp";
const char* outDumpName = "/sdcard/OutgoingRTPDump.rtp";
#else
const char* inDumpName = "IncomingRTPDump.rtp";
const char* outDumpName = "OutgoingRTPDump.rtp";
#endif
std::string inDumpName =
ViETest::GetResultOutputPath() + "IncomingRTPDump.rtp";
std::string outDumpName =
ViETest::GetResultOutputPath() + "OutgoingRTPDump.rtp";
EXPECT_EQ(0, ViE.rtp_rtcp->StartRTPDump(
tbChannel.videoChannel, inDumpName, webrtc::kRtpIncoming));
tbChannel.videoChannel, inDumpName.c_str(), webrtc::kRtpIncoming));
EXPECT_EQ(0, ViE.rtp_rtcp->StartRTPDump(
tbChannel.videoChannel, outDumpName, webrtc::kRtpOutgoing));
tbChannel.videoChannel, outDumpName.c_str(), webrtc::kRtpOutgoing));
EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
@ -353,11 +348,11 @@ void ViEAutoTest::ViERtpRtcpStandardTest()
// Make sure data was actually saved to the file and we stored the same
// amount of data in both files
FILE* inDump = fopen(inDumpName, "r");
FILE* inDump = fopen(inDumpName.c_str(), "r");
fseek(inDump, 0L, SEEK_END);
long inEndPos = ftell(inDump);
fclose(inDump);
FILE* outDump = fopen(outDumpName, "r");
FILE* outDump = fopen(outDumpName.c_str(), "r");
fseek(outDump, 0L, SEEK_END);
long outEndPos = ftell(outDump);
fclose(outDump);

28
src/video_engine/test/auto_test/source/vie_autotest_simulcast.cc
View File

@ -8,11 +8,13 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "vie_autotest_defines.h"
#include "vie_autotest.h"
#include <iostream>
#include "common_types.h"
#include "tb_external_transport.h"
#include "voe_base.h"
#include "vie_autotest_defines.h"
#include "vie_autotest.h"
#include "vie_base.h"
#include "vie_capture.h"
#include "vie_codec.h"
@ -20,8 +22,6 @@
#include "vie_render.h"
#include "vie_rtp_rtcp.h"
#include <iostream>
#include "tb_external_transport.h"
#define VCM_RED_PAYLOAD_TYPE 96
#define VCM_ULPFEC_PAYLOAD_TYPE 97
@ -51,28 +51,16 @@ int VideoEngineSimulcastTest(void* window1, void* window2)
return -1;
}
#ifdef WEBRTC_ANDROID
error = ptrViE->SetTraceFile("/sdcard/ViETrace.txt");
std::string trace_file =
ViETest::GetResultOutputPath() + "ViESimulcast_trace.txt";
error = ptrViE->SetTraceFile(trace_file.c_str());
if (error == -1)
{
printf("ERROR in VideoEngine::SetTraceFile\n");
return -1;
}
error = ptrViE->SetTraceFile("/sdcard/ViEEncryptedTrace.txt");
if (error == -1)
{
printf("ERROR in VideoEngine::SetTraceFile\n");
return -1;
}
#else
error = ptrViE->SetTraceFile("ViETrace.txt");
if (error == -1)
{
printf("ERROR in VideoEngine::SetTraceFile\n");
return -1;
}
#endif
//
// Init VideoEngine and create a channel
//

11
src/video_engine/test/auto_test/source/vie_comparison_tests.cc
View File

@ -18,8 +18,7 @@
#include "vie_fake_camera.h"
#include "vie_to_file_renderer.h"
void ViEComparisonTests::TestCallSetup(
bool ViEComparisonTests::TestCallSetup(
const std::string& i420_video_file,
int width,
int height,
@ -38,7 +37,7 @@ void ViEComparisonTests::TestCallSetup(
// No point in continuing if we have no proper video source
ADD_FAILURE() << "Could not open input video " << i420_video_file <<
": aborting test...";
return;
return false;
}
int capture_id = fake_camera.capture_id();
@ -78,9 +77,10 @@ void ViEComparisonTests::TestCallSetup(
fake_camera.StopCamera();
EXPECT_EQ(0, interfaces.base->DeleteChannel(video_channel));
return true;
}
void ViEComparisonTests::TestCodecs(
bool ViEComparisonTests::TestCodecs(
const std::string& i420_video_file,
int width,
int height,
@ -94,7 +94,7 @@ void ViEComparisonTests::TestCodecs(
// No point in continuing if we have no proper video source
ADD_FAILURE() << "Could not open input video " << i420_video_file <<
": aborting test...";
return;
return false;
}
int video_channel = -1;
@ -115,4 +115,5 @@ void ViEComparisonTests::TestCodecs(
width, height);
fake_camera.StopCamera();
return true;
}