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

Cleanup ReceiveSideCongestionController api from OnReceivedPacket taking legacy RTPHeader

Browse Source 
Bug: webrtc:14859
Change-Id: I595859c021c2cd0adcf60af0f560e30010bae7a5
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/300261
Reviewed-by: Per Kjellander <perkj@webrtc.org>
Auto-Submit: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39770}
This commit is contained in:
Danil Chapovalov 2023-04-04 13:31:23 +02:00 committed by WebRTC LUCI CQ
parent 0b06b2785b
commit deb25d2f45
4 changed files with 37 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
modules/congestion_controller/include/receive_side_congestion_controller.h
View File

@ -44,11 +44,6 @@ class ReceiveSideCongestionController : public CallStatsObserver {
void OnReceivedPacket(const RtpPacketReceived& packet, MediaType media_type); void OnReceivedPacket(const RtpPacketReceived& packet, MediaType media_type);
// TODO(perkj, bugs.webrtc.org/14859): Remove all usage. This method is
// currently not used by PeerConnections.
virtual void OnReceivedPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header);
// Implements CallStatsObserver. // Implements CallStatsObserver.
void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override; void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;

13
modules/congestion_controller/receive_side_congestion_controller.cc
View File

@ -106,19 +106,6 @@ void ReceiveSideCongestionController::OnReceivedPacket(
} }
} }
void ReceiveSideCongestionController::OnReceivedPacket(
int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header) {
remote_estimator_proxy_.IncomingPacket(arrival_time_ms, payload_size, header);
if (!header.extension.hasTransportSequenceNumber) {
// Receive-side BWE.
MutexLock lock(&mutex_);
PickEstimator(header.extension.hasAbsoluteSendTime);
rbe_->IncomingPacket(arrival_time_ms, payload_size, header);
}
}
void ReceiveSideCongestionController::OnBitrateChanged(int bitrate_bps) { void ReceiveSideCongestionController::OnBitrateChanged(int bitrate_bps) {
remote_estimator_proxy_.OnBitrateChanged(bitrate_bps); remote_estimator_proxy_.OnBitrateChanged(bitrate_bps);
} }

112
modules/remote_bitrate_estimator/remote_estimator_proxy.cc
View File

@ -28,9 +28,7 @@
namespace webrtc { namespace webrtc {
namespace { namespace {
// The maximum allowed value for a timestamp in milliseconds. This is lower
// than the numerical limit since we often convert to microseconds.
constexpr int64_t kMaxTimeMs = std::numeric_limits<int64_t>::max() / 1000;
constexpr TimeDelta kBackWindow = TimeDelta::Millis(500); constexpr TimeDelta kBackWindow = TimeDelta::Millis(500);
constexpr TimeDelta kMinInterval = TimeDelta::Millis(50); constexpr TimeDelta kMinInterval = TimeDelta::Millis(50);
constexpr TimeDelta kMaxInterval = TimeDelta::Millis(250); constexpr TimeDelta kMaxInterval = TimeDelta::Millis(250);
@ -89,15 +87,11 @@ void RemoteEstimatorProxy::IncomingPacket(const RtpPacketReceived& packet) {
return; return;
} }
Packet internal_packet = {.arrival_time = packet.arrival_time(), uint16_t seqnum = 0;
.size = DataSize::Bytes(packet.size()), absl::optional<FeedbackRequest> feedback_request;
.ssrc = packet.Ssrc()}; if (!packet.GetExtension<TransportSequenceNumber>(&seqnum) &&
uint16_t seqnum; !packet.GetExtension<TransportSequenceNumberV2>(&seqnum,
if (packet.GetExtension<TransportSequenceNumber>(&seqnum) || &feedback_request)) {
packet.GetExtension<TransportSequenceNumberV2>(
&seqnum, &internal_packet.feedback_request)) {
internal_packet.transport_sequence_number = seqnum;
} else {
// This function expected to be called only for packets that have // This function expected to be called only for packets that have
// TransportSequenceNumber rtp header extension, however malformed RTP // TransportSequenceNumber rtp header extension, however malformed RTP
// packet may contain unparsable TransportSequenceNumber. // packet may contain unparsable TransportSequenceNumber.
@ -107,81 +101,49 @@ void RemoteEstimatorProxy::IncomingPacket(const RtpPacketReceived& packet) {
return; return;
} }
internal_packet.absolute_send_time_24bits =
packet.GetExtension<AbsoluteSendTime>();
MutexLock lock(&lock_); MutexLock lock(&lock_);
send_periodic_feedback_ = packet.HasExtension<TransportSequenceNumber>(); send_periodic_feedback_ = packet.HasExtension<TransportSequenceNumber>();
IncomingPacket(internal_packet); media_ssrc_ = packet.Ssrc();
} int64_t seq = unwrapper_.Unwrap(seqnum);
void RemoteEstimatorProxy::IncomingPacket(int64_t arrival_time_ms, if (send_periodic_feedback_) {
size_t payload_size, MaybeCullOldPackets(seq, packet.arrival_time());
const RTPHeader& header) {
if (arrival_time_ms < 0 || arrival_time_ms >= kMaxTimeMs) { if (!periodic_window_start_seq_ || seq < *periodic_window_start_seq_) {
RTC_LOG(LS_WARNING) << "Arrival time out of bounds: " << arrival_time_ms; periodic_window_start_seq_ = seq;
}
}
// We are only interested in the first time a packet is received.
if (packet_arrival_times_.has_received(seq)) {
return; return;
} }
Packet packet = {.arrival_time = Timestamp::Millis(arrival_time_ms),
.size = DataSize::Bytes(header.headerLength + payload_size),
.ssrc = header.ssrc};
if (header.extension.hasTransportSequenceNumber) {
packet.transport_sequence_number = header.extension.transportSequenceNumber;
}
if (header.extension.hasAbsoluteSendTime) {
packet.absolute_send_time_24bits = header.extension.absoluteSendTime;
}
packet.feedback_request = header.extension.feedback_request;
MutexLock lock(&lock_); packet_arrival_times_.AddPacket(seq, packet.arrival_time());
IncomingPacket(packet);
}
void RemoteEstimatorProxy::IncomingPacket(Packet packet) { // Limit the range of sequence numbers to send feedback for.
media_ssrc_ = packet.ssrc; if (periodic_window_start_seq_ <
int64_t seq = 0; packet_arrival_times_.begin_sequence_number()) {
periodic_window_start_seq_ = packet_arrival_times_.begin_sequence_number();
if (packet.transport_sequence_number.has_value()) {
seq = unwrapper_.Unwrap(*packet.transport_sequence_number);
if (send_periodic_feedback_) {
MaybeCullOldPackets(seq, packet.arrival_time);
if (!periodic_window_start_seq_ || seq < *periodic_window_start_seq_) {
periodic_window_start_seq_ = seq;
}
}
// We are only interested in the first time a packet is received.
if (packet_arrival_times_.has_received(seq)) {
return;
}
packet_arrival_times_.AddPacket(seq, packet.arrival_time);
// Limit the range of sequence numbers to send feedback for.
if (!periodic_window_start_seq_.has_value() ||
periodic_window_start_seq_.value() <
packet_arrival_times_.begin_sequence_number()) {
periodic_window_start_seq_ =
packet_arrival_times_.begin_sequence_number();
}
if (packet.feedback_request) {
// Send feedback packet immediately.
SendFeedbackOnRequest(seq, *packet.feedback_request);
}
} }
if (network_state_estimator_ && packet.absolute_send_time_24bits) { if (feedback_request.has_value()) {
// Send feedback packet immediately.
SendFeedbackOnRequest(seq, *feedback_request);
}
absl::optional<uint32_t> absolute_send_time_24bits =
packet.GetExtension<AbsoluteSendTime>();
if (network_state_estimator_ && absolute_send_time_24bits.has_value()) {
PacketResult packet_result; PacketResult packet_result;
packet_result.receive_time = packet.arrival_time; packet_result.receive_time = packet.arrival_time();
abs_send_timestamp_ += GetAbsoluteSendTimeDelta( abs_send_timestamp_ += GetAbsoluteSendTimeDelta(*absolute_send_time_24bits,
*packet.absolute_send_time_24bits, previous_abs_send_time_); previous_abs_send_time_);
previous_abs_send_time_ = *packet.absolute_send_time_24bits; previous_abs_send_time_ = *absolute_send_time_24bits;
packet_result.sent_packet.send_time = abs_send_timestamp_; packet_result.sent_packet.send_time = abs_send_timestamp_;
packet_result.sent_packet.size = packet.size + packet_overhead_; packet_result.sent_packet.size =
DataSize::Bytes(packet.size()) + packet_overhead_;
packet_result.sent_packet.sequence_number = seq; packet_result.sent_packet.sequence_number = seq;
network_state_estimator_->OnReceivedPacket(packet_result); network_state_estimator_->OnReceivedPacket(packet_result);
} }

16
modules/remote_bitrate_estimator/remote_estimator_proxy.h
View File

@ -47,12 +47,6 @@ class RemoteEstimatorProxy {
void IncomingPacket(const RtpPacketReceived& packet); void IncomingPacket(const RtpPacketReceived& packet);
// TODO(perkj, bugs.webrtc.org/14859): Remove all usage. This method is
// currently not used by PeerConnections.
void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header);
// Sends periodic feedback if it is time to send it. // Sends periodic feedback if it is time to send it.
// Returns time until next call to Process should be made. // Returns time until next call to Process should be made.
TimeDelta Process(Timestamp now); TimeDelta Process(Timestamp now);
@ -61,16 +55,6 @@ class RemoteEstimatorProxy {
void SetTransportOverhead(DataSize overhead_per_packet); void SetTransportOverhead(DataSize overhead_per_packet);
private: private:
struct Packet {
Timestamp arrival_time;
DataSize size;
uint32_t ssrc;
absl::optional<uint32_t> absolute_send_time_24bits;
absl::optional<uint16_t> transport_sequence_number;
absl::optional<FeedbackRequest> feedback_request;
};
void IncomingPacket(Packet packet) RTC_EXCLUSIVE_LOCKS_REQUIRED(&lock_);
void MaybeCullOldPackets(int64_t sequence_number, Timestamp arrival_time) void MaybeCullOldPackets(int64_t sequence_number, Timestamp arrival_time)
RTC_EXCLUSIVE_LOCKS_REQUIRED(&lock_); RTC_EXCLUSIVE_LOCKS_REQUIRED(&lock_);
void SendPeriodicFeedbacks() RTC_EXCLUSIVE_LOCKS_REQUIRED(&lock_); void SendPeriodicFeedbacks() RTC_EXCLUSIVE_LOCKS_REQUIRED(&lock_);