admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

In remote bitrate estimator pass packet using RtpPacketReceived class

Browse Source 
Bug: webrtc:15054
Change-Id: I23c9008e1979a56bba9421a00e4f0f8ff937d122
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/313261
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#40485}
This commit is contained in:
Danil Chapovalov 2023-07-26 15:51:49 +02:00 committed by WebRTC LUCI CQ
parent 6e937574f7
commit 4f4e989436
7 changed files with 43 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
modules/congestion_controller/receive_side_congestion_controller.cc
View File

@ -98,11 +98,8 @@ void ReceiveSideCongestionController::OnReceivedPacket(
} else {
// Receive-side BWE.
MutexLock lock(&mutex_);
RTPHeader header;
packet.GetHeader(&header);
PickEstimator(packet.HasExtension<AbsoluteSendTime>());
rbe_->IncomingPacket(packet.arrival_time().ms(),
packet.payload_size() + packet.padding_size(), header);
rbe_->IncomingPacket(packet);
}
}

14
modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h
View File

@ -13,15 +13,13 @@
#ifndef MODULES_REMOTE_BITRATE_ESTIMATOR_INCLUDE_REMOTE_BITRATE_ESTIMATOR_H_
#define MODULES_REMOTE_BITRATE_ESTIMATOR_INCLUDE_REMOTE_BITRATE_ESTIMATOR_H_
#include <map>
#include <memory>
#include <cstdint>
#include <vector>
#include "api/units/data_rate.h"
#include "api/units/time_delta.h"
#include "modules/include/module_common_types.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/rtcp_packet.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
namespace webrtc {
@ -45,12 +43,8 @@ class RemoteBitrateEstimator : public CallStatsObserver {
// Called for each incoming packet. 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.
// Note that `arrival_time_ms` can be of an arbitrary time base.
virtual void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header) = 0;
// remote bitrate estimate will be updated.
virtual void IncomingPacket(const RtpPacketReceived& rtp_packet) = 0;
// Removes all data for `ssrc`.
virtual void RemoveStream(uint32_t ssrc) = 0;

25
modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc
View File

@ -23,6 +23,8 @@
#include "api/units/timestamp.h"
#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
#include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "system_wrappers/include/metrics.h"
@ -208,26 +210,19 @@ bool RemoteBitrateEstimatorAbsSendTime::IsBitrateImproving(
}
void RemoteBitrateEstimatorAbsSendTime::IncomingPacket(
int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header) {
if (!header.extension.hasAbsoluteSendTime) {
const RtpPacketReceived& rtp_packet) {
uint32_t send_time_24bits;
if (!rtp_packet.GetExtension<AbsoluteSendTime>(&send_time_24bits)) {
RTC_LOG(LS_WARNING)
<< "RemoteBitrateEstimatorAbsSendTimeImpl: Incoming packet "
"is missing absolute send time extension!";
return;
}
IncomingPacketInfo(Timestamp::Millis(arrival_time_ms),
header.extension.absoluteSendTime,
DataSize::Bytes(payload_size), header.ssrc);
}
void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
Timestamp arrival_time,
uint32_t send_time_24bits,
DataSize payload_size,
uint32_t ssrc) {
RTC_CHECK(send_time_24bits < (1ul << 24));
Timestamp arrival_time = rtp_packet.arrival_time();
DataSize payload_size =
DataSize::Bytes(rtp_packet.payload_size() + rtp_packet.padding_size());
if (!uma_recorded_) {
RTC_HISTOGRAM_ENUMERATION(kBweTypeHistogram, BweNames::kReceiverAbsSendTime,
BweNames::kBweNamesMax);
@ -270,7 +265,7 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
TimeoutStreams(now);
RTC_DCHECK(inter_arrival_);
RTC_DCHECK(estimator_);
ssrcs_.insert_or_assign(ssrc, now);
ssrcs_.insert_or_assign(rtp_packet.Ssrc(), now);
// For now only try to detect probes while we don't have a valid estimate.
// We currently assume that only packets larger than 200 bytes are paced by

9
modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h
View File

@ -49,9 +49,7 @@ class RemoteBitrateEstimatorAbsSendTime : public RemoteBitrateEstimator {
~RemoteBitrateEstimatorAbsSendTime() override;
void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header) override;
void IncomingPacket(const RtpPacketReceived& rtp_packet) override;
TimeDelta Process() override;
void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
void RemoveStream(uint32_t ssrc) override;
@ -89,11 +87,6 @@ class RemoteBitrateEstimatorAbsSendTime : public RemoteBitrateEstimator {
static void MaybeAddCluster(const Cluster& cluster_aggregate,
std::list<Cluster>& clusters);
void IncomingPacketInfo(Timestamp arrival_time,
uint32_t send_time_24bits,
DataSize payload_size,
uint32_t ssrc);
std::list<Cluster> ComputeClusters() const;
const Cluster* FindBestProbe(const std::list<Cluster>& clusters) const;

21
modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
View File

@ -19,6 +19,8 @@
#include "modules/remote_bitrate_estimator/inter_arrival.h"
#include "modules/remote_bitrate_estimator/overuse_detector.h"
#include "modules/remote_bitrate_estimator/overuse_estimator.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "system_wrappers/include/clock.h"
@ -73,19 +75,19 @@ RemoteBitrateEstimatorSingleStream::~RemoteBitrateEstimatorSingleStream() {
}
void RemoteBitrateEstimatorSingleStream::IncomingPacket(
int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header) {
const RtpPacketReceived& rtp_packet) {
absl::optional<int32_t> transmission_time_offset =
rtp_packet.GetExtension<TransmissionOffset>();
if (!uma_recorded_) {
BweNames type = BweNames::kReceiverTOffset;
if (!header.extension.hasTransmissionTimeOffset)
type = BweNames::kReceiverNoExtension;
BweNames type = transmission_time_offset.has_value()
? BweNames::kReceiverTOffset
: BweNames::kReceiverNoExtension;
RTC_HISTOGRAM_ENUMERATION(kBweTypeHistogram, type, BweNames::kBweNamesMax);
uma_recorded_ = true;
}
uint32_t ssrc = header.ssrc;
uint32_t ssrc = rtp_packet.Ssrc();
uint32_t rtp_timestamp =
header.timestamp + header.extension.transmissionTimeOffset;
rtp_packet.Timestamp() + transmission_time_offset.value_or(0);
int64_t now_ms = clock_->TimeInMilliseconds();
SsrcOveruseEstimatorMap::iterator it = overuse_detectors_.find(ssrc);
if (it == overuse_detectors_.end()) {
@ -113,6 +115,7 @@ void RemoteBitrateEstimatorSingleStream::IncomingPacket(
incoming_bitrate_.Reset();
last_valid_incoming_bitrate_ = 0;
}
size_t payload_size = rtp_packet.payload_size() + rtp_packet.padding_size();
incoming_bitrate_.Update(payload_size, now_ms);
const BandwidthUsage prior_state = estimator->detector.State();
@ -120,7 +123,7 @@ void RemoteBitrateEstimatorSingleStream::IncomingPacket(
int64_t time_delta = 0;
int size_delta = 0;
if (estimator->inter_arrival.ComputeDeltas(
rtp_timestamp, arrival_time_ms, now_ms, payload_size,
rtp_timestamp, rtp_packet.arrival_time().ms(), now_ms, payload_size,
&timestamp_delta, &time_delta, &size_delta)) {
double timestamp_delta_ms = timestamp_delta * kTimestampToMs;
estimator->estimator.Update(time_delta, timestamp_delta_ms, size_delta,

4
modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h
View File

@ -43,9 +43,7 @@ class RemoteBitrateEstimatorSingleStream : public RemoteBitrateEstimator {
~RemoteBitrateEstimatorSingleStream() override;
void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header) override;
void IncomingPacket(const RtpPacketReceived& rtp_packet) override;
TimeDelta Process() override;
void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
void RemoveStream(uint32_t ssrc) override;

23
modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc
View File

@ -13,6 +13,9 @@
#include <limits>
#include <utility>
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "rtc_base/checks.h"
namespace webrtc {
@ -229,15 +232,17 @@ void RemoteBitrateEstimatorTest::IncomingPacket(uint32_t ssrc,
int64_t arrival_time,
uint32_t rtp_timestamp,
uint32_t absolute_send_time) {
RTPHeader header;
memset(&header, 0, sizeof(header));
header.ssrc = ssrc;
header.timestamp = rtp_timestamp;
header.extension.hasAbsoluteSendTime = true;
header.extension.absoluteSendTime = absolute_send_time;
RTC_CHECK_GE(arrival_time + arrival_time_offset_ms_, 0);
bitrate_estimator_->IncomingPacket(arrival_time + arrival_time_offset_ms_,
payload_size, header);
RtpHeaderExtensionMap extensions;
extensions.Register<AbsoluteSendTime>(1);
RtpPacketReceived rtp_packet(&extensions);
rtp_packet.SetSsrc(ssrc);
rtp_packet.SetTimestamp(rtp_timestamp);
rtp_packet.SetExtension<AbsoluteSendTime>(absolute_send_time);
rtp_packet.SetPayloadSize(payload_size);
rtp_packet.set_arrival_time(
Timestamp::Millis(arrival_time + arrival_time_offset_ms_));
bitrate_estimator_->IncomingPacket(rtp_packet);
}
// Generates a frame of packets belonging to a stream at a given bitrate and