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

Delete SendDelayObserver interface

Browse Source 
send delay is now measured through  SendPacketObserver interface

Bug: None
Change-Id: I0dc3de1522e2824d9431d7e3a3dc524588687dda
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/319500
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#40755}
This commit is contained in:
Danil Chapovalov 2023-09-13 18:06:58 +02:00 committed by WebRTC LUCI CQ
parent 745641e589
commit 3aa951a7c6
12 changed files with 10 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
call/rtp_transport_controller_send_interface.h
View File

@ -57,7 +57,6 @@ struct RtpSenderObservers {
BitrateStatisticsObserver* bitrate_observer;
FrameCountObserver* frame_count_observer;
RtcpPacketTypeCounterObserver* rtcp_type_observer;
SendSideDelayObserver* send_delay_observer;
SendPacketObserver* send_packet_observer;
};

1
call/rtp_video_sender.cc
View File

@ -224,7 +224,6 @@ std::vector<RtpStreamSender> CreateRtpStreamSenders(
observers.report_block_data_observer;
configuration.paced_sender = transport->packet_sender();
configuration.send_bitrate_observer = observers.bitrate_observer;
configuration.send_side_delay_observer = observers.send_delay_observer;
configuration.send_packet_observer = observers.send_packet_observer;
configuration.event_log = event_log;
configuration.retransmission_rate_limiter = retransmission_rate_limiter;

7
call/rtp_video_sender_unittest.cc
View File

@ -66,8 +66,7 @@ RtpSenderObservers CreateObservers(
StreamDataCountersCallback* rtp_stats,
BitrateStatisticsObserver* bitrate_observer,
FrameCountObserver* frame_count_observer,
RtcpPacketTypeCounterObserver* rtcp_type_observer,
SendSideDelayObserver* send_delay_observer) {
RtcpPacketTypeCounterObserver* rtcp_type_observer) {
RtpSenderObservers observers;
observers.rtcp_rtt_stats = nullptr;
observers.intra_frame_callback = intra_frame_callback;
@ -77,7 +76,6 @@ RtpSenderObservers CreateObservers(
observers.bitrate_observer = bitrate_observer;
observers.frame_count_observer = frame_count_observer;
observers.rtcp_type_observer = rtcp_type_observer;
observers.send_delay_observer = send_delay_observer;
observers.send_packet_observer = nullptr;
return observers;
}
@ -145,8 +143,7 @@ class RtpVideoSenderTestFixture {
time_controller_.GetClock(), suspended_ssrcs, suspended_payload_states,
config_.rtp, config_.rtcp_report_interval_ms, &transport_,
CreateObservers(&encoder_feedback_, &stats_proxy_, &stats_proxy_,
&stats_proxy_, frame_count_observer, &stats_proxy_,
&stats_proxy_),
&stats_proxy_, frame_count_observer, &stats_proxy_),
&transport_controller_, &event_log_, &retransmission_rate_limiter_,
std::make_unique<FecControllerDefault>(time_controller_.GetClock()),
nullptr, CryptoOptions{}, frame_transformer,

11
modules/rtp_rtcp/include/rtp_rtcp_defines.h
View File

@ -406,19 +406,8 @@ class BitrateStatisticsObserver {
uint32_t ssrc) = 0;
};
// Callback, used to notify an observer whenever the send-side delay is updated.
class SendSideDelayObserver {
public:
virtual ~SendSideDelayObserver() {}
virtual void SendSideDelayUpdated(int avg_delay_ms,
int max_delay_ms,
uint32_t ssrc) = 0;
};
// Callback, used to notify an observer whenever a packet is sent to the
// transport.
// TODO(asapersson): This class will remove the need for SendSideDelayObserver.
// Remove SendSideDelayObserver once possible.
class SendPacketObserver {
public:
virtual ~SendPacketObserver() = default;

87
modules/rtp_rtcp/source/deprecated/deprecated_rtp_sender_egress.cc
View File

@ -23,7 +23,6 @@
namespace webrtc {
namespace {
constexpr uint32_t kTimestampTicksPerMs = 90;
constexpr int kSendSideDelayWindowMs = 1000;
constexpr TimeDelta kBitrateStatisticsWindow = TimeDelta::Seconds(1);
constexpr size_t kRtpSequenceNumberMapMaxEntries = 1 << 13;
@ -73,15 +72,12 @@ DEPRECATED_RtpSenderEgress::DEPRECATED_RtpSenderEgress(
is_audio_(config.audio),
need_rtp_packet_infos_(config.need_rtp_packet_infos),
transport_feedback_observer_(config.transport_feedback_callback),
send_side_delay_observer_(config.send_side_delay_observer),
send_packet_observer_(config.send_packet_observer),
rtp_stats_callback_(config.rtp_stats_callback),
bitrate_callback_(config.send_bitrate_observer),
media_has_been_sent_(false),
force_part_of_allocation_(false),
timestamp_offset_(0),
max_delay_it_(send_delays_.end()),
sum_delays_ms_(0),
send_rates_(kNumMediaTypes, BitrateTracker(kBitrateStatisticsWindow)),
rtp_sequence_number_map_(need_rtp_packet_infos_
? std::make_unique<RtpSequenceNumberMap>(
@ -180,7 +176,6 @@ void DEPRECATED_RtpSenderEgress::SendPacket(
if (packet->packet_type() != RtpPacketMediaType::kPadding &&
packet->packet_type() != RtpPacketMediaType::kRetransmission) {
UpdateDelayStatistics(packet->capture_time().ms(), now_ms, packet_ssrc);
UpdateOnSendPacket(options.packet_id, packet->capture_time().ms(),
packet_ssrc);
}
@ -317,88 +312,6 @@ void DEPRECATED_RtpSenderEgress::AddPacketToTransportFeedback(
}
}
void DEPRECATED_RtpSenderEgress::UpdateDelayStatistics(int64_t capture_time_ms,
int64_t now_ms,
uint32_t ssrc) {
if (!send_side_delay_observer_ || capture_time_ms <= 0)
return;
int avg_delay_ms = 0;
int max_delay_ms = 0;
{
MutexLock lock(&lock_);
// Compute the max and average of the recent capture-to-send delays.
// The time complexity of the current approach depends on the distribution
// of the delay values. This could be done more efficiently.
// Remove elements older than kSendSideDelayWindowMs.
auto lower_bound =
send_delays_.lower_bound(now_ms - kSendSideDelayWindowMs);
for (auto it = send_delays_.begin(); it != lower_bound; ++it) {
if (max_delay_it_ == it) {
max_delay_it_ = send_delays_.end();
}
sum_delays_ms_ -= it->second;
}
send_delays_.erase(send_delays_.begin(), lower_bound);
if (max_delay_it_ == send_delays_.end()) {
// Removed the previous max. Need to recompute.
RecomputeMaxSendDelay();
}
// Add the new element.
RTC_DCHECK_GE(now_ms, 0);
RTC_DCHECK_LE(now_ms, std::numeric_limits<int64_t>::max() / 2);
RTC_DCHECK_GE(capture_time_ms, 0);
RTC_DCHECK_LE(capture_time_ms, std::numeric_limits<int64_t>::max() / 2);
int64_t diff_ms = now_ms - capture_time_ms;
RTC_DCHECK_GE(diff_ms, static_cast<int64_t>(0));
RTC_DCHECK_LE(diff_ms, std::numeric_limits<int>::max());
int new_send_delay = rtc::dchecked_cast<int>(now_ms - capture_time_ms);
SendDelayMap::iterator it;
bool inserted;
std::tie(it, inserted) =
send_delays_.insert(std::make_pair(now_ms, new_send_delay));
if (!inserted) {
// TODO(terelius): If we have multiple delay measurements during the same
// millisecond then we keep the most recent one. It is not clear that this
// is the right decision, but it preserves an earlier behavior.
int previous_send_delay = it->second;
sum_delays_ms_ -= previous_send_delay;
it->second = new_send_delay;
if (max_delay_it_ == it && new_send_delay < previous_send_delay) {
RecomputeMaxSendDelay();
}
}
if (max_delay_it_ == send_delays_.end() ||
it->second >= max_delay_it_->second) {
max_delay_it_ = it;
}
sum_delays_ms_ += new_send_delay;
size_t num_delays = send_delays_.size();
RTC_DCHECK(max_delay_it_ != send_delays_.end());
max_delay_ms = rtc::dchecked_cast<int>(max_delay_it_->second);
int64_t avg_ms = (sum_delays_ms_ + num_delays / 2) / num_delays;
RTC_DCHECK_GE(avg_ms, static_cast<int64_t>(0));
RTC_DCHECK_LE(avg_ms,
static_cast<int64_t>(std::numeric_limits<int>::max()));
avg_delay_ms =
rtc::dchecked_cast<int>((sum_delays_ms_ + num_delays / 2) / num_delays);
}
send_side_delay_observer_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms,
ssrc);
}
void DEPRECATED_RtpSenderEgress::RecomputeMaxSendDelay() {
max_delay_it_ = send_delays_.begin();
for (auto it = send_delays_.begin(); it != send_delays_.end(); ++it) {
if (it->second >= max_delay_it_->second) {
max_delay_it_ = it;
}
}
}
void DEPRECATED_RtpSenderEgress::UpdateOnSendPacket(int packet_id,
int64_t capture_time_ms,
uint32_t ssrc) {

14
modules/rtp_rtcp/source/deprecated/deprecated_rtp_sender_egress.h
View File

@ -83,20 +83,11 @@ class DEPRECATED_RtpSenderEgress {
RTC_LOCKS_EXCLUDED(lock_);
private:
// Maps capture time in milliseconds to send-side delay in milliseconds.
// Send-side delay is the difference between transmission time and capture
// time.
typedef std::map<int64_t, int> SendDelayMap;
RtpSendRates GetSendRatesLocked() const RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_);
bool HasCorrectSsrc(const RtpPacketToSend& packet) const;
void AddPacketToTransportFeedback(uint16_t packet_id,
const RtpPacketToSend& packet,
const PacedPacketInfo& pacing_info);
void UpdateDelayStatistics(int64_t capture_time_ms,
int64_t now_ms,
uint32_t ssrc);
void RecomputeMaxSendDelay() RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_);
void UpdateOnSendPacket(int packet_id,
int64_t capture_time_ms,
uint32_t ssrc);
@ -119,7 +110,6 @@ class DEPRECATED_RtpSenderEgress {
const bool need_rtp_packet_infos_;
TransportFeedbackObserver* const transport_feedback_observer_;
SendSideDelayObserver* const send_side_delay_observer_;
SendPacketObserver* const send_packet_observer_;
StreamDataCountersCallback* const rtp_stats_callback_;
BitrateStatisticsObserver* const bitrate_callback_;
@ -129,10 +119,6 @@ class DEPRECATED_RtpSenderEgress {
bool force_part_of_allocation_ RTC_GUARDED_BY(lock_);
uint32_t timestamp_offset_ RTC_GUARDED_BY(lock_);
SendDelayMap send_delays_ RTC_GUARDED_BY(lock_);
SendDelayMap::const_iterator max_delay_it_ RTC_GUARDED_BY(lock_);
// The sum of delays over a kSendSideDelayWindowMs sliding window.
int64_t sum_delays_ms_ RTC_GUARDED_BY(lock_);
StreamDataCounters rtp_stats_ RTC_GUARDED_BY(lock_);
StreamDataCounters rtx_rtp_stats_ RTC_GUARDED_BY(lock_);
// One element per value in RtpPacketMediaType, with index matching value.

1
modules/rtp_rtcp/source/rtp_rtcp_interface.h
View File

@ -95,7 +95,6 @@ class RtpRtcpInterface : public RtcpFeedbackSenderInterface {
VideoFecGenerator* fec_generator = nullptr;
BitrateStatisticsObserver* send_bitrate_observer = nullptr;
SendSideDelayObserver* send_side_delay_observer = nullptr;
RtcEventLog* event_log = nullptr;
SendPacketObserver* send_packet_observer = nullptr;
RateLimiter* retransmission_rate_limiter = nullptr;

93
modules/rtp_rtcp/source/rtp_sender_egress.cc
View File

@ -23,7 +23,6 @@
namespace webrtc {
namespace {
constexpr uint32_t kTimestampTicksPerMs = 90;
constexpr TimeDelta kSendSideDelayWindow = TimeDelta::Seconds(1);
constexpr TimeDelta kBitrateStatisticsWindow = TimeDelta::Seconds(1);
constexpr size_t kRtpSequenceNumberMapMaxEntries = 1 << 13;
constexpr TimeDelta kUpdateInterval = kBitrateStatisticsWindow;
@ -96,15 +95,12 @@ RtpSenderEgress::RtpSenderEgress(const RtpRtcpInterface::Configuration& config,
need_rtp_packet_infos_(config.need_rtp_packet_infos),
fec_generator_(config.fec_generator),
transport_feedback_observer_(config.transport_feedback_callback),
send_side_delay_observer_(config.send_side_delay_observer),
send_packet_observer_(config.send_packet_observer),
rtp_stats_callback_(config.rtp_stats_callback),
bitrate_callback_(config.send_bitrate_observer),
media_has_been_sent_(false),
force_part_of_allocation_(false),
timestamp_offset_(0),
max_delay_it_(send_delays_.end()),
sum_delays_(TimeDelta::Zero()),
send_rates_(kNumMediaTypes, BitrateTracker(kBitrateStatisticsWindow)),
rtp_sequence_number_map_(need_rtp_packet_infos_
? std::make_unique<RtpSequenceNumberMap>(
@ -263,11 +259,11 @@ void RtpSenderEgress::CompleteSendPacket(const Packet& compound_packet,
options.additional_data = packet->additional_data();
const uint32_t packet_ssrc = packet->Ssrc();
if (packet->packet_type() != RtpPacketMediaType::kPadding &&
packet->packet_type() != RtpPacketMediaType::kRetransmission) {
UpdateDelayStatistics(packet->capture_time(), now, packet_ssrc);
UpdateOnSendPacket(packet_id, packet->capture_time(), packet_ssrc);
packet->packet_type() != RtpPacketMediaType::kRetransmission &&
send_packet_observer_ != nullptr && packet->capture_time().IsFinite()) {
send_packet_observer_->OnSendPacket(packet_id, packet->capture_time(),
packet->Ssrc());
}
options.batchable = enable_send_packet_batching_ && !is_audio_;
options.last_packet_in_batch = last_in_batch;
@ -294,8 +290,8 @@ void RtpSenderEgress::CompleteSendPacket(const Packet& compound_packet,
RTC_DCHECK(packet->packet_type().has_value());
RtpPacketMediaType packet_type = *packet->packet_type();
RtpPacketCounter counter(*packet);
size_t size = packet->size();
UpdateRtpStats(now, packet_ssrc, packet_type, std::move(counter), size);
UpdateRtpStats(now, packet->Ssrc(), packet_type, std::move(counter),
packet->size());
}
}
@ -441,83 +437,6 @@ void RtpSenderEgress::AddPacketToTransportFeedback(
}
}
void RtpSenderEgress::UpdateDelayStatistics(Timestamp capture_time,
Timestamp now,
uint32_t ssrc) {
RTC_DCHECK_RUN_ON(worker_queue_);
if (!send_side_delay_observer_ || capture_time.IsInfinite())
return;
TimeDelta avg_delay = TimeDelta::Zero();
TimeDelta max_delay = TimeDelta::Zero();
{
// Compute the max and average of the recent capture-to-send delays.
// The time complexity of the current approach depends on the distribution
// of the delay values. This could be done more efficiently.
// Remove elements older than kSendSideDelayWindowMs.
auto lower_bound = send_delays_.lower_bound(now - kSendSideDelayWindow);
for (auto it = send_delays_.begin(); it != lower_bound; ++it) {
if (max_delay_it_ == it) {
max_delay_it_ = send_delays_.end();
}
sum_delays_ -= it->second;
}
send_delays_.erase(send_delays_.begin(), lower_bound);
if (max_delay_it_ == send_delays_.end()) {
// Removed the previous max. Need to recompute.
RecomputeMaxSendDelay();
}
// Add the new element.
TimeDelta new_send_delay = now - capture_time;
auto [it, inserted] = send_delays_.emplace(now, new_send_delay);
if (!inserted) {
// TODO(terelius): If we have multiple delay measurements during the same
// millisecond then we keep the most recent one. It is not clear that this
// is the right decision, but it preserves an earlier behavior.
TimeDelta previous_send_delay = it->second;
sum_delays_ -= previous_send_delay;
it->second = new_send_delay;
if (max_delay_it_ == it && new_send_delay < previous_send_delay) {
RecomputeMaxSendDelay();
}
}
if (max_delay_it_ == send_delays_.end() ||
it->second >= max_delay_it_->second) {
max_delay_it_ = it;
}
sum_delays_ += new_send_delay;
size_t num_delays = send_delays_.size();
RTC_DCHECK(max_delay_it_ != send_delays_.end());
max_delay = max_delay_it_->second;
avg_delay = sum_delays_ / num_delays;
}
send_side_delay_observer_->SendSideDelayUpdated(avg_delay.ms(),
max_delay.ms(), ssrc);
}
void RtpSenderEgress::RecomputeMaxSendDelay() {
RTC_DCHECK_RUN_ON(worker_queue_);
max_delay_it_ = send_delays_.begin();
for (auto it = send_delays_.begin(); it != send_delays_.end(); ++it) {
if (it->second >= max_delay_it_->second) {
max_delay_it_ = it;
}
}
}
void RtpSenderEgress::UpdateOnSendPacket(absl::optional<uint16_t> packet_id,
Timestamp capture_time,
uint32_t ssrc) {
if (!send_packet_observer_ || capture_time.IsInfinite()) {
return;
}
send_packet_observer_->OnSendPacket(packet_id, capture_time, ssrc);
}
bool RtpSenderEgress::SendPacketToNetwork(const RtpPacketToSend& packet,
const PacketOptions& options,
const PacedPacketInfo& pacing_info) {

16
modules/rtp_rtcp/source/rtp_sender_egress.h
View File

@ -113,13 +113,7 @@ class RtpSenderEgress {
void AddPacketToTransportFeedback(uint16_t packet_id,
const RtpPacketToSend& packet,
const PacedPacketInfo& pacing_info);
void UpdateDelayStatistics(Timestamp capture_time,
Timestamp now,
uint32_t ssrc);
void RecomputeMaxSendDelay();
void UpdateOnSendPacket(absl::optional<uint16_t> packet_id,
Timestamp capture_time,
uint32_t ssrc);
// Sends packet on to `transport_`, leaving the RTP module.
bool SendPacketToNetwork(const RtpPacketToSend& packet,
const PacketOptions& options,
@ -153,7 +147,6 @@ class RtpSenderEgress {
absl::optional<uint16_t> last_sent_rtx_seq_ RTC_GUARDED_BY(worker_queue_);
TransportFeedbackObserver* const transport_feedback_observer_;
SendSideDelayObserver* const send_side_delay_observer_;
SendPacketObserver* const send_packet_observer_;
StreamDataCountersCallback* const rtp_stats_callback_;
BitrateStatisticsObserver* const bitrate_callback_;
@ -162,13 +155,6 @@ class RtpSenderEgress {
bool force_part_of_allocation_ RTC_GUARDED_BY(worker_queue_);
uint32_t timestamp_offset_ RTC_GUARDED_BY(worker_queue_);
// Maps capture time to send-side delay. Send-side delay is the difference
// between transmission time and capture time.
std::map<Timestamp, TimeDelta> send_delays_ RTC_GUARDED_BY(worker_queue_);
std::map<Timestamp, TimeDelta>::const_iterator max_delay_it_
RTC_GUARDED_BY(worker_queue_);
// The sum of delays over a kSendSideDelayWindowMs sliding window.
TimeDelta sum_delays_ RTC_GUARDED_BY(worker_queue_);
StreamDataCounters rtp_stats_ RTC_GUARDED_BY(worker_queue_);
StreamDataCounters rtx_rtp_stats_ RTC_GUARDED_BY(worker_queue_);
// One element per value in RtpPacketMediaType, with index matching value.

54
modules/rtp_rtcp/source/rtp_sender_egress_unittest.cc
View File

@ -77,11 +77,6 @@ class MockStreamDataCountersCallback : public StreamDataCountersCallback {
(override));
};
class MockSendSideDelayObserver : public SendSideDelayObserver {
public:
MOCK_METHOD(void, SendSideDelayUpdated, (int, int, uint32_t), (override));
};
struct TransmittedPacket {
TransmittedPacket(rtc::ArrayView<const uint8_t> data,
const PacketOptions& packet_options,
@ -329,48 +324,6 @@ TEST_F(RtpSenderEgressTest,
EXPECT_EQ(offset, 0);
}
TEST_F(RtpSenderEgressTest, OnSendSideDelayUpdated) {
StrictMock<MockSendSideDelayObserver> send_side_delay_observer;
RtpRtcpInterface::Configuration config = DefaultConfig();
config.send_side_delay_observer = &send_side_delay_observer;
auto sender = std::make_unique<RtpSenderEgress>(config, &packet_history_);
// Send packet with 10 ms send-side delay. The average, max and total should
// be 10 ms.
EXPECT_CALL(send_side_delay_observer, SendSideDelayUpdated(10, 10, kSsrc));
int64_t capture_time_ms = clock_->TimeInMilliseconds();
time_controller_.AdvanceTime(TimeDelta::Millis(10));
sender->SendPacket(BuildRtpPacket(/*marker=*/true, capture_time_ms),
PacedPacketInfo());
// Send another packet with 20 ms delay. The average, max and total should be
// 15, 20 and 30 ms respectively.
EXPECT_CALL(send_side_delay_observer, SendSideDelayUpdated(15, 20, kSsrc));
capture_time_ms = clock_->TimeInMilliseconds();
time_controller_.AdvanceTime(TimeDelta::Millis(20));
sender->SendPacket(BuildRtpPacket(/*marker=*/true, capture_time_ms),
PacedPacketInfo());
// Send another packet at the same time, which replaces the last packet.
// Since this packet has 0 ms delay, the average is now 5 ms and max is 10 ms.
// The total counter stays the same though.
// TODO(terelius): Is is not clear that this is the right behavior.
EXPECT_CALL(send_side_delay_observer, SendSideDelayUpdated(5, 10, kSsrc));
capture_time_ms = clock_->TimeInMilliseconds();
sender->SendPacket(BuildRtpPacket(/*marker=*/true, capture_time_ms),
PacedPacketInfo());
// Send a packet 1 second later. The earlier packets should have timed
// out, so both max and average should be the delay of this packet. The total
// keeps increasing.
time_controller_.AdvanceTime(TimeDelta::Seconds(1));
EXPECT_CALL(send_side_delay_observer, SendSideDelayUpdated(1, 1, kSsrc));
capture_time_ms = clock_->TimeInMilliseconds();
time_controller_.AdvanceTime(TimeDelta::Millis(1));
sender->SendPacket(BuildRtpPacket(/*marker=*/true, capture_time_ms),
PacedPacketInfo());
}
TEST_F(RtpSenderEgressTest, WritesPacerExitToTimingExtension) {
std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
header_extensions_.RegisterByUri(kVideoTimingExtensionId,
@ -852,7 +805,6 @@ TEST_F(RtpSenderEgressTest, SendPacketSetsPacketOptions) {
TEST_F(RtpSenderEgressTest, SendPacketUpdatesStats) {
const size_t kPayloadSize = 1000;
StrictMock<MockSendSideDelayObserver> send_side_delay_observer;
const rtc::ArrayView<const RtpExtensionSize> kNoRtpHeaderExtensionSizes;
FlexfecSender flexfec(kFlexfectPayloadType, kFlexFecSsrc, kSsrc, /*mid=*/"",
@ -860,7 +812,6 @@ TEST_F(RtpSenderEgressTest, SendPacketUpdatesStats) {
/*rtp_state=*/nullptr, time_controller_.GetClock());
RtpRtcpInterface::Configuration config = DefaultConfig();
config.fec_generator = &flexfec;
config.send_side_delay_observer = &send_side_delay_observer;
auto sender = std::make_unique<RtpSenderEgress>(config, &packet_history_);
header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
@ -889,11 +840,6 @@ TEST_F(RtpSenderEgressTest, SendPacketUpdatesStats) {
const int64_t kDiffMs = 25;
time_controller_.AdvanceTime(TimeDelta::Millis(kDiffMs));
EXPECT_CALL(send_side_delay_observer,
SendSideDelayUpdated(kDiffMs, kDiffMs, kSsrc));
EXPECT_CALL(send_side_delay_observer,
SendSideDelayUpdated(kDiffMs, kDiffMs, kFlexFecSsrc));
EXPECT_CALL(send_packet_observer_, OnSendPacket(Eq(1), capture_time, kSsrc));
sender->SendPacket(std::move(video_packet), PacedPacketInfo());

8
video/send_statistics_proxy.h
View File

@ -43,8 +43,7 @@ class SendStatisticsProxy : public VideoStreamEncoderObserver,
public RtcpPacketTypeCounterObserver,
public StreamDataCountersCallback,
public BitrateStatisticsObserver,
public FrameCountObserver,
public SendSideDelayObserver {
public FrameCountObserver {
public:
static constexpr TimeDelta kStatsTimeout = TimeDelta::Seconds(5);
// Number of required samples to be collected before a metric is added
@ -129,11 +128,6 @@ class SendStatisticsProxy : public VideoStreamEncoderObserver,
void FrameCountUpdated(const FrameCounts& frame_counts,
uint32_t ssrc) override;
// From SendSideDelayObserver.
void SendSideDelayUpdated(int avg_delay_ms,
int max_delay_ms,
uint32_t ssrc) override {}
private:
class SampleCounter {
public:

1
video/video_send_stream.cc
View File

@ -101,7 +101,6 @@ RtpSenderObservers CreateObservers(RtcpRttStats* call_stats,
observers.bitrate_observer = stats_proxy;
observers.frame_count_observer = stats_proxy;
observers.rtcp_type_observer = stats_proxy;
observers.send_delay_observer = nullptr;
observers.send_packet_observer = send_packet_observer;
return observers;
}