44caf01c34
Modify bitrate controller to update bitrate based on process call and not only whenever a RTCP receiver block is received. Additionally: Add condition to only start rampup after a receiver block is received. This was same as old behaviour but now an explicit check is needed to verify process does not ramps up before the first block. Fix logic around capping max bitrate increase at 8% per second. Before it was only increasing once every 1 second and each increase would be as high as 8%. If receiver blocks had a different interval before it would lose an update or waste an update slot and not ramp up as much as a 8% (e.g. if RTCP received < 1 second). Did not touch decrease logic, however since it can be triggered more often it may decrease much faster and closer to the original written cap of once every 300ms + rtt. Note: rampup_tests.cc don't seem to be affected by this since there is no packet loss or REMB that go higher than expected cap. bitrate_controller_unittests.cc are don't really simulate a clock and the process thread, but trigger update by inserting an rtcp block. BUG=3065 R=stefan@webrtc.org, mflodman@webrtc.org git-svn-id: http://webrtc.googlecode.com/svn/trunk@5794 4adac7df-926f-26a2-2b94-8c16560cd09d
83 lines
3.4 KiB
C++
83 lines
3.4 KiB
C++
/*
|
|
* 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.
|
|
*
|
|
* Usage: this class will register multiple RtcpBitrateObserver's one at each
|
|
* RTCP module. It will aggregate the results and run one bandwidth estimation
|
|
* and push the result to the encoders via BitrateObserver(s).
|
|
*/
|
|
|
|
#ifndef WEBRTC_MODULES_BITRATE_CONTROLLER_INCLUDE_BITRATE_CONTROLLER_H_
|
|
#define WEBRTC_MODULES_BITRATE_CONTROLLER_INCLUDE_BITRATE_CONTROLLER_H_
|
|
|
|
#include "webrtc/modules/interface/module.h"
|
|
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
|
|
|
|
namespace webrtc {
|
|
|
|
class BitrateObserver {
|
|
/*
|
|
* Observer class for the encoders, each encoder should implement this class
|
|
* to get the target bitrate. It also get the fraction loss and rtt to
|
|
* optimize its settings for this type of network. |target_bitrate| is the
|
|
* target media/payload bitrate excluding packet headers, measured in bits
|
|
* per second.
|
|
*/
|
|
public:
|
|
virtual void OnNetworkChanged(const uint32_t target_bitrate,
|
|
const uint8_t fraction_loss, // 0 - 255.
|
|
const uint32_t rtt) = 0;
|
|
|
|
virtual ~BitrateObserver() {}
|
|
};
|
|
|
|
class BitrateController : public Module {
|
|
/*
|
|
* This class collects feedback from all streams sent to a peer (via
|
|
* RTCPBandwidthObservers). It does one aggregated send side bandwidth
|
|
* estimation and divide the available bitrate between all its registered
|
|
* BitrateObservers.
|
|
*/
|
|
public:
|
|
// The argument |enforce_min_bitrate| controls the behavior when the available
|
|
// bitrate is lower than the minimum bitrate, or the sum of minimum bitrates.
|
|
// When true, the bitrate will never be set lower than the minimum bitrate(s).
|
|
// When false, the bitrate observers will be allocated rates up to their
|
|
// respective minimum bitrate, satisfying one observer after the other.
|
|
static BitrateController* CreateBitrateController(Clock* clock,
|
|
bool enforce_min_bitrate);
|
|
virtual ~BitrateController() {}
|
|
|
|
virtual RtcpBandwidthObserver* CreateRtcpBandwidthObserver() = 0;
|
|
|
|
// Gets the available payload bandwidth in bits per second. Note that
|
|
// this bandwidth excludes packet headers.
|
|
virtual bool AvailableBandwidth(uint32_t* bandwidth) const = 0;
|
|
|
|
/*
|
|
* Set the start and max send bitrate used by the bandwidth management.
|
|
*
|
|
* observer, updates bitrates if already in use.
|
|
* min_bitrate_kbit = 0 equals no min bitrate.
|
|
* max_bitrate_kit = 0 equals no max bitrate.
|
|
*/
|
|
virtual void SetBitrateObserver(BitrateObserver* observer,
|
|
const uint32_t start_bitrate,
|
|
const uint32_t min_bitrate,
|
|
const uint32_t max_bitrate) = 0;
|
|
|
|
virtual void RemoveBitrateObserver(BitrateObserver* observer) = 0;
|
|
|
|
// Changes the mode that was set in the constructor.
|
|
virtual void EnforceMinBitrate(bool enforce_min_bitrate) = 0;
|
|
|
|
virtual void SetReservedBitrate(uint32_t reserved_bitrate_bps) = 0;
|
|
};
|
|
} // namespace webrtc
|
|
#endif // WEBRTC_MODULES_BITRATE_CONTROLLER_INCLUDE_BITRATE_CONTROLLER_H_
|