summaryrefslogtreecommitdiff
path: root/modules/rtp_rtcp
diff options
context:
space:
mode:
Diffstat (limited to 'modules/rtp_rtcp')
-rw-r--r--modules/rtp_rtcp/interface/rtp_rtcp_defines.h4
-rw-r--r--modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc6
-rw-r--r--modules/rtp_rtcp/source/rtcp_receiver.cc14
-rw-r--r--modules/rtp_rtcp/source/rtcp_receiver.h10
-rw-r--r--modules/rtp_rtcp/source/rtcp_sender.cc27
-rw-r--r--modules/rtp_rtcp/source/rtcp_sender.h5
-rw-r--r--modules/rtp_rtcp/source/rtcp_sender_unittest.cc18
-rw-r--r--modules/rtp_rtcp/source/rtp_header_extension.cc10
-rw-r--r--modules/rtp_rtcp/source/rtp_rtcp_impl.cc95
-rw-r--r--modules/rtp_rtcp/source/rtp_rtcp_impl.h10
-rw-r--r--modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc10
-rw-r--r--modules/rtp_rtcp/source/rtp_sender.cc126
-rw-r--r--modules/rtp_rtcp/source/rtp_sender.h15
-rw-r--r--modules/rtp_rtcp/source/rtp_sender_unittest.cc52
-rw-r--r--modules/rtp_rtcp/source/ssrc_database.cc93
-rw-r--r--modules/rtp_rtcp/source/ssrc_database.h9
16 files changed, 189 insertions, 315 deletions
diff --git a/modules/rtp_rtcp/interface/rtp_rtcp_defines.h b/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
index e1bec5fc..99808439 100644
--- a/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
+++ b/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
@@ -198,12 +198,14 @@ struct RtpState {
start_timestamp(0),
timestamp(0),
capture_time_ms(-1),
- last_timestamp_time_ms(-1) {}
+ last_timestamp_time_ms(-1),
+ media_has_been_sent(false) {}
uint16_t sequence_number;
uint32_t start_timestamp;
uint32_t timestamp;
int64_t capture_time_ms;
int64_t last_timestamp_time_ms;
+ bool media_has_been_sent;
};
class RtpData
diff --git a/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc b/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
index 0514277f..5e580a34 100644
--- a/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
@@ -121,7 +121,8 @@ TEST_F(RtcpFormatRembTest, TestNonCompund) {
uint32_t SSRC = 456789;
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpNonCompound));
EXPECT_EQ(0, rtcp_sender_->SetREMBData(1234, 1, &SSRC));
- RTCPSender::FeedbackState feedback_state(dummy_rtp_rtcp_impl_);
+ RTCPSender::FeedbackState feedback_state =
+ dummy_rtp_rtcp_impl_->GetFeedbackState();
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRemb));
}
@@ -129,7 +130,8 @@ TEST_F(RtcpFormatRembTest, TestCompund) {
uint32_t SSRCs[2] = {456789, 98765};
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
EXPECT_EQ(0, rtcp_sender_->SetREMBData(1234, 2, SSRCs));
- RTCPSender::FeedbackState feedback_state(dummy_rtp_rtcp_impl_);
+ RTCPSender::FeedbackState feedback_state =
+ dummy_rtp_rtcp_impl_->GetFeedbackState();
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRemb));
}
} // namespace
diff --git a/modules/rtp_rtcp/source/rtcp_receiver.cc b/modules/rtp_rtcp/source/rtcp_receiver.cc
index b38ae1f0..54b991bf 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -224,12 +224,12 @@ bool RTCPReceiver::GetAndResetXrRrRtt(uint16_t* rtt_ms) {
return true;
}
-int32_t
-RTCPReceiver::NTP(uint32_t *ReceivedNTPsecs,
- uint32_t *ReceivedNTPfrac,
- uint32_t *RTCPArrivalTimeSecs,
- uint32_t *RTCPArrivalTimeFrac,
- uint32_t *rtcp_timestamp) const
+// TODO(pbos): Make this fail when we haven't received NTP.
+bool RTCPReceiver::NTP(uint32_t* ReceivedNTPsecs,
+ uint32_t* ReceivedNTPfrac,
+ uint32_t* RTCPArrivalTimeSecs,
+ uint32_t* RTCPArrivalTimeFrac,
+ uint32_t* rtcp_timestamp) const
{
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
if(ReceivedNTPsecs)
@@ -251,7 +251,7 @@ RTCPReceiver::NTP(uint32_t *ReceivedNTPsecs,
if (rtcp_timestamp) {
*rtcp_timestamp = _remoteSenderInfo.RTPtimeStamp;
}
- return 0;
+ return true;
}
bool RTCPReceiver::LastReceivedXrReferenceTimeInfo(
diff --git a/modules/rtp_rtcp/source/rtcp_receiver.h b/modules/rtp_rtcp/source/rtcp_receiver.h
index ebffb7cf..84eb24c7 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver.h
+++ b/modules/rtp_rtcp/source/rtcp_receiver.h
@@ -63,11 +63,11 @@ public:
char cName[RTCP_CNAME_SIZE]) const;
// get received NTP
- int32_t NTP(uint32_t *ReceivedNTPsecs,
- uint32_t *ReceivedNTPfrac,
- uint32_t *RTCPArrivalTimeSecs,
- uint32_t *RTCPArrivalTimeFrac,
- uint32_t *rtcp_timestamp) const;
+ bool NTP(uint32_t* ReceivedNTPsecs,
+ uint32_t* ReceivedNTPfrac,
+ uint32_t* RTCPArrivalTimeSecs,
+ uint32_t* RTCPArrivalTimeFrac,
+ uint32_t* rtcp_timestamp) const;
bool LastReceivedXrReferenceTimeInfo(RtcpReceiveTimeInfo* info) const;
diff --git a/modules/rtp_rtcp/source/rtcp_sender.cc b/modules/rtp_rtcp/source/rtcp_sender.cc
index 2cf7e1cb..1edbee43 100644
--- a/modules/rtp_rtcp/source/rtcp_sender.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender.cc
@@ -65,30 +65,11 @@ std::string NACKStringBuilder::GetResult()
return _stream.str();
}
-RTCPSender::FeedbackState::FeedbackState(ModuleRtpRtcpImpl* module)
- : send_payload_type(module->SendPayloadType()),
- frequency_hz(module->CurrentSendFrequencyHz()),
- packet_count_sent(module->PacketCountSent()),
- byte_count_sent(module->ByteCountSent()),
- module(module) {
- uint32_t last_ntp_secs = 0, last_ntp_frac = 0, last_remote_sr = 0;
- module->LastReceivedNTP(last_ntp_secs, last_ntp_frac, last_remote_sr);
- last_rr_ntp_secs = last_ntp_secs;
- last_rr_ntp_frac = last_ntp_frac;
- remote_sr = last_remote_sr;
-
- has_last_xr_rr = module->LastReceivedXrReferenceTimeInfo(&last_xr_rr);
-
- uint32_t send_bitrate = 0, tmp;
- module->BitrateSent(&send_bitrate, &tmp, &tmp, &tmp);
- this->send_bitrate = send_bitrate;
-}
-
RTCPSender::FeedbackState::FeedbackState()
: send_payload_type(0),
frequency_hz(0),
- packet_count_sent(0),
- byte_count_sent(0),
+ packets_sent(0),
+ media_bytes_sent(0),
send_bitrate(0),
last_rr_ntp_secs(0),
last_rr_ntp_frac(0),
@@ -654,12 +635,12 @@ int32_t RTCPSender::BuildSR(const FeedbackState& feedback_state,
//sender's packet count
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos,
- feedback_state.packet_count_sent);
+ feedback_state.packets_sent);
pos += 4;
//sender's octet count
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos,
- feedback_state.byte_count_sent);
+ feedback_state.media_bytes_sent);
pos += 4;
uint8_t numberOfReportBlocks = 0;
diff --git a/modules/rtp_rtcp/source/rtcp_sender.h b/modules/rtp_rtcp/source/rtcp_sender.h
index fad3b5e3..26c44b04 100644
--- a/modules/rtp_rtcp/source/rtcp_sender.h
+++ b/modules/rtp_rtcp/source/rtcp_sender.h
@@ -51,13 +51,12 @@ class RTCPSender
{
public:
struct FeedbackState {
- explicit FeedbackState(ModuleRtpRtcpImpl* module);
FeedbackState();
uint8_t send_payload_type;
uint32_t frequency_hz;
- uint32_t packet_count_sent;
- uint32_t byte_count_sent;
+ uint32_t packets_sent;
+ uint32_t media_bytes_sent;
uint32_t send_bitrate;
uint32_t last_rr_ntp_secs;
diff --git a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
index cba1c346..b8d53953 100644
--- a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@@ -337,7 +337,7 @@ class RtcpSenderTest : public ::testing::Test {
TEST_F(RtcpSenderTest, RtcpOff) {
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpOff));
- RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_);
+ RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
}
@@ -381,7 +381,7 @@ TEST_F(RtcpSenderTest, TestCompound) {
EXPECT_EQ(0, rtcp_sender_->SetIJStatus(true));
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
- RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_);
+ RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRr));
// Transmission time offset packet should be received.
@@ -392,7 +392,7 @@ TEST_F(RtcpSenderTest, TestCompound) {
TEST_F(RtcpSenderTest, TestCompound_NoRtpReceived) {
EXPECT_EQ(0, rtcp_sender_->SetIJStatus(true));
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
- RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_);
+ RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRr));
// Transmission time offset packet should not be received.
@@ -402,7 +402,7 @@ TEST_F(RtcpSenderTest, TestCompound_NoRtpReceived) {
TEST_F(RtcpSenderTest, TestXrReceiverReferenceTime) {
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
- RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_);
+ RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false));
rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
@@ -413,7 +413,7 @@ TEST_F(RtcpSenderTest, TestXrReceiverReferenceTime) {
TEST_F(RtcpSenderTest, TestNoXrReceiverReferenceTimeIfSending) {
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
- RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_);
+ RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, true));
rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
@@ -424,7 +424,7 @@ TEST_F(RtcpSenderTest, TestNoXrReceiverReferenceTimeIfSending) {
TEST_F(RtcpSenderTest, TestNoXrReceiverReferenceTimeIfNotEnabled) {
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
- RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_);
+ RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false));
rtcp_sender_->SendRtcpXrReceiverReferenceTime(false);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
@@ -435,7 +435,7 @@ TEST_F(RtcpSenderTest, TestNoXrReceiverReferenceTimeIfNotEnabled) {
TEST_F(RtcpSenderTest, TestSendTimeOfXrRrReport) {
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
- RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_);
+ RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false));
rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
uint32_t ntp_sec;
@@ -475,7 +475,7 @@ TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) {
TMMBRSet bounding_set;
EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3));
ASSERT_EQ(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags);
- RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_);
+ RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state,kRtcpSr));
// We now expect the packet to show up in the rtcp_packet_info_ of
// test_transport_.
@@ -498,7 +498,7 @@ TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndValid) {
EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3));
ASSERT_EQ(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags);
- RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_);
+ RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
// We now expect the packet to show up in the rtcp_packet_info_ of
// test_transport_.
diff --git a/modules/rtp_rtcp/source/rtp_header_extension.cc b/modules/rtp_rtcp/source/rtp_header_extension.cc
index 2e72d750..9a1836e1 100644
--- a/modules/rtp_rtcp/source/rtp_header_extension.cc
+++ b/modules/rtp_rtcp/source/rtp_header_extension.cc
@@ -65,6 +65,16 @@ int32_t RtpHeaderExtensionMap::Deregister(const RTPExtensionType type) {
return 0;
}
+bool RtpHeaderExtensionMap::IsRegistered(RTPExtensionType type) const {
+ std::map<uint8_t, HeaderExtension*>::const_iterator it =
+ extensionMap_.begin();
+ for (; it != extensionMap_.end(); ++it) {
+ if (it->second->type == type)
+ return true;
+ }
+ return false;
+}
+
int32_t RtpHeaderExtensionMap::GetType(const uint8_t id,
RTPExtensionType* type) const {
assert(type);
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index 349340f5..1a3b79cb 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -230,8 +230,7 @@ int32_t ModuleRtpRtcpImpl::Process() {
}
if (rtcp_sender_.TimeToSendRTCPReport()) {
- RTCPSender::FeedbackState feedback_state(this);
- rtcp_sender_.SendRTCP(feedback_state, kRtcpReport);
+ rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpReport);
}
}
@@ -418,12 +417,29 @@ int32_t ModuleRtpRtcpImpl::SetCSRCs(
return 0; // TODO(pwestin): change to void.
}
-uint32_t ModuleRtpRtcpImpl::PacketCountSent() const {
- return rtp_sender_.Packets();
-}
+// TODO(pbos): Handle media and RTX streams separately (separate RTCP
+// feedbacks).
+RTCPSender::FeedbackState ModuleRtpRtcpImpl::GetFeedbackState() {
+ StreamDataCounters rtp_stats;
+ StreamDataCounters rtx_stats;
+ rtp_sender_.GetDataCounters(&rtp_stats, &rtx_stats);
+
+ RTCPSender::FeedbackState state;
+ state.send_payload_type = SendPayloadType();
+ state.frequency_hz = CurrentSendFrequencyHz();
+ state.packets_sent = rtp_stats.packets + rtx_stats.packets;
+ state.media_bytes_sent = rtp_stats.bytes + rtx_stats.bytes;
+ state.module = this;
+
+ LastReceivedNTP(&state.last_rr_ntp_secs,
+ &state.last_rr_ntp_frac,
+ &state.remote_sr);
-uint32_t ModuleRtpRtcpImpl::ByteCountSent() const {
- return rtp_sender_.Bytes();
+ state.has_last_xr_rr = LastReceivedXrReferenceTimeInfo(&state.last_xr_rr);
+
+ uint32_t tmp;
+ BitrateSent(&state.send_bitrate, &tmp, &tmp, &tmp);
+ return state;
}
int ModuleRtpRtcpImpl::CurrentSendFrequencyHz() const {
@@ -433,8 +449,7 @@ int ModuleRtpRtcpImpl::CurrentSendFrequencyHz() const {
int32_t ModuleRtpRtcpImpl::SetSendingStatus(const bool sending) {
if (rtcp_sender_.Sending() != sending) {
// Sends RTCP BYE when going from true to false
- RTCPSender::FeedbackState feedback_state(this);
- if (rtcp_sender_.SetSendingStatus(feedback_state, sending) != 0) {
+ if (rtcp_sender_.SetSendingStatus(GetFeedbackState(), sending) != 0) {
LOG(LS_WARNING) << "Failed to send RTCP BYE";
}
@@ -499,8 +514,7 @@ int32_t ModuleRtpRtcpImpl::SendOutgoingData(
if (!IsDefaultModule()) {
// Don't send RTCP from default module.
if (rtcp_sender_.TimeToSendRTCPReport(kVideoFrameKey == frame_type)) {
- RTCPSender::FeedbackState feedback_state(this);
- rtcp_sender_.SendRTCP(feedback_state, kRtcpReport);
+ rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpReport);
}
return rtp_sender_.SendOutgoingData(frame_type,
payload_type,
@@ -599,14 +613,10 @@ int ModuleRtpRtcpImpl::TimeToSendPadding(int bytes) {
}
} else {
CriticalSectionScoped lock(critical_section_module_ptrs_.get());
- // Decide what media stream to pad on based on a round-robin scheme.
for (size_t i = 0; i < child_modules_.size(); ++i) {
- padding_index_ = (padding_index_ + 1) % child_modules_.size();
// Send padding on one of the modules sending media.
- if (child_modules_[padding_index_]->SendingMedia() &&
- child_modules_[padding_index_]->rtp_sender_.GetTargetBitrate() > 0) {
- return child_modules_[padding_index_]->rtp_sender_.TimeToSendPadding(
- bytes);
+ if (child_modules_[i]->SendingMedia()) {
+ return child_modules_[i]->rtp_sender_.TimeToSendPadding(bytes);
}
}
}
@@ -751,7 +761,9 @@ int32_t ModuleRtpRtcpImpl::RemoteNTP(
received_ntpfrac,
rtcp_arrival_time_secs,
rtcp_arrival_time_frac,
- rtcp_timestamp);
+ rtcp_timestamp)
+ ? 0
+ : -1;
}
// Get RoundTripTime.
@@ -782,8 +794,7 @@ int32_t ModuleRtpRtcpImpl::ResetSendDataCountersRTP() {
// Force a send of an RTCP packet.
// Normal SR and RR are triggered via the process function.
int32_t ModuleRtpRtcpImpl::SendRTCP(uint32_t rtcp_packet_type) {
- RTCPSender::FeedbackState feedback_state(this);
- return rtcp_sender_.SendRTCP(feedback_state, rtcp_packet_type);
+ return rtcp_sender_.SendRTCP(GetFeedbackState(), rtcp_packet_type);
}
int32_t ModuleRtpRtcpImpl::SetRTCPApplicationSpecificData(
@@ -811,11 +822,17 @@ bool ModuleRtpRtcpImpl::RtcpXrRrtrStatus() const {
int32_t ModuleRtpRtcpImpl::DataCountersRTP(
uint32_t* bytes_sent,
uint32_t* packets_sent) const {
+ StreamDataCounters rtp_stats;
+ StreamDataCounters rtx_stats;
+ rtp_sender_.GetDataCounters(&rtp_stats, &rtx_stats);
+
if (bytes_sent) {
- *bytes_sent = rtp_sender_.Bytes();
+ *bytes_sent = rtp_stats.bytes + rtp_stats.padding_bytes +
+ rtp_stats.header_bytes + rtx_stats.bytes +
+ rtx_stats.padding_bytes + rtx_stats.header_bytes;
}
if (packets_sent) {
- *packets_sent = rtp_sender_.Packets();
+ *packets_sent = rtp_stats.packets + rtx_stats.packets;
}
return 0;
}
@@ -955,9 +972,8 @@ int32_t ModuleRtpRtcpImpl::SendNACK(const uint16_t* nack_list,
}
nack_last_seq_number_sent_ = nack_list[start_id + nackLength - 1];
- RTCPSender::FeedbackState feedback_state(this);
return rtcp_sender_.SendRTCP(
- feedback_state, kRtcpNack, nackLength, &nack_list[start_id]);
+ GetFeedbackState(), kRtcpNack, nackLength, &nack_list[start_id]);
}
// Store the sent packets, needed to answer to a Negative acknowledgment
@@ -1074,9 +1090,8 @@ int32_t ModuleRtpRtcpImpl::RequestKeyFrame() {
int32_t ModuleRtpRtcpImpl::SendRTCPSliceLossIndication(
const uint8_t picture_id) {
- RTCPSender::FeedbackState feedback_state(this);
return rtcp_sender_.SendRTCP(
- feedback_state, kRtcpSli, 0, 0, false, picture_id);
+ GetFeedbackState(), kRtcpSli, 0, 0, false, picture_id);
}
int32_t ModuleRtpRtcpImpl::SetCameraDelay(const int32_t delay_ms) {
@@ -1245,9 +1260,8 @@ void ModuleRtpRtcpImpl::OnRequestSendReport() {
int32_t ModuleRtpRtcpImpl::SendRTCPReferencePictureSelection(
const uint64_t picture_id) {
- RTCPSender::FeedbackState feedback_state(this);
return rtcp_sender_.SendRTCP(
- feedback_state, kRtcpRpsi, 0, 0, false, picture_id);
+ GetFeedbackState(), kRtcpRpsi, 0, 0, false, picture_id);
}
uint32_t ModuleRtpRtcpImpl::SendTimeOfSendReport(
@@ -1274,23 +1288,24 @@ void ModuleRtpRtcpImpl::OnReceivedNACK(
rtp_sender_.OnReceivedNACK(nack_sequence_numbers, rtt);
}
-int32_t ModuleRtpRtcpImpl::LastReceivedNTP(
- uint32_t& rtcp_arrival_time_secs, // When we got the last report.
- uint32_t& rtcp_arrival_time_frac,
- uint32_t& remote_sr) {
+bool ModuleRtpRtcpImpl::LastReceivedNTP(
+ uint32_t* rtcp_arrival_time_secs, // When we got the last report.
+ uint32_t* rtcp_arrival_time_frac,
+ uint32_t* remote_sr) const {
// Remote SR: NTP inside the last received (mid 16 bits from sec and frac).
uint32_t ntp_secs = 0;
uint32_t ntp_frac = 0;
- if (-1 == rtcp_receiver_.NTP(&ntp_secs,
- &ntp_frac,
- &rtcp_arrival_time_secs,
- &rtcp_arrival_time_frac,
- NULL)) {
- return -1;
+ if (!rtcp_receiver_.NTP(&ntp_secs,
+ &ntp_frac,
+ rtcp_arrival_time_secs,
+ rtcp_arrival_time_frac,
+ NULL)) {
+ return false;
}
- remote_sr = ((ntp_secs & 0x0000ffff) << 16) + ((ntp_frac & 0xffff0000) >> 16);
- return 0;
+ *remote_sr =
+ ((ntp_secs & 0x0000ffff) << 16) + ((ntp_frac & 0xffff0000) >> 16);
+ return true;
}
bool ModuleRtpRtcpImpl::LastReceivedXrReferenceTimeInfo(
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/modules/rtp_rtcp/source/rtp_rtcp_impl.h
index 7e7ea027..4a23dd40 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@@ -89,12 +89,10 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
virtual int32_t SetCSRCStatus(const bool include) OVERRIDE;
- virtual uint32_t PacketCountSent() const;
+ virtual RTCPSender::FeedbackState GetFeedbackState();
virtual int CurrentSendFrequencyHz() const;
- virtual uint32_t ByteCountSent() const;
-
virtual void SetRTXSendStatus(const int mode) OVERRIDE;
virtual void RTXSendStatus(int* mode, uint32_t* ssrc,
@@ -328,9 +326,9 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
const FecProtectionParams* delta_params,
const FecProtectionParams* key_params) OVERRIDE;
- virtual int32_t LastReceivedNTP(uint32_t& NTPsecs,
- uint32_t& NTPfrac,
- uint32_t& remote_sr);
+ virtual bool LastReceivedNTP(uint32_t* NTPsecs,
+ uint32_t* NTPfrac,
+ uint32_t* remote_sr) const;
virtual bool LastReceivedXrReferenceTimeInfo(RtcpReceiveTimeInfo* info) const;
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
index 930778c3..3101a1fe 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
@@ -388,7 +388,7 @@ class RtpSendingTest : public ::testing::Test {
VideoCodec codec_;
};
-TEST_F(RtpSendingTest, RoundRobinPadding) {
+TEST_F(RtpSendingTest, DISABLED_RoundRobinPadding) {
// We have to send on an SSRC to be allowed to pad, since a marker bit must
// be sent prior to padding packets.
const uint8_t payload[200] = {0};
@@ -410,9 +410,13 @@ TEST_F(RtpSendingTest, RoundRobinPadding) {
ExpectPadding(expected_padding);
}
-TEST_F(RtpSendingTest, RoundRobinPaddingRtx) {
+TEST_F(RtpSendingTest, DISABLED_RoundRobinPaddingRtx) {
// Enable RTX to allow padding to be sent prior to media.
for (int i = 1; i < codec_.numberOfSimulcastStreams + 1; ++i) {
+ // Abs-send-time is needed to be allowed to send padding prior to media,
+ // as otherwise the timestmap used for BWE will be broken.
+ senders_[i]->RegisterSendRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
+ 1);
senders_[i]->SetRtxSendPayloadType(96);
senders_[i]->SetRtxSsrc(kSenderRtxSsrc + i);
senders_[i]->SetRTXSendStatus(kRtxRetransmitted);
@@ -436,7 +440,7 @@ TEST_F(RtpSendingTest, RoundRobinPaddingRtx) {
ExpectPadding(expected_padding);
}
-TEST_F(RtpSendingTest, RoundRobinPaddingRtxRedundantPayloads) {
+TEST_F(RtpSendingTest, DISABLED_RoundRobinPaddingRtxRedundantPayloads) {
for (int i = 1; i < codec_.numberOfSimulcastStreams + 1; ++i) {
senders_[i]->SetRtxSendPayloadType(96);
senders_[i]->SetRtxSsrc(kSenderRtxSsrc + i);
diff --git a/modules/rtp_rtcp/source/rtp_sender.cc b/modules/rtp_rtcp/source/rtp_sender.cc
index c24b15a3..eb88be7c 100644
--- a/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/modules/rtp_rtcp/source/rtp_sender.cc
@@ -87,6 +87,7 @@ RTPSender::RTPSender(const int32_t id,
timestamp_(0),
capture_time_ms_(0),
last_timestamp_time_ms_(0),
+ media_has_been_sent_(false),
last_packet_marker_bit_(false),
num_csrcs_(0),
csrcs_(),
@@ -430,14 +431,9 @@ int32_t RTPSender::SendOutgoingData(
"Send", "type", FrameTypeToString(frame_type));
assert(frame_type != kAudioFrameSpeech && frame_type != kAudioFrameCN);
- if (frame_type == kFrameEmpty) {
- if (paced_sender_->Enabled()) {
- // Padding is driven by the pacer and not by the encoder.
- return 0;
- }
- return SendPaddingAccordingToBitrate(payload_type, capture_timestamp,
- capture_time_ms) ? 0 : -1;
- }
+ if (frame_type == kFrameEmpty)
+ return 0;
+
ret_val = video_->SendVideo(video_type, frame_type, payload_type,
capture_timestamp, capture_time_ms,
payload_data, payload_size,
@@ -475,45 +471,6 @@ int RTPSender::SendRedundantPayloads(int payload_type, int bytes_to_send) {
return bytes_to_send - bytes_left;
}
-bool RTPSender::SendPaddingAccordingToBitrate(
- int8_t payload_type, uint32_t capture_timestamp,
- int64_t capture_time_ms) {
- // Current bitrate since last estimate(1 second) averaged with the
- // estimate since then, to get the most up to date bitrate.
- uint32_t current_bitrate = bitrate_sent_.BitrateNow();
- uint32_t target_bitrate = GetTargetBitrate();
- int bitrate_diff = target_bitrate - current_bitrate;
- if (bitrate_diff <= 0) {
- return true;
- }
- int bytes = 0;
- if (current_bitrate == 0) {
- // Start up phase. Send one 33.3 ms batch to start with.
- bytes = (bitrate_diff / 8) / 30;
- } else {
- bytes = (bitrate_diff / 8);
- // Cap at 200 ms of target send data.
- int bytes_cap = target_bitrate / 1000 * 25; // 1000 / 8 / 5.
- if (bytes > bytes_cap) {
- bytes = bytes_cap;
- }
- }
- uint32_t timestamp;
- {
- CriticalSectionScoped cs(send_critsect_);
- // Add the random RTP timestamp offset and store the capture time for
- // later calculation of the send time offset.
- timestamp = start_timestamp_ + capture_timestamp;
- timestamp_ = timestamp;
- capture_time_ms_ = capture_time_ms;
- last_timestamp_time_ms_ = clock_->TimeInMilliseconds();
- }
- int bytes_sent = SendPadData(payload_type, timestamp, capture_time_ms,
- bytes, false, false);
- // We did not manage to send all bytes. Comparing with 31 due to modulus 32.
- return bytes - bytes_sent < 31;
-}
-
int RTPSender::BuildPaddingPacket(uint8_t* packet, int header_length,
int32_t bytes) {
int padding_bytes_in_packet = kMaxPaddingLength;
@@ -536,9 +493,7 @@ int RTPSender::BuildPaddingPacket(uint8_t* packet, int header_length,
int RTPSender::SendPadData(int payload_type,
uint32_t timestamp,
int64_t capture_time_ms,
- int32_t bytes,
- bool force_full_size_packets,
- bool over_rtx) {
+ int32_t bytes) {
// Drop this packet if we're not sending media packets.
if (!SendingMedia()) {
return bytes;
@@ -547,36 +502,34 @@ int RTPSender::SendPadData(int payload_type,
int bytes_sent = 0;
for (; bytes > 0; bytes -= padding_bytes_in_packet) {
// Always send full padding packets.
- if (force_full_size_packets && bytes < kMaxPaddingLength)
+ if (bytes < kMaxPaddingLength)
bytes = kMaxPaddingLength;
- if (bytes < kMaxPaddingLength) {
- if (force_full_size_packets) {
- bytes = kMaxPaddingLength;
- } else {
- // Round to the nearest multiple of 32.
- bytes = (bytes + 16) & 0xffe0;
- }
- }
- if (bytes < 32) {
- // Sanity don't send empty packets.
- break;
- }
+
uint32_t ssrc;
uint16_t sequence_number;
+ bool over_rtx;
{
CriticalSectionScoped cs(send_critsect_);
// Only send padding packets following the last packet of a frame,
// indicated by the marker bit.
- if (!over_rtx && !last_packet_marker_bit_)
- return bytes_sent;
if (rtx_ == kRtxOff) {
+ // Without RTX we can't send padding in the middle of frames.
+ if (!last_packet_marker_bit_)
+ return bytes_sent;
ssrc = ssrc_;
sequence_number = sequence_number_;
++sequence_number_;
+ over_rtx = false;
} else {
+ // Without abs-send-time a media packet must be sent before padding so
+ // that the timestamps used for estimation are correct.
+ if (!media_has_been_sent_ && !rtp_header_extension_map_.IsRegistered(
+ kRtpExtensionAbsoluteSendTime))
+ return bytes_sent;
ssrc = ssrc_rtx_;
sequence_number = sequence_number_rtx_;
++sequence_number_rtx_;
+ over_rtx = true;
}
}
@@ -656,10 +609,13 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id, uint32_t min_resend_time) {
return length;
}
}
-
- CriticalSectionScoped lock(send_critsect_);
+ int rtx = kRtxOff;
+ {
+ CriticalSectionScoped lock(send_critsect_);
+ rtx = rtx_;
+ }
return PrepareAndSendPacket(data_buffer, length, capture_time_ms,
- (rtx_ & kRtxRetransmitted) > 0, true) ?
+ (rtx & kRtxRetransmitted) > 0, true) ?
length : -1;
}
@@ -852,6 +808,10 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
diff_ms);
UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms);
bool ret = SendPacketToNetwork(buffer_to_send_ptr, length);
+ if (ret) {
+ CriticalSectionScoped lock(send_critsect_);
+ media_has_been_sent_ = true;
+ }
UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx,
is_retransmit);
return ret;
@@ -907,6 +867,7 @@ bool RTPSender::IsFecPacket(const uint8_t* buffer,
}
int RTPSender::TimeToSendPadding(int bytes) {
+ assert(bytes > 0);
int payload_type;
int64_t capture_time_ms;
uint32_t timestamp;
@@ -933,12 +894,8 @@ int RTPSender::TimeToSendPadding(int bytes) {
bytes_sent = SendRedundantPayloads(payload_type, bytes);
bytes -= bytes_sent;
if (bytes > 0) {
- int padding_sent = SendPadData(payload_type,
- timestamp,
- capture_time_ms,
- bytes,
- true,
- rtx != kRtxOff);
+ int padding_sent =
+ SendPadData(payload_type, timestamp, capture_time_ms, bytes);
bytes_sent += padding_sent;
}
return bytes_sent;
@@ -992,6 +949,11 @@ int32_t RTPSender::SendToNetwork(
uint32_t length = payload_length + rtp_header_length;
if (!SendPacketToNetwork(buffer, length))
return -1;
+ assert(payload_length - rtp_header.paddingLength > 0);
+ {
+ CriticalSectionScoped lock(send_critsect_);
+ media_has_been_sent_ = true;
+ }
UpdateRtpStats(buffer, length, rtp_header, false, false);
return 0;
}
@@ -1061,17 +1023,11 @@ void RTPSender::ResetDataCounters() {
}
}
-uint32_t RTPSender::Packets() const {
- CriticalSectionScoped lock(statistics_crit_.get());
- return rtp_stats_.packets + rtx_rtp_stats_.packets;
-}
-
-// Number of sent RTP bytes.
-uint32_t RTPSender::Bytes() const {
+void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
+ StreamDataCounters* rtx_stats) const {
CriticalSectionScoped lock(statistics_crit_.get());
- return rtp_stats_.bytes + rtp_stats_.header_bytes + rtp_stats_.padding_bytes +
- rtx_rtp_stats_.bytes + rtx_rtp_stats_.header_bytes +
- rtx_rtp_stats_.padding_bytes;
+ *rtp_stats = rtp_stats_;
+ *rtx_stats = rtx_rtp_stats_;
}
int RTPSender::CreateRTPHeader(
@@ -1732,6 +1688,7 @@ void RTPSender::SetRtpState(const RtpState& rtp_state) {
timestamp_ = rtp_state.timestamp;
capture_time_ms_ = rtp_state.capture_time_ms;
last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms;
+ media_has_been_sent_ = rtp_state.media_has_been_sent;
}
RtpState RTPSender::GetRtpState() const {
@@ -1743,6 +1700,7 @@ RtpState RTPSender::GetRtpState() const {
state.timestamp = timestamp_;
state.capture_time_ms = capture_time_ms_;
state.last_timestamp_time_ms = last_timestamp_time_ms_;
+ state.media_has_been_sent = media_has_been_sent_;
return state;
}
diff --git a/modules/rtp_rtcp/source/rtp_sender.h b/modules/rtp_rtcp/source/rtp_sender.h
index 4a9e10ed..f3a2bdc1 100644
--- a/modules/rtp_rtcp/source/rtp_sender.h
+++ b/modules/rtp_rtcp/source/rtp_sender.h
@@ -109,11 +109,8 @@ class RTPSender : public RTPSenderInterface, public Bitrate::Observer {
void SetSendingMediaStatus(const bool enabled);
bool SendingMedia() const;
- // Number of sent RTP packets.
- uint32_t Packets() const;
-
- // Number of sent RTP bytes.
- uint32_t Bytes() const;
+ void GetDataCounters(StreamDataCounters* rtp_stats,
+ StreamDataCounters* rtx_stats) const;
void ResetDataCounters();
@@ -270,9 +267,7 @@ class RTPSender : public RTPSenderInterface, public Bitrate::Observer {
int SendPadData(int payload_type,
uint32_t timestamp,
int64_t capture_time_ms,
- int32_t bytes,
- bool force_full_size_packets,
- bool only_pad_after_markerbit);
+ int32_t bytes);
// Called on update of RTP statistics.
void RegisterRtpStatisticsCallback(StreamDataCountersCallback* callback);
@@ -312,9 +307,6 @@ class RTPSender : public RTPSenderInterface, public Bitrate::Observer {
int SendRedundantPayloads(int payload_type, int bytes);
- bool SendPaddingAccordingToBitrate(int8_t payload_type,
- uint32_t capture_timestamp,
- int64_t capture_time_ms);
int BuildPaddingPacket(uint8_t* packet, int header_length, int32_t bytes);
void BuildRtxPacket(uint8_t* buffer, uint16_t* length,
@@ -395,6 +387,7 @@ class RTPSender : public RTPSenderInterface, public Bitrate::Observer {
uint32_t timestamp_ GUARDED_BY(send_critsect_);
int64_t capture_time_ms_ GUARDED_BY(send_critsect_);
int64_t last_timestamp_time_ms_ GUARDED_BY(send_critsect_);
+ bool media_has_been_sent_ GUARDED_BY(send_critsect_);
bool last_packet_marker_bit_ GUARDED_BY(send_critsect_);
uint8_t num_csrcs_ GUARDED_BY(send_critsect_);
uint32_t csrcs_[kRtpCsrcSize] GUARDED_BY(send_critsect_);
diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 40b10548..e9b01def 100644
--- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -39,6 +39,7 @@ const uint8_t kAudioLevel = 0x5a;
const uint8_t kAudioLevelExtensionId = 9;
const int kAudioPayload = 103;
const uint64_t kStartTime = 123456789;
+const size_t kMaxPaddingSize = 224u;
} // namespace
using testing::_;
@@ -700,7 +701,7 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
kAbsoluteSendTimeExtensionId);
rtp_sender_->SetTargetBitrate(300000);
const size_t kNumPayloadSizes = 10;
- const int kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700, 750,
+ const size_t kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700, 750,
800, 850, 900, 950};
// Send 10 packets of increasing size.
for (size_t i = 0; i < kNumPayloadSizes; ++i) {
@@ -711,25 +712,27 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false);
fake_clock_.AdvanceTimeMilliseconds(33);
}
- const int kPaddingPayloadSize = 224;
// The amount of padding to send it too small to send a payload packet.
- EXPECT_CALL(transport, SendPacket(_, _, kPaddingPayloadSize + rtp_header_len))
+ EXPECT_CALL(transport,
+ SendPacket(_, _, kMaxPaddingSize + rtp_header_len))
.WillOnce(testing::ReturnArg<2>());
- EXPECT_EQ(kPaddingPayloadSize, rtp_sender_->TimeToSendPadding(49));
+ EXPECT_EQ(kMaxPaddingSize,
+ static_cast<size_t>(rtp_sender_->TimeToSendPadding(49)));
const int kRtxHeaderSize = 2;
EXPECT_CALL(transport, SendPacket(_, _, kPayloadSizes[0] +
rtp_header_len + kRtxHeaderSize))
.WillOnce(testing::ReturnArg<2>());
- EXPECT_EQ(kPayloadSizes[0], rtp_sender_->TimeToSendPadding(500));
+ EXPECT_EQ(kPayloadSizes[0],
+ static_cast<size_t>(rtp_sender_->TimeToSendPadding(500)));
EXPECT_CALL(transport, SendPacket(_, _, kPayloadSizes[kNumPayloadSizes - 1] +
rtp_header_len + kRtxHeaderSize))
.WillOnce(testing::ReturnArg<2>());
- EXPECT_CALL(transport, SendPacket(_, _, kPaddingPayloadSize + rtp_header_len))
+ EXPECT_CALL(transport, SendPacket(_, _, kMaxPaddingSize + rtp_header_len))
.WillOnce(testing::ReturnArg<2>());
- EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kPaddingPayloadSize,
- rtp_sender_->TimeToSendPadding(999));
+ EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize,
+ static_cast<size_t>(rtp_sender_->TimeToSendPadding(999)));
}
TEST_F(RtpSenderTest, SendGenericVideo) {
@@ -959,7 +962,6 @@ TEST_F(RtpSenderTest, StreamDataCountersCallbacks) {
const uint8_t kRedPayloadType = 96;
const uint8_t kUlpfecPayloadType = 97;
- const uint32_t kMaxPaddingSize = 224;
char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
const uint8_t payload_type = 127;
ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
@@ -988,7 +990,7 @@ TEST_F(RtpSenderTest, StreamDataCountersCallbacks) {
// Send padding.
rtp_sender_->TimeToSendPadding(kMaxPaddingSize);
// {bytes = 6, header = 24, padding = 224, packets = 3, retrans = 1, fec = 0}
- EXPECT_TRUE(callback.Matches(ssrc, 6, 24, 224, 3, 1, 0));
+ EXPECT_TRUE(callback.Matches(ssrc, 6, 24, kMaxPaddingSize, 3, 1, 0));
// Send FEC.
rtp_sender_->SetGenericFECStatus(true, kRedPayloadType, kUlpfecPayloadType);
@@ -1003,7 +1005,7 @@ TEST_F(RtpSenderTest, StreamDataCountersCallbacks) {
sizeof(payload), NULL));
// {bytes = 34, header = 48, padding = 224, packets = 5, retrans = 1, fec = 1}
- EXPECT_TRUE(callback.Matches(ssrc, 34, 48, 224, 5, 1, 1));
+ EXPECT_TRUE(callback.Matches(ssrc, 34, 48, kMaxPaddingSize, 5, 1, 1));
rtp_sender_->RegisterRtpStatisticsCallback(NULL);
}
@@ -1093,13 +1095,25 @@ TEST_F(RtpSenderTest, BytesReportedCorrectly) {
sizeof(payload),
0));
- EXPECT_GT(transport_.total_bytes_sent_, 0u);
- EXPECT_EQ(transport_.total_bytes_sent_, rtp_sender_->Bytes());
- size_t last_bytes_sent = transport_.total_bytes_sent_;
-
- rtp_sender_->TimeToSendPadding(42);
-
- EXPECT_GT(transport_.total_bytes_sent_, last_bytes_sent);
- EXPECT_EQ(transport_.total_bytes_sent_, rtp_sender_->Bytes());
+ // Will send 2 full-size padding packets.
+ rtp_sender_->TimeToSendPadding(1);
+ rtp_sender_->TimeToSendPadding(1);
+
+ StreamDataCounters rtp_stats;
+ StreamDataCounters rtx_stats;
+ rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
+
+ // Payload + 1-byte generic header.
+ EXPECT_EQ(rtp_stats.bytes, sizeof(payload) + 1);
+ EXPECT_EQ(rtp_stats.header_bytes, 12u);
+ EXPECT_EQ(rtp_stats.padding_bytes, 0u);
+ EXPECT_EQ(rtx_stats.bytes, 0u);
+ EXPECT_EQ(rtx_stats.header_bytes, 24u);
+ EXPECT_EQ(rtx_stats.padding_bytes, 2 * kMaxPaddingSize);
+
+ EXPECT_EQ(transport_.total_bytes_sent_,
+ rtp_stats.bytes + rtp_stats.header_bytes + rtp_stats.padding_bytes +
+ rtx_stats.bytes + rtx_stats.header_bytes +
+ rtx_stats.padding_bytes);
}
} // namespace webrtc
diff --git a/modules/rtp_rtcp/source/ssrc_database.cc b/modules/rtp_rtcp/source/ssrc_database.cc
index df09b01b..4e230833 100644
--- a/modules/rtp_rtcp/source/ssrc_database.cc
+++ b/modules/rtp_rtcp/source/ssrc_database.cc
@@ -57,45 +57,12 @@ SSRCDatabase::CreateSSRC()
uint32_t ssrc = GenerateRandom();
-#ifndef WEBRTC_NO_STL
-
while(_ssrcMap.find(ssrc) != _ssrcMap.end())
{
ssrc = GenerateRandom();
}
_ssrcMap[ssrc] = 0;
-#else
- if(_sizeOfSSRC <= _numberOfSSRC)
- {
- // allocate more space
- const int newSize = _sizeOfSSRC + 10;
- uint32_t* tempSSRCVector = new uint32_t[newSize];
- memcpy(tempSSRCVector, _ssrcVector, _sizeOfSSRC*sizeof(uint32_t));
- delete [] _ssrcVector;
-
- _ssrcVector = tempSSRCVector;
- _sizeOfSSRC = newSize;
- }
-
- // check if in DB
- if(_ssrcVector)
- {
- for (int i=0; i<_numberOfSSRC; i++)
- {
- if (_ssrcVector[i] == ssrc)
- {
- // we have a match
- i = 0; // start over with a new ssrc
- ssrc = GenerateRandom();
- }
-
- }
- // add to database
- _ssrcVector[_numberOfSSRC] = ssrc;
- _numberOfSSRC++;
- }
-#endif
return ssrc;
}
@@ -103,39 +70,7 @@ int32_t
SSRCDatabase::RegisterSSRC(const uint32_t ssrc)
{
CriticalSectionScoped lock(_critSect);
-
-#ifndef WEBRTC_NO_STL
-
_ssrcMap[ssrc] = 0;
-
-#else
- if(_sizeOfSSRC <= _numberOfSSRC)
- {
- // allocate more space
- const int newSize = _sizeOfSSRC + 10;
- uint32_t* tempSSRCVector = new uint32_t[newSize];
- memcpy(tempSSRCVector, _ssrcVector, _sizeOfSSRC*sizeof(uint32_t));
- delete [] _ssrcVector;
-
- _ssrcVector = tempSSRCVector;
- _sizeOfSSRC = newSize;
- }
- // check if in DB
- if(_ssrcVector)
- {
- for (int i=0; i<_numberOfSSRC; i++)
- {
- if (_ssrcVector[i] == ssrc)
- {
- // we have a match
- return -1;
- }
- }
- // add to database
- _ssrcVector[_numberOfSSRC] = ssrc;
- _numberOfSSRC++;
- }
-#endif
return 0;
}
@@ -143,26 +78,7 @@ int32_t
SSRCDatabase::ReturnSSRC(const uint32_t ssrc)
{
CriticalSectionScoped lock(_critSect);
-
-#ifndef WEBRTC_NO_STL
_ssrcMap.erase(ssrc);
-
-#else
- if(_ssrcVector)
- {
- for (int i=0; i<_numberOfSSRC; i++)
- {
- if (_ssrcVector[i] == ssrc)
- {
- // we have a match
- // remove from database
- _ssrcVector[i] = _ssrcVector[_numberOfSSRC-1];
- _numberOfSSRC--;
- break;
- }
- }
- }
-#endif
return 0;
}
@@ -178,21 +94,12 @@ SSRCDatabase::SSRCDatabase()
srand(tv.tv_usec);
#endif
-#ifdef WEBRTC_NO_STL
- _sizeOfSSRC = 10;
- _numberOfSSRC = 0;
- _ssrcVector = new uint32_t[10];
-#endif
_critSect = CriticalSectionWrapper::CreateCriticalSection();
}
SSRCDatabase::~SSRCDatabase()
{
-#ifdef WEBRTC_NO_STL
- delete [] _ssrcVector;
-#else
_ssrcMap.clear();
-#endif
delete _critSect;
}
diff --git a/modules/rtp_rtcp/source/ssrc_database.h b/modules/rtp_rtcp/source/ssrc_database.h
index e1f90e79..2d4932af 100644
--- a/modules/rtp_rtcp/source/ssrc_database.h
+++ b/modules/rtp_rtcp/source/ssrc_database.h
@@ -11,9 +11,7 @@
#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_SSRC_DATABASE_H_
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_SSRC_DATABASE_H_
-#ifndef WEBRTC_NO_STL
#include <map>
-#endif
#include "webrtc/system_wrappers/interface/static_instance.h"
#include "webrtc/typedefs.h"
@@ -46,14 +44,7 @@ private:
uint32_t GenerateRandom();
-#ifdef WEBRTC_NO_STL
- int _numberOfSSRC;
- int _sizeOfSSRC;
-
- uint32_t* _ssrcVector;
-#else
std::map<uint32_t, uint32_t> _ssrcMap;
-#endif
CriticalSectionWrapper* _critSect;
};
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-23 14:19:12 +0000