diff options
author | andresp@webrtc.org <andresp@webrtc.org@4adac7df-926f-26a2-2b94-8c16560cd09d> | 2013-05-14 12:10:58 +0000 |
---|---|---|
committer | andresp@webrtc.org <andresp@webrtc.org@4adac7df-926f-26a2-2b94-8c16560cd09d> | 2013-05-14 12:10:58 +0000 |
commit | 0425392858172d13eb65a1143a12c2787cea4b1b (patch) | |
tree | e8bacf2c09f1030d648e4788ad046100131b6df0 | |
parent | 5ba433cad0d4ab117ce24862c4f0cd30015ab096 (diff) | |
download | webrtc-0425392858172d13eb65a1143a12c2787cea4b1b.tar.gz |
Adding a factory to remote bitrate estimator and allow it to be set via config.
Additionally:
- clean api to set remote bitrate estimator mode.
- clean api to set over use detector options.
R=mflodman@webrtc.org, stefan@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/1448006
git-svn-id: http://webrtc.googlecode.com/svn/trunk/webrtc@4027 4adac7df-926f-26a2-2b94-8c16560cd09d
21 files changed, 197 insertions, 369 deletions
diff --git a/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h b/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h index fa1129f2..80b2759c 100644 --- a/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h +++ b/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h @@ -39,17 +39,8 @@ class RemoteBitrateObserver { class RemoteBitrateEstimator : public CallStatsObserver, public Module { public: - enum EstimationMode { - kMultiStreamEstimation, - kSingleStreamEstimation - }; - virtual ~RemoteBitrateEstimator() {} - static RemoteBitrateEstimator* Create(const OverUseDetectorOptions& options, - EstimationMode mode, - RemoteBitrateObserver* observer, - Clock* clock); // Stores an RTCP SR (NTP, RTP timestamp) tuple for a specific SSRC to be used // in future RTP timestamp to NTP time conversions. As soon as any SSRC has @@ -80,6 +71,24 @@ class RemoteBitrateEstimator : public CallStatsObserver, public Module { static const int kStreamTimeOutMs = 2000; }; +struct RemoteBitrateEstimatorFactory { + RemoteBitrateEstimatorFactory() {} + virtual ~RemoteBitrateEstimatorFactory() {} + + virtual RemoteBitrateEstimator* Create( + RemoteBitrateObserver* observer, + Clock* clock) const; +}; + +struct MultiStreamRemoteBitrateEstimatorFactory + : RemoteBitrateEstimatorFactory { + MultiStreamRemoteBitrateEstimatorFactory() {} + virtual ~MultiStreamRemoteBitrateEstimatorFactory() {} + + virtual RemoteBitrateEstimator* Create( + RemoteBitrateObserver* observer, + Clock* clock) const; +}; } // namespace webrtc #endif // WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_INCLUDE_REMOTE_BITRATE_ESTIMATOR_H_ diff --git a/modules/remote_bitrate_estimator/remote_bitrate_estimator.gypi b/modules/remote_bitrate_estimator/remote_bitrate_estimator.gypi index 6ee7f10d..c5c3cfe0 100644 --- a/modules/remote_bitrate_estimator/remote_bitrate_estimator.gypi +++ b/modules/remote_bitrate_estimator/remote_bitrate_estimator.gypi @@ -36,9 +36,7 @@ 'bitrate_estimator.h', 'overuse_detector.cc', 'overuse_detector.h', - 'remote_bitrate_estimator_multi_stream.h', 'remote_bitrate_estimator_multi_stream.cc', - 'remote_bitrate_estimator_single_stream.h', 'remote_bitrate_estimator_single_stream.cc', 'remote_rate_control.cc', 'remote_rate_control.h', diff --git a/modules/remote_bitrate_estimator/remote_bitrate_estimator_multi_stream.cc b/modules/remote_bitrate_estimator/remote_bitrate_estimator_multi_stream.cc index a69a899d..cebe48b4 100644 --- a/modules/remote_bitrate_estimator/remote_bitrate_estimator_multi_stream.cc +++ b/modules/remote_bitrate_estimator/remote_bitrate_estimator_multi_stream.cc @@ -8,36 +8,91 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_multi_stream.h" +#include <map> +#include "webrtc/modules/remote_bitrate_estimator/bitrate_estimator.h" +#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" #include "webrtc/modules/remote_bitrate_estimator/include/rtp_to_ntp.h" -#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h" +#include "webrtc/modules/remote_bitrate_estimator/overuse_detector.h" +#include "webrtc/modules/remote_bitrate_estimator/remote_rate_control.h" #include "webrtc/system_wrappers/interface/clock.h" +#include "webrtc/system_wrappers/interface/constructor_magic.h" +#include "webrtc/system_wrappers/interface/critical_section_wrapper.h" +#include "webrtc/system_wrappers/interface/scoped_ptr.h" #include "webrtc/system_wrappers/interface/tick_util.h" +#include "webrtc/typedefs.h" namespace webrtc { +namespace { +class RemoteBitrateEstimatorMultiStream : public RemoteBitrateEstimator { + public: + RemoteBitrateEstimatorMultiStream(RemoteBitrateObserver* observer, + Clock* clock); -RemoteBitrateEstimator* RemoteBitrateEstimator::Create( - const OverUseDetectorOptions& options, - EstimationMode mode, - RemoteBitrateObserver* observer, - Clock* clock) { - switch (mode) { - case kMultiStreamEstimation: - return new RemoteBitrateEstimatorMultiStream(options, observer, clock); - case kSingleStreamEstimation: - return new RemoteBitrateEstimatorSingleStream(options, observer, clock); - } - return NULL; -} + ~RemoteBitrateEstimatorMultiStream() {} + + // Stores an RTCP SR (NTP, RTP timestamp) tuple for a specific SSRC to be used + // in future RTP timestamp to NTP time conversions. As soon as any SSRC has + // two tuples the RemoteBitrateEstimator will switch to multi-stream mode. + void IncomingRtcp(unsigned int ssrc, uint32_t ntp_secs, uint32_t ntp_frac, + uint32_t rtp_timestamp); + + // Called for each incoming packet. The first SSRC will immediately be used + // for over-use detection. Subsequent SSRCs will only be used when at least + // two RTCP SR reports with the same SSRC have been received. Updates the + // incoming payload bitrate estimate and the over-use detector. + // If an over-use is detected the remote bitrate estimate will be updated. + // Note that |payload_size| is the packet size excluding headers. + void IncomingPacket(unsigned int ssrc, + int payload_size, + int64_t arrival_time, + uint32_t rtp_timestamp); + + // Triggers a new estimate calculation. + // Implements the Module interface. + virtual int32_t Process(); + virtual int32_t TimeUntilNextProcess(); + // Set the current round-trip time experienced by the stream. + // Implements the StatsObserver interface. + virtual void OnRttUpdate(uint32_t rtt); + + // Removes all data for |ssrc|. + void RemoveStream(unsigned int ssrc); + + // Returns true if a valid estimate exists and sets |bitrate_bps| to the + // estimated payload bitrate in bits per second. |ssrcs| is the list of ssrcs + // currently being received and of which the bitrate estimate is based upon. + bool LatestEstimate(std::vector<unsigned int>* ssrcs, + unsigned int* bitrate_bps) const; + + private: + typedef std::map<unsigned int, synchronization::RtcpList> StreamMap; + + // Triggers a new estimate calculation. + void UpdateEstimate(int64_t time_now); + + void GetSsrcs(std::vector<unsigned int>* ssrcs) const; + + Clock* clock_; + RemoteRateControl remote_rate_; + OveruseDetector overuse_detector_; + BitRateStats incoming_bitrate_; + RemoteBitrateObserver* observer_; + StreamMap streams_; + scoped_ptr<CriticalSectionWrapper> crit_sect_; + unsigned int initial_ssrc_; + bool multi_stream_; + int32_t last_process_time_; + + DISALLOW_COPY_AND_ASSIGN(RemoteBitrateEstimatorMultiStream); +}; RemoteBitrateEstimatorMultiStream::RemoteBitrateEstimatorMultiStream( - const OverUseDetectorOptions& options, RemoteBitrateObserver* observer, Clock* clock) : clock_(clock), remote_rate_(), - overuse_detector_(options), + overuse_detector_(OverUseDetectorOptions()), incoming_bitrate_(), observer_(observer), streams_(), @@ -203,5 +258,11 @@ void RemoteBitrateEstimatorMultiStream::GetSsrcs( (*ssrcs)[i] = it->first; } } +} // namespace +RemoteBitrateEstimator* MultiStreamRemoteBitrateEstimatorFactory::Create( + RemoteBitrateObserver* observer, + Clock* clock) const { + return new RemoteBitrateEstimatorMultiStream(observer, clock); +} } // namespace webrtc diff --git a/modules/remote_bitrate_estimator/remote_bitrate_estimator_multi_stream.h b/modules/remote_bitrate_estimator/remote_bitrate_estimator_multi_stream.h deleted file mode 100644 index 713b961b..00000000 --- a/modules/remote_bitrate_estimator/remote_bitrate_estimator_multi_stream.h +++ /dev/null @@ -1,98 +0,0 @@ -/* - * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -// This class estimates the incoming available bandwidth. - -#ifndef WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_INCLUDE_REMOTE_BITRATE_ESTIMATOR_IMPL_H_ -#define WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_INCLUDE_REMOTE_BITRATE_ESTIMATOR_IMPL_H_ - -#include <map> - -#include "modules/remote_bitrate_estimator/bitrate_estimator.h" -#include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" -#include "modules/remote_bitrate_estimator/include/rtp_to_ntp.h" -#include "modules/remote_bitrate_estimator/overuse_detector.h" -#include "modules/remote_bitrate_estimator/remote_rate_control.h" -#include "system_wrappers/interface/constructor_magic.h" -#include "system_wrappers/interface/critical_section_wrapper.h" -#include "system_wrappers/interface/scoped_ptr.h" -#include "typedefs.h" - -namespace webrtc { - -class Clock; - -class RemoteBitrateEstimatorMultiStream : public RemoteBitrateEstimator { - public: - RemoteBitrateEstimatorMultiStream(const OverUseDetectorOptions& options, - RemoteBitrateObserver* observer, - Clock* clock); - - ~RemoteBitrateEstimatorMultiStream() {} - - // Stores an RTCP SR (NTP, RTP timestamp) tuple for a specific SSRC to be used - // in future RTP timestamp to NTP time conversions. As soon as any SSRC has - // two tuples the RemoteBitrateEstimator will switch to multi-stream mode. - void IncomingRtcp(unsigned int ssrc, uint32_t ntp_secs, uint32_t ntp_frac, - uint32_t rtp_timestamp); - - // Called for each incoming packet. The first SSRC will immediately be used - // for over-use detection. Subsequent SSRCs will only be used when at least - // two RTCP SR reports with the same SSRC have been received. Updates the - // incoming payload bitrate estimate and the over-use detector. - // If an over-use is detected the remote bitrate estimate will be updated. - // Note that |payload_size| is the packet size excluding headers. - void IncomingPacket(unsigned int ssrc, - int payload_size, - int64_t arrival_time, - uint32_t rtp_timestamp); - - // Triggers a new estimate calculation. - // Implements the Module interface. - virtual int32_t Process(); - virtual int32_t TimeUntilNextProcess(); - // Set the current round-trip time experienced by the stream. - // Implements the StatsObserver interface. - virtual void OnRttUpdate(uint32_t rtt); - - // Removes all data for |ssrc|. - void RemoveStream(unsigned int ssrc); - - // Returns true if a valid estimate exists and sets |bitrate_bps| to the - // estimated payload bitrate in bits per second. |ssrcs| is the list of ssrcs - // currently being received and of which the bitrate estimate is based upon. - bool LatestEstimate(std::vector<unsigned int>* ssrcs, - unsigned int* bitrate_bps) const; - - private: - typedef std::map<unsigned int, synchronization::RtcpList> StreamMap; - - // Triggers a new estimate calculation. - void UpdateEstimate(int64_t time_now); - - void GetSsrcs(std::vector<unsigned int>* ssrcs) const; - - Clock* clock_; - RemoteRateControl remote_rate_; - OveruseDetector overuse_detector_; - BitRateStats incoming_bitrate_; - RemoteBitrateObserver* observer_; - StreamMap streams_; - scoped_ptr<CriticalSectionWrapper> crit_sect_; - unsigned int initial_ssrc_; - bool multi_stream_; - int32_t last_process_time_; - - DISALLOW_COPY_AND_ASSIGN(RemoteBitrateEstimatorMultiStream); -}; - -} // namespace webrtc - -#endif // WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_INCLUDE_REMOTE_BITRATE_ESTIMATOR_IMPL_H_ diff --git a/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc b/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc index 6098b2f0..d79aad8e 100644 --- a/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc +++ b/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc @@ -8,18 +8,75 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h" +#include <map> +#include "webrtc/modules/remote_bitrate_estimator/bitrate_estimator.h" +#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" +#include "webrtc/modules/remote_bitrate_estimator/overuse_detector.h" +#include "webrtc/modules/remote_bitrate_estimator/remote_rate_control.h" #include "webrtc/system_wrappers/interface/clock.h" +#include "webrtc/system_wrappers/interface/critical_section_wrapper.h" +#include "webrtc/system_wrappers/interface/scoped_ptr.h" +#include "webrtc/typedefs.h" namespace webrtc { +namespace { +class RemoteBitrateEstimatorSingleStream : public RemoteBitrateEstimator { + public: + RemoteBitrateEstimatorSingleStream(RemoteBitrateObserver* observer, + Clock* clock); + + void IncomingRtcp(unsigned int ssrc, uint32_t ntp_secs, uint32_t ntp_frac, + uint32_t rtp_timestamp) {} + + // Called for each incoming packet. If this is a new SSRC, a new + // BitrateControl will be created. Updates the incoming payload bitrate + // estimate and the over-use detector. If an over-use is detected the + // remote bitrate estimate will be updated. Note that |payload_size| is the + // packet size excluding headers. + void IncomingPacket(unsigned int ssrc, + int payload_size, + int64_t arrival_time, + uint32_t rtp_timestamp); + + // Triggers a new estimate calculation. + // Implements the Module interface. + virtual int32_t Process(); + virtual int32_t TimeUntilNextProcess(); + // Set the current round-trip time experienced by the stream. + // Implements the StatsObserver interface. + virtual void OnRttUpdate(uint32_t rtt); + + // Removes all data for |ssrc|. + void RemoveStream(unsigned int ssrc); + + // Returns true if a valid estimate exists and sets |bitrate_bps| to the + // estimated payload bitrate in bits per second. |ssrcs| is the list of ssrcs + // currently being received and of which the bitrate estimate is based upon. + bool LatestEstimate(std::vector<unsigned int>* ssrcs, + unsigned int* bitrate_bps) const; + + private: + typedef std::map<unsigned int, OveruseDetector> SsrcOveruseDetectorMap; + + // Triggers a new estimate calculation. + void UpdateEstimate(int64_t time_now); + + void GetSsrcs(std::vector<unsigned int>* ssrcs) const; + + Clock* clock_; + SsrcOveruseDetectorMap overuse_detectors_; + BitRateStats incoming_bitrate_; + RemoteRateControl remote_rate_; + RemoteBitrateObserver* observer_; + scoped_ptr<CriticalSectionWrapper> crit_sect_; + int64_t last_process_time_; +}; RemoteBitrateEstimatorSingleStream::RemoteBitrateEstimatorSingleStream( - const OverUseDetectorOptions& options, RemoteBitrateObserver* observer, Clock* clock) - : options_(options), - clock_(clock), + : clock_(clock), observer_(observer), crit_sect_(CriticalSectionWrapper::CreateCriticalSection()), last_process_time_(-1) { @@ -42,7 +99,7 @@ void RemoteBitrateEstimatorSingleStream::IncomingPacket( // group. std::pair<SsrcOveruseDetectorMap::iterator, bool> insert_result = overuse_detectors_.insert(std::make_pair(ssrc, OveruseDetector( - options_))); + OverUseDetectorOptions()))); it = insert_result.first; } OveruseDetector* overuse_detector = &it->second; @@ -159,5 +216,11 @@ void RemoteBitrateEstimatorSingleStream::GetSsrcs( (*ssrcs)[i] = it->first; } } +} // namespace +RemoteBitrateEstimator* RemoteBitrateEstimatorFactory::Create( + RemoteBitrateObserver* observer, + Clock* clock) const { + return new RemoteBitrateEstimatorSingleStream(observer, clock); +} } // namespace webrtc diff --git a/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h b/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h deleted file mode 100644 index 575ed09c..00000000 --- a/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h +++ /dev/null @@ -1,88 +0,0 @@ -/* - * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -// This class estimates the incoming available bandwidth. - -#ifndef WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_INCLUDE_REMOTE_BITRATE_ESTIMATOR_SINGLE_STREAM_H_ -#define WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_INCLUDE_REMOTE_BITRATE_ESTIMATOR_SINGLE_STREAM_H_ - -#include <map> - -#include "webrtc/modules/remote_bitrate_estimator/bitrate_estimator.h" -#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" -#include "webrtc/modules/remote_bitrate_estimator/overuse_detector.h" -#include "webrtc/modules/remote_bitrate_estimator/remote_rate_control.h" -#include "webrtc/system_wrappers/interface/critical_section_wrapper.h" -#include "webrtc/system_wrappers/interface/scoped_ptr.h" -#include "webrtc/typedefs.h" - -namespace webrtc { - -class Clock; - -class RemoteBitrateEstimatorSingleStream : public RemoteBitrateEstimator { - public: - RemoteBitrateEstimatorSingleStream(const OverUseDetectorOptions& options, - RemoteBitrateObserver* observer, - Clock* clock); - - virtual ~RemoteBitrateEstimatorSingleStream() {} - - void IncomingRtcp(unsigned int ssrc, uint32_t ntp_secs, uint32_t ntp_frac, - uint32_t rtp_timestamp) {} - - // Called for each incoming packet. If this is a new SSRC, a new - // BitrateControl will be created. Updates the incoming payload bitrate - // estimate and the over-use detector. If an over-use is detected the - // remote bitrate estimate will be updated. Note that |payload_size| is the - // packet size excluding headers. - void IncomingPacket(unsigned int ssrc, - int payload_size, - int64_t arrival_time, - uint32_t rtp_timestamp); - - // Triggers a new estimate calculation. - // Implements the Module interface. - virtual int32_t Process(); - virtual int32_t TimeUntilNextProcess(); - // Set the current round-trip time experienced by the stream. - // Implements the StatsObserver interface. - virtual void OnRttUpdate(uint32_t rtt); - - // Removes all data for |ssrc|. - void RemoveStream(unsigned int ssrc); - - // Returns true if a valid estimate exists and sets |bitrate_bps| to the - // estimated payload bitrate in bits per second. |ssrcs| is the list of ssrcs - // currently being received and of which the bitrate estimate is based upon. - bool LatestEstimate(std::vector<unsigned int>* ssrcs, - unsigned int* bitrate_bps) const; - - private: - typedef std::map<unsigned int, OveruseDetector> SsrcOveruseDetectorMap; - - // Triggers a new estimate calculation. - void UpdateEstimate(int64_t time_now); - - void GetSsrcs(std::vector<unsigned int>* ssrcs) const; - - const OverUseDetectorOptions& options_; - Clock* clock_; - SsrcOveruseDetectorMap overuse_detectors_; - BitRateStats incoming_bitrate_; - RemoteRateControl remote_rate_; - RemoteBitrateObserver* observer_; - scoped_ptr<CriticalSectionWrapper> crit_sect_; - int64_t last_process_time_; -}; - -} // namespace webrtc - -#endif // WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_INCLUDE_REMOTE_BITRATE_ESTIMATOR_SINGLE_STREAM_H_ diff --git a/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc b/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc index f8801941..3c87e4d0 100644 --- a/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc +++ b/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc @@ -195,9 +195,7 @@ RemoteBitrateEstimatorTest::RemoteBitrateEstimatorTest(bool align_streams) void RemoteBitrateEstimatorTest::SetUp() { bitrate_observer_.reset(new testing::TestBitrateObserver); bitrate_estimator_.reset( - RemoteBitrateEstimator::Create( - overuse_detector_options_, - RemoteBitrateEstimator::kSingleStreamEstimation, + RemoteBitrateEstimatorFactory().Create( bitrate_observer_.get(), &clock_)); stream_generator_.reset(new testing::StreamGenerator( diff --git a/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc b/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc index 994361f4..de9069f9 100644 --- a/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc +++ b/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc @@ -62,11 +62,10 @@ class RtcpFormatRembTest : public ::testing::Test { : over_use_detector_options_(), system_clock_(Clock::GetRealTimeClock()), remote_bitrate_observer_(), - remote_bitrate_estimator_(RemoteBitrateEstimator::Create( - over_use_detector_options_, - RemoteBitrateEstimator::kSingleStreamEstimation, - &remote_bitrate_observer_, - system_clock_)) {} + remote_bitrate_estimator_( + RemoteBitrateEstimatorFactory().Create( + &remote_bitrate_observer_, + system_clock_)) {} virtual void SetUp(); virtual void TearDown(); diff --git a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc index b0f5c206..0595010a 100644 --- a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc +++ b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc @@ -171,9 +171,7 @@ class RtcpReceiverTest : public ::testing::Test { system_clock_(1335900000), remote_bitrate_observer_(), remote_bitrate_estimator_( - RemoteBitrateEstimator::Create( - over_use_detector_options_, - RemoteBitrateEstimator::kSingleStreamEstimation, + RemoteBitrateEstimatorFactory().Create( &remote_bitrate_observer_, &system_clock_)) { test_transport_ = new TestTransport(); diff --git a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc index 74dd91de..a5726d3f 100644 --- a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc +++ b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc @@ -277,9 +277,7 @@ class RtcpSenderTest : public ::testing::Test { system_clock_(Clock::GetRealTimeClock()), remote_bitrate_observer_(), remote_bitrate_estimator_( - RemoteBitrateEstimator::Create( - over_use_detector_options_, - RemoteBitrateEstimator::kSingleStreamEstimation, + RemoteBitrateEstimatorFactory().Create( &remote_bitrate_observer_, system_clock_)) { test_transport_ = new TestTransport(); diff --git a/video_engine/include/vie_rtp_rtcp.h b/video_engine/include/vie_rtp_rtcp.h index b1fd90c5..cff180b3 100644 --- a/video_engine/include/vie_rtp_rtcp.h +++ b/video_engine/include/vie_rtp_rtcp.h @@ -232,10 +232,6 @@ class WEBRTC_DLLEXPORT ViERTP_RTCP { bool sender, bool receiver) = 0; - // Sets the bandwidth estimation mode. This can only be changed before - // adding a channel. - virtual int SetBandwidthEstimationMode(BandwidthEstimationMode mode) = 0; - // Enables RTP timestamp extension offset described in RFC 5450. This call // must be done before ViECodec::SetSendCodec is called. virtual int SetSendTimestampOffsetStatus(int video_channel, diff --git a/video_engine/test/auto_test/source/vie_autotest_loopback.cc b/video_engine/test/auto_test/source/vie_autotest_loopback.cc index 29162491..6bfe3f95 100644 --- a/video_engine/test/auto_test/source/vie_autotest_loopback.cc +++ b/video_engine/test/auto_test/source/vie_autotest_loopback.cc @@ -100,33 +100,6 @@ int VideoEngineSampleCode(void* window1, void* window2) return -1; } - printf("Bandwidth estimation modes:\n"); - printf("1. Single-stream bandwidth estimation\n"); - printf("2. Multi-stream bandwidth estimation\n"); - printf("Choose bandwidth estimation mode (default is 1): "); - std::string str; - std::getline(std::cin, str); - int bwe_mode_choice = atoi(str.c_str()); - webrtc::BandwidthEstimationMode bwe_mode; - switch (bwe_mode_choice) { - case 1: - bwe_mode = webrtc::kViESingleStreamEstimation; - break; - case 2: - bwe_mode = webrtc::kViEMultiStreamEstimation; - break; - default: - bwe_mode = webrtc::kViESingleStreamEstimation; - break; - } - - error = ptrViERtpRtcp->SetBandwidthEstimationMode(bwe_mode); - if (error == -1) - { - printf("ERROR in ViERTP_RTCP::SetBandwidthEstimationMode\n"); - return -1; - } - int videoChannel = -1; error = ptrViEBase->CreateChannel(videoChannel); if (error == -1) @@ -375,6 +348,7 @@ int VideoEngineSampleCode(void* window1, void* window2) } // Set spatial resolution option + std::string str; std::cout << std::endl; std::cout << "Enter frame size option (default is CIF):" << std::endl; std::cout << "1. QCIF (176X144) " << std::endl; diff --git a/video_engine/test/auto_test/source/vie_autotest_rtp_rtcp.cc b/video_engine/test/auto_test/source/vie_autotest_rtp_rtcp.cc index 6ec57dfd..c0832cdc 100644 --- a/video_engine/test/auto_test/source/vie_autotest_rtp_rtcp.cc +++ b/video_engine/test/auto_test/source/vie_autotest_rtp_rtcp.cc @@ -536,19 +536,9 @@ void ViEAutoTest::ViERtpRtcpAPITest() // Create VIE TbInterfaces ViE("ViERtpRtcpAPITest"); - // Verify that we can set the bandwidth estimation mode, as that API only - // is valid to call before creating channels. - EXPECT_EQ(0, ViE.rtp_rtcp->SetBandwidthEstimationMode( - webrtc::kViESingleStreamEstimation)); - // Create a video channel TbVideoChannel tbChannel(ViE, webrtc::kVideoCodecVP8); - EXPECT_EQ(-1, ViE.rtp_rtcp->SetBandwidthEstimationMode( - webrtc::kViESingleStreamEstimation)); - EXPECT_EQ(-1, ViE.rtp_rtcp->SetBandwidthEstimationMode( - webrtc::kViEMultiStreamEstimation)); - // Create a capture device TbCaptureDevice tbCapture(ViE); tbCapture.ConnectTo(tbChannel.videoChannel); diff --git a/video_engine/test/auto_test/source/vie_autotest_simulcast.cc b/video_engine/test/auto_test/source/vie_autotest_simulcast.cc index 5c01cbf9..1363c352 100644 --- a/video_engine/test/auto_test/source/vie_autotest_simulcast.cc +++ b/video_engine/test/auto_test/source/vie_autotest_simulcast.cc @@ -145,32 +145,6 @@ int VideoEngineSimulcastTest(void* window1, void* window2) { return -1; } - printf("Bandwidth estimation modes:\n"); - printf("1. Single-stream bandwidth estimation\n"); - printf("2. Multi-stream bandwidth estimation\n"); - printf("Choose bandwidth estimation mode (default is 1): "); - std::string str; - std::getline(std::cin, str); - int bwe_mode_choice = atoi(str.c_str()); - webrtc::BandwidthEstimationMode bwe_mode; - switch (bwe_mode_choice) { - case 1: - bwe_mode = webrtc::kViESingleStreamEstimation; - break; - case 2: - bwe_mode = webrtc::kViEMultiStreamEstimation; - break; - default: - bwe_mode = webrtc::kViESingleStreamEstimation; - break; - } - - error = vie_rtp_rtcp->SetBandwidthEstimationMode(bwe_mode); - if (error == -1) { - printf("ERROR in ViERTP_RTCP::SetBandwidthEstimationMode\n"); - return -1; - } - int video_channel = -1; error = vie_base->CreateChannel(video_channel); if (error == -1) { @@ -392,6 +366,7 @@ int VideoEngineSimulcastTest(void* window1, void* window2) { } // Set start bit rate. + std::string str; std::cout << std::endl; std::cout << "Choose start rate (in kbps). Press enter for default: "; std::getline(std::cin, str); diff --git a/video_engine/vie_channel_group.cc b/video_engine/vie_channel_group.cc index 1a78659f..1b4484fa 100644 --- a/video_engine/vie_channel_group.cc +++ b/video_engine/vie_channel_group.cc @@ -8,29 +8,30 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "video_engine/vie_channel_group.h" +#include "webrtc/video_engine/vie_channel_group.h" -#include "modules/bitrate_controller/include/bitrate_controller.h" -#include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" -#include "modules/rtp_rtcp/interface/rtp_rtcp.h" -#include "modules/utility/interface/process_thread.h" -#include "video_engine/call_stats.h" -#include "video_engine/encoder_state_feedback.h" -#include "video_engine/vie_channel.h" -#include "video_engine/vie_encoder.h" -#include "video_engine/vie_remb.h" +#include "webrtc/common.h" +#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h" +#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" +#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" +#include "webrtc/modules/utility/interface/process_thread.h" +#include "webrtc/video_engine/call_stats.h" +#include "webrtc/video_engine/encoder_state_feedback.h" +#include "webrtc/video_engine/vie_channel.h" +#include "webrtc/video_engine/vie_encoder.h" +#include "webrtc/video_engine/vie_remb.h" namespace webrtc { ChannelGroup::ChannelGroup(ProcessThread* process_thread, - const OverUseDetectorOptions& options, - RemoteBitrateEstimator::EstimationMode mode, const Config& config) : remb_(new VieRemb()), bitrate_controller_(BitrateController::CreateBitrateController()), call_stats_(new CallStats()), - remote_bitrate_estimator_(RemoteBitrateEstimator::Create( - options, mode, remb_.get(), Clock::GetRealTimeClock())), + remote_bitrate_estimator_( + config.Get<RemoteBitrateEstimatorFactory>().Create( + remb_.get(), + Clock::GetRealTimeClock())), encoder_state_feedback_(new EncoderStateFeedback()), process_thread_(process_thread) { call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get()); diff --git a/video_engine/vie_channel_group.h b/video_engine/vie_channel_group.h index 6a313680..7d4fc2b8 100644 --- a/video_engine/vie_channel_group.h +++ b/video_engine/vie_channel_group.h @@ -13,7 +13,6 @@ #include <set> -#include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" #include "system_wrappers/interface/scoped_ptr.h" namespace webrtc { @@ -22,8 +21,8 @@ class BitrateController; class CallStats; class Config; class EncoderStateFeedback; -struct OverUseDetectorOptions; class ProcessThread; +class RemoteBitrateEstimator; class ViEChannel; class ViEEncoder; class VieRemb; @@ -33,8 +32,6 @@ class VieRemb; class ChannelGroup { public: ChannelGroup(ProcessThread* process_thread, - const OverUseDetectorOptions& options, - RemoteBitrateEstimator::EstimationMode mode, const Config& config); ~ChannelGroup(); diff --git a/video_engine/vie_channel_manager.cc b/video_engine/vie_channel_manager.cc index 874b16f8..7f74afd1 100644 --- a/video_engine/vie_channel_manager.cc +++ b/video_engine/vie_channel_manager.cc @@ -29,7 +29,6 @@ namespace webrtc { ViEChannelManager::ViEChannelManager( int engine_id, int number_of_cores, - const OverUseDetectorOptions& options, const Config& config) : channel_id_critsect_(CriticalSectionWrapper::CreateCriticalSection()), engine_id_(engine_id), @@ -39,8 +38,6 @@ ViEChannelManager::ViEChannelManager( voice_sync_interface_(NULL), voice_engine_(NULL), module_process_thread_(NULL), - over_use_detector_options_(options), - bwe_mode_(RemoteBitrateEstimator::kSingleStreamEstimation), config_(config) { WEBRTC_TRACE(kTraceMemory, kTraceVideo, ViEId(engine_id), "ViEChannelManager::ViEChannelManager(engine_id: %d)", @@ -94,8 +91,6 @@ int ViEChannelManager::CreateChannel(int* channel_id) { // Create a new channel group and add this channel. ChannelGroup* group = new ChannelGroup(module_process_thread_, - over_use_detector_options_, - bwe_mode_, config_); BitrateController* bitrate_controller = group->GetBitrateController(); ViEEncoder* vie_encoder = new ViEEncoder(engine_id_, new_channel_id, @@ -372,26 +367,6 @@ bool ViEChannelManager::SetRembStatus(int channel_id, bool sender, return group->SetChannelRembStatus(channel_id, sender, receiver, channel); } -bool ViEChannelManager::SetBandwidthEstimationMode( - BandwidthEstimationMode mode) { - CriticalSectionScoped cs(channel_id_critsect_); - if (channel_groups_.size() > 0) { - return false; - } - switch (mode) { - case kViEMultiStreamEstimation: - bwe_mode_ = RemoteBitrateEstimator::kMultiStreamEstimation; - break; - case kViESingleStreamEstimation: - bwe_mode_ = RemoteBitrateEstimator::kSingleStreamEstimation; - break; - default: - assert(false); - return false; - } - return true; -} - void ViEChannelManager::UpdateSsrcs(int channel_id, const std::list<unsigned int>& ssrcs) { CriticalSectionScoped cs(channel_id_critsect_); diff --git a/video_engine/vie_channel_manager.h b/video_engine/vie_channel_manager.h index a093b85b..19932136 100644 --- a/video_engine/vie_channel_manager.h +++ b/video_engine/vie_channel_manager.h @@ -14,14 +14,14 @@ #include <list> #include <map> -#include "engine_configurations.h" // NOLINT -#include "system_wrappers/interface/scoped_ptr.h" -#include "typedefs.h" // NOLINT -#include "video_engine/include/vie_rtp_rtcp.h" -#include "video_engine/vie_channel_group.h" -#include "video_engine/vie_defines.h" -#include "video_engine/vie_manager_base.h" -#include "video_engine/vie_remb.h" +#include "webrtc/engine_configurations.h" +#include "webrtc/system_wrappers/interface/scoped_ptr.h" +#include "webrtc/typedefs.h" +#include "webrtc/video_engine/include/vie_rtp_rtcp.h" +#include "webrtc/video_engine/vie_channel_group.h" +#include "webrtc/video_engine/vie_defines.h" +#include "webrtc/video_engine/vie_manager_base.h" +#include "webrtc/video_engine/vie_remb.h" namespace webrtc { @@ -45,7 +45,6 @@ class ViEChannelManager: private ViEManagerBase { public: ViEChannelManager(int engine_id, int number_of_cores, - const OverUseDetectorOptions& options, const Config& config); ~ViEChannelManager(); @@ -76,10 +75,6 @@ class ViEChannelManager: private ViEManagerBase { // Adds a channel to include when sending REMB. bool SetRembStatus(int channel_id, bool sender, bool receiver); - // Sets the bandwidth estimation mode. This can only be changed before - // adding a channel. - bool SetBandwidthEstimationMode(BandwidthEstimationMode mode); - // Updates the SSRCs for a channel. If one of the SSRCs already is registered, // it will simply be ignored and no error is returned. void UpdateSsrcs(int channel_id, const std::list<unsigned int>& ssrcs); @@ -137,8 +132,6 @@ class ViEChannelManager: private ViEManagerBase { VoiceEngine* voice_engine_; ProcessThread* module_process_thread_; - const OverUseDetectorOptions& over_use_detector_options_; - RemoteBitrateEstimator::EstimationMode bwe_mode_; const Config& config_; }; diff --git a/video_engine/vie_rtp_rtcp_impl.cc b/video_engine/vie_rtp_rtcp_impl.cc index 5a4d5288..a58f8a02 100644 --- a/video_engine/vie_rtp_rtcp_impl.cc +++ b/video_engine/vie_rtp_rtcp_impl.cc @@ -718,15 +718,6 @@ int ViERTP_RTCPImpl::SetRembStatus(int video_channel, bool sender, return 0; } -int ViERTP_RTCPImpl::SetBandwidthEstimationMode(BandwidthEstimationMode mode) { - WEBRTC_TRACE(kTraceApiCall, kTraceVideo, shared_data_->instance_id(), - "ViERTP_RTCPImpl::SetBandwidthEstimationMode(%d)", mode); - if (!shared_data_->channel_manager()->SetBandwidthEstimationMode(mode)) { - return -1; - } - return 0; -} - int ViERTP_RTCPImpl::SetSendTimestampOffsetStatus(int video_channel, bool enable, int id) { diff --git a/video_engine/vie_rtp_rtcp_impl.h b/video_engine/vie_rtp_rtcp_impl.h index 257974ce..f41c3367 100644 --- a/video_engine/vie_rtp_rtcp_impl.h +++ b/video_engine/vie_rtp_rtcp_impl.h @@ -76,7 +76,6 @@ class ViERTP_RTCPImpl const ViEKeyFrameRequestMethod method); virtual int SetTMMBRStatus(const int video_channel, const bool enable); virtual int SetRembStatus(int video_channel, bool sender, bool receiver); - virtual int SetBandwidthEstimationMode(BandwidthEstimationMode mode); virtual int SetSendTimestampOffsetStatus(int video_channel, bool enable, int id); diff --git a/video_engine/vie_shared_data.cc b/video_engine/vie_shared_data.cc index 4e6ebcc0..bdcc0ef2 100644 --- a/video_engine/vie_shared_data.cc +++ b/video_engine/vie_shared_data.cc @@ -28,7 +28,6 @@ ViESharedData::ViESharedData(const Config& config) number_cores_(CpuInfo::DetectNumberOfCores()), over_use_detector_options_(), channel_manager_(*new ViEChannelManager(instance_id_, number_cores_, - over_use_detector_options_, config)), input_manager_(*new ViEInputManager(instance_id_, config)), render_manager_(*new ViERenderManager(instance_id_)), |