YangWX/crossdesk
1
0
Fork 0
mirror of https://github.com/kunkundi/crossdesk.git synced 2025-10-26 12:15:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

[feat] enable congestion controller

Browse Source
This commit is contained in:
dijunkun
2025-02-07 17:42:05 +08:00
parent 316a0220a8
commit 8d7068aa32
32 changed files with 184 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/channel/audio_channel_send.cpp
View File

@@ -12,8 +12,10 @@ AudioChannelSend::AudioChannelSend(
: ice_agent_(ice_agent), ice_io_statistics_(ice_io_statistics) {}
void AudioChannelSend::Initialize(rtp::PAYLOAD_TYPE payload_type) {
rtp_packetizer_ = RtpPacketizer::Create(payload_type);
rtp_audio_sender_ = std::make_unique<RtpAudioSender>(ice_io_statistics_);
rtp_packetizer_ =
RtpPacketizer::Create(payload_type, rtp_audio_sender_->GetSsrc());
rtp_audio_sender_->SetSendDataFunc(
[this](const char *data, size_t size) -> int {
if (!ice_agent_) {

4
src/channel/data_channel_send.cpp
View File

@@ -12,8 +12,10 @@ DataChannelSend::DataChannelSend(
: ice_agent_(ice_agent), ice_io_statistics_(ice_io_statistics) {}
void DataChannelSend::Initialize(rtp::PAYLOAD_TYPE payload_type) {
rtp_packetizer_ = RtpPacketizer::Create(payload_type);
rtp_data_sender_ = std::make_unique<RtpDataSender>(ice_io_statistics_);
rtp_packetizer_ =
RtpPacketizer::Create(payload_type, rtp_data_sender_->GetSsrc());
rtp_data_sender_->SetSendDataFunc(
[this](const char *data, size_t size) -> int {
if (!ice_agent_) {

5
src/channel/rtp_channel/rtp_audio_sender.cpp
View File

@@ -2,6 +2,7 @@
#include <chrono>
#include "common.h"
#include "log.h"
#define RTCP_SR_INTERVAL 1000
@@ -9,7 +10,7 @@
RtpAudioSender::RtpAudioSender() { SetPeriod(std::chrono::milliseconds(5)); }
RtpAudioSender::RtpAudioSender(std::shared_ptr<IOStatistics> io_statistics)
: io_statistics_(io_statistics) {
: ssrc_(GenerateUniqueSsrc()), io_statistics_(io_statistics) {
SetPeriod(std::chrono::milliseconds(5));
}
@@ -17,6 +18,8 @@ RtpAudioSender::~RtpAudioSender() {
if (rtp_statistics_) {
rtp_statistics_->Stop();
}
SSRCManager::Instance().DeleteSsrc(ssrc_);
}
void RtpAudioSender::Enqueue(std::vector<RtpPacket>& rtp_packets) {

5
src/channel/rtp_channel/rtp_audio_sender.h
View File

@@ -25,8 +25,8 @@ class RtpAudioSender : public ThreadBase {
public:
void Enqueue(std::vector<RtpPacket> &rtp_packets);
void SetSendDataFunc(std::function<int(const char *, size_t)> data_send_func);
uint32_t GetSsrc() { return ssrc_; }
private:
private:
int SendRtpPacket(RtpPacket &rtp_packet);
int SendRtcpSR(RtcpSenderReport &rtcp_sr);
@@ -39,6 +39,9 @@ class RtpAudioSender : public ThreadBase {
private:
std::function<int(const char *, size_t)> data_send_func_ = nullptr;
RingBuffer<RtpPacket> rtp_packe_queue_;
private:
uint32_t ssrc_ = 0;
std::unique_ptr<RtpStatistics> rtp_statistics_ = nullptr;
std::shared_ptr<IOStatistics> io_statistics_ = nullptr;
uint32_t last_send_bytes_ = 0;

5
src/channel/rtp_channel/rtp_data_sender.cpp
View File

@@ -2,6 +2,7 @@
#include <chrono>
#include "common.h"
#include "log.h"
#define RTCP_SR_INTERVAL 1000
@@ -9,7 +10,7 @@
RtpDataSender::RtpDataSender() {}
RtpDataSender::RtpDataSender(std::shared_ptr<IOStatistics> io_statistics)
: io_statistics_(io_statistics) {
: ssrc_(GenerateUniqueSsrc()), io_statistics_(io_statistics) {
SetPeriod(std::chrono::milliseconds(5));
}
@@ -17,6 +18,8 @@ RtpDataSender::~RtpDataSender() {
if (rtp_statistics_) {
rtp_statistics_->Stop();
}
SSRCManager::Instance().DeleteSsrc(ssrc_);
}
void RtpDataSender::Enqueue(std::vector<RtpPacket>& rtp_packets) {

2
src/channel/rtp_channel/rtp_data_sender.h
View File

@@ -25,6 +25,7 @@ class RtpDataSender : public ThreadBase {
public:
void Enqueue(std::vector<RtpPacket> &rtp_packets);
void SetSendDataFunc(std::function<int(const char *, size_t)> data_send_func);
uint32_t GetSsrc() { return ssrc_; }
private:
private:
@@ -41,6 +42,7 @@ class RtpDataSender : public ThreadBase {
RingBuffer<RtpPacket> rtp_packe_queue_;
private:
uint32_t ssrc_ = 0;
std::unique_ptr<RtpStatistics> rtp_statistics_ = nullptr;
std::shared_ptr<IOStatistics> io_statistics_ = nullptr;
uint32_t last_send_bytes_ = 0;

39
src/channel/rtp_channel/rtp_video_receiver.cpp
View File

@@ -9,34 +9,35 @@
#define NV12_BUFFER_SIZE (1280 * 720 * 3 / 2)
#define RTCP_RR_INTERVAL 1000
RtpVideoReceiver::RtpVideoReceiver()
RtpVideoReceiver::RtpVideoReceiver(std::shared_ptr<Clock> clock)
: feedback_ssrc_(GenerateUniqueSsrc()),
active_remb_module_(nullptr),
receive_side_congestion_controller_(
clock_,
clock,
[this](std::vector<std::unique_ptr<RtcpPacket>> packets) {
SendCombinedRtcpPacket(std::move(packets));
},
[this](int64_t bitrate_bps, std::vector<uint32_t> ssrcs) {
SendRemb(bitrate_bps, ssrcs);
}),
clock_(Clock::GetRealTimeClockShared()) {
clock_(clock) {
SetPeriod(std::chrono::milliseconds(5));
// rtcp_thread_ = std::thread(&RtpVideoReceiver::RtcpThread, this);
}
RtpVideoReceiver::RtpVideoReceiver(std::shared_ptr<IOStatistics> io_statistics)
RtpVideoReceiver::RtpVideoReceiver(std::shared_ptr<Clock> clock,
std::shared_ptr<IOStatistics> io_statistics)
: io_statistics_(io_statistics),
feedback_ssrc_(GenerateUniqueSsrc()),
receive_side_congestion_controller_(
clock_,
clock,
[this](std::vector<std::unique_ptr<RtcpPacket>> packets) {
SendCombinedRtcpPacket(std::move(packets));
},
[this](int64_t bitrate_bps, std::vector<uint32_t> ssrcs) {
SendRemb(bitrate_bps, ssrcs);
}),
clock_(Clock::GetRealTimeClockShared()) {
clock_(clock) {
SetPeriod(std::chrono::milliseconds(5));
// rtcp_thread_ = std::thread(&RtpVideoReceiver::RtcpThread, this);
@@ -404,6 +405,21 @@ int RtpVideoReceiver::SendRtcpRR(RtcpReceiverReport& rtcp_rr) {
return 0;
}
TimeDelta AtoToTimeDelta(uint16_t receive_info) {
// receive_info
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |R|ECN| Arrival time offset |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
const uint16_t ato = receive_info & 0x1FFF;
if (ato == 0x1FFE) {
return TimeDelta::PlusInfinity();
}
if (ato == 0x1FFF) {
return TimeDelta::MinusInfinity();
}
return TimeDelta::Seconds(ato) / 1024;
}
void RtpVideoReceiver::SendCombinedRtcpPacket(
std::vector<std::unique_ptr<RtcpPacket>> rtcp_packets) {
if (!data_send_func_) {
@@ -414,9 +430,18 @@ void RtpVideoReceiver::SendCombinedRtcpPacket(
RTCPSender rtcp_sender(
[this](const uint8_t* buffer, size_t size) -> int {
webrtc::rtcp::CommonHeader rtcp_block;
// bool valid = true;
// if (!rtcp_block.Parse(buffer, size)) {
// valid = false;
// }
webrtc::rtcp::CongestionControlFeedback feedback;
feedback.Parse(rtcp_block);
return data_send_func_((const char*)buffer, size);
},
IP_PACKET_SIZE);
1200);
for (auto& rtcp_packet : rtcp_packets) {
rtcp_packet->SetSenderSsrc(feedback_ssrc_);

5
src/channel/rtp_channel/rtp_video_receiver.h
View File

@@ -23,8 +23,9 @@ using namespace webrtc;
class RtpVideoReceiver : public ThreadBase {
public:
RtpVideoReceiver();
RtpVideoReceiver(std::shared_ptr<IOStatistics> io_statistics);
RtpVideoReceiver(std::shared_ptr<Clock> clock);
RtpVideoReceiver(std::shared_ptr<Clock> clock,
std::shared_ptr<IOStatistics> io_statistics);
virtual ~RtpVideoReceiver();
public:

19
src/channel/rtp_channel/rtp_video_sender.cpp
View File

@@ -2,6 +2,7 @@
#include <chrono>
#include "common.h"
#include "log.h"
// #define SAVE_RTP_SENT_STREAM
@@ -11,7 +12,7 @@
RtpVideoSender::RtpVideoSender() {}
RtpVideoSender::RtpVideoSender(std::shared_ptr<IOStatistics> io_statistics)
: io_statistics_(io_statistics) {
: ssrc_(GenerateUniqueSsrc()), io_statistics_(io_statistics) {
SetPeriod(std::chrono::milliseconds(5));
#ifdef SAVE_RTP_SENT_STREAM
file_rtp_sent_ = fopen("rtp_sent_stream.h264", "w+b");
@@ -26,6 +27,8 @@ RtpVideoSender::~RtpVideoSender() {
rtp_statistics_->Stop();
}
SSRCManager::Instance().DeleteSsrc(ssrc_);
#ifdef SAVE_RTP_SENT_STREAM
if (file_rtp_sent_) {
fflush(file_rtp_sent_);
@@ -51,12 +54,26 @@ void RtpVideoSender::SetSendDataFunc(
data_send_func_ = data_send_func;
}
void RtpVideoSender::SetOnSentPacketFunc(
std::function<void(const webrtc::RtpPacketToSend&)> on_sent_packet_func) {
on_sent_packet_func_ = on_sent_packet_func;
}
int RtpVideoSender::SendRtpPacket(RtpPacket& rtp_packet) {
if (!data_send_func_) {
LOG_ERROR("data_send_func_ is nullptr");
return -1;
}
if (on_sent_packet_func_) {
webrtc::RtpPacketToSend rtp_packet_to_send;
rtp_packet_to_send.SetSequenceNumber(rtp_packet.SequenceNumber());
rtp_packet_to_send.SetSsrc(rtp_packet.Ssrc());
rtp_packet_to_send.set_transport_sequence_number(transport_seq_++);
rtp_packet_to_send.set_packet_type(webrtc::RtpPacketMediaType::kVideo);
on_sent_packet_func_(rtp_packet_to_send);
}
if (0 != data_send_func_((const char*)rtp_packet.Buffer().data(),
rtp_packet.Size())) {
// LOG_ERROR("Send rtp packet failed");

10
src/channel/rtp_channel/rtp_video_sender.h
View File

@@ -7,6 +7,7 @@
#include "ringbuffer.h"
#include "rtcp_sender_report.h"
#include "rtp_packet.h"
#include "rtp_packet_to_send.h"
#include "rtp_statistics.h"
#include "thread_base.h"
@@ -19,6 +20,9 @@ class RtpVideoSender : public ThreadBase {
public:
void Enqueue(std::vector<RtpPacket> &rtp_packets);
void SetSendDataFunc(std::function<int(const char *, size_t)> data_send_func);
void SetOnSentPacketFunc(
std::function<void(const webrtc::RtpPacketToSend &)> on_sent_packet_func);
uint32_t GetSsrc() { return ssrc_; }
private:
int SendRtpPacket(RtpPacket &rtp_packet);
@@ -31,9 +35,12 @@ class RtpVideoSender : public ThreadBase {
private:
std::function<int(const char *, size_t)> data_send_func_ = nullptr;
std::function<void(const webrtc::RtpPacketToSend &)> on_sent_packet_func_ =
nullptr;
RingBuffer<RtpPacket> rtp_packe_queue_;
private:
uint32_t ssrc_ = 0;
std::unique_ptr<RtpStatistics> rtp_statistics_ = nullptr;
std::shared_ptr<IOStatistics> io_statistics_ = nullptr;
uint32_t last_send_bytes_ = 0;
@@ -41,6 +48,9 @@ class RtpVideoSender : public ThreadBase {
uint32_t total_rtp_payload_sent_ = 0;
uint32_t total_rtp_packets_sent_ = 0;
private:
int64_t transport_seq_ = 0;
private:
FILE *file_rtp_sent_ = nullptr;
};

8
src/channel/video_channel_receive.cpp
View File

@@ -5,17 +5,19 @@
VideoChannelReceive::VideoChannelReceive() {}
VideoChannelReceive::VideoChannelReceive(
std::shared_ptr<IceAgent> ice_agent,
std::shared_ptr<webrtc::Clock> clock, std::shared_ptr<IceAgent> ice_agent,
std::shared_ptr<IOStatistics> ice_io_statistics,
std::function<void(VideoFrame &)> on_receive_complete_frame)
: ice_agent_(ice_agent),
ice_io_statistics_(ice_io_statistics),
on_receive_complete_frame_(on_receive_complete_frame) {}
on_receive_complete_frame_(on_receive_complete_frame),
clock_(clock) {}
VideoChannelReceive::~VideoChannelReceive() {}
void VideoChannelReceive::Initialize(rtp::PAYLOAD_TYPE payload_type) {
rtp_video_receiver_ = std::make_unique<RtpVideoReceiver>(ice_io_statistics_);
rtp_video_receiver_ =
std::make_unique<RtpVideoReceiver>(clock_, ice_io_statistics_);
rtp_video_receiver_->SetOnReceiveCompleteFrame(
[this](VideoFrame &video_frame) -> void {
on_receive_complete_frame_(video_frame);

6
src/channel/video_channel_receive.h
View File

@@ -7,6 +7,7 @@
#ifndef _VIDEO_CHANNEL_RECEIVE_H_
#define _VIDEO_CHANNEL_RECEIVE_H_
#include "clock.h"
#include "ice_agent.h"
#include "rtp_video_receiver.h"
@@ -14,7 +15,7 @@ class VideoChannelReceive {
public:
VideoChannelReceive();
VideoChannelReceive(
std::shared_ptr<IceAgent> ice_agent,
std::shared_ptr<webrtc::Clock> clock, std::shared_ptr<IceAgent> ice_agent,
std::shared_ptr<IOStatistics> ice_io_statistics,
std::function<void(VideoFrame &)> on_receive_complete_frame);
@@ -31,6 +32,9 @@ class VideoChannelReceive {
std::shared_ptr<IOStatistics> ice_io_statistics_ = nullptr;
std::unique_ptr<RtpVideoReceiver> rtp_video_receiver_ = nullptr;
std::function<void(VideoFrame &)> on_receive_complete_frame_ = nullptr;
private:
std::shared_ptr<Clock> clock_;
};
#endif

39
src/channel/video_channel_send.cpp
View File

@@ -1,21 +1,25 @@
#include "video_channel_send.h"
#include "log.h"
#include "rtc_base/network/sent_packet.h"
VideoChannelSend::VideoChannelSend() {}
VideoChannelSend::~VideoChannelSend() {}
VideoChannelSend::VideoChannelSend(
std::shared_ptr<IceAgent> ice_agent,
std::shared_ptr<webrtc::Clock> clock, std::shared_ptr<IceAgent> ice_agent,
std::shared_ptr<IOStatistics> ice_io_statistics)
: ice_agent_(ice_agent), ice_io_statistics_(ice_io_statistics){};
: ice_agent_(ice_agent),
ice_io_statistics_(ice_io_statistics),
clock_(clock){};
void VideoChannelSend::Initialize(rtp::PAYLOAD_TYPE payload_type) {
controller_ = std::make_unique<CongestionControl>();
rtp_packetizer_ = RtpPacketizer::Create(payload_type);
rtp_video_sender_ = std::make_unique<RtpVideoSender>(ice_io_statistics_);
rtp_packetizer_ =
RtpPacketizer::Create(payload_type, rtp_video_sender_->GetSsrc());
rtp_video_sender_->SetSendDataFunc(
[this](const char* data, size_t size) -> int {
if (!ice_agent_) {
@@ -33,9 +37,31 @@ void VideoChannelSend::Initialize(rtp::PAYLOAD_TYPE payload_type) {
}
ice_io_statistics_->UpdateVideoOutboundBytes((uint32_t)size);
return ice_agent_->Send(data, size);
});
rtp_video_sender_->SetOnSentPacketFunc(
[this](const webrtc::RtpPacketToSend& packet) -> void {
webrtc::PacedPacketInfo pacing_info;
size_t transport_overhead_bytes_per_packet_ = 0;
webrtc::Timestamp creation_time =
webrtc::Timestamp::Millis(clock_->TimeInMilliseconds());
transport_feedback_adapter_.AddPacket(
packet, pacing_info, transport_overhead_bytes_per_packet_,
creation_time);
rtc::SentPacket sent_packet;
sent_packet.packet_id = packet.transport_sequence_number().value();
sent_packet.send_time_ms = clock_->TimeInMilliseconds();
sent_packet.info.included_in_feedback = true;
sent_packet.info.included_in_allocation = true;
sent_packet.info.packet_size_bytes = packet.size();
sent_packet.info.packet_type = rtc::PacketType::kData;
transport_feedback_adapter_.ProcessSentPacket(sent_packet);
});
rtp_video_sender_->Start();
}
@@ -71,7 +97,8 @@ void VideoChannelSend::HandleTransportPacketsFeedback(
// if (transport_is_ecn_capable_) {
// // If transport does not support ECN, packets should not be sent as
// ECT(1).
// // TODO: bugs.webrtc.org/42225697 - adapt to ECN feedback and continue to
// // TODO: bugs.webrtc.org/42225697 - adapt to ECN feedback and
// continue to
// // send packets as ECT(1) if transport is ECN capable.
// transport_is_ecn_capable_ = false;
// LOG_INFO("Transport is {} ECN capable. Stop sending ECT(1)",
@@ -103,8 +130,8 @@ void VideoChannelSend::PostUpdates(webrtc::NetworkControlUpdate update) {
}
void VideoChannelSend::UpdateControlState() {
// std::optional<TargetTransferRate> update = control_handler_->GetUpdate();
// if (!update) return;
// std::optional<TargetTransferRate> update =
// control_handler_->GetUpdate(); if (!update) return;
// retransmission_rate_limiter_.SetMaxRate(update->target_rate.bps());
// observer_->OnTargetTransferRate(*update);
}

5
src/channel/video_channel_send.h
View File

@@ -8,6 +8,7 @@
#define _VIDEO_CHANNEL_SEND_H_
#include "api/transport/network_types.h"
#include "clock.h"
#include "congestion_control.h"
#include "congestion_control_feedback.h"
#include "ice_agent.h"
@@ -19,7 +20,8 @@
class VideoChannelSend {
public:
VideoChannelSend();
VideoChannelSend(std::shared_ptr<IceAgent> ice_agent,
VideoChannelSend(std::shared_ptr<webrtc::Clock> clock,
std::shared_ptr<IceAgent> ice_agent,
std::shared_ptr<IOStatistics> ice_io_statistics);
~VideoChannelSend();
@@ -47,6 +49,7 @@ class VideoChannelSend {
std::unique_ptr<RtpVideoSender> rtp_video_sender_ = nullptr;
private:
std::shared_ptr<Clock> clock_;
int64_t current_offset_ = std::numeric_limits<int64_t>::min();
// Used by RFC 8888 congestion control feedback to track base time.
std::optional<uint32_t> last_feedback_compact_ntp_time_;

2
src/qos/congestion_control.cpp
View File

@@ -114,6 +114,8 @@ NetworkControlUpdate CongestionControl::OnTransportPacketsFeedback(
if (report.feedback_time > next_loss_update_) {
next_loss_update_ =
report.feedback_time + TimeDelta::Millis(kLossUpdateInterval);
LOG_WARN("lost_packets_since_last_loss_update_ = [{}]",
lost_packets_since_last_loss_update_);
bandwidth_estimation_->UpdatePacketsLost(
lost_packets_since_last_loss_update_,
expected_packets_since_last_loss_update_, report.feedback_time);

3
src/qos/congestion_control_feedback.cpp
View File

@@ -297,6 +297,9 @@ bool CongestionControlFeedback::Parse(const rtcp::CommonHeader& packet) {
uint16_t seq_no = base_seqno + i;
bool received = (packet_info & 0x8000);
TimeDelta arrival_time_offset = AtoToTimeDelta(packet_info);
LOG_ERROR("received:{} = [{} {}]", received,
ToString(arrival_time_offset), arrival_time_offset.IsFinite());
packets_.push_back(
{ssrc, seq_no,
received ? AtoToTimeDelta(packet_info) : TimeDelta::MinusInfinity(),

1
src/qos/congestion_control_feedback_generator.cc
View File

@@ -94,6 +94,7 @@ void CongestionControlFeedbackGenerator::SendFeedback(Timestamp now) {
for (auto& [unused, tracker] : feedback_trackers_) {
tracker.AddPacketsToFeedback(now, rtcp_packet_info);
}
marker_bit_seen_ = false;
first_arrival_time_since_feedback_ = std::nullopt;

21
src/qos/send_side_bandwidth_estimation.cc
View File

@@ -204,6 +204,7 @@ void SendSideBandwidthEstimation::SetBitrates(
void SendSideBandwidthEstimation::SetSendBitrate(DataRate bitrate,
Timestamp at_time) {
LOG_ERROR("3");
// Reset to avoid being capped by the estimate.
delay_based_limit_ = DataRate::PlusInfinity();
UpdateTargetBitrate(bitrate, at_time);
@@ -244,6 +245,7 @@ DataRate SendSideBandwidthEstimation::GetEstimatedLinkCapacity() const {
void SendSideBandwidthEstimation::UpdateReceiverEstimate(Timestamp at_time,
DataRate bandwidth) {
LOG_ERROR("6");
// TODO(srte): Ensure caller passes PlusInfinity, not zero, to represent no
// limitation.
receiver_limit_ = bandwidth.IsZero() ? DataRate::PlusInfinity() : bandwidth;
@@ -252,6 +254,7 @@ void SendSideBandwidthEstimation::UpdateReceiverEstimate(Timestamp at_time,
void SendSideBandwidthEstimation::UpdateDelayBasedEstimate(Timestamp at_time,
DataRate bitrate) {
LOG_ERROR("7");
link_capacity_.UpdateDelayBasedEstimate(at_time, bitrate);
// TODO(srte): Ensure caller passes PlusInfinity, not zero, to represent no
// limitation.
@@ -342,7 +345,9 @@ void SendSideBandwidthEstimation::UpdateRtt(TimeDelta rtt, Timestamp at_time) {
}
void SendSideBandwidthEstimation::UpdateEstimate(Timestamp at_time) {
LOG_ERROR("1");
if (rtt_backoff_.IsRttAboveLimit()) {
LOG_ERROR("11");
if (at_time - time_last_decrease_ >= rtt_backoff_.drop_interval_ &&
current_target_ > rtt_backoff_.bandwidth_floor_) {
time_last_decrease_ = at_time;
@@ -357,7 +362,7 @@ void SendSideBandwidthEstimation::UpdateEstimate(Timestamp at_time) {
ApplyTargetLimits(at_time);
return;
}
LOG_ERROR("111");
// We trust the REMB and/or delay-based estimate during the first 2 seconds if
// we haven't had any packet loss reported, to allow startup bitrate probing.
if (last_fraction_loss_ == 0 && IsInStartPhase(at_time)) {
@@ -376,22 +381,28 @@ void SendSideBandwidthEstimation::UpdateEstimate(Timestamp at_time) {
return;
}
}
LOG_ERROR("112");
UpdateMinHistory(at_time);
if (last_loss_packet_report_.IsInfinite()) {
// No feedback received.
// TODO(srte): This is likely redundant in most cases.
LOG_ERROR("113");
ApplyTargetLimits(at_time);
return;
}
TimeDelta time_since_loss_packet_report = at_time - last_loss_packet_report_;
if (time_since_loss_packet_report < 1.2 * kMaxRtcpFeedbackInterval) {
LOG_ERROR("114");
// We only care about loss above a given bitrate threshold.
float loss = last_fraction_loss_ / 256.0f;
LOG_ERROR("current_target_ = [{}], loss = [{}]", ToString(current_target_),
loss);
// We only make decisions based on loss when the bitrate is above a
// threshold. This is a crude way of handling loss which is uncorrelated
// to congestion.
if (current_target_ < bitrate_threshold_ || loss <= low_loss_threshold_) {
LOG_ERROR("115");
// Loss < 2%: Increase rate by 8% of the min bitrate in the last
// kBweIncreaseInterval.
// Note that by remembering the bitrate over the last second one can
@@ -412,14 +423,18 @@ void SendSideBandwidthEstimation::UpdateEstimate(Timestamp at_time) {
UpdateTargetBitrate(new_bitrate, at_time);
return;
} else if (current_target_ > bitrate_threshold_) {
LOG_ERROR("116");
if (loss <= high_loss_threshold_) {
LOG_ERROR("117");
// Loss between 2% - 10%: Do nothing.
} else {
LOG_ERROR("118");
// Loss > 10%: Limit the rate decreases to once a kBweDecreaseInterval
// + rtt.
if (!has_decreased_since_last_fraction_loss_ &&
(at_time - time_last_decrease_) >=
(kBweDecreaseInterval + last_round_trip_time_)) {
LOG_ERROR("119");
time_last_decrease_ = at_time;
// Reduce rate:
@@ -436,6 +451,7 @@ void SendSideBandwidthEstimation::UpdateEstimate(Timestamp at_time) {
}
}
}
LOG_ERROR("120");
// TODO(srte): This is likely redundant in most cases.
ApplyTargetLimits(at_time);
}
@@ -447,6 +463,7 @@ void SendSideBandwidthEstimation::UpdatePropagationRtt(
void SendSideBandwidthEstimation::OnSentPacket(const SentPacket& sent_packet) {
// Only feedback-triggering packets will be reported here.
LOG_ERROR("5");
rtt_backoff_.last_packet_sent_ = sent_packet.send_time;
}
@@ -495,6 +512,7 @@ void SendSideBandwidthEstimation::MaybeLogLowBitrateWarning(DataRate bitrate,
void SendSideBandwidthEstimation::UpdateTargetBitrate(DataRate new_bitrate,
Timestamp at_time) {
new_bitrate = std::min(new_bitrate, GetUpperLimit());
LOG_WARN("new_bitrate: [{}]", ToString(new_bitrate).c_str());
if (new_bitrate < min_bitrate_configured_) {
MaybeLogLowBitrateWarning(new_bitrate, at_time);
new_bitrate = min_bitrate_configured_;
@@ -504,6 +522,7 @@ void SendSideBandwidthEstimation::UpdateTargetBitrate(DataRate new_bitrate,
}
void SendSideBandwidthEstimation::ApplyTargetLimits(Timestamp at_time) {
LOG_ERROR("2");
UpdateTargetBitrate(current_target_, at_time);
}

3
src/qos/transport_feedback_adapter.cc
View File

@@ -262,6 +262,7 @@ TransportFeedbackAdapter::ProcessCongestionControlFeedback(
int failed_lookups = 0;
bool supports_ecn = true;
std::vector<PacketResult> packet_result_vector;
LOG_ERROR("20");
for (const rtcp::CongestionControlFeedback::PacketInfo& packet_info :
feedback.packets()) {
std::optional<PacketFeedback> packet_feedback = RetrievePacketFeedback(
@@ -277,7 +278,9 @@ TransportFeedbackAdapter::ProcessCongestionControlFeedback(
}
PacketResult result;
result.sent_packet = packet_feedback->sent;
LOG_ERROR("21");
if (packet_info.arrival_time_offset.IsFinite()) {
LOG_ERROR("22");
result.receive_time = current_offset_ - packet_info.arrival_time_offset;
supports_ecn &= packet_info.ecn != EcnMarking::kNotEct;
}

4
src/rtcp/rtcp_sender/rtcp_sender.h
View File

@@ -19,12 +19,12 @@ class RTCPSender {
RTCPSender(std::function<int(const uint8_t*, size_t)> callback,
size_t max_packet_size)
: callback_(callback), max_packet_size_(max_packet_size) {
if (max_packet_size > IP_PACKET_SIZE) {
if (max_packet_size >= IP_PACKET_SIZE) {
LOG_ERROR("max_packet_size must be less than IP_PACKET_SIZE");
}
}
~RTCPSender() {
if (index_ == 0) {
if (index_ != 0) {
LOG_ERROR("Unsent rtcp packet");
}
}

0
src/rtp/rtp_packet/rtp_packet.hxx → src/rtp/rtp_packet/rtp_packet.x
View File

9
src/rtp/rtp_packetizer/rtp_packetizer.cpp
View File

@@ -4,13 +4,14 @@
#include "rtp_packetizer_generic.h"
#include "rtp_packetizer_h264.h"
std::unique_ptr<RtpPacketizer> RtpPacketizer::Create(uint32_t payload_type) {
std::unique_ptr<RtpPacketizer> RtpPacketizer::Create(uint32_t payload_type,
uint32_t ssrc) {
switch (payload_type) {
case rtp::PAYLOAD_TYPE::H264:
return std::make_unique<RtpPacketizerH264>();
return std::make_unique<RtpPacketizerH264>(ssrc);
case rtp::PAYLOAD_TYPE::AV1:
return std::make_unique<RtpPacketizerAv1>();
return std::make_unique<RtpPacketizerAv1>(ssrc);
default:
return std::make_unique<RtpPacketizerGeneric>();
return std::make_unique<RtpPacketizerGeneric>(ssrc);
}
}

3
src/rtp/rtp_packetizer/rtp_packetizer.h
View File

@@ -15,7 +15,8 @@
class RtpPacketizer {
public:
static std::unique_ptr<RtpPacketizer> Create(uint32_t payload_type);
static std::unique_ptr<RtpPacketizer> Create(uint32_t payload_type,
uint32_t ssrc);
virtual ~RtpPacketizer() = default;

2
src/rtp/rtp_packetizer/rtp_packetizer_av1.cpp
View File

@@ -1,6 +1,6 @@
#include "rtp_packetizer_av1.h"
RtpPacketizerAv1::RtpPacketizerAv1() {}
RtpPacketizerAv1::RtpPacketizerAv1(uint32_t ssrc) {}
RtpPacketizerAv1::~RtpPacketizerAv1() {}

2
src/rtp/rtp_packetizer/rtp_packetizer_av1.h
View File

@@ -11,7 +11,7 @@
class RtpPacketizerAv1 : public RtpPacketizer {
public:
RtpPacketizerAv1();
RtpPacketizerAv1(uint32_t ssrc);
virtual ~RtpPacketizerAv1();

4
src/rtp/rtp_packetizer/rtp_packetizer_generic.cpp
View File

@@ -1,6 +1,6 @@
#include "rtp_packetizer_generic.h"
RtpPacketizerGeneric::RtpPacketizerGeneric()
RtpPacketizerGeneric::RtpPacketizerGeneric(uint32_t ssrc)
: version_(kRtpVersion),
has_padding_(false),
has_extension_(true),
@@ -9,7 +9,7 @@ RtpPacketizerGeneric::RtpPacketizerGeneric()
payload_type_(rtp::PAYLOAD_TYPE::DATA),
sequence_number_(0),
timestamp_(0),
ssrc_(0),
ssrc_(ssrc),
profile_(0),
extension_profile_(0),
extension_len_(0),

2
src/rtp/rtp_packetizer/rtp_packetizer_generic.h
View File

@@ -11,7 +11,7 @@
class RtpPacketizerGeneric : public RtpPacketizer {
public:
RtpPacketizerGeneric();
RtpPacketizerGeneric(uint32_t ssrc);
virtual ~RtpPacketizerGeneric();

4
src/rtp/rtp_packetizer/rtp_packetizer_h264.cpp
View File

@@ -1,6 +1,6 @@
#include "rtp_packetizer_h264.h"
RtpPacketizerH264::RtpPacketizerH264()
RtpPacketizerH264::RtpPacketizerH264(uint32_t ssrc)
: version_(kRtpVersion),
has_padding_(false),
has_extension_(true),
@@ -9,7 +9,7 @@ RtpPacketizerH264::RtpPacketizerH264()
payload_type_(rtp::PAYLOAD_TYPE::H264),
sequence_number_(0),
timestamp_(0),
ssrc_(0),
ssrc_(ssrc),
profile_(0),
extension_profile_(0),
extension_len_(0),

2
src/rtp/rtp_packetizer/rtp_packetizer_h264.h
View File

@@ -11,7 +11,7 @@
class RtpPacketizerH264 : public RtpPacketizer {
public:
RtpPacketizerH264();
RtpPacketizerH264(uint32_t ssrc);
virtual ~RtpPacketizerH264();

9
src/transport/ice_transport.cpp
View File

@@ -25,7 +25,8 @@ IceTransport::IceTransport(
remote_user_id_(remote_user_id),
ice_ws_transport_(ice_ws_transmission),
on_ice_status_change_(on_ice_status_change),
user_data_(user_data) {}
user_data_(user_data),
clock_(webrtc::Clock::GetRealTimeClockShared()) {}
IceTransport::~IceTransport() {
user_data_ = nullptr;
@@ -119,8 +120,8 @@ void IceTransport::InitializeChannels(
rtp::PAYLOAD_TYPE video_codec_payload_type) {
video_codec_payload_type_ = video_codec_payload_type;
video_channel_send_ =
std::make_unique<VideoChannelSend>(ice_agent_, ice_io_statistics_);
video_channel_send_ = std::make_unique<VideoChannelSend>(clock_, ice_agent_,
ice_io_statistics_);
audio_channel_send_ =
std::make_unique<AudioChannelSend>(ice_agent_, ice_io_statistics_);
data_channel_send_ =
@@ -132,7 +133,7 @@ void IceTransport::InitializeChannels(
std::weak_ptr<IceTransport> weak_self = shared_from_this();
video_channel_receive_ = std::make_unique<VideoChannelReceive>(
ice_agent_, ice_io_statistics_,
clock_, ice_agent_, ice_io_statistics_,
[this, weak_self](VideoFrame &video_frame) {
if (auto self = weak_self.lock()) {
OnReceiveCompleteFrame(video_frame);

2
src/transport/ice_transport.h
View File

@@ -14,6 +14,7 @@
// #include "congestion_control.h"
#include "audio_channel_receive.h"
#include "audio_channel_send.h"
#include "clock.h"
#include "data_channel_receive.h"
#include "data_channel_send.h"
#include "ice_agent.h"
@@ -219,6 +220,7 @@ class IceTransport : public std::enable_shared_from_this<IceTransport> {
on_receive_net_status_report_ = nullptr;
private:
std::shared_ptr<webrtc::Clock> clock_;
std::unique_ptr<VideoChannelSend> video_channel_send_ = nullptr;
std::unique_ptr<VideoChannelReceive> video_channel_receive_ = nullptr;
std::unique_ptr<AudioChannelSend> audio_channel_send_ = nullptr;

1
xmake.lua
View File

@@ -44,6 +44,7 @@ target("common")
add_deps("log")
add_files("src/common/common.cpp",
"src/common/rtc_base/*.cc",
"src/common/rtc_base/network/*.cc",
"src/common/rtc_base/numerics/*.cc",
"src/common/api/units/*.cc",
"src/common/api/transport/*.cc")