Support VP8 encoder settings in VideoSendStream.
Stop-gap solution to support VP8 codec settings in the new API until
encoder settings can be passed on to the VideoEncoder without requiring
explicit support for the codec.
BUG=3424
R=stefan@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/17929004
git-svn-id: http://webrtc.googlecode.com/svn/trunk@6650 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/webrtc/test/call_test.cc b/webrtc/test/call_test.cc
index 16dad71..d683ff2 100644
--- a/webrtc/test/call_test.cc
+++ b/webrtc/test/call_test.cc
@@ -16,6 +16,7 @@
CallTest::CallTest()
: clock_(Clock::GetRealTimeClock()),
+ encoder_settings_(NULL),
send_stream_(NULL),
fake_encoder_(clock_) {
}
@@ -39,6 +40,7 @@
if (test->ShouldCreateReceivers()) {
CreateMatchingReceiveConfigs();
}
+ encoder_settings_ = test->GetEncoderSettings();
test->ModifyConfigs(&send_config_, &receive_configs_, &video_streams_);
CreateStreams();
test->OnStreamsCreated(send_stream_, receive_streams_);
@@ -128,8 +130,8 @@
assert(send_stream_ == NULL);
assert(receive_streams_.empty());
- send_stream_ =
- sender_call_->CreateVideoSendStream(send_config_, video_streams_, NULL);
+ send_stream_ = sender_call_->CreateVideoSendStream(
+ send_config_, video_streams_, encoder_settings_);
for (size_t i = 0; i < receive_configs_.size(); ++i) {
receive_streams_.push_back(
@@ -183,6 +185,10 @@
return 1;
}
+const void* BaseTest::GetEncoderSettings() {
+ return NULL;
+}
+
void BaseTest::ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
diff --git a/webrtc/test/call_test.h b/webrtc/test/call_test.h
index e24d835..f9baf1e 100644
--- a/webrtc/test/call_test.h
+++ b/webrtc/test/call_test.h
@@ -63,6 +63,7 @@
scoped_ptr<Call> sender_call_;
VideoSendStream::Config send_config_;
std::vector<VideoStream> video_streams_;
+ const void* encoder_settings_;
VideoSendStream* send_stream_;
scoped_ptr<Call> receiver_call_;
@@ -89,6 +90,7 @@
virtual Call::Config GetReceiverCallConfig();
virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
+ virtual const void* GetEncoderSettings();
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index ff3fe50..be3fa5c 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -298,8 +298,6 @@
const void* encoder_settings) {
assert(!streams.empty());
assert(config_.rtp.ssrcs.size() >= streams.size());
- // TODO(pbos): Wire encoder_settings.
- assert(encoder_settings == NULL);
VideoCodec video_codec;
memset(&video_codec, 0, sizeof(video_codec));
@@ -317,6 +315,16 @@
video_codec.codecSpecific.VP8.keyFrameInterval = 3000;
}
+ if (video_codec.codecType == kVideoCodecVP8) {
+ if (encoder_settings != NULL) {
+ video_codec.codecSpecific.VP8 =
+ *reinterpret_cast<const VideoCodecVP8*>(encoder_settings);
+ }
+ } else {
+ // TODO(pbos): Support encoder_settings codec-agnostically.
+ assert(encoder_settings == NULL);
+ }
+
strncpy(video_codec.plName,
config_.encoder_settings.payload_name.c_str(),
kPayloadNameSize - 1);
diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc
index 08c4faf..bb9d7fa 100644
--- a/webrtc/video/video_send_stream_tests.cc
+++ b/webrtc/video/video_send_stream_tests.cc
@@ -1369,4 +1369,65 @@
EXPECT_EQ(1u, test_encoder.num_releases());
}
+TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
+ class VideoCodecConfigObserver : public test::SendTest,
+ public test::FakeEncoder {
+ public:
+ VideoCodecConfigObserver()
+ : SendTest(kDefaultTimeoutMs),
+ FakeEncoder(Clock::GetRealTimeClock()),
+ num_initializations_(0) {
+ memset(&vp8_settings_, 0, sizeof(vp8_settings_));
+ }
+
+ private:
+ virtual void ModifyConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ std::vector<VideoStream>* video_streams) OVERRIDE {
+ send_config->encoder_settings.encoder = this;
+ send_config->encoder_settings.payload_name = "VP8";
+
+ video_streams_ = *video_streams;
+ }
+
+ virtual void OnStreamsCreated(
+ VideoSendStream* send_stream,
+ const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
+ stream_ = send_stream;
+ }
+
+ virtual int32_t InitEncode(const VideoCodec* config,
+ int32_t number_of_cores,
+ uint32_t max_payload_size) OVERRIDE {
+ EXPECT_EQ(kVideoCodecVP8, config->codecType);
+ EXPECT_EQ(0,
+ memcmp(&config->codecSpecific.VP8,
+ &vp8_settings_,
+ sizeof(vp8_settings_)));
+ ++num_initializations_;
+ return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
+ }
+
+ virtual void PerformTest() OVERRIDE {
+ EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
+
+ vp8_settings_.denoisingOn = true;
+ stream_->ReconfigureVideoEncoder(video_streams_, &vp8_settings_);
+ EXPECT_EQ(2u, num_initializations_)
+ << "ReconfigureVideoEncoder did not reinitialize the encoder with "
+ "new encoder settings.";
+ }
+
+ virtual const void* GetEncoderSettings() OVERRIDE { return &vp8_settings_; }
+
+ VideoCodecVP8 vp8_settings_;
+ size_t num_initializations_;
+ VideoSendStream* stream_;
+ std::vector<VideoStream> video_streams_;
+ } test;
+
+ RunBaseTest(&test);
+}
+
} // namespace webrtc
