Config struct for VideoEncoder.
Used for config parameters in common between multiple codecs as well as the encoder-specific pointer. In particular this contains content mode (realtime video vs. screenshare). BUG=1788 R=mflodman@webrtc.org, stefan@webrtc.org Review URL: https://webrtc-codereview.appspot.com/16319004 git-svn-id: http://webrtc.googlecode.com/svn/trunk@7239 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
pbos@webrtc.org
parent
02686115cc
commit
bbe0a8517d
@ -229,13 +229,9 @@ void WebRtcVideoEncoderFactory2::DestroyVideoEncoderSettings(
|
||||
if (encoder_settings == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (_stricmp(codec.name.c_str(), kVp8CodecName) == 0) {
|
||||
delete reinterpret_cast<webrtc::VideoCodecVP8*>(encoder_settings);
|
||||
return;
|
||||
}
|
||||
// We should be able to destroy all encoder settings we've allocated.
|
||||
assert(false);
|
||||
}
|
||||
|
||||
bool WebRtcVideoEncoderFactory2::SupportsCodec(const VideoCodec& codec) {
|
||||
@ -1389,8 +1385,8 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame(
|
||||
|
||||
LOG(LS_VERBOSE) << "SwapFrame: " << video_frame_.width() << "x"
|
||||
<< video_frame_.height() << " -> (codec) "
|
||||
<< parameters_.video_streams.back().width << "x"
|
||||
<< parameters_.video_streams.back().height;
|
||||
<< parameters_.encoder_config.streams.back().width << "x"
|
||||
<< parameters_.encoder_config.streams.back().height;
|
||||
stream_->Input()->SwapFrame(&video_frame_);
|
||||
}
|
||||
|
||||
@ -1446,7 +1442,7 @@ bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat(
|
||||
<< parameters_.config.rtp.ssrcs[0] << ".";
|
||||
} else {
|
||||
// TODO(pbos): Fix me, this only affects the last stream!
|
||||
parameters_.video_streams.back().max_framerate =
|
||||
parameters_.encoder_config.streams.back().max_framerate =
|
||||
VideoFormat::IntervalToFps(format.interval);
|
||||
SetDimensions(format.width, format.height, false);
|
||||
}
|
||||
@ -1494,7 +1490,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
|
||||
if (video_streams.empty()) {
|
||||
return;
|
||||
}
|
||||
parameters_.video_streams = video_streams;
|
||||
parameters_.encoder_config.streams = video_streams;
|
||||
format_ = VideoFormat(codec_settings.codec.width,
|
||||
codec_settings.codec.height,
|
||||
VideoFormat::FpsToInterval(30),
|
||||
@ -1541,7 +1537,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
|
||||
int width,
|
||||
int height,
|
||||
bool override_max) {
|
||||
assert(!parameters_.video_streams.empty());
|
||||
assert(!parameters_.encoder_config.streams.empty());
|
||||
LOG(LS_VERBOSE) << "SetDimensions: " << width << "x" << height;
|
||||
|
||||
VideoCodecSettings codec_settings;
|
||||
@ -1554,27 +1550,30 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
|
||||
height = codec_settings.codec.height;
|
||||
}
|
||||
|
||||
if (parameters_.video_streams.back().width == width &&
|
||||
parameters_.video_streams.back().height == height) {
|
||||
if (parameters_.encoder_config.streams.back().width == width &&
|
||||
parameters_.encoder_config.streams.back().height == height) {
|
||||
return;
|
||||
}
|
||||
|
||||
void* encoder_settings = encoder_factory_->CreateVideoEncoderSettings(
|
||||
codec_settings.codec, parameters_.options);
|
||||
webrtc::VideoEncoderConfig encoder_config = parameters_.encoder_config;
|
||||
encoder_config.encoder_specific_settings =
|
||||
encoder_factory_->CreateVideoEncoderSettings(codec_settings.codec,
|
||||
parameters_.options);
|
||||
|
||||
VideoCodec codec = codec_settings.codec;
|
||||
codec.width = width;
|
||||
codec.height = height;
|
||||
std::vector<webrtc::VideoStream> video_streams =
|
||||
encoder_factory_->CreateVideoStreams(codec,
|
||||
parameters_.options,
|
||||
parameters_.config.rtp.ssrcs.size());
|
||||
|
||||
bool stream_reconfigured = stream_->ReconfigureVideoEncoder(
|
||||
video_streams, encoder_settings);
|
||||
encoder_config.streams = encoder_factory_->CreateVideoStreams(
|
||||
codec, parameters_.options, parameters_.config.rtp.ssrcs.size());
|
||||
|
||||
encoder_factory_->DestroyVideoEncoderSettings(codec_settings.codec,
|
||||
encoder_settings);
|
||||
bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
|
||||
|
||||
encoder_factory_->DestroyVideoEncoderSettings(
|
||||
codec_settings.codec,
|
||||
encoder_config.encoder_specific_settings);
|
||||
|
||||
encoder_config.encoder_specific_settings = NULL;
|
||||
|
||||
if (!stream_reconfigured) {
|
||||
LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: "
|
||||
@ -1582,7 +1581,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
|
||||
return;
|
||||
}
|
||||
|
||||
parameters_.video_streams = video_streams;
|
||||
parameters_.encoder_config = encoder_config;
|
||||
}
|
||||
|
||||
void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
|
||||
@ -1646,9 +1645,9 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo() {
|
||||
info.input_frame_width = last_captured_frame_format.width;
|
||||
info.input_frame_height = last_captured_frame_format.height;
|
||||
info.send_frame_width =
|
||||
static_cast<int>(parameters_.video_streams.front().width);
|
||||
static_cast<int>(parameters_.encoder_config.streams.front().width);
|
||||
info.send_frame_height =
|
||||
static_cast<int>(parameters_.video_streams.front().height);
|
||||
static_cast<int>(parameters_.encoder_config.streams.front().height);
|
||||
}
|
||||
|
||||
// TODO(pbos): Support or remove the following stats.
|
||||
@ -1665,14 +1664,18 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
|
||||
|
||||
VideoCodecSettings codec_settings;
|
||||
parameters_.codec_settings.Get(&codec_settings);
|
||||
void* encoder_settings = encoder_factory_->CreateVideoEncoderSettings(
|
||||
codec_settings.codec, parameters_.options);
|
||||
parameters_.encoder_config.encoder_specific_settings =
|
||||
encoder_factory_->CreateVideoEncoderSettings(codec_settings.codec,
|
||||
parameters_.options);
|
||||
|
||||
stream_ = call_->CreateVideoSendStream(
|
||||
parameters_.config, parameters_.video_streams, encoder_settings);
|
||||
stream_ = call_->CreateVideoSendStream(parameters_.config,
|
||||
parameters_.encoder_config);
|
||||
|
||||
encoder_factory_->DestroyVideoEncoderSettings(codec_settings.codec,
|
||||
encoder_settings);
|
||||
encoder_factory_->DestroyVideoEncoderSettings(
|
||||
codec_settings.codec,
|
||||
parameters_.encoder_config.encoder_specific_settings);
|
||||
|
||||
parameters_.encoder_config.encoder_specific_settings = NULL;
|
||||
|
||||
if (sending_) {
|
||||
stream_->Start();
|
||||
|
||||
@ -119,9 +119,8 @@ class WebRtcVideoEncoderFactory2 {
|
||||
const VideoCodec& codec,
|
||||
const VideoOptions& options);
|
||||
|
||||
virtual void* CreateVideoEncoderSettings(
|
||||
const VideoCodec& codec,
|
||||
const VideoOptions& options);
|
||||
virtual void* CreateVideoEncoderSettings(const VideoCodec& codec,
|
||||
const VideoOptions& options);
|
||||
|
||||
virtual void DestroyVideoEncoderSettings(const VideoCodec& codec,
|
||||
void* encoder_settings);
|
||||
@ -316,7 +315,7 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler,
|
||||
// Sent resolutions + bitrates etc. by the underlying VideoSendStream,
|
||||
// typically changes when setting a new resolution or reconfiguring
|
||||
// bitrates.
|
||||
std::vector<webrtc::VideoStream> video_streams;
|
||||
webrtc::VideoEncoderConfig encoder_config;
|
||||
};
|
||||
|
||||
void SetCodecAndOptions(const VideoCodecSettings& codec,
|
||||
|
||||
@ -68,13 +68,10 @@ void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
|
||||
namespace cricket {
|
||||
FakeVideoSendStream::FakeVideoSendStream(
|
||||
const webrtc::VideoSendStream::Config& config,
|
||||
const std::vector<webrtc::VideoStream>& video_streams,
|
||||
const void* encoder_settings)
|
||||
: sending_(false),
|
||||
config_(config),
|
||||
codec_settings_set_(false) {
|
||||
const webrtc::VideoEncoderConfig& encoder_config)
|
||||
: sending_(false), config_(config), codec_settings_set_(false) {
|
||||
assert(config.encoder_settings.encoder != NULL);
|
||||
ReconfigureVideoEncoder(video_streams, encoder_settings);
|
||||
ReconfigureVideoEncoder(encoder_config);
|
||||
}
|
||||
|
||||
webrtc::VideoSendStream::Config FakeVideoSendStream::GetConfig() {
|
||||
@ -82,7 +79,7 @@ webrtc::VideoSendStream::Config FakeVideoSendStream::GetConfig() {
|
||||
}
|
||||
|
||||
std::vector<webrtc::VideoStream> FakeVideoSendStream::GetVideoStreams() {
|
||||
return video_streams_;
|
||||
return encoder_config_.streams;
|
||||
}
|
||||
|
||||
bool FakeVideoSendStream::IsSending() const {
|
||||
@ -104,15 +101,14 @@ webrtc::VideoSendStream::Stats FakeVideoSendStream::GetStats() const {
|
||||
}
|
||||
|
||||
bool FakeVideoSendStream::ReconfigureVideoEncoder(
|
||||
const std::vector<webrtc::VideoStream>& streams,
|
||||
const void* encoder_specific) {
|
||||
video_streams_ = streams;
|
||||
if (encoder_specific != NULL) {
|
||||
const webrtc::VideoEncoderConfig& config) {
|
||||
encoder_config_ = config;
|
||||
if (config.encoder_specific_settings != NULL) {
|
||||
assert(config_.encoder_settings.payload_name == "VP8");
|
||||
vp8_settings_ =
|
||||
*reinterpret_cast<const webrtc::VideoCodecVP8*>(encoder_specific);
|
||||
vp8_settings_ = *reinterpret_cast<const webrtc::VideoCodecVP8*>(
|
||||
config.encoder_specific_settings);
|
||||
}
|
||||
codec_settings_set_ = encoder_specific != NULL;
|
||||
codec_settings_set_ = config.encoder_specific_settings != NULL;
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -226,10 +222,9 @@ webrtc::Call::NetworkState FakeCall::GetNetworkState() const {
|
||||
|
||||
webrtc::VideoSendStream* FakeCall::CreateVideoSendStream(
|
||||
const webrtc::VideoSendStream::Config& config,
|
||||
const std::vector<webrtc::VideoStream>& video_streams,
|
||||
const void* encoder_settings) {
|
||||
const webrtc::VideoEncoderConfig& encoder_config) {
|
||||
FakeVideoSendStream* fake_stream =
|
||||
new FakeVideoSendStream(config, video_streams, encoder_settings);
|
||||
new FakeVideoSendStream(config, encoder_config);
|
||||
video_send_streams_.push_back(fake_stream);
|
||||
return fake_stream;
|
||||
}
|
||||
|
||||
@ -39,8 +39,7 @@ namespace cricket {
|
||||
class FakeVideoSendStream : public webrtc::VideoSendStream {
|
||||
public:
|
||||
FakeVideoSendStream(const webrtc::VideoSendStream::Config& config,
|
||||
const std::vector<webrtc::VideoStream>& video_streams,
|
||||
const void* encoder_settings);
|
||||
const webrtc::VideoEncoderConfig& encoder_config);
|
||||
webrtc::VideoSendStream::Config GetConfig();
|
||||
std::vector<webrtc::VideoStream> GetVideoStreams();
|
||||
|
||||
@ -51,8 +50,7 @@ class FakeVideoSendStream : public webrtc::VideoSendStream {
|
||||
virtual webrtc::VideoSendStream::Stats GetStats() const OVERRIDE;
|
||||
|
||||
virtual bool ReconfigureVideoEncoder(
|
||||
const std::vector<webrtc::VideoStream>& streams,
|
||||
const void* encoder_specific);
|
||||
const webrtc::VideoEncoderConfig& config) OVERRIDE;
|
||||
|
||||
virtual webrtc::VideoSendStreamInput* Input() OVERRIDE;
|
||||
|
||||
@ -61,7 +59,7 @@ class FakeVideoSendStream : public webrtc::VideoSendStream {
|
||||
|
||||
bool sending_;
|
||||
webrtc::VideoSendStream::Config config_;
|
||||
std::vector<webrtc::VideoStream> video_streams_;
|
||||
webrtc::VideoEncoderConfig encoder_config_;
|
||||
bool codec_settings_set_;
|
||||
webrtc::VideoCodecVP8 vp8_settings_;
|
||||
};
|
||||
@ -108,8 +106,7 @@ class FakeCall : public webrtc::Call {
|
||||
private:
|
||||
virtual webrtc::VideoSendStream* CreateVideoSendStream(
|
||||
const webrtc::VideoSendStream::Config& config,
|
||||
const std::vector<webrtc::VideoStream>& video_streams,
|
||||
const void* encoder_settings) OVERRIDE;
|
||||
const webrtc::VideoEncoderConfig& encoder_config) OVERRIDE;
|
||||
|
||||
virtual void DestroyVideoSendStream(
|
||||
webrtc::VideoSendStream* send_stream) OVERRIDE;
|
||||
|
||||
@ -92,8 +92,7 @@ class Call {
|
||||
|
||||
virtual VideoSendStream* CreateVideoSendStream(
|
||||
const VideoSendStream::Config& config,
|
||||
const std::vector<VideoStream>& video_streams,
|
||||
const void* encoder_settings) = 0;
|
||||
const VideoEncoderConfig& encoder_config) = 0;
|
||||
|
||||
virtual void DestroyVideoSendStream(VideoSendStream* send_stream) = 0;
|
||||
|
||||
|
||||
@ -108,6 +108,20 @@ struct VideoStream {
|
||||
std::vector<int> temporal_layers;
|
||||
};
|
||||
|
||||
struct VideoEncoderConfig {
|
||||
enum ContentType {
|
||||
kRealtimeVideo,
|
||||
kScreenshare,
|
||||
};
|
||||
|
||||
VideoEncoderConfig()
|
||||
: content_type(kRealtimeVideo), encoder_specific_settings(NULL) {}
|
||||
|
||||
std::vector<VideoStream> streams;
|
||||
ContentType content_type;
|
||||
void* encoder_specific_settings;
|
||||
};
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // WEBRTC_CONFIG_H_
|
||||
|
||||
@ -16,7 +16,6 @@ namespace test {
|
||||
|
||||
CallTest::CallTest()
|
||||
: clock_(Clock::GetRealTimeClock()),
|
||||
encoder_settings_(NULL),
|
||||
send_stream_(NULL),
|
||||
fake_encoder_(clock_) {
|
||||
}
|
||||
@ -40,8 +39,7 @@ void CallTest::RunBaseTest(BaseTest* test) {
|
||||
if (test->ShouldCreateReceivers()) {
|
||||
CreateMatchingReceiveConfigs();
|
||||
}
|
||||
encoder_settings_ = test->GetEncoderSettings();
|
||||
test->ModifyConfigs(&send_config_, &receive_configs_, &video_streams_);
|
||||
test->ModifyConfigs(&send_config_, &receive_configs_, &encoder_config_);
|
||||
CreateStreams();
|
||||
test->OnStreamsCreated(send_stream_, receive_streams_);
|
||||
|
||||
@ -92,7 +90,7 @@ void CallTest::CreateSendConfig(size_t num_streams) {
|
||||
send_config_.encoder_settings.encoder = &fake_encoder_;
|
||||
send_config_.encoder_settings.payload_name = "FAKE";
|
||||
send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
|
||||
video_streams_ = test::CreateVideoStreams(num_streams);
|
||||
encoder_config_.streams = test::CreateVideoStreams(num_streams);
|
||||
for (size_t i = 0; i < num_streams; ++i)
|
||||
send_config_.rtp.ssrcs.push_back(kSendSsrcs[i]);
|
||||
}
|
||||
@ -123,7 +121,7 @@ void CallTest::CreateMatchingReceiveConfigs() {
|
||||
}
|
||||
|
||||
void CallTest::CreateFrameGeneratorCapturer() {
|
||||
VideoStream stream = video_streams_.back();
|
||||
VideoStream stream = encoder_config_.streams.back();
|
||||
frame_generator_capturer_.reset(
|
||||
test::FrameGeneratorCapturer::Create(send_stream_->Input(),
|
||||
stream.width,
|
||||
@ -135,8 +133,8 @@ void CallTest::CreateStreams() {
|
||||
assert(send_stream_ == NULL);
|
||||
assert(receive_streams_.empty());
|
||||
|
||||
send_stream_ = sender_call_->CreateVideoSendStream(
|
||||
send_config_, video_streams_, encoder_settings_);
|
||||
send_stream_ =
|
||||
sender_call_->CreateVideoSendStream(send_config_, encoder_config_);
|
||||
|
||||
for (size_t i = 0; i < receive_configs_.size(); ++i) {
|
||||
receive_streams_.push_back(
|
||||
@ -193,14 +191,10 @@ size_t BaseTest::GetNumStreams() const {
|
||||
return 1;
|
||||
}
|
||||
|
||||
const void* BaseTest::GetEncoderSettings() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void BaseTest::ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) {
|
||||
VideoEncoderConfig* encoder_config) {
|
||||
}
|
||||
|
||||
void BaseTest::OnStreamsCreated(
|
||||
|
||||
@ -65,8 +65,7 @@ class CallTest : public ::testing::Test {
|
||||
|
||||
scoped_ptr<Call> sender_call_;
|
||||
VideoSendStream::Config send_config_;
|
||||
std::vector<VideoStream> video_streams_;
|
||||
const void* encoder_settings_;
|
||||
VideoEncoderConfig encoder_config_;
|
||||
VideoSendStream* send_stream_;
|
||||
|
||||
scoped_ptr<Call> receiver_call_;
|
||||
@ -93,11 +92,10 @@ class BaseTest : public RtpRtcpObserver {
|
||||
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,
|
||||
std::vector<VideoStream>* video_streams);
|
||||
VideoEncoderConfig* encoder_config);
|
||||
virtual void OnStreamsCreated(
|
||||
VideoSendStream* send_stream,
|
||||
const std::vector<VideoReceiveStream*>& receive_streams);
|
||||
|
||||
@ -148,7 +148,7 @@ class BitrateEstimatorTest : public test::CallTest {
|
||||
send_config_.encoder_settings.encoder = NULL;
|
||||
send_config_.encoder_settings.payload_name = "FAKE";
|
||||
send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
|
||||
video_streams_ = test::CreateVideoStreams(1);
|
||||
encoder_config_.streams = test::CreateVideoStreams(1);
|
||||
|
||||
receive_config_ = VideoReceiveStream::Config();
|
||||
assert(receive_config_.codecs.empty());
|
||||
@ -195,14 +195,14 @@ class BitrateEstimatorTest : public test::CallTest {
|
||||
test_->send_config_.rtp.ssrcs[0]++;
|
||||
test_->send_config_.encoder_settings.encoder = &fake_encoder_;
|
||||
send_stream_ = test_->sender_call_->CreateVideoSendStream(
|
||||
test_->send_config_, test_->video_streams_, NULL);
|
||||
assert(test_->video_streams_.size() == 1);
|
||||
frame_generator_capturer_.reset(
|
||||
test::FrameGeneratorCapturer::Create(send_stream_->Input(),
|
||||
test_->video_streams_[0].width,
|
||||
test_->video_streams_[0].height,
|
||||
30,
|
||||
Clock::GetRealTimeClock()));
|
||||
test_->send_config_, test_->encoder_config_);
|
||||
assert(test_->encoder_config_.streams.size() == 1);
|
||||
frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
|
||||
send_stream_->Input(),
|
||||
test_->encoder_config_.streams[0].width,
|
||||
test_->encoder_config_.streams[0].height,
|
||||
30,
|
||||
Clock::GetRealTimeClock()));
|
||||
send_stream_->Start();
|
||||
frame_generator_capturer_->Start();
|
||||
|
||||
|
||||
@ -87,8 +87,7 @@ class Call : public webrtc::Call, public PacketReceiver {
|
||||
|
||||
virtual VideoSendStream* CreateVideoSendStream(
|
||||
const VideoSendStream::Config& config,
|
||||
const std::vector<VideoStream>& video_streams,
|
||||
const void* encoder_settings) OVERRIDE;
|
||||
const VideoEncoderConfig& encoder_config) OVERRIDE;
|
||||
|
||||
virtual void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream)
|
||||
OVERRIDE;
|
||||
@ -196,8 +195,7 @@ PacketReceiver* Call::Receiver() { return this; }
|
||||
|
||||
VideoSendStream* Call::CreateVideoSendStream(
|
||||
const VideoSendStream::Config& config,
|
||||
const std::vector<VideoStream>& video_streams,
|
||||
const void* encoder_settings) {
|
||||
const VideoEncoderConfig& encoder_config) {
|
||||
assert(config.rtp.ssrcs.size() > 0);
|
||||
|
||||
// TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
|
||||
@ -207,8 +205,7 @@ VideoSendStream* Call::CreateVideoSendStream(
|
||||
overuse_observer_proxy_.get(),
|
||||
video_engine_,
|
||||
config,
|
||||
video_streams,
|
||||
encoder_settings,
|
||||
encoder_config,
|
||||
suspended_send_ssrcs_,
|
||||
base_channel_id_,
|
||||
config_.start_bitrate_bps != -1 ? config_.start_bitrate_bps
|
||||
|
||||
@ -399,7 +399,7 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
(*receive_configs)[0].renderer = this;
|
||||
// Enable the receiver side rtt calculation.
|
||||
(*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report = true;
|
||||
@ -546,7 +546,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
if (pad_to_min_bitrate_) {
|
||||
send_config->rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
|
||||
} else {
|
||||
|
||||
@ -208,7 +208,7 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) {
|
||||
Start();
|
||||
|
||||
scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
|
||||
video_streams_[0].width, video_streams_[0].height));
|
||||
encoder_config_.streams[0].width, encoder_config_.streams[0].height));
|
||||
send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
|
||||
|
||||
EXPECT_EQ(kEventSignaled, renderer.Wait())
|
||||
@ -238,13 +238,13 @@ TEST_F(EndToEndTest, SendsAndReceivesH264) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->encoder_settings.encoder = &fake_encoder_;
|
||||
send_config->encoder_settings.payload_name = "H264";
|
||||
send_config->encoder_settings.payload_type = kFakeSendPayloadType;
|
||||
(*video_streams)[0].min_bitrate_bps = 50000;
|
||||
(*video_streams)[0].target_bitrate_bps =
|
||||
(*video_streams)[0].max_bitrate_bps = 2000000;
|
||||
encoder_config->streams[0].min_bitrate_bps = 50000;
|
||||
encoder_config->streams[0].target_bitrate_bps =
|
||||
encoder_config->streams[0].max_bitrate_bps = 2000000;
|
||||
|
||||
(*receive_configs)[0].renderer = this;
|
||||
VideoCodec codec =
|
||||
@ -369,7 +369,7 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
|
||||
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
|
||||
}
|
||||
@ -463,7 +463,7 @@ TEST_F(EndToEndTest, DISABLED_CanReceiveFec) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
// TODO(pbos): Run this test with combined NACK/FEC enabled as well.
|
||||
// int rtp_history_ms = 1000;
|
||||
// (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms;
|
||||
@ -541,7 +541,7 @@ void EndToEndTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
|
||||
(*receive_configs)[0].pre_render_callback = this;
|
||||
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
|
||||
@ -647,9 +647,9 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
|
||||
VideoEncoder::Create(VideoEncoder::kVp8));
|
||||
send_config_.encoder_settings.encoder = encoder.get();
|
||||
send_config_.encoder_settings.payload_name = "VP8";
|
||||
ASSERT_EQ(1u, video_streams_.size()) << "Test setup error.";
|
||||
video_streams_[0].width = kWidth;
|
||||
video_streams_[0].height = kHeight;
|
||||
ASSERT_EQ(1u, encoder_config_.streams.size()) << "Test setup error.";
|
||||
encoder_config_.streams[0].width = kWidth;
|
||||
encoder_config_.streams[0].height = kHeight;
|
||||
send_config_.pre_encode_callback = &pre_encode_callback;
|
||||
|
||||
CreateMatchingReceiveConfigs();
|
||||
@ -744,7 +744,7 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->rtp.nack.rtp_history_ms = rtp_history_ms_;
|
||||
(*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_;
|
||||
(*receive_configs)[0].renderer = this;
|
||||
@ -891,7 +891,7 @@ void EndToEndTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
|
||||
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
|
||||
(*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_;
|
||||
@ -988,15 +988,16 @@ TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) {
|
||||
send_config.encoder_settings.encoder = encoders[i].get();
|
||||
send_config.encoder_settings.payload_name = "VP8";
|
||||
send_config.encoder_settings.payload_type = 124;
|
||||
std::vector<VideoStream> video_streams = test::CreateVideoStreams(1);
|
||||
VideoStream* stream = &video_streams[0];
|
||||
VideoEncoderConfig encoder_config;
|
||||
encoder_config.streams = test::CreateVideoStreams(1);
|
||||
VideoStream* stream = &encoder_config.streams[0];
|
||||
stream->width = width;
|
||||
stream->height = height;
|
||||
stream->max_framerate = 5;
|
||||
stream->min_bitrate_bps = stream->target_bitrate_bps =
|
||||
stream->max_bitrate_bps = 100000;
|
||||
send_streams[i] =
|
||||
sender_call->CreateVideoSendStream(send_config, video_streams, NULL);
|
||||
sender_call->CreateVideoSendStream(send_config, encoder_config);
|
||||
send_streams[i]->Start();
|
||||
|
||||
VideoReceiveStream::Config receive_config;
|
||||
@ -1087,7 +1088,7 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
|
||||
Start();
|
||||
|
||||
scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
|
||||
video_streams_[0].width, video_streams_[0].height));
|
||||
encoder_config_.streams[0].width, encoder_config_.streams[0].height));
|
||||
send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
|
||||
|
||||
EXPECT_EQ(kEventSignaled, post_encode_observer.Wait())
|
||||
@ -1212,7 +1213,7 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
(*receive_configs)[0].rtp.rtcp_mode = newapi::kRtcpReducedSize;
|
||||
(*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report =
|
||||
enable_rrtr_;
|
||||
@ -1280,19 +1281,19 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
if (num_ssrcs_ > 1) {
|
||||
// Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
|
||||
for (size_t i = 0; i < video_streams->size(); ++i) {
|
||||
(*video_streams)[i].min_bitrate_bps = 10000;
|
||||
(*video_streams)[i].target_bitrate_bps = 15000;
|
||||
(*video_streams)[i].max_bitrate_bps = 20000;
|
||||
for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
|
||||
encoder_config->streams[i].min_bitrate_bps = 10000;
|
||||
encoder_config->streams[i].target_bitrate_bps = 15000;
|
||||
encoder_config->streams[i].max_bitrate_bps = 20000;
|
||||
}
|
||||
}
|
||||
|
||||
all_streams_ = *video_streams;
|
||||
encoder_config_all_streams_ = *encoder_config;
|
||||
if (send_single_ssrc_first_)
|
||||
video_streams->resize(1);
|
||||
encoder_config->streams.resize(1);
|
||||
}
|
||||
|
||||
virtual void OnStreamsCreated(
|
||||
@ -1308,7 +1309,7 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
|
||||
|
||||
if (send_single_ssrc_first_) {
|
||||
// Set full simulcast and continue with the rest of the SSRCs.
|
||||
send_stream_->ReconfigureVideoEncoder(all_streams_, NULL);
|
||||
send_stream_->ReconfigureVideoEncoder(encoder_config_all_streams_);
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting on additional SSRCs.";
|
||||
}
|
||||
@ -1325,7 +1326,7 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
|
||||
bool expect_single_ssrc_;
|
||||
|
||||
VideoSendStream* send_stream_;
|
||||
std::vector<VideoStream> all_streams_;
|
||||
VideoEncoderConfig encoder_config_all_streams_;
|
||||
} test(kSendSsrcs, num_ssrcs, send_single_ssrc_first);
|
||||
|
||||
RunBaseTest(&test);
|
||||
@ -1469,7 +1470,7 @@ TEST_F(EndToEndTest, GetStats) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->pre_encode_callback = this; // Used to inject delay.
|
||||
send_config->rtp.c_name = "SomeCName";
|
||||
|
||||
@ -1645,12 +1646,12 @@ TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
// Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
|
||||
for (size_t i = 0; i < video_streams->size(); ++i) {
|
||||
(*video_streams)[i].min_bitrate_bps = 10000;
|
||||
(*video_streams)[i].target_bitrate_bps = 15000;
|
||||
(*video_streams)[i].max_bitrate_bps = 20000;
|
||||
for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
|
||||
encoder_config->streams[i].min_bitrate_bps = 10000;
|
||||
encoder_config->streams[i].target_bitrate_bps = 15000;
|
||||
encoder_config->streams[i].max_bitrate_bps = 20000;
|
||||
}
|
||||
// Significantly higher than max bitrates for all video streams -> forcing
|
||||
// padding to trigger redundant padding on all RTX SSRCs.
|
||||
@ -1784,10 +1785,10 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
|
||||
}
|
||||
|
||||
// Lower bitrates so that all streams send initially.
|
||||
for (size_t i = 0; i < video_streams_.size(); ++i) {
|
||||
video_streams_[i].min_bitrate_bps = 10000;
|
||||
video_streams_[i].target_bitrate_bps = 15000;
|
||||
video_streams_[i].max_bitrate_bps = 20000;
|
||||
for (size_t i = 0; i < encoder_config_.streams.size(); ++i) {
|
||||
encoder_config_.streams[i].min_bitrate_bps = 10000;
|
||||
encoder_config_.streams[i].target_bitrate_bps = 15000;
|
||||
encoder_config_.streams[i].max_bitrate_bps = 20000;
|
||||
}
|
||||
|
||||
CreateMatchingReceiveConfigs();
|
||||
@ -1806,10 +1807,10 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
|
||||
sender_call_->DestroyVideoSendStream(send_stream_);
|
||||
|
||||
// Re-create VideoSendStream with only one stream.
|
||||
std::vector<VideoStream> one_stream = video_streams_;
|
||||
one_stream.resize(1);
|
||||
VideoEncoderConfig one_stream = encoder_config_;
|
||||
one_stream.streams.resize(1);
|
||||
send_stream_ =
|
||||
sender_call_->CreateVideoSendStream(send_config_, one_stream, NULL);
|
||||
sender_call_->CreateVideoSendStream(send_config_, one_stream);
|
||||
send_stream_->Start();
|
||||
CreateFrameGeneratorCapturer();
|
||||
frame_generator_capturer_->Start();
|
||||
@ -1819,19 +1820,19 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
|
||||
<< "Timed out waiting for single RTP packet.";
|
||||
|
||||
// Reconfigure back to use all streams.
|
||||
send_stream_->ReconfigureVideoEncoder(video_streams_, NULL);
|
||||
send_stream_->ReconfigureVideoEncoder(encoder_config_);
|
||||
observer.ResetExpectedSsrcs(kNumSsrcs);
|
||||
EXPECT_EQ(kEventSignaled, observer.Wait())
|
||||
<< "Timed out waiting for all SSRCs to send packets.";
|
||||
|
||||
// Reconfigure down to one stream.
|
||||
send_stream_->ReconfigureVideoEncoder(one_stream, NULL);
|
||||
send_stream_->ReconfigureVideoEncoder(one_stream);
|
||||
observer.ResetExpectedSsrcs(1);
|
||||
EXPECT_EQ(kEventSignaled, observer.Wait())
|
||||
<< "Timed out waiting for single RTP packet.";
|
||||
|
||||
// Reconfigure back to use all streams.
|
||||
send_stream_->ReconfigureVideoEncoder(video_streams_, NULL);
|
||||
send_stream_->ReconfigureVideoEncoder(encoder_config_);
|
||||
observer.ResetExpectedSsrcs(kNumSsrcs);
|
||||
EXPECT_EQ(kEventSignaled, observer.Wait())
|
||||
<< "Timed out waiting for all SSRCs to send packets.";
|
||||
@ -1934,7 +1935,7 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->encoder_settings.encoder = this;
|
||||
}
|
||||
|
||||
|
||||
@ -393,7 +393,7 @@ void FullStackTest::RunTest(const FullStackTestParams& params) {
|
||||
send_config_.encoder_settings.payload_name = "VP8";
|
||||
send_config_.encoder_settings.payload_type = 124;
|
||||
|
||||
VideoStream* stream = &video_streams_[0];
|
||||
VideoStream* stream = &encoder_config_.streams[0];
|
||||
stream->width = params.clip.width;
|
||||
stream->height = params.clip.height;
|
||||
stream->min_bitrate_bps = params.min_bitrate_bps;
|
||||
|
||||
@ -129,8 +129,9 @@ void Loopback() {
|
||||
send_config.encoder_settings.encoder = encoder.get();
|
||||
send_config.encoder_settings.payload_name = flags::Codec();
|
||||
send_config.encoder_settings.payload_type = 124;
|
||||
std::vector<VideoStream> video_streams = test::CreateVideoStreams(1);
|
||||
VideoStream* stream = &video_streams[0];
|
||||
VideoEncoderConfig encoder_config;
|
||||
encoder_config.streams = test::CreateVideoStreams(1);
|
||||
VideoStream* stream = &encoder_config.streams[0];
|
||||
stream->width = flags::Width();
|
||||
stream->height = flags::Height();
|
||||
stream->min_bitrate_bps = static_cast<int>(flags::MinBitrate()) * 1000;
|
||||
@ -140,7 +141,7 @@ void Loopback() {
|
||||
stream->max_qp = 56;
|
||||
|
||||
VideoSendStream* send_stream =
|
||||
call->CreateVideoSendStream(send_config, video_streams, NULL);
|
||||
call->CreateVideoSendStream(send_config, encoder_config);
|
||||
|
||||
Clock* test_clock = Clock::GetRealTimeClock();
|
||||
|
||||
|
||||
@ -411,8 +411,8 @@ void RampUpTest::RunRampUpTest(bool rtx,
|
||||
receiver_transport.SetReceiver(sender_call_->Receiver());
|
||||
|
||||
if (num_streams == 1) {
|
||||
video_streams_[0].target_bitrate_bps = 2000000;
|
||||
video_streams_[0].max_bitrate_bps = 2000000;
|
||||
encoder_config_.streams[0].target_bitrate_bps = 2000000;
|
||||
encoder_config_.streams[0].max_bitrate_bps = 2000000;
|
||||
}
|
||||
|
||||
send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
|
||||
@ -430,9 +430,9 @@ void RampUpTest::RunRampUpTest(bool rtx,
|
||||
// For multi stream rampup until all streams are being sent. That means
|
||||
// enough birate to send all the target streams plus the min bitrate of
|
||||
// the last one.
|
||||
int expected_bitrate_bps = video_streams_.back().min_bitrate_bps;
|
||||
for (size_t i = 0; i < video_streams_.size() - 1; ++i) {
|
||||
expected_bitrate_bps += video_streams_[i].target_bitrate_bps;
|
||||
int expected_bitrate_bps = encoder_config_.streams.back().min_bitrate_bps;
|
||||
for (size_t i = 0; i < encoder_config_.streams.size() - 1; ++i) {
|
||||
expected_bitrate_bps += encoder_config_.streams[i].target_bitrate_bps;
|
||||
}
|
||||
stream_observer.set_expected_bitrate_bps(expected_bitrate_bps);
|
||||
}
|
||||
|
||||
@ -114,8 +114,7 @@ VideoSendStream::VideoSendStream(
|
||||
CpuOveruseObserver* overuse_observer,
|
||||
webrtc::VideoEngine* video_engine,
|
||||
const VideoSendStream::Config& config,
|
||||
const std::vector<VideoStream> video_streams,
|
||||
const void* encoder_settings,
|
||||
const VideoEncoderConfig& encoder_config,
|
||||
const std::map<uint32_t, RtpState>& suspended_ssrcs,
|
||||
int base_channel,
|
||||
int start_bitrate_bps)
|
||||
@ -211,7 +210,7 @@ VideoSendStream::VideoSendStream(
|
||||
}
|
||||
|
||||
codec_ = ViECodec::GetInterface(video_engine);
|
||||
if (!ReconfigureVideoEncoder(video_streams, encoder_settings))
|
||||
if (!ReconfigureVideoEncoder(encoder_config))
|
||||
abort();
|
||||
|
||||
if (overuse_observer)
|
||||
@ -297,8 +296,8 @@ void VideoSendStream::Stop() {
|
||||
}
|
||||
|
||||
bool VideoSendStream::ReconfigureVideoEncoder(
|
||||
const std::vector<VideoStream>& streams,
|
||||
const void* encoder_settings) {
|
||||
const VideoEncoderConfig& config) {
|
||||
const std::vector<VideoStream>& streams = config.streams;
|
||||
assert(!streams.empty());
|
||||
assert(config_.rtp.ssrcs.size() >= streams.size());
|
||||
|
||||
@ -311,6 +310,14 @@ bool VideoSendStream::ReconfigureVideoEncoder(
|
||||
} else {
|
||||
video_codec.codecType = kVideoCodecGeneric;
|
||||
}
|
||||
switch (config.content_type) {
|
||||
case VideoEncoderConfig::kRealtimeVideo:
|
||||
video_codec.mode = kRealtimeVideo;
|
||||
break;
|
||||
case VideoEncoderConfig::kScreenshare:
|
||||
video_codec.mode = kScreensharing;
|
||||
break;
|
||||
}
|
||||
|
||||
if (video_codec.codecType == kVideoCodecVP8) {
|
||||
video_codec.codecSpecific.VP8 = VideoEncoder::GetDefaultVp8Settings();
|
||||
@ -319,13 +326,13 @@ bool VideoSendStream::ReconfigureVideoEncoder(
|
||||
}
|
||||
|
||||
if (video_codec.codecType == kVideoCodecVP8) {
|
||||
if (encoder_settings != NULL) {
|
||||
video_codec.codecSpecific.VP8 =
|
||||
*reinterpret_cast<const VideoCodecVP8*>(encoder_settings);
|
||||
if (config.encoder_specific_settings != NULL) {
|
||||
video_codec.codecSpecific.VP8 = *reinterpret_cast<const VideoCodecVP8*>(
|
||||
config.encoder_specific_settings);
|
||||
}
|
||||
} else {
|
||||
// TODO(pbos): Support encoder_settings codec-agnostically.
|
||||
assert(encoder_settings == NULL);
|
||||
assert(config.encoder_specific_settings == NULL);
|
||||
}
|
||||
|
||||
strncpy(video_codec.plName,
|
||||
|
||||
@ -46,8 +46,7 @@ class VideoSendStream : public webrtc::VideoSendStream,
|
||||
CpuOveruseObserver* overuse_observer,
|
||||
webrtc::VideoEngine* video_engine,
|
||||
const VideoSendStream::Config& config,
|
||||
const std::vector<VideoStream> video_streams,
|
||||
const void* encoder_settings,
|
||||
const VideoEncoderConfig& encoder_config,
|
||||
const std::map<uint32_t, RtpState>& suspended_ssrcs,
|
||||
int base_channel,
|
||||
int start_bitrate);
|
||||
@ -57,8 +56,8 @@ class VideoSendStream : public webrtc::VideoSendStream,
|
||||
virtual void Start() OVERRIDE;
|
||||
virtual void Stop() OVERRIDE;
|
||||
|
||||
virtual bool ReconfigureVideoEncoder(const std::vector<VideoStream>& streams,
|
||||
const void* encoder_settings) OVERRIDE;
|
||||
virtual bool ReconfigureVideoEncoder(
|
||||
const VideoEncoderConfig& config) OVERRIDE;
|
||||
|
||||
virtual Stats GetStats() const OVERRIDE;
|
||||
|
||||
|
||||
@ -114,7 +114,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->rtp.c_name = kCName;
|
||||
}
|
||||
|
||||
@ -152,7 +152,7 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->rtp.extensions.push_back(
|
||||
RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
|
||||
}
|
||||
@ -193,7 +193,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->encoder_settings.encoder = &encoder_;
|
||||
send_config->rtp.extensions.push_back(
|
||||
RtpExtension(RtpExtension::kTOffset, kTOffsetExtensionId));
|
||||
@ -360,7 +360,7 @@ TEST_F(VideoSendStreamTest, SupportsFec) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->rtp.fec.red_payload_type = kRedPayloadType;
|
||||
send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
|
||||
}
|
||||
@ -440,7 +440,7 @@ void VideoSendStreamTest::TestNackRetransmission(
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
|
||||
send_config->rtp.rtx.payload_type = retransmit_payload_type_;
|
||||
if (retransmit_ssrc_ != kSendSsrcs[0])
|
||||
@ -613,7 +613,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
if (use_fec_) {
|
||||
send_config->rtp.fec.red_payload_type = kRedPayloadType;
|
||||
send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
|
||||
@ -788,14 +788,14 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
|
||||
send_config->pre_encode_callback = this;
|
||||
send_config->suspend_below_min_bitrate = true;
|
||||
int min_bitrate_bps = (*video_streams)[0].min_bitrate_bps;
|
||||
int min_bitrate_bps = encoder_config->streams[0].min_bitrate_bps;
|
||||
set_low_remb_bps(min_bitrate_bps - 10000);
|
||||
int threshold_window = std::max(min_bitrate_bps / 10, 10000);
|
||||
ASSERT_GT((*video_streams)[0].max_bitrate_bps,
|
||||
ASSERT_GT(encoder_config->streams[0].max_bitrate_bps,
|
||||
min_bitrate_bps + threshold_window + 5000);
|
||||
set_high_remb_bps(min_bitrate_bps + threshold_window + 5000);
|
||||
}
|
||||
@ -977,7 +977,7 @@ TEST_F(VideoSendStreamTest, ProducesStats) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
SetConfig(*send_config);
|
||||
}
|
||||
|
||||
@ -1074,7 +1074,7 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
|
||||
}
|
||||
|
||||
@ -1133,8 +1133,8 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndI420VideoFrames) {
|
||||
// Prepare five input frames. Send I420VideoFrame and TextureVideoFrame
|
||||
// alternatively.
|
||||
ScopedVector<I420VideoFrame> input_frames;
|
||||
int width = static_cast<int>(video_streams_[0].width);
|
||||
int height = static_cast<int>(video_streams_[0].height);
|
||||
int width = static_cast<int>(encoder_config_.streams[0].width);
|
||||
int height = static_cast<int>(encoder_config_.streams[0].height);
|
||||
webrtc::RefCountImpl<FakeNativeHandle>* handle1 =
|
||||
new webrtc::RefCountImpl<FakeNativeHandle>();
|
||||
webrtc::RefCountImpl<FakeNativeHandle>* handle2 =
|
||||
@ -1154,7 +1154,7 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndI420VideoFrames) {
|
||||
send_stream_->Input()->SwapFrame(frame.get());
|
||||
// Do not send the next frame too fast, so the frame dropper won't drop it.
|
||||
if (i < input_frames.size() - 1)
|
||||
SleepMs(1000 / video_streams_[0].max_framerate);
|
||||
SleepMs(1000 / encoder_config_.streams[0].max_framerate);
|
||||
// Wait until the output frame is received before sending the next input
|
||||
// frame. Or the previous input frame may be replaced without delivering.
|
||||
observer.WaitOutputFrame();
|
||||
@ -1327,16 +1327,16 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->encoder_settings.encoder = this;
|
||||
video_streams_ = *video_streams;
|
||||
encoder_config_ = *encoder_config;
|
||||
}
|
||||
|
||||
virtual void PerformTest() OVERRIDE {
|
||||
EXPECT_EQ(kEventSignaled, Wait())
|
||||
<< "Timed out while waiting for Encode.";
|
||||
EXPECT_EQ(0u, num_releases());
|
||||
stream_->ReconfigureVideoEncoder(video_streams_, NULL);
|
||||
stream_->ReconfigureVideoEncoder(encoder_config_);
|
||||
EXPECT_EQ(0u, num_releases());
|
||||
stream_->Stop();
|
||||
// Encoder should not be released before destroying the VideoSendStream.
|
||||
@ -1354,7 +1354,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
|
||||
bool callback_registered_ GUARDED_BY(crit_);
|
||||
size_t num_releases_ GUARDED_BY(crit_);
|
||||
bool released_ GUARDED_BY(crit_);
|
||||
std::vector<VideoStream> video_streams_;
|
||||
VideoEncoderConfig encoder_config_;
|
||||
} test_encoder;
|
||||
|
||||
RunBaseTest(&test_encoder);
|
||||
@ -1363,6 +1363,62 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
|
||||
EXPECT_EQ(1u, test_encoder.num_releases());
|
||||
}
|
||||
|
||||
TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {
|
||||
class VideoCodecConfigObserver : public test::SendTest,
|
||||
public test::FakeEncoder {
|
||||
public:
|
||||
VideoCodecConfigObserver()
|
||||
: SendTest(kDefaultTimeoutMs),
|
||||
FakeEncoder(Clock::GetRealTimeClock()),
|
||||
num_initializations_(0) {}
|
||||
|
||||
private:
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->encoder_settings.encoder = this;
|
||||
encoder_config_ = *encoder_config;
|
||||
}
|
||||
|
||||
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 {
|
||||
if (num_initializations_ == 0) {
|
||||
// Verify default values.
|
||||
EXPECT_EQ(kRealtimeVideo, config->mode);
|
||||
} else {
|
||||
// Verify that changed values are propagated.
|
||||
EXPECT_EQ(kScreensharing, config->mode);
|
||||
}
|
||||
++num_initializations_;
|
||||
return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
|
||||
}
|
||||
|
||||
virtual void PerformTest() OVERRIDE {
|
||||
EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
|
||||
|
||||
encoder_config_.content_type = VideoEncoderConfig::kScreenshare;
|
||||
stream_->ReconfigureVideoEncoder(encoder_config_);
|
||||
EXPECT_EQ(2u, num_initializations_)
|
||||
<< "ReconfigureVideoEncoder did not reinitialize the encoder with "
|
||||
"new encoder settings.";
|
||||
}
|
||||
|
||||
size_t num_initializations_;
|
||||
VideoSendStream* stream_;
|
||||
VideoEncoderConfig encoder_config_;
|
||||
} test;
|
||||
|
||||
RunBaseTest(&test);
|
||||
}
|
||||
|
||||
TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
|
||||
class VideoCodecConfigObserver : public test::SendTest,
|
||||
public test::FakeEncoder {
|
||||
@ -1378,11 +1434,12 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
|
||||
virtual void ModifyConfigs(
|
||||
VideoSendStream::Config* send_config,
|
||||
std::vector<VideoReceiveStream::Config>* receive_configs,
|
||||
std::vector<VideoStream>* video_streams) OVERRIDE {
|
||||
VideoEncoderConfig* encoder_config) OVERRIDE {
|
||||
send_config->encoder_settings.encoder = this;
|
||||
send_config->encoder_settings.payload_name = "VP8";
|
||||
|
||||
video_streams_ = *video_streams;
|
||||
encoder_config->encoder_specific_settings = &vp8_settings_;
|
||||
encoder_config_ = *encoder_config;
|
||||
}
|
||||
|
||||
virtual void OnStreamsCreated(
|
||||
@ -1407,26 +1464,23 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
|
||||
EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
|
||||
|
||||
vp8_settings_.denoisingOn = true;
|
||||
stream_->ReconfigureVideoEncoder(video_streams_, &vp8_settings_);
|
||||
stream_->ReconfigureVideoEncoder(encoder_config_);
|
||||
EXPECT_EQ(2u, num_initializations_)
|
||||
<< "ReconfigureVideoEncoder did not reinitialize the encoder with "
|
||||
"new encoder settings.";
|
||||
}
|
||||
|
||||
int32_t Encode(
|
||||
const I420VideoFrame& input_image,
|
||||
const CodecSpecificInfo* codec_specific_info,
|
||||
const std::vector<VideoFrameType>* frame_types) {
|
||||
int32_t Encode(const I420VideoFrame& input_image,
|
||||
const CodecSpecificInfo* codec_specific_info,
|
||||
const std::vector<VideoFrameType>* frame_types) OVERRIDE {
|
||||
// Silently skip the encode, FakeEncoder::Encode doesn't produce VP8.
|
||||
return 0;
|
||||
}
|
||||
|
||||
virtual const void* GetEncoderSettings() OVERRIDE { return &vp8_settings_; }
|
||||
|
||||
VideoCodecVP8 vp8_settings_;
|
||||
size_t num_initializations_;
|
||||
VideoSendStream* stream_;
|
||||
std::vector<VideoStream> video_streams_;
|
||||
VideoEncoderConfig encoder_config_;
|
||||
} test;
|
||||
|
||||
RunBaseTest(&test);
|
||||
|
||||
@ -153,8 +153,7 @@ class VideoSendStream {
|
||||
// Set which streams to send. Must have at least as many SSRCs as configured
|
||||
// in the config. Encoder settings are passed on to the encoder instance along
|
||||
// with the VideoStream settings.
|
||||
virtual bool ReconfigureVideoEncoder(const std::vector<VideoStream>& streams,
|
||||
const void* encoder_settings) = 0;
|
||||
virtual bool ReconfigureVideoEncoder(const VideoEncoderConfig& config) = 0;
|
||||
|
||||
virtual Stats GetStats() const = 0;
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user