From 3f83f9cae99b605aee71b46839e902653baeb3f6 Mon Sep 17 00:00:00 2001 From: "pbos@webrtc.org" Date: Thu, 13 Mar 2014 12:52:27 +0000 Subject: 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/webrtc@5694 4adac7df-926f-26a2-2b94-8c16560cd09d --- test/fake_encoder.cc | 29 ++++++++++++++++++++--------- test/fake_encoder.h | 8 +++----- test/rtp_rtcp_observer.h | 4 ++-- 3 files changed, 25 insertions(+), 16 deletions(-) (limited to 'test') diff --git a/test/fake_encoder.cc b/test/fake_encoder.cc index f4e5227e..fc8712e5 100644 --- a/test/fake_encoder.cc +++ b/test/fake_encoder.cc @@ -19,6 +19,7 @@ FakeEncoder::FakeEncoder(Clock* clock) : 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 @@ void FakeEncoder::SetCodecSettings(VideoCodec* codec, 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 @@ int32_t FakeEncoder::Encode( const CodecSpecificInfo* codec_specific_info, const std::vector* 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 @@ int32_t FakeEncoder::Encode( 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 @@ int32_t FakeEncoder::Encode( 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 @@ int32_t FakeEncoder::SetRates(uint32_t new_target_bitrate, uint32_t framerate) { target_bitrate_kbps_ = new_target_bitrate; return 0; } + } // namespace test } // namespace webrtc diff --git a/test/fake_encoder.h b/test/fake_encoder.h index c57a4dce..e2d8d6b4 100644 --- a/test/fake_encoder.h +++ b/test/fake_encoder.h @@ -25,23 +25,20 @@ class FakeEncoder : public VideoEncoder { 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* 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 @@ class FakeEncoder : public VideoEncoder { 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/test/rtp_rtcp_observer.h b/test/rtp_rtcp_observer.h index 5ed9a3f3..00422cce 100644 --- a/test/rtp_rtcp_observer.h +++ b/test/rtp_rtcp_observer.h @@ -33,8 +33,8 @@ class RtpRtcpObserver { 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); } -- cgit v1.2.3