zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert of Adding audio to video_quality_test. (patchset #10 id:230001 of https://codereview.webrtc.org/2136573002/ )

Browse Source 
Reason for revert:
This CL breaks https://build.chromium.org/p/client.webrtc/waterfall?builder=Win64%20Debug%20(Clang)

Need to align values to struct Params {} in a proper way. Relanding will follow.

Original issue's description:
> Adding audio to video_quality_test.
>
> This CL adds an audio loopback to video_quality_test (only RunWithVideoRenderer)
>
> BUG=
>
> Committed: https://crrev.com/65a6578e339f52eb5bc400c5715e60498e4af2c1
> Cr-Commit-Position: refs/heads/master@{#13784}

TBR=stefan@webrtc.org,terelius@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=

Review-Url: https://codereview.webrtc.org/2249163002
Cr-Commit-Position: refs/heads/master@{#13785}
This commit is contained in:
minyue
2016-08-16 08:25:43 -07:00
committed by Commit bot
parent 65a6578e33
commit f095012dc2
4 changed files with 16 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
webrtc/video/screenshare_loopback.cc
View File

@ -235,11 +235,7 @@ void Loopback() {
{"screenshare", 0.0, 0.0, flags::DurationSecs(), flags::OutputFilename(),
flags::GraphTitle()},
pipe_config,
flags::FLAGS_logs,
{}, // ss.
false, // audio.
false, // audio_video_sync.
};
flags::FLAGS_logs};
std::vector<std::string> stream_descriptors;
stream_descriptors.push_back(flags::Stream0());
@ -255,7 +251,7 @@ void Loopback() {
if (flags::DurationSecs()) {
test.RunWithAnalyzer(params);
} else {
test.RunWithRenderers(params);
test.RunWithVideoRenderer(params);
}
}
} // namespace webrtc

12
webrtc/video/video_loopback.cc
View File

@ -191,11 +191,6 @@ DEFINE_bool(allow_reordering, false, "Allow packet reordering to occur");
DEFINE_bool(use_fec, false, "Use forward error correction.");
DEFINE_bool(audio, false, "Add audio stream");
DEFINE_bool(audio_video_sync, false, "Sync audio and video stream (no effect if"
" audio is false)");
DEFINE_string(
force_fieldtrials,
"",
@ -241,10 +236,7 @@ void Loopback() {
{"video", 0.0, 0.0, flags::DurationSecs(), flags::OutputFilename(),
flags::GraphTitle()},
pipe_config,
flags::FLAGS_logs,
{}, // ss.
flags::FLAGS_audio,
flags::FLAGS_audio_video_sync};
flags::FLAGS_logs};
std::vector<std::string> stream_descriptors;
stream_descriptors.push_back(flags::Stream0());
@ -260,7 +252,7 @@ void Loopback() {
if (flags::DurationSecs()) {
test.RunWithAnalyzer(params);
} else {
test.RunWithRenderers(params);
test.RunWithVideoRenderer(params);
}
}
} // namespace webrtc

154
webrtc/video/video_quality_test.cc
View File

@ -34,68 +34,15 @@
#include "webrtc/test/testsupport/fileutils.h"
#include "webrtc/test/video_renderer.h"
#include "webrtc/video/video_quality_test.h"
#include "webrtc/voice_engine/include/voe_base.h"
#include "webrtc/voice_engine/include/voe_codec.h"
namespace {
constexpr int kSendStatsPollingIntervalMs = 1000;
constexpr int kPayloadTypeH264 = 122;
constexpr int kPayloadTypeVP8 = 123;
constexpr int kPayloadTypeVP9 = 124;
constexpr size_t kMaxComparisons = 10;
constexpr char kSyncGroup[] = "av_sync";
constexpr int kOpusMinBitrate = 6000;
constexpr int kOpusBitrateFb = 32000;
struct VoiceEngineState {
VoiceEngineState()
: voice_engine(nullptr),
base(nullptr),
codec(nullptr),
send_channel_id(-1),
receive_channel_id(-1) {}
webrtc::VoiceEngine* voice_engine;
webrtc::VoEBase* base;
webrtc::VoECodec* codec;
int send_channel_id;
int receive_channel_id;
};
void CreateVoiceEngine(VoiceEngineState* voe,
rtc::scoped_refptr<webrtc::AudioDecoderFactory>
decoder_factory) {
voe->voice_engine = webrtc::VoiceEngine::Create();
voe->base = webrtc::VoEBase::GetInterface(voe->voice_engine);
voe->codec = webrtc::VoECodec::GetInterface(voe->voice_engine);
EXPECT_EQ(0, voe->base->Init(nullptr, nullptr, decoder_factory));
webrtc::Config voe_config;
voe_config.Set<webrtc::VoicePacing>(new webrtc::VoicePacing(true));
voe->send_channel_id = voe->base->CreateChannel(voe_config);
EXPECT_GE(voe->send_channel_id, 0);
voe->receive_channel_id = voe->base->CreateChannel();
EXPECT_GE(voe->receive_channel_id, 0);
}
void DestroyVoiceEngine(VoiceEngineState* voe) {
voe->base->DeleteChannel(voe->send_channel_id);
voe->send_channel_id = -1;
voe->base->DeleteChannel(voe->receive_channel_id);
voe->receive_channel_id = -1;
voe->base->Release();
voe->base = nullptr;
voe->codec->Release();
voe->codec = nullptr;
webrtc::VoiceEngine::Delete(voe->voice_engine);
voe->voice_engine = nullptr;
}
} // namespace
namespace webrtc {
static const int kSendStatsPollingIntervalMs = 1000;
static const int kPayloadTypeH264 = 122;
static const int kPayloadTypeVP8 = 123;
static const int kPayloadTypeVP9 = 124;
static const size_t kMaxComparisons = 10;
class VideoAnalyzer : public PacketReceiver,
public Transport,
public rtc::VideoSinkInterface<VideoFrame>,
@ -1055,7 +1002,6 @@ void VideoQualityTest::CreateCapturer(VideoCaptureInput* input) {
void VideoQualityTest::RunWithAnalyzer(const Params& params) {
params_ = params;
RTC_CHECK(!params_.audio);
// TODO(ivica): Merge with RunWithRenderer and use a flag / argument to
// differentiate between the analyzer and the renderer case.
CheckParams();
@ -1153,7 +1099,7 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
fclose(graph_data_output_file);
}
void VideoQualityTest::RunWithRenderers(const Params& params) {
void VideoQualityTest::RunWithVideoRenderer(const Params& params) {
params_ = params;
CheckParams();
@ -1177,15 +1123,6 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
// match the full stack tests.
Call::Config call_config;
call_config.bitrate_config = params_.common.call_bitrate_config;
::VoiceEngineState voe;
if (params_.audio) {
CreateVoiceEngine(&voe, decoder_factory_);
AudioState::Config audio_state_config;
audio_state_config.voice_engine = voe.voice_engine;
call_config.audio_state = AudioState::Create(audio_state_config);
}
std::unique_ptr<Call> call(Call::Create(call_config));
test::LayerFilteringTransport transport(
@ -1200,8 +1137,6 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
video_send_config_.local_renderer = local_preview.get();
video_receive_configs_[stream_id].renderer = loopback_video.get();
if (params_.audio && params_.audio_video_sync)
video_receive_configs_[stream_id].sync_group = kSyncGroup;
video_send_config_.suspend_below_min_bitrate =
params_.common.suspend_below_min_bitrate;
@ -1220,91 +1155,24 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
video_send_stream_ =
call->CreateVideoSendStream(video_send_config_, video_encoder_config_);
VideoReceiveStream* video_receive_stream =
VideoReceiveStream* receive_stream =
call->CreateVideoReceiveStream(video_receive_configs_[stream_id].Copy());
CreateCapturer(video_send_stream_->Input());
AudioReceiveStream* audio_receive_stream = nullptr;
if (params_.audio) {
audio_send_config_ = AudioSendStream::Config(&transport);
audio_send_config_.voe_channel_id = voe.send_channel_id;
audio_send_config_.rtp.ssrc = kAudioSendSsrc;
// Add extension to enable audio send side BWE, and allow audio bit rate
// adaptation.
audio_send_config_.rtp.extensions.clear();
if (params_.common.send_side_bwe) {
audio_send_config_.rtp.extensions.push_back(webrtc::RtpExtension(
webrtc::RtpExtension::kTransportSequenceNumberUri,
test::kTransportSequenceNumberExtensionId));
audio_send_config_.min_bitrate_kbps = kOpusMinBitrate / 1000;
audio_send_config_.max_bitrate_kbps = kOpusBitrateFb / 1000;
}
audio_send_stream_ = call->CreateAudioSendStream(audio_send_config_);
AudioReceiveStream::Config audio_config;
audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
audio_config.rtcp_send_transport = &transport;
audio_config.voe_channel_id = voe.receive_channel_id;
audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc;
audio_config.rtp.transport_cc = params_.common.send_side_bwe;
audio_config.rtp.extensions = audio_send_config_.rtp.extensions;
audio_config.decoder_factory = decoder_factory_;
if (params_.audio_video_sync)
audio_config.sync_group = kSyncGroup;
audio_receive_stream =call->CreateAudioReceiveStream(audio_config);
const CodecInst kOpusInst = {120, "OPUS", 48000, 960, 2, 64000};
EXPECT_EQ(0, voe.codec->SetSendCodec(voe.send_channel_id, kOpusInst));
}
// Start sending and receiving video.
video_receive_stream->Start();
receive_stream->Start();
video_send_stream_->Start();
capturer_->Start();
if (params_.audio) {
// Start receiving audio.
audio_receive_stream->Start();
EXPECT_EQ(0, voe.base->StartPlayout(voe.receive_channel_id));
EXPECT_EQ(0, voe.base->StartReceive(voe.receive_channel_id));
// Start sending audio.
audio_send_stream_->Start();
EXPECT_EQ(0, voe.base->StartSend(voe.send_channel_id));
}
test::PressEnterToContinue();
if (params_.audio) {
// Stop sending audio.
EXPECT_EQ(0, voe.base->StopSend(voe.send_channel_id));
audio_send_stream_->Stop();
// Stop receiving audio.
EXPECT_EQ(0, voe.base->StopReceive(voe.receive_channel_id));
EXPECT_EQ(0, voe.base->StopPlayout(voe.receive_channel_id));
audio_receive_stream->Stop();
}
// Stop receiving and sending video.
capturer_->Stop();
video_send_stream_->Stop();
video_receive_stream->Stop();
receive_stream->Stop();
call->DestroyVideoReceiveStream(video_receive_stream);
call->DestroyVideoReceiveStream(receive_stream);
call->DestroyVideoSendStream(video_send_stream_);
if (params_.audio) {
call->DestroyAudioSendStream(audio_send_stream_);
call->DestroyAudioReceiveStream(audio_receive_stream);
}
transport.StopSending();
if (params_.audio)
DestroyVoiceEngine(&voe);
}
} // namespace webrtc

4
webrtc/video/video_quality_test.h
View File

@ -70,8 +70,6 @@ class VideoQualityTest : public test::CallTest {
// If empty, bitrates are generated in VP9Impl automatically.
std::vector<SpatialLayer> spatial_layers;
} ss;
bool audio;
bool audio_video_sync;
};
// (*) Set to -1.1 if generating graph data for simulcast or SVC and the
// selected stream/layer doesn't have the same resolution as the largest
@ -79,7 +77,7 @@ class VideoQualityTest : public test::CallTest {
VideoQualityTest();
void RunWithAnalyzer(const Params& params);
void RunWithRenderers(const Params& params);
void RunWithVideoRenderer(const Params& params);
static void FillScalabilitySettings(
Params* params,