webrtc/talk/media/base/hybridvideoengine_unittest.cc

487 lines
19 KiB
C++
Raw Normal View History

/*
* libjingle
* Copyright 2004 Google Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "talk/media/base/fakemediaengine.h"
#include "talk/media/base/fakenetworkinterface.h"
#include "talk/media/base/fakevideocapturer.h"
#include "talk/media/base/hybridvideoengine.h"
#include "talk/media/base/mediachannel.h"
#include "talk/media/base/testutils.h"
#include "webrtc/base/gunit.h"
static const cricket::VideoCodec kGenericCodec(97, "Generic", 640, 360, 30, 0);
static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 360, 30, 0);
static const cricket::VideoCodec kCodecsVp8Only[] = { kVp8Codec };
static const cricket::VideoCodec kCodecsGenericOnly[] = { kGenericCodec };
static const cricket::VideoCodec kCodecsVp8First[] = { kVp8Codec,
kGenericCodec };
static const cricket::VideoCodec kCodecsGenericFirst[] = { kGenericCodec,
kVp8Codec };
using cricket::StreamParams;
class FakeVp8VideoEngine : public cricket::FakeVideoEngine {
public:
FakeVp8VideoEngine() {
SetCodecs(MAKE_VECTOR(kCodecsVp8Only));
}
};
class FakeGenericVideoEngine : public cricket::FakeVideoEngine {
public:
FakeGenericVideoEngine() {
SetCodecs(MAKE_VECTOR(kCodecsGenericOnly));
}
// For testing purposes, mimic the behavior of a media engine that throws out
// resolutions that don't match the codec list. A width or height of 0
// trivially will never match the codec list, so this is sufficient for
// testing the case we want (0x0).
virtual bool FindCodec(const cricket::VideoCodec& codec) {
if (codec.width == 0 || codec.height == 0) {
return false;
} else {
return cricket::FakeVideoEngine::FindCodec(codec);
}
}
};
class HybridVideoEngineForTest : public cricket::HybridVideoEngine<
FakeVp8VideoEngine, FakeGenericVideoEngine> {
public:
HybridVideoEngineForTest()
:
num_ch1_send_on_(0),
num_ch1_send_off_(0),
send_width_(0),
send_height_(0) { }
cricket::FakeVideoEngine* sub_engine1() { return &video1_; }
cricket::FakeVideoEngine* sub_engine2() { return &video2_; }
// From base class HybridVideoEngine.
void OnSendChange1(cricket::VideoMediaChannel* channel1, bool send) {
if (send) {
++num_ch1_send_on_;
} else {
++num_ch1_send_off_;
}
}
// From base class HybridVideoEngine
void OnNewSendResolution(int width, int height) {
send_width_ = width;
send_height_ = height;
}
int num_ch1_send_on() const { return num_ch1_send_on_; }
int num_ch1_send_off() const { return num_ch1_send_off_; }
int send_width() const { return send_width_; }
int send_height() const { return send_height_; }
private:
int num_ch1_send_on_;
int num_ch1_send_off_;
int send_width_;
int send_height_;
};
class HybridVideoEngineTest : public testing::Test {
public:
HybridVideoEngineTest() : sub_channel1_(NULL), sub_channel2_(NULL) {
}
~HybridVideoEngineTest() {
engine_.Terminate();
}
bool SetupEngine() {
bool result = engine_.Init(rtc::Thread::Current());
if (result) {
channel_.reset(engine_.CreateChannel(NULL));
result = (channel_.get() != NULL);
sub_channel1_ = engine_.sub_engine1()->GetChannel(0);
sub_channel2_ = engine_.sub_engine2()->GetChannel(0);
}
return result;
}
bool SetupRenderAndAddStream(const StreamParams& sp) {
if (!SetupEngine())
return false;
channel_->SetInterface(transport_.get());
return channel_->SetRecvCodecs(engine_.codecs()) &&
channel_->AddSendStream(sp) &&
channel_->SetRender(true);
}
void DeliverPacket(const void* data, int len) {
rtc::Buffer packet(data, len);
channel_->OnPacketReceived(&packet, rtc::CreatePacketTime(0));
}
void DeliverRtcp(const void* data, int len) {
rtc::Buffer packet(data, len);
channel_->OnRtcpReceived(&packet, rtc::CreatePacketTime(0));
}
protected:
void TestSetSendCodecs(cricket::FakeVideoEngine* sub_engine,
const std::vector<cricket::VideoCodec>& codecs) {
EXPECT_TRUE(SetupRenderAndAddStream(StreamParams::CreateLegacy(1234)));
EXPECT_TRUE(channel_->SetSendCodecs(codecs));
cricket::FakeVideoMediaChannel* sub_channel = sub_engine->GetChannel(0);
ASSERT_EQ(1U, sub_channel->send_codecs().size());
EXPECT_EQ(codecs[0], sub_channel->send_codecs()[0]);
EXPECT_TRUE(channel_->SetSend(true));
EXPECT_TRUE(sub_channel->sending());
}
void TestSetSendBandwidth(cricket::FakeVideoEngine* sub_engine,
const std::vector<cricket::VideoCodec>& codecs,
int start_bitrate,
int max_bitrate) {
EXPECT_TRUE(SetupRenderAndAddStream(StreamParams::CreateLegacy(1234)));
EXPECT_TRUE(channel_->SetSendCodecs(codecs));
EXPECT_TRUE(channel_->SetStartSendBandwidth(start_bitrate));
EXPECT_TRUE(channel_->SetMaxSendBandwidth(max_bitrate));
cricket::FakeVideoMediaChannel* sub_channel = sub_engine->GetChannel(0);
EXPECT_EQ(start_bitrate, sub_channel->start_bps());
EXPECT_EQ(max_bitrate, sub_channel->max_bps());
}
HybridVideoEngineForTest engine_;
rtc::scoped_ptr<cricket::HybridVideoMediaChannel> channel_;
rtc::scoped_ptr<cricket::FakeNetworkInterface> transport_;
cricket::FakeVideoMediaChannel* sub_channel1_;
cricket::FakeVideoMediaChannel* sub_channel2_;
};
TEST_F(HybridVideoEngineTest, StartupShutdown) {
EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
engine_.Terminate();
}
// Tests that SetDefaultVideoEncoderConfig passes down to both engines.
TEST_F(HybridVideoEngineTest, SetDefaultVideoEncoderConfig) {
cricket::VideoEncoderConfig config(
cricket::VideoCodec(105, "", 640, 400, 30, 0), 1, 2);
EXPECT_TRUE(engine_.SetDefaultEncoderConfig(config));
cricket::VideoEncoderConfig config_1 = config;
config_1.max_codec.name = kCodecsVp8Only[0].name;
EXPECT_EQ(config_1, engine_.sub_engine1()->default_encoder_config());
cricket::VideoEncoderConfig config_2 = config;
config_2.max_codec.name = kCodecsGenericOnly[0].name;
EXPECT_EQ(config_2, engine_.sub_engine2()->default_encoder_config());
}
// Tests that GetDefaultVideoEncoderConfig picks a meaningful encoder config
// based on the underlying engine config and then after a call to
// SetDefaultEncoderConfig on the hybrid engine.
TEST_F(HybridVideoEngineTest, SetDefaultVideoEncoderConfigDefaultValue) {
cricket::VideoEncoderConfig blank_config;
cricket::VideoEncoderConfig meaningful_config1(
cricket::VideoCodec(111, "abcd", 320, 240, 30, 0), 1, 2);
cricket::VideoEncoderConfig meaningful_config2(
cricket::VideoCodec(111, "abcd", 1280, 720, 30, 0), 1, 2);
cricket::VideoEncoderConfig meaningful_config3(
cricket::VideoCodec(111, "abcd", 640, 360, 30, 0), 1, 2);
engine_.sub_engine1()->SetDefaultEncoderConfig(blank_config);
engine_.sub_engine2()->SetDefaultEncoderConfig(blank_config);
EXPECT_EQ(blank_config, engine_.GetDefaultEncoderConfig());
engine_.sub_engine2()->SetDefaultEncoderConfig(meaningful_config2);
EXPECT_EQ(meaningful_config2, engine_.GetDefaultEncoderConfig());
engine_.sub_engine1()->SetDefaultEncoderConfig(meaningful_config1);
EXPECT_EQ(meaningful_config1, engine_.GetDefaultEncoderConfig());
EXPECT_TRUE(engine_.SetDefaultEncoderConfig(meaningful_config3));
// The overall config should now match, though the codec name will have been
// rewritten for the first media engine.
meaningful_config3.max_codec.name = kCodecsVp8Only[0].name;
EXPECT_EQ(meaningful_config3, engine_.GetDefaultEncoderConfig());
}
// Tests that our engine has the right codecs in the right order.
TEST_F(HybridVideoEngineTest, CheckCodecs) {
const std::vector<cricket::VideoCodec>& c = engine_.codecs();
ASSERT_EQ(2U, c.size());
EXPECT_EQ(kVp8Codec, c[0]);
EXPECT_EQ(kGenericCodec, c[1]);
}
// Tests that our engine has the right caps.
TEST_F(HybridVideoEngineTest, CheckCaps) {
EXPECT_EQ(cricket::VIDEO_SEND | cricket::VIDEO_RECV,
engine_.GetCapabilities());
}
// Tests that we can create and destroy a channel.
TEST_F(HybridVideoEngineTest, CreateChannel) {
EXPECT_TRUE(SetupEngine());
EXPECT_TRUE(sub_channel1_ != NULL);
EXPECT_TRUE(sub_channel2_ != NULL);
}
// Tests that we properly handle failures in CreateChannel.
TEST_F(HybridVideoEngineTest, CreateChannelFail) {
engine_.sub_engine1()->set_fail_create_channel(true);
EXPECT_FALSE(SetupEngine());
EXPECT_TRUE(channel_.get() == NULL);
EXPECT_TRUE(sub_channel1_ == NULL);
EXPECT_TRUE(sub_channel2_ == NULL);
engine_.sub_engine1()->set_fail_create_channel(false);
engine_.sub_engine2()->set_fail_create_channel(true);
EXPECT_FALSE(SetupEngine());
EXPECT_TRUE(channel_.get() == NULL);
EXPECT_TRUE(sub_channel1_ == NULL);
EXPECT_TRUE(sub_channel2_ == NULL);
}
// Test that we set our inbound codecs and settings properly.
TEST_F(HybridVideoEngineTest, SetLocalDescription) {
EXPECT_TRUE(SetupEngine());
channel_->SetInterface(transport_.get());
EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
ASSERT_EQ(1U, sub_channel1_->recv_codecs().size());
ASSERT_EQ(1U, sub_channel2_->recv_codecs().size());
EXPECT_EQ(kVp8Codec, sub_channel1_->recv_codecs()[0]);
EXPECT_EQ(kGenericCodec, sub_channel2_->recv_codecs()[0]);
StreamParams stream;
stream.id = "TestStream";
stream.ssrcs.push_back(1234);
stream.cname = "5678";
EXPECT_TRUE(channel_->AddSendStream(stream));
EXPECT_EQ(1234U, sub_channel1_->send_ssrc());
EXPECT_EQ(1234U, sub_channel2_->send_ssrc());
EXPECT_EQ("5678", sub_channel1_->rtcp_cname());
EXPECT_EQ("5678", sub_channel2_->rtcp_cname());
EXPECT_TRUE(channel_->SetRender(true));
// We've called SetRender, so we should be playing out, but not yet sending.
EXPECT_TRUE(sub_channel1_->playout());
EXPECT_TRUE(sub_channel2_->playout());
EXPECT_FALSE(sub_channel1_->sending());
EXPECT_FALSE(sub_channel2_->sending());
// We may get SetSend(false) calls during call setup.
// Since this causes no change in state, they should no-op and return true.
EXPECT_TRUE(channel_->SetSend(false));
EXPECT_FALSE(sub_channel1_->sending());
EXPECT_FALSE(sub_channel2_->sending());
}
TEST_F(HybridVideoEngineTest, OnNewSendResolution) {
EXPECT_TRUE(SetupEngine());
EXPECT_TRUE(channel_->SetSendCodecs(MAKE_VECTOR(kCodecsVp8First)));
EXPECT_EQ(640, engine_.send_width());
EXPECT_EQ(360, engine_.send_height());
}
// Test that we converge to the active channel for engine 1.
TEST_F(HybridVideoEngineTest, SetSendCodecs1) {
// This will nuke the object that sub_channel2_ points to.
TestSetSendCodecs(engine_.sub_engine1(), MAKE_VECTOR(kCodecsVp8First));
EXPECT_TRUE(engine_.sub_engine2()->GetChannel(0) == NULL);
}
// Test that we converge to the active channel for engine 2.
TEST_F(HybridVideoEngineTest, SetSendCodecs2) {
// This will nuke the object that sub_channel1_ points to.
TestSetSendCodecs(engine_.sub_engine2(), MAKE_VECTOR(kCodecsGenericFirst));
EXPECT_TRUE(engine_.sub_engine1()->GetChannel(0) == NULL);
}
// Test that we don't accidentally eat 0x0 in SetSendCodecs
TEST_F(HybridVideoEngineTest, SetSendCodecs0x0) {
EXPECT_TRUE(SetupRenderAndAddStream(StreamParams::CreateLegacy(1234)));
// Send using generic codec, but with 0x0 resolution.
std::vector<cricket::VideoCodec> codecs(MAKE_VECTOR(kCodecsGenericFirst));
codecs.resize(1);
codecs[0].width = 0;
codecs[0].height = 0;
EXPECT_TRUE(channel_->SetSendCodecs(codecs));
}
// Test setting the send bandwidth for VP8.
TEST_F(HybridVideoEngineTest, SetSendBandwidth1) {
TestSetSendBandwidth(engine_.sub_engine1(),
MAKE_VECTOR(kCodecsVp8First),
100000,
384000);
}
// Test setting the send bandwidth for a generic codec.
TEST_F(HybridVideoEngineTest, SetSendBandwidth2) {
TestSetSendBandwidth(engine_.sub_engine2(),
MAKE_VECTOR(kCodecsGenericFirst),
100001,
384002);
}
// Test that we dump RTP packets that arrive early.
TEST_F(HybridVideoEngineTest, HandleEarlyRtp) {
static const uint8 kPacket[1024] = { 0 };
static const uint8 kRtcp[1024] = { 1 };
EXPECT_TRUE(SetupRenderAndAddStream(StreamParams::CreateLegacy(1234)));
DeliverPacket(kPacket, sizeof(kPacket));
DeliverRtcp(kRtcp, sizeof(kRtcp));
EXPECT_TRUE(sub_channel1_->CheckNoRtp());
EXPECT_TRUE(sub_channel2_->CheckNoRtp());
EXPECT_TRUE(sub_channel1_->CheckNoRtcp());
EXPECT_TRUE(sub_channel2_->CheckNoRtcp());
}
// Test that we properly pass on normal RTP packets.
TEST_F(HybridVideoEngineTest, HandleRtp) {
static const uint8 kPacket[1024] = { 0 };
static const uint8 kRtcp[1024] = { 1 };
EXPECT_TRUE(SetupRenderAndAddStream(StreamParams::CreateLegacy(1234)));
EXPECT_TRUE(channel_->SetSendCodecs(MAKE_VECTOR(kCodecsVp8First)));
EXPECT_TRUE(channel_->SetSend(true));
DeliverPacket(kPacket, sizeof(kPacket));
DeliverRtcp(kRtcp, sizeof(kRtcp));
EXPECT_TRUE(sub_channel1_->CheckRtp(kPacket, sizeof(kPacket)));
EXPECT_TRUE(sub_channel1_->CheckRtcp(kRtcp, sizeof(kRtcp)));
}
// Test that we properly connect media error signal.
TEST_F(HybridVideoEngineTest, MediaErrorSignal) {
cricket::VideoMediaErrorCatcher catcher;
// Verify no signal from either channel before the active channel is set.
EXPECT_TRUE(SetupEngine());
channel_->SignalMediaError.connect(&catcher,
&cricket::VideoMediaErrorCatcher::OnError);
sub_channel1_->SignalMediaError(1, cricket::VideoMediaChannel::ERROR_OTHER);
EXPECT_EQ(0U, catcher.ssrc());
sub_channel2_->SignalMediaError(2,
cricket::VideoMediaChannel::ERROR_REC_DEVICE_OPEN_FAILED);
EXPECT_EQ(0U, catcher.ssrc());
// Set vp8 as active channel and verify that a signal comes from it.
EXPECT_TRUE(channel_->SetSendCodecs(MAKE_VECTOR(kCodecsVp8First)));
sub_channel1_->SignalMediaError(1, cricket::VideoMediaChannel::ERROR_OTHER);
EXPECT_EQ(cricket::VideoMediaChannel::ERROR_OTHER, catcher.error());
EXPECT_EQ(1U, catcher.ssrc());
// Set generic codec as active channel and verify that a signal comes from it.
EXPECT_TRUE(SetupEngine());
channel_->SignalMediaError.connect(&catcher,
&cricket::VideoMediaErrorCatcher::OnError);
EXPECT_TRUE(channel_->SetSendCodecs(MAKE_VECTOR(kCodecsGenericFirst)));
sub_channel2_->SignalMediaError(2,
cricket::VideoMediaChannel::ERROR_REC_DEVICE_OPEN_FAILED);
EXPECT_EQ(cricket::VideoMediaChannel::ERROR_REC_DEVICE_OPEN_FAILED,
catcher.error());
EXPECT_EQ(2U, catcher.ssrc());
}
// Test that SetSend doesn't re-enter.
TEST_F(HybridVideoEngineTest, RepeatSetSend) {
EXPECT_TRUE(SetupEngine());
EXPECT_TRUE(channel_->SetSendCodecs(MAKE_VECTOR(kCodecsVp8First)));
// Verify initial status.
EXPECT_FALSE(channel_->sending());
EXPECT_FALSE(sub_channel1_->sending());
EXPECT_EQ(0, engine_.num_ch1_send_on());
EXPECT_EQ(0, engine_.num_ch1_send_off());
// Verfiy SetSend(true) works correctly.
EXPECT_TRUE(channel_->SetSend(true));
EXPECT_TRUE(channel_->sending());
EXPECT_TRUE(sub_channel1_->sending());
EXPECT_EQ(1, engine_.num_ch1_send_on());
EXPECT_EQ(0, engine_.num_ch1_send_off());
// SetSend(true) again and verify nothing changes.
EXPECT_TRUE(channel_->SetSend(true));
EXPECT_TRUE(channel_->sending());
EXPECT_TRUE(sub_channel1_->sending());
EXPECT_EQ(1, engine_.num_ch1_send_on());
EXPECT_EQ(0, engine_.num_ch1_send_off());
// Verify SetSend(false) works correctly.
EXPECT_TRUE(channel_->SetSend(false));
EXPECT_FALSE(channel_->sending());
EXPECT_FALSE(sub_channel1_->sending());
EXPECT_EQ(1, engine_.num_ch1_send_on());
EXPECT_EQ(1, engine_.num_ch1_send_off());
// SetSend(false) again and verfiy nothing changes.
EXPECT_TRUE(channel_->SetSend(false));
EXPECT_FALSE(channel_->sending());
EXPECT_FALSE(sub_channel1_->sending());
EXPECT_EQ(1, engine_.num_ch1_send_on());
EXPECT_EQ(1, engine_.num_ch1_send_off());
}
// Test that SetOptions.
TEST_F(HybridVideoEngineTest, SetOptions) {
cricket::VideoOptions vmo;
vmo.video_high_bitrate.Set(true);
vmo.system_low_adaptation_threshhold.Set(0.10f);
EXPECT_TRUE(SetupEngine());
EXPECT_TRUE(channel_->SetOptions(vmo));
bool high_bitrate;
float low;
EXPECT_TRUE(sub_channel1_->GetOptions(&vmo));
EXPECT_TRUE(vmo.video_high_bitrate.Get(&high_bitrate));
EXPECT_TRUE(high_bitrate);
EXPECT_TRUE(vmo.system_low_adaptation_threshhold.Get(&low));
EXPECT_EQ(0.10f, low);
EXPECT_TRUE(sub_channel2_->GetOptions(&vmo));
EXPECT_TRUE(vmo.video_high_bitrate.Get(&high_bitrate));
EXPECT_TRUE(high_bitrate);
EXPECT_TRUE(vmo.system_low_adaptation_threshhold.Get(&low));
EXPECT_EQ(0.10f, low);
vmo.video_high_bitrate.Set(false);
vmo.system_low_adaptation_threshhold.Set(0.50f);
EXPECT_TRUE(channel_->SetOptions(vmo));
EXPECT_TRUE(sub_channel1_->GetOptions(&vmo));
EXPECT_TRUE(vmo.video_high_bitrate.Get(&high_bitrate));
EXPECT_FALSE(high_bitrate);
EXPECT_TRUE(vmo.system_low_adaptation_threshhold.Get(&low));
EXPECT_EQ(0.50f, low);
EXPECT_TRUE(sub_channel2_->GetOptions(&vmo));
EXPECT_TRUE(vmo.video_high_bitrate.Get(&high_bitrate));
EXPECT_FALSE(high_bitrate);
EXPECT_TRUE(vmo.system_low_adaptation_threshhold.Get(&low));
EXPECT_EQ(0.50f, low);
}
TEST_F(HybridVideoEngineTest, SetCapturer) {
EXPECT_TRUE(SetupEngine());
// Set vp8 as active channel and verify that capturer can be set.
EXPECT_TRUE(channel_->SetSendCodecs(MAKE_VECTOR(kCodecsVp8First)));
cricket::FakeVideoCapturer fake_video_capturer;
EXPECT_TRUE(channel_->SetCapturer(0, &fake_video_capturer));
EXPECT_TRUE(channel_->SetCapturer(0, NULL));
// Set generic codec active channel and verify that capturer can be set.
EXPECT_TRUE(SetupEngine());
EXPECT_TRUE(channel_->SetSendCodecs(MAKE_VECTOR(kCodecsGenericFirst)));
EXPECT_TRUE(channel_->SetCapturer(0, &fake_video_capturer));
EXPECT_TRUE(channel_->SetCapturer(0, NULL));
}