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

Remove "webrtc_rtp" traces.

Browse Source 
They have been disabled by default for years, and should have been made redundant by the event logs.

Bug: webrtc:8982
Change-Id: I491923cbc93378d28f5166d24756b335619d9c12
Reviewed-on: https://webrtc-review.googlesource.com/82800
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Jonas Olsson <jonasolsson@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23598}
This commit is contained in:
Jonas Olsson 2018-06-13 14:48:21 +02:00 committed by Commit Bot
parent 29c36b24a8
commit 9633cff81a
10 changed files with 0 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
modules/rtp_rtcp/source/rtcp_receiver.cc
View File

@ -420,9 +420,6 @@ void RTCPReceiver::HandleSenderReport(const CommonHeader& rtcp_block,
UpdateTmmbrRemoteIsAlive(remote_ssrc);
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
"remote_ssrc", remote_ssrc, "ssrc", main_ssrc_);
// Have I received RTP packets from this party?
if (remote_ssrc_ == remote_ssrc) {
// Only signal that we have received a SR when we accept one.
@ -455,9 +452,6 @@ void RTCPReceiver::HandleReceiverReport(const CommonHeader& rtcp_block,
UpdateTmmbrRemoteIsAlive(remote_ssrc);
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
"remote_ssrc", remote_ssrc, "ssrc", main_ssrc_);
packet_information->packet_type_flags |= kRtcpRr;
for (const ReportBlock& report_block : receiver_report.report_blocks())
@ -532,8 +526,6 @@ void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
packet_information->rtt_ms = rtt_ms;
}
TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT",
report_block.source_ssrc(), rtt_ms);
packet_information->report_blocks.push_back(report_block_info->report_block);
}
@ -801,8 +793,6 @@ void RTCPReceiver::HandlePli(const CommonHeader& rtcp_block,
}
if (main_ssrc_ == pli.media_ssrc()) {
TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PLI");
++packet_type_counter_.pli_packets;
// Received a signal that we need to send a new key frame.
packet_information->packet_type_flags |= kRtcpPli;

47
modules/rtp_rtcp/source/rtcp_sender.cc
View File

@ -49,35 +49,6 @@ const uint32_t kRtcpAnyExtendedReports =
kRtcpXrTargetBitrate;
} // namespace
NACKStringBuilder::NACKStringBuilder()
: stream_(""), count_(0), prevNack_(0), consecutive_(false) {}
NACKStringBuilder::~NACKStringBuilder() {}
void NACKStringBuilder::PushNACK(uint16_t nack) {
if (count_ == 0) {
stream_ << nack;
} else if (nack == prevNack_ + 1) {
consecutive_ = true;
} else {
if (consecutive_) {
stream_ << "-" << prevNack_;
consecutive_ = false;
}
stream_ << "," << nack;
}
count_++;
prevNack_ = nack;
}
std::string NACKStringBuilder::GetResult() {
if (consecutive_) {
stream_ << "-" << prevNack_;
consecutive_ = false;
}
return stream_.str();
}
RTCPSender::FeedbackState::FeedbackState()
: packets_sent(0),
media_bytes_sent(0),
@ -482,11 +453,7 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildPLI(const RtcpContext& ctx) {
pli->SetSenderSsrc(ssrc_);
pli->SetMediaSsrc(remote_ssrc_);
TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"RTCPSender::PLI");
++packet_type_counter_.pli_packets;
TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_PLICount",
ssrc_, packet_type_counter_.pli_packets);
return std::unique_ptr<rtcp::RtcpPacket>(pli);
}
@ -498,11 +465,7 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) {
fir->SetSenderSsrc(ssrc_);
fir->AddRequestTo(remote_ssrc_, sequence_number_fir_);
TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"RTCPSender::FIR");
++packet_type_counter_.fir_packets;
TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_FIRCount",
ssrc_, packet_type_counter_.fir_packets);
return std::unique_ptr<rtcp::RtcpPacket>(fir);
}
@ -514,9 +477,6 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildREMB(
remb->SetBitrateBps(remb_bitrate_);
remb->SetSsrcs(remb_ssrcs_);
TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"RTCPSender::REMB");
return std::unique_ptr<rtcp::RtcpPacket>(remb);
}
@ -612,20 +572,13 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildNACK(
nack->SetPacketIds(ctx.nack_list_, ctx.nack_size_);
// Report stats.
NACKStringBuilder stringBuilder;
for (int idx = 0; idx < ctx.nack_size_; ++idx) {
stringBuilder.PushNACK(ctx.nack_list_[idx]);
nack_stats_.ReportRequest(ctx.nack_list_[idx]);
}
packet_type_counter_.nack_requests = nack_stats_.requests();
packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests();
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"RTCPSender::NACK", "nacks",
TRACE_STR_COPY(stringBuilder.GetResult().c_str()));
++packet_type_counter_.nack_packets;
TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_NACKCount",
ssrc_, packet_type_counter_.nack_packets);
return std::unique_ptr<rtcp::RtcpPacket>(nack);
}

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

@ -14,7 +14,6 @@
#include <map>
#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <vector>
@ -41,21 +40,6 @@ namespace webrtc {
class ModuleRtpRtcpImpl;
class RtcEventLog;
class NACKStringBuilder {
public:
NACKStringBuilder();
~NACKStringBuilder();
void PushNACK(uint16_t nack);
std::string GetResult();
private:
std::ostringstream stream_;
int count_;
uint16_t prevNack_;
bool consecutive_;
};
class RTCPSender {
public:
struct FeedbackState {

155
modules/rtp_rtcp/source/rtcp_sender_unittest.cc
View File

@ -28,161 +28,6 @@ using ::testing::SizeIs;
namespace webrtc {
TEST(NACKStringBuilderTest, TestCase1) {
NACKStringBuilder builder;
builder.PushNACK(5);
builder.PushNACK(7);
builder.PushNACK(9);
builder.PushNACK(10);
builder.PushNACK(11);
builder.PushNACK(12);
builder.PushNACK(15);
builder.PushNACK(18);
builder.PushNACK(19);
EXPECT_EQ(std::string("5,7,9-12,15,18-19"), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase2) {
NACKStringBuilder builder;
builder.PushNACK(5);
builder.PushNACK(6);
builder.PushNACK(7);
builder.PushNACK(9);
builder.PushNACK(10);
builder.PushNACK(11);
builder.PushNACK(12);
builder.PushNACK(15);
builder.PushNACK(18);
builder.PushNACK(19);
EXPECT_EQ(std::string("5-7,9-12,15,18-19"), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase3) {
NACKStringBuilder builder;
builder.PushNACK(5);
builder.PushNACK(7);
builder.PushNACK(9);
builder.PushNACK(10);
builder.PushNACK(11);
builder.PushNACK(12);
builder.PushNACK(15);
builder.PushNACK(18);
builder.PushNACK(19);
builder.PushNACK(21);
EXPECT_EQ(std::string("5,7,9-12,15,18-19,21"), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase4) {
NACKStringBuilder builder;
builder.PushNACK(5);
builder.PushNACK(7);
builder.PushNACK(8);
builder.PushNACK(9);
builder.PushNACK(10);
builder.PushNACK(11);
builder.PushNACK(12);
builder.PushNACK(15);
builder.PushNACK(18);
builder.PushNACK(19);
EXPECT_EQ(std::string("5,7-12,15,18-19"), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase5) {
NACKStringBuilder builder;
builder.PushNACK(5);
builder.PushNACK(7);
builder.PushNACK(9);
builder.PushNACK(10);
builder.PushNACK(11);
builder.PushNACK(12);
builder.PushNACK(15);
builder.PushNACK(16);
builder.PushNACK(18);
builder.PushNACK(19);
EXPECT_EQ(std::string("5,7,9-12,15-16,18-19"), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase6) {
NACKStringBuilder builder;
builder.PushNACK(5);
builder.PushNACK(7);
builder.PushNACK(9);
builder.PushNACK(10);
builder.PushNACK(11);
builder.PushNACK(12);
builder.PushNACK(15);
builder.PushNACK(16);
builder.PushNACK(17);
builder.PushNACK(18);
builder.PushNACK(19);
EXPECT_EQ(std::string("5,7,9-12,15-19"), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase7) {
NACKStringBuilder builder;
builder.PushNACK(5);
builder.PushNACK(6);
builder.PushNACK(7);
builder.PushNACK(8);
builder.PushNACK(11);
builder.PushNACK(12);
builder.PushNACK(13);
builder.PushNACK(14);
builder.PushNACK(15);
EXPECT_EQ(std::string("5-8,11-15"), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase8) {
NACKStringBuilder builder;
builder.PushNACK(5);
builder.PushNACK(7);
builder.PushNACK(9);
builder.PushNACK(11);
builder.PushNACK(15);
builder.PushNACK(17);
builder.PushNACK(19);
EXPECT_EQ(std::string("5,7,9,11,15,17,19"), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase9) {
NACKStringBuilder builder;
builder.PushNACK(5);
builder.PushNACK(6);
builder.PushNACK(7);
builder.PushNACK(8);
builder.PushNACK(9);
builder.PushNACK(10);
builder.PushNACK(11);
builder.PushNACK(12);
EXPECT_EQ(std::string("5-12"), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase10) {
NACKStringBuilder builder;
builder.PushNACK(5);
EXPECT_EQ(std::string("5"), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase11) {
NACKStringBuilder builder;
EXPECT_EQ(std::string(""), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase12) {
NACKStringBuilder builder;
builder.PushNACK(5);
builder.PushNACK(6);
EXPECT_EQ(std::string("5-6"), builder.GetResult());
}
TEST(NACKStringBuilderTest, TestCase13) {
NACKStringBuilder builder;
builder.PushNACK(5);
builder.PushNACK(6);
builder.PushNACK(9);
EXPECT_EQ(std::string("5-6,9"), builder.GetResult());
}
class RtcpPacketTypeCounterObserverImpl : public RtcpPacketTypeCounterObserver {
public:
RtcpPacketTypeCounterObserverImpl() : ssrc_(0) {}

3
modules/rtp_rtcp/source/rtp_receiver_audio.cc
View File

@ -135,9 +135,6 @@ int32_t RTPReceiverAudio::ParseRtpPacket(WebRtcRTPHeader* rtp_header,
const uint8_t* payload,
size_t payload_length,
int64_t timestamp_ms) {
TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "Audio::ParseRtp",
"seqnum", rtp_header->header.sequenceNumber, "timestamp",
rtp_header->header.timestamp);
rtp_header->type.Audio.numEnergy = rtp_header->header.numCSRCs;
num_energy_ = rtp_header->type.Audio.numEnergy;
if (rtp_header->type.Audio.numEnergy > 0 &&

3
modules/rtp_rtcp/source/rtp_receiver_video.cc
View File

@ -50,9 +50,6 @@ int32_t RTPReceiverVideo::ParseRtpPacket(WebRtcRTPHeader* rtp_header,
const uint8_t* payload,
size_t payload_length,
int64_t timestamp_ms) {
TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "Video::ParseRtp",
"seqnum", rtp_header->header.sequenceNumber, "timestamp",
rtp_header->header.timestamp);
rtp_header->type.Video.codec =
specific_payload.video_payload().videoCodecType;

18
modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -687,9 +687,6 @@ bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet,
packet, pacing_info.probe_cluster_id));
}
}
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"RTPSender::SendPacketToNetwork", "size", packet.size(),
"sent", bytes_sent);
// TODO(pwestin): Add a separate bitrate for sent bitrate after pacer.
if (bytes_sent <= 0) {
RTC_LOG(LS_WARNING) << "Transport failed to send packet.";
@ -714,9 +711,6 @@ int RTPSender::SetSelectiveRetransmissions(uint8_t settings) {
void RTPSender::OnReceivedNack(
const std::vector<uint16_t>& nack_sequence_numbers,
int64_t avg_rtt) {
TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"RTPSender::OnReceivedNACK", "num_seqnum",
nack_sequence_numbers.size(), "avg_rtt", avg_rtt);
packet_history_.SetRtt(5 + avg_rtt);
for (uint16_t seq_no : nack_sequence_numbers) {
const int32_t bytes_sent = ReSendPacket(seq_no);
@ -772,15 +766,6 @@ bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
int64_t capture_time_ms = packet->capture_time_ms();
RtpPacketToSend* packet_to_send = packet.get();
if (!is_retransmit && packet->Marker()) {
TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend",
capture_time_ms);
}
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"PrepareAndSendPacket", "timestamp", packet->Timestamp(),
"seqnum", packet->SequenceNumber());
std::unique_ptr<RtpPacketToSend> packet_rtx;
if (send_over_rtx) {
packet_rtx = BuildRtxPacket(*packet);
@ -944,9 +929,6 @@ bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
if (last_capture_time_ms_sent_ == 0 ||
corrected_time_ms > last_capture_time_ms_sent_) {
last_capture_time_ms_sent_ = corrected_time_ms;
TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"PacedSend", corrected_time_ms,
"capture_time_ms", corrected_time_ms);
}
return true;
}

3
modules/rtp_rtcp/source/rtp_sender_audio.cc
View File

@ -321,9 +321,6 @@ bool RTPSenderAudio::SendTelephoneEventPacket(bool ended,
dtmfbuffer[1] = E | R | volume;
ByteWriter<uint16_t>::WriteBigEndian(dtmfbuffer + 2, duration);
TRACE_EVENT_INSTANT2(
TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "Audio::SendTelephoneEvent",
"timestamp", packet->Timestamp(), "seqnum", packet->SequenceNumber());
result = rtp_sender_->SendToNetwork(std::move(packet), kAllowRetransmission,
RtpPacketSender::kHighPriority);
send_count--;

15
modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -104,7 +104,6 @@ void RTPSenderVideo::SendVideoPacket(std::unique_ptr<RtpPacketToSend> packet,
// Remember some values about the packet before sending it away.
size_t packet_size = packet->size();
uint16_t seq_num = packet->SequenceNumber();
uint32_t rtp_timestamp = packet->Timestamp();
if (!rtp_sender_->SendToNetwork(std::move(packet), storage,
RtpPacketSender::kLowPriority)) {
RTC_LOG(LS_WARNING) << "Failed to send video packet " << seq_num;
@ -112,16 +111,12 @@ void RTPSenderVideo::SendVideoPacket(std::unique_ptr<RtpPacketToSend> packet,
}
rtc::CritScope cs(&stats_crit_);
video_bitrate_.Update(packet_size, clock_->TimeInMilliseconds());
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"Video::PacketNormal", "timestamp", rtp_timestamp,
"seqnum", seq_num);
}
void RTPSenderVideo::SendVideoPacketAsRedMaybeWithUlpfec(
std::unique_ptr<RtpPacketToSend> media_packet,
StorageType media_packet_storage,
bool protect_media_packet) {
uint32_t rtp_timestamp = media_packet->Timestamp();
uint16_t media_seq_num = media_packet->SequenceNumber();
std::unique_ptr<RtpPacketToSend> red_packet(
@ -158,9 +153,6 @@ void RTPSenderVideo::SendVideoPacketAsRedMaybeWithUlpfec(
RtpPacketSender::kLowPriority)) {
rtc::CritScope cs(&stats_crit_);
video_bitrate_.Update(red_packet_size, clock_->TimeInMilliseconds());
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"Video::PacketRed", "timestamp", rtp_timestamp,
"seqnum", media_seq_num);
} else {
RTC_LOG(LS_WARNING) << "Failed to send RED packet " << media_seq_num;
}
@ -176,9 +168,6 @@ void RTPSenderVideo::SendVideoPacketAsRedMaybeWithUlpfec(
RtpPacketSender::kLowPriority)) {
rtc::CritScope cs(&stats_crit_);
fec_bitrate_.Update(fec_packet->length(), clock_->TimeInMilliseconds());
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"Video::PacketUlpfec", "timestamp", rtp_timestamp,
"seqnum", fec_sequence_number);
} else {
RTC_LOG(LS_WARNING) << "Failed to send ULPFEC packet "
<< fec_sequence_number;
@ -202,15 +191,11 @@ void RTPSenderVideo::SendVideoPacketWithFlexfec(
flexfec_sender_->GetFecPackets();
for (auto& fec_packet : fec_packets) {
size_t packet_length = fec_packet->size();
uint32_t timestamp = fec_packet->Timestamp();
uint16_t seq_num = fec_packet->SequenceNumber();
if (rtp_sender_->SendToNetwork(std::move(fec_packet), kDontRetransmit,
RtpPacketSender::kLowPriority)) {
rtc::CritScope cs(&stats_crit_);
fec_bitrate_.Update(packet_length, clock_->TimeInMilliseconds());
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"Video::PacketFlexfec", "timestamp", timestamp,
"seqnum", seq_num);
} else {
RTC_LOG(LS_WARNING) << "Failed to send FlexFEC packet " << seq_num;
}

4
modules/video_coding/jitter_buffer.cc
View File

@ -1049,8 +1049,6 @@ bool VCMJitterBuffer::UpdateNackList(uint16_t sequence_number) {
for (uint16_t i = latest_received_sequence_number_ + 1;
IsNewerSequenceNumber(sequence_number, i); ++i) {
missing_sequence_numbers_.insert(missing_sequence_numbers_.end(), i);
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "AddNack",
"seqnum", i);
}
if (TooLargeNackList() && !HandleTooLargeNackList()) {
RTC_LOG(LS_WARNING) << "Requesting key frame due to too large NACK list.";
@ -1064,8 +1062,6 @@ bool VCMJitterBuffer::UpdateNackList(uint16_t sequence_number) {
}
} else {
missing_sequence_numbers_.erase(sequence_number);
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RemoveNack",
"seqnum", sequence_number);
}
return true;
}