Implement minimum transmit bitrate.
Utilizing minimum transmission bitrate prevents low remote bitrate
estimates (bitrate estimation dips) when encoding non-complex content
such as screenshare of a static image even though there's nothing wrong
with the link.
Requires pacing to be enabled for now, pending issue 3036.
BUG=3014
R=mflodman@webrtc.org, stefan@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/9719004
git-svn-id: http://webrtc.googlecode.com/svn/trunk@5694 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/webrtc/test/fake_encoder.cc b/webrtc/test/fake_encoder.cc
index f4e5227..fc8712e 100644
--- a/webrtc/test/fake_encoder.cc
+++ b/webrtc/test/fake_encoder.cc
@@ -19,6 +19,7 @@
: clock_(clock),
callback_(NULL),
target_bitrate_kbps_(0),
+ max_target_bitrate_kbps_(-1),
last_encode_time_ms_(0) {
// Generate some arbitrary not-all-zero data
for (size_t i = 0; i < sizeof(encoded_buffer_); ++i) {
@@ -62,6 +63,11 @@
strcpy(codec->plName, "FAKE");
}
+void FakeEncoder::SetMaxBitrate(int max_kbps) {
+ assert(max_kbps >= -1); // max_kbps == -1 disables it.
+ max_target_bitrate_kbps_ = max_kbps;
+}
+
int32_t FakeEncoder::InitEncode(const VideoCodec* config,
int32_t number_of_cores,
uint32_t max_payload_size) {
@@ -75,19 +81,22 @@
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) {
assert(config_.maxFramerate > 0);
- int delta_since_last_encode = 1000 / config_.maxFramerate;
+ int time_since_last_encode_ms = 1000 / config_.maxFramerate;
int64_t time_now_ms = clock_->TimeInMilliseconds();
if (last_encode_time_ms_ > 0) {
// For all frames but the first we can estimate the display time by looking
// at the display time of the previous frame.
- delta_since_last_encode = time_now_ms - last_encode_time_ms_;
+ time_since_last_encode_ms = time_now_ms - last_encode_time_ms_;
}
- int bits_available = target_bitrate_kbps_ * delta_since_last_encode;
+ int bits_available = target_bitrate_kbps_ * time_since_last_encode_ms;
int min_bits =
- config_.simulcastStream[0].minBitrate * delta_since_last_encode;
+ config_.simulcastStream[0].minBitrate * time_since_last_encode_ms;
if (bits_available < min_bits)
bits_available = min_bits;
+ int max_bits = max_target_bitrate_kbps_ * time_since_last_encode_ms;
+ if (max_bits > 0 && max_bits < bits_available)
+ bits_available = max_bits;
last_encode_time_ms_ = time_now_ms;
for (int i = 0; i < config_.numberOfSimulcastStreams; ++i) {
@@ -95,10 +104,10 @@
memset(&specifics, 0, sizeof(specifics));
specifics.codecType = kVideoCodecGeneric;
specifics.codecSpecific.generic.simulcast_idx = i;
- int min_stream_bits = config_.simulcastStream[i].minBitrate *
- delta_since_last_encode;
- int max_stream_bits = config_.simulcastStream[i].maxBitrate *
- delta_since_last_encode;
+ int min_stream_bits =
+ config_.simulcastStream[i].minBitrate * time_since_last_encode_ms;
+ int max_stream_bits =
+ config_.simulcastStream[i].maxBitrate * time_since_last_encode_ms;
int stream_bits = (bits_available > max_stream_bits) ? max_stream_bits :
bits_available;
int stream_bytes = (stream_bits + 7) / 8;
@@ -110,7 +119,8 @@
encoded._timeStamp = input_image.timestamp();
encoded.capture_time_ms_ = input_image.render_time_ms();
encoded._frameType = (*frame_types)[i];
- if (min_stream_bits > bits_available) {
+ // Always encode something on the first frame.
+ if (min_stream_bits > bits_available && i > 0) {
encoded._length = 0;
encoded._frameType = kSkipFrame;
}
@@ -138,5 +148,6 @@
target_bitrate_kbps_ = new_target_bitrate;
return 0;
}
+
} // namespace test
} // namespace webrtc
diff --git a/webrtc/test/fake_encoder.h b/webrtc/test/fake_encoder.h
index c57a4dc..e2d8d6b 100644
--- a/webrtc/test/fake_encoder.h
+++ b/webrtc/test/fake_encoder.h
@@ -25,23 +25,20 @@
virtual ~FakeEncoder();
static void SetCodecSettings(VideoCodec* codec, size_t num_streams);
+ // Sets max bitrate. Not thread-safe, call before registering the encoder.
+ void SetMaxBitrate(int max_kbps);
virtual int32_t InitEncode(const VideoCodec* config,
int32_t number_of_cores,
uint32_t max_payload_size) OVERRIDE;
-
virtual int32_t Encode(
const I420VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) OVERRIDE;
-
virtual int32_t RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) OVERRIDE;
-
virtual int32_t Release() OVERRIDE;
-
virtual int32_t SetChannelParameters(uint32_t packet_loss, int rtt) OVERRIDE;
-
virtual int32_t SetRates(uint32_t new_target_bitrate,
uint32_t framerate) OVERRIDE;
@@ -50,6 +47,7 @@
VideoCodec config_;
EncodedImageCallback* callback_;
int target_bitrate_kbps_;
+ int max_target_bitrate_kbps_;
int64_t last_encode_time_ms_;
uint8_t encoded_buffer_[100000];
};
diff --git a/webrtc/test/rtp_rtcp_observer.h b/webrtc/test/rtp_rtcp_observer.h
index 5ed9a3f..00422cc 100644
--- a/webrtc/test/rtp_rtcp_observer.h
+++ b/webrtc/test/rtp_rtcp_observer.h
@@ -33,8 +33,8 @@
return &receive_transport_;
}
- void SetReceivers(PacketReceiver* send_transport_receiver,
- PacketReceiver* receive_transport_receiver) {
+ virtual void SetReceivers(PacketReceiver* send_transport_receiver,
+ PacketReceiver* receive_transport_receiver) {
send_transport_.SetReceiver(send_transport_receiver);
receive_transport_.SetReceiver(receive_transport_receiver);
}
diff --git a/webrtc/video/call_perf_tests.cc b/webrtc/video/call_perf_tests.cc
index 4c0f5ed..31cfab5 100644
--- a/webrtc/video/call_perf_tests.cc
+++ b/webrtc/video/call_perf_tests.cc
@@ -50,6 +50,7 @@
public:
CallPerfTest()
: send_stream_(NULL), fake_encoder_(Clock::GetRealTimeClock()) {}
+
protected:
VideoSendStream::Config GetSendTestConfig(Call* call) {
VideoSendStream::Config config = call->GetDefaultSendConfig();
@@ -60,6 +61,7 @@
config.codec.plType = kSendPayloadType;
return config;
}
+
void RunVideoSendTest(Call* call,
const VideoSendStream::Config& config,
test::RtpRtcpObserver* observer) {
@@ -78,6 +80,8 @@
call->DestroyVideoSendStream(send_stream_);
}
+ void TestMinTransmitBitrate(bool pad_to_min_bitrate);
+
VideoSendStream* send_stream_;
test::FakeEncoder fake_encoder_;
};
@@ -388,4 +392,133 @@
VideoSendStream::Config send_config = GetSendTestConfig(call.get());
RunVideoSendTest(call.get(), send_config, &observer);
}
+
+void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
+ static const int kMaxEncodeBitrateKbps = 30;
+ static const int kMinTransmitBitrateKbps = 150;
+ static const int kMinAcceptableTransmitBitrate = 130;
+ static const int kMaxAcceptableTransmitBitrate = 170;
+ static const int kNumBitrateObservationsInRange = 100;
+ class BitrateObserver : public test::RtpRtcpObserver, public PacketReceiver {
+ public:
+ explicit BitrateObserver(bool using_min_transmit_bitrate)
+ : test::RtpRtcpObserver(kLongTimeoutMs),
+ send_stream_(NULL),
+ send_transport_receiver_(NULL),
+ using_min_transmit_bitrate_(using_min_transmit_bitrate),
+ num_bitrate_observations_in_range_(0) {}
+
+ virtual void SetReceivers(PacketReceiver* send_transport_receiver,
+ PacketReceiver* receive_transport_receiver)
+ OVERRIDE {
+ send_transport_receiver_ = send_transport_receiver;
+ test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
+ }
+
+ void SetSendStream(VideoSendStream* send_stream) {
+ send_stream_ = send_stream;
+ }
+
+ private:
+ virtual bool DeliverPacket(const uint8_t* packet, size_t length) OVERRIDE {
+ VideoSendStream::Stats stats = send_stream_->GetStats();
+ if (stats.substreams.size() > 0) {
+ assert(stats.substreams.size() == 1);
+ int bitrate_kbps = stats.substreams.begin()->second.bitrate_bps / 1000;
+ if (bitrate_kbps > 0) {
+ test::PrintResult(
+ "bitrate_stats_",
+ (using_min_transmit_bitrate_ ? "min_transmit_bitrate"
+ : "without_min_transmit_bitrate"),
+ "bitrate_kbps",
+ static_cast<size_t>(bitrate_kbps),
+ "kbps",
+ false);
+ if (using_min_transmit_bitrate_) {
+ if (bitrate_kbps > kMinAcceptableTransmitBitrate &&
+ bitrate_kbps < kMaxAcceptableTransmitBitrate) {
+ ++num_bitrate_observations_in_range_;
+ }
+ } else {
+ // Expect bitrate stats to roughly match the max encode bitrate.
+ if (bitrate_kbps > kMaxEncodeBitrateKbps - 5 &&
+ bitrate_kbps < kMaxEncodeBitrateKbps + 5) {
+ ++num_bitrate_observations_in_range_;
+ }
+ }
+ if (num_bitrate_observations_in_range_ ==
+ kNumBitrateObservationsInRange)
+ observation_complete_->Set();
+ }
+ }
+ return send_transport_receiver_->DeliverPacket(packet, length);
+ }
+
+ VideoSendStream* send_stream_;
+ PacketReceiver* send_transport_receiver_;
+ const bool using_min_transmit_bitrate_;
+ int num_bitrate_observations_in_range_;
+ } observer(pad_to_min_bitrate);
+
+ scoped_ptr<Call> sender_call(
+ Call::Create(Call::Config(observer.SendTransport())));
+ scoped_ptr<Call> receiver_call(
+ Call::Create(Call::Config(observer.ReceiveTransport())));
+
+ VideoSendStream::Config send_config = GetSendTestConfig(sender_call.get());
+ fake_encoder_.SetMaxBitrate(kMaxEncodeBitrateKbps);
+
+ observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
+
+ send_config.pacing = true;
+ if (pad_to_min_bitrate) {
+ send_config.rtp.min_transmit_bitrate_kbps = kMinTransmitBitrateKbps;
+ } else {
+ assert(send_config.rtp.min_transmit_bitrate_kbps == 0);
+ }
+
+ VideoReceiveStream::Config receive_config =
+ receiver_call->GetDefaultReceiveConfig();
+ receive_config.codecs.clear();
+ receive_config.codecs.push_back(send_config.codec);
+ test::FakeDecoder fake_decoder;
+ ExternalVideoDecoder decoder;
+ decoder.decoder = &fake_decoder;
+ decoder.payload_type = send_config.codec.plType;
+ receive_config.external_decoders.push_back(decoder);
+ receive_config.rtp.remote_ssrc = send_config.rtp.ssrcs[0];
+ receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
+
+ VideoSendStream* send_stream =
+ sender_call->CreateVideoSendStream(send_config);
+ VideoReceiveStream* receive_stream =
+ receiver_call->CreateVideoReceiveStream(receive_config);
+ scoped_ptr<test::FrameGeneratorCapturer> capturer(
+ test::FrameGeneratorCapturer::Create(send_stream->Input(),
+ send_config.codec.width,
+ send_config.codec.height,
+ 30,
+ Clock::GetRealTimeClock()));
+ observer.SetSendStream(send_stream);
+ receive_stream->StartReceiving();
+ send_stream->StartSending();
+ capturer->Start();
+
+ EXPECT_EQ(kEventSignaled, observer.Wait())
+ << "Timeout while waiting for send-bitrate stats.";
+
+ send_stream->StopSending();
+ receive_stream->StopReceiving();
+ observer.StopSending();
+ capturer->Stop();
+ sender_call->DestroyVideoSendStream(send_stream);
+ receiver_call->DestroyVideoReceiveStream(receive_stream);
+}
+
+TEST_F(CallPerfTest, PadsToMinTransmitBitrate) { TestMinTransmitBitrate(true); }
+
+TEST_F(CallPerfTest, NoPadWithoutMinTransmitBitrate) {
+ TestMinTransmitBitrate(false);
+}
+
} // namespace webrtc
diff --git a/webrtc/video/call_tests.cc b/webrtc/video/call_tests.cc
index a945f64..6e922d3 100644
--- a/webrtc/video/call_tests.cc
+++ b/webrtc/video/call_tests.cc
@@ -1475,4 +1475,5 @@
TEST_F(CallTest, ReceiverReferenceTimeReportDisabled) {
TestXrReceiverReferenceTimeReport(false);
}
+
} // namespace webrtc
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 8ec8575..5cacb56 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -49,6 +49,10 @@
config_.pacing = true;
rtp_rtcp_->SetTransmissionSmoothingStatus(channel_, config_.pacing);
+ assert(config_.rtp.min_transmit_bitrate_kbps >= 0);
+ rtp_rtcp_->SetMinTransmitBitrate(channel_,
+ config_.rtp.min_transmit_bitrate_kbps);
+
for (size_t i = 0; i < config_.rtp.extensions.size(); ++i) {
const std::string& extension = config_.rtp.extensions[i].name;
int id = config_.rtp.extensions[i].id;
diff --git a/webrtc/video_engine/include/vie_rtp_rtcp.h b/webrtc/video_engine/include/vie_rtp_rtcp.h
index a358e48..e4ef74a 100644
--- a/webrtc/video_engine/include/vie_rtp_rtcp.h
+++ b/webrtc/video_engine/include/vie_rtp_rtcp.h
@@ -266,6 +266,15 @@
virtual int SetTransmissionSmoothingStatus(int video_channel,
bool enable) = 0;
+ // Sets a minimal bitrate which will be padded to when the encoder doesn't
+ // produce enough bitrate.
+ // TODO(pbos): Remove default implementation when libjingle's
+ // FakeWebRtcVideoEngine is updated.
+ virtual int SetMinTransmitBitrate(int video_channel,
+ int min_transmit_bitrate_kbps) {
+ return -1;
+ };
+
// This function returns our locally created statistics of the received RTP
// stream.
virtual int GetReceiveChannelRtcpStatistics(const int video_channel,
diff --git a/webrtc/video_engine/vie_encoder.cc b/webrtc/video_engine/vie_encoder.cc
index 940358c..22a74fb 100644
--- a/webrtc/video_engine/vie_encoder.cc
+++ b/webrtc/video_engine/vie_encoder.cc
@@ -149,6 +149,7 @@
bitrate_controller_(bitrate_controller),
time_of_last_incoming_frame_ms_(0),
send_padding_(false),
+ min_transmit_bitrate_kbps_(0),
target_delay_ms_(0),
network_is_transmitting_(true),
encoder_paused_(false),
@@ -459,9 +460,14 @@
kTransmissionMaxBitrateMultiplier *
video_codec.maxBitrate * 1000);
- paced_sender_->UpdateBitrate(video_codec.startBitrate,
- video_codec.startBitrate,
- video_codec.startBitrate);
+ CriticalSectionScoped crit(data_cs_.get());
+ int pad_up_to_bitrate_kbps = video_codec.startBitrate;
+ if (pad_up_to_bitrate_kbps < min_transmit_bitrate_kbps_)
+ pad_up_to_bitrate_kbps = min_transmit_bitrate_kbps_;
+
+ paced_sender_->UpdateBitrate(
+ video_codec.startBitrate, pad_up_to_bitrate_kbps, pad_up_to_bitrate_kbps);
+
return 0;
}
@@ -527,7 +533,8 @@
bool send_padding;
{
CriticalSectionScoped cs(data_cs_.get());
- send_padding = send_padding_ || video_suspended_;
+ send_padding =
+ send_padding_ || video_suspended_ || min_transmit_bitrate_kbps_ > 0;
}
if (send_padding) {
return default_rtp_rtcp_->TimeToSendPadding(bytes);
@@ -1028,6 +1035,12 @@
return true;
}
+void ViEEncoder::SetMinTransmitBitrate(int min_transmit_bitrate_kbps) {
+ assert(min_transmit_bitrate_kbps >= 0);
+ CriticalSectionScoped crit(data_cs_.get());
+ min_transmit_bitrate_kbps_ = min_transmit_bitrate_kbps;
+}
+
// Called from ViEBitrateObserver.
void ViEEncoder::OnNetworkChanged(const uint32_t bitrate_bps,
const uint8_t fraction_lost,
@@ -1091,17 +1104,21 @@
max_padding_bitrate_kbps = 0;
}
- paced_sender_->UpdateBitrate(bitrate_kbps,
- max_padding_bitrate_kbps,
- pad_up_to_bitrate_kbps);
- default_rtp_rtcp_->SetTargetSendBitrate(stream_bitrates);
{
CriticalSectionScoped cs(data_cs_.get());
+ if (pad_up_to_bitrate_kbps < min_transmit_bitrate_kbps_)
+ pad_up_to_bitrate_kbps = min_transmit_bitrate_kbps_;
+ if (max_padding_bitrate_kbps < min_transmit_bitrate_kbps_)
+ max_padding_bitrate_kbps = min_transmit_bitrate_kbps_;
+ paced_sender_->UpdateBitrate(
+ bitrate_kbps, max_padding_bitrate_kbps, pad_up_to_bitrate_kbps);
+ default_rtp_rtcp_->SetTargetSendBitrate(stream_bitrates);
if (video_suspended_ == video_is_suspended)
return;
video_suspended_ = video_is_suspended;
}
// State changed, inform codec observer.
+ CriticalSectionScoped crit(callback_cs_.get());
if (codec_observer_) {
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo,
ViEId(engine_id_, channel_id_),
diff --git a/webrtc/video_engine/vie_encoder.h b/webrtc/video_engine/vie_encoder.h
index d3271c3..8e22ecf 100644
--- a/webrtc/video_engine/vie_encoder.h
+++ b/webrtc/video_engine/vie_encoder.h
@@ -20,6 +20,7 @@
#include "webrtc/modules/video_coding/main/interface/video_coding_defines.h"
#include "webrtc/modules/video_processing/main/interface/video_processing.h"
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
+#include "webrtc/system_wrappers/interface/thread_annotations.h"
#include "webrtc/typedefs.h"
#include "webrtc/frame_callback.h"
#include "webrtc/video_engine/vie_defines.h"
@@ -154,6 +155,8 @@
// Sets SSRCs for all streams.
bool SetSsrcs(const std::list<unsigned int>& ssrcs);
+ void SetMinTransmitBitrate(int min_transmit_bitrate_kbps);
+
// Effect filter.
int32_t RegisterEffectFilter(ViEEffectFilter* effect_filter);
@@ -207,6 +210,7 @@
int64_t time_of_last_incoming_frame_ms_;
bool send_padding_;
+ int min_transmit_bitrate_kbps_ GUARDED_BY(data_cs_);
int target_delay_ms_;
bool network_is_transmitting_;
bool encoder_paused_;
@@ -216,7 +220,7 @@
bool fec_enabled_;
bool nack_enabled_;
- ViEEncoderObserver* codec_observer_;
+ ViEEncoderObserver* codec_observer_ GUARDED_BY(callback_cs_);
ViEEffectFilter* effect_filter_;
ProcessThread& module_process_thread_;
diff --git a/webrtc/video_engine/vie_rtp_rtcp_impl.cc b/webrtc/video_engine/vie_rtp_rtcp_impl.cc
index 54afa93..6717e84 100644
--- a/webrtc/video_engine/vie_rtp_rtcp_impl.cc
+++ b/webrtc/video_engine/vie_rtp_rtcp_impl.cc
@@ -850,6 +850,16 @@
return 0;
}
+int ViERTP_RTCPImpl::SetMinTransmitBitrate(int video_channel,
+ int min_transmit_bitrate_kbps) {
+ ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
+ ViEEncoder* vie_encoder = cs.Encoder(video_channel);
+ if (vie_encoder == NULL)
+ return -1;
+ vie_encoder->SetMinTransmitBitrate(min_transmit_bitrate_kbps);
+ return 0;
+}
+
int ViERTP_RTCPImpl::GetReceiveChannelRtcpStatistics(
const int video_channel,
RtcpStatistics& basic_stats,
diff --git a/webrtc/video_engine/vie_rtp_rtcp_impl.h b/webrtc/video_engine/vie_rtp_rtcp_impl.h
index 227fa5e..3120bee 100644
--- a/webrtc/video_engine/vie_rtp_rtcp_impl.h
+++ b/webrtc/video_engine/vie_rtp_rtcp_impl.h
@@ -90,6 +90,8 @@
int id);
virtual int SetRtcpXrRrtrStatus(int video_channel, bool enable);
virtual int SetTransmissionSmoothingStatus(int video_channel, bool enable);
+ virtual int SetMinTransmitBitrate(int video_channel,
+ int min_transmit_bitrate_kbps);
virtual int GetReceiveChannelRtcpStatistics(const int video_channel,
RtcpStatistics& basic_stats,
int& rtt_ms) const;
diff --git a/webrtc/video_send_stream.h b/webrtc/video_send_stream.h
index c3140c0..5a4c89d 100644
--- a/webrtc/video_send_stream.h
+++ b/webrtc/video_send_stream.h
@@ -68,13 +68,20 @@
static const size_t kDefaultMaxPacketSize = 1500 - 40; // TCP over IPv4.
struct Rtp {
- Rtp() : max_packet_size(kDefaultMaxPacketSize) {}
+ Rtp()
+ : max_packet_size(kDefaultMaxPacketSize),
+ min_transmit_bitrate_kbps(0) {}
std::vector<uint32_t> ssrcs;
// Max RTP packet size delivered to send transport from VideoEngine.
size_t max_packet_size;
+ // Padding will be used up to this bitrate regardless of the bitrate
+ // produced by the encoder. Padding above what's actually produced by the
+ // encoder helps maintaining a higher bitrate estimate.
+ int min_transmit_bitrate_kbps;
+
// RTP header extensions to use for this send stream.
std::vector<RtpExtension> extensions;
