diff --git a/webrtc/call/call.cc b/webrtc/call/call.cc index 14bfbccc36..111bc4562c 100644 --- a/webrtc/call/call.cc +++ b/webrtc/call/call.cc @@ -666,7 +666,8 @@ PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type, if (stream->DeliverRtcp(packet, length)) { rtcp_delivered = true; if (event_log_) - event_log_->LogRtcpPacket(true, media_type, packet, length); + event_log_->LogRtcpPacket(kIncomingPacket, media_type, packet, + length); } } } @@ -676,7 +677,8 @@ PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type, if (stream->DeliverRtcp(packet, length)) { rtcp_delivered = true; if (event_log_) - event_log_->LogRtcpPacket(false, media_type, packet, length); + event_log_->LogRtcpPacket(kIncomingPacket, media_type, packet, + length); } } } @@ -706,7 +708,7 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type, ? DELIVERY_OK : DELIVERY_PACKET_ERROR; if (status == DELIVERY_OK && event_log_) - event_log_->LogRtpHeader(true, media_type, packet, length); + event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length); return status; } } @@ -718,7 +720,7 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type, ? DELIVERY_OK : DELIVERY_PACKET_ERROR; if (status == DELIVERY_OK && event_log_) - event_log_->LogRtpHeader(true, media_type, packet, length); + event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length); return status; } } diff --git a/webrtc/call/mock/mock_rtc_event_log.h b/webrtc/call/mock/mock_rtc_event_log.h new file mode 100644 index 0000000000..f523105d0e --- /dev/null +++ b/webrtc/call/mock/mock_rtc_event_log.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef WEBRTC_CALL_MOCK_MOCK_RTC_EVENT_LOG_H_ +#define WEBRTC_CALL_MOCK_MOCK_RTC_EVENT_LOG_H_ + +#include + +#include "testing/gmock/include/gmock/gmock.h" + +#include "webrtc/call/rtc_event_log.h" + +namespace webrtc { + +class MockRtcEventLog : public RtcEventLog { + public: + MOCK_METHOD1(SetBufferDuration, void(int64_t buffer_duration_us)); + + MOCK_METHOD2(StartLogging, + void(const std::string& file_name, int duration_ms)); + + MOCK_METHOD1(StartLogging, bool(rtc::PlatformFile log_file)); + + MOCK_METHOD0(StopLogging, void()); + + MOCK_METHOD1(LogVideoReceiveStreamConfig, + void(const webrtc::VideoReceiveStream::Config& config)); + + MOCK_METHOD1(LogVideoSendStreamConfig, + void(const webrtc::VideoSendStream::Config& config)); + + MOCK_METHOD4(LogRtpHeader, + void(PacketDirection direction, + MediaType media_type, + const uint8_t* header, + size_t packet_length)); + + MOCK_METHOD4(LogRtcpPacket, + void(PacketDirection direction, + MediaType media_type, + const uint8_t* packet, + size_t length)); + + MOCK_METHOD1(LogAudioPlayout, void(uint32_t ssrc)); + + MOCK_METHOD3(LogBwePacketLossEvent, + void(int32_t bitrate, + uint8_t fraction_loss, + int32_t total_packets)); +}; + +} // namespace webrtc + +#endif // WEBRTC_CALL_MOCK_MOCK_RTC_EVENT_LOG_H_ diff --git a/webrtc/call/rtc_event_log.cc b/webrtc/call/rtc_event_log.cc index 9f592ce479..361db81c06 100644 --- a/webrtc/call/rtc_event_log.cc +++ b/webrtc/call/rtc_event_log.cc @@ -47,11 +47,11 @@ class RtcEventLogImpl final : public RtcEventLog { const VideoReceiveStream::Config& config) override {} void LogVideoSendStreamConfig( const VideoSendStream::Config& config) override {} - void LogRtpHeader(bool incoming, + void LogRtpHeader(PacketDirection direction, MediaType media_type, const uint8_t* header, size_t packet_length) override {} - void LogRtcpPacket(bool incoming, + void LogRtcpPacket(PacketDirection direction, MediaType media_type, const uint8_t* packet, size_t length) override {} @@ -74,11 +74,11 @@ class RtcEventLogImpl final : public RtcEventLog { void LogVideoReceiveStreamConfig( const VideoReceiveStream::Config& config) override; void LogVideoSendStreamConfig(const VideoSendStream::Config& config) override; - void LogRtpHeader(bool incoming, + void LogRtpHeader(PacketDirection direction, MediaType media_type, const uint8_t* header, size_t packet_length) override; - void LogRtcpPacket(bool incoming, + void LogRtcpPacket(PacketDirection direction, MediaType media_type, const uint8_t* packet, size_t length) override; @@ -327,7 +327,7 @@ void RtcEventLogImpl::LogVideoSendStreamConfig( HandleEvent(&event); } -void RtcEventLogImpl::LogRtpHeader(bool incoming, +void RtcEventLogImpl::LogRtpHeader(PacketDirection direction, MediaType media_type, const uint8_t* header, size_t packet_length) { @@ -351,14 +351,14 @@ void RtcEventLogImpl::LogRtpHeader(bool incoming, rtclog::Event rtp_event; rtp_event.set_timestamp_us(clock_->TimeInMicroseconds()); rtp_event.set_type(rtclog::Event::RTP_EVENT); - rtp_event.mutable_rtp_packet()->set_incoming(incoming); + rtp_event.mutable_rtp_packet()->set_incoming(direction == kIncomingPacket); rtp_event.mutable_rtp_packet()->set_type(ConvertMediaType(media_type)); rtp_event.mutable_rtp_packet()->set_packet_length(packet_length); rtp_event.mutable_rtp_packet()->set_header(header, header_length); HandleEvent(&rtp_event); } -void RtcEventLogImpl::LogRtcpPacket(bool incoming, +void RtcEventLogImpl::LogRtcpPacket(PacketDirection direction, MediaType media_type, const uint8_t* packet, size_t length) { @@ -366,7 +366,7 @@ void RtcEventLogImpl::LogRtcpPacket(bool incoming, rtclog::Event rtcp_event; rtcp_event.set_timestamp_us(clock_->TimeInMicroseconds()); rtcp_event.set_type(rtclog::Event::RTCP_EVENT); - rtcp_event.mutable_rtcp_packet()->set_incoming(incoming); + rtcp_event.mutable_rtcp_packet()->set_incoming(direction == kIncomingPacket); rtcp_event.mutable_rtcp_packet()->set_type(ConvertMediaType(media_type)); RTCPUtility::RtcpCommonHeader header; diff --git a/webrtc/call/rtc_event_log.h b/webrtc/call/rtc_event_log.h index 489687a195..027f6867c6 100644 --- a/webrtc/call/rtc_event_log.h +++ b/webrtc/call/rtc_event_log.h @@ -30,6 +30,8 @@ class RtcEventLogImpl; enum class MediaType; +enum PacketDirection { kIncomingPacket = 0, kOutgoingPacket }; + class RtcEventLog { public: virtual ~RtcEventLog() {} @@ -63,13 +65,13 @@ class RtcEventLog { // Logs the header of an incoming or outgoing RTP packet. packet_length // is the total length of the packet, including both header and payload. - virtual void LogRtpHeader(bool incoming, + virtual void LogRtpHeader(PacketDirection direction, MediaType media_type, const uint8_t* header, size_t packet_length) = 0; // Logs an incoming or outgoing RTCP packet. - virtual void LogRtcpPacket(bool incoming, + virtual void LogRtcpPacket(PacketDirection direction, MediaType media_type, const uint8_t* packet, size_t length) = 0; diff --git a/webrtc/call/rtc_event_log_unittest.cc b/webrtc/call/rtc_event_log_unittest.cc index 0998071827..7003203930 100644 --- a/webrtc/call/rtc_event_log_unittest.cc +++ b/webrtc/call/rtc_event_log_unittest.cc @@ -314,7 +314,8 @@ size_t GenerateRtpPacket(uint32_t extensions_bitvector, nullptr, // SendTimeObserver* nullptr, // BitrateStatisticsObserver* nullptr, // FrameCountObserver* - nullptr); // SendSideDelayObserver* + nullptr, // SendSideDelayObserver* + nullptr); // RtcEventLog* std::vector csrcs; for (unsigned i = 0; i < csrcs_count; i++) { @@ -480,12 +481,12 @@ void LogSessionAndReadBack(size_t rtp_count, size_t bwe_loss_index = 1; for (size_t i = 1; i <= rtp_count; i++) { log_dumper->LogRtpHeader( - (i % 2 == 0), // Every second packet is incoming. + (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket, (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO, rtp_packets[i - 1].data(), rtp_packets[i - 1].size()); if (i * rtcp_count >= rtcp_index * rtp_count) { log_dumper->LogRtcpPacket( - rtcp_index % 2 == 0, // Every second packet is incoming + (rtcp_index % 2 == 0) ? kIncomingPacket : kOutgoingPacket, rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO, rtcp_packets[rtcp_index - 1]->Buffer(), rtcp_packets[rtcp_index - 1]->Length()); @@ -643,16 +644,18 @@ void DropOldEvents(uint32_t extensions_bitvector, log_dumper->SetBufferDuration(50000); log_dumper->LogVideoReceiveStreamConfig(receiver_config); log_dumper->LogVideoSendStreamConfig(sender_config); - log_dumper->LogRtpHeader(false, MediaType::AUDIO, old_rtp_packet.data(), - old_rtp_packet.size()); - log_dumper->LogRtcpPacket(true, MediaType::AUDIO, old_rtcp_packet->Buffer(), + log_dumper->LogRtpHeader(kOutgoingPacket, MediaType::AUDIO, + old_rtp_packet.data(), old_rtp_packet.size()); + log_dumper->LogRtcpPacket(kIncomingPacket, MediaType::AUDIO, + old_rtcp_packet->Buffer(), old_rtcp_packet->Length()); // Sleep 55 ms to let old events be removed from the queue. rtc::Thread::SleepMs(55); log_dumper->StartLogging(temp_filename, 10000000); - log_dumper->LogRtpHeader(true, MediaType::VIDEO, recent_rtp_packet.data(), + log_dumper->LogRtpHeader(kIncomingPacket, MediaType::VIDEO, + recent_rtp_packet.data(), recent_rtp_packet.size()); - log_dumper->LogRtcpPacket(false, MediaType::VIDEO, + log_dumper->LogRtcpPacket(kOutgoingPacket, MediaType::VIDEO, recent_rtcp_packet->Buffer(), recent_rtcp_packet->Length()); } diff --git a/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h b/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h index 6a7022a94c..d9d03e686b 100644 --- a/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h +++ b/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h @@ -24,6 +24,8 @@ class ReceiveStatistics; class RemoteBitrateEstimator; class RtpReceiver; class Transport; +class RtcEventLog; + namespace rtcp { class TransportFeedback; } @@ -73,6 +75,9 @@ class RtpRtcp : public Module { BitrateStatisticsObserver* send_bitrate_observer; FrameCountObserver* send_frame_count_observer; SendSideDelayObserver* send_side_delay_observer; + RtcEventLog* event_log; + + RTC_DISALLOW_COPY_AND_ASSIGN(Configuration); }; /* diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc index 87c0259b3e..183076ff59 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc @@ -94,7 +94,7 @@ void RtcpFormatRembTest::SetUp() { nullptr, nullptr, dummy_rtp_rtcp_impl_); test_transport_ = new TestTransport(rtcp_receiver_); rtcp_sender_ = new RTCPSender(false, system_clock_, receive_statistics_.get(), - nullptr, test_transport_); + nullptr, nullptr, test_transport_); } void RtcpFormatRembTest::TearDown() { diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc index 4b0914d47d..88ada8d957 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc @@ -20,6 +20,8 @@ #include "webrtc/base/checks.h" #include "webrtc/base/logging.h" #include "webrtc/base/trace_event.h" +#include "webrtc/call.h" +#include "webrtc/call/rtc_event_log.h" #include "webrtc/common_types.h" #include "webrtc/modules/rtp_rtcp/source/byte_io.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h" @@ -89,16 +91,21 @@ RTCPSender::FeedbackState::FeedbackState() class PacketContainer : public rtcp::CompoundPacket, public rtcp::RtcpPacket::PacketReadyCallback { public: - explicit PacketContainer(Transport* transport) - : transport_(transport), bytes_sent_(0) {} + PacketContainer(Transport* transport, RtcEventLog* event_log) + : transport_(transport), event_log_(event_log), bytes_sent_(0) {} virtual ~PacketContainer() { for (RtcpPacket* packet : appended_packets_) delete packet; } void OnPacketReady(uint8_t* data, size_t length) override { - if (transport_->SendRtcp(data, length)) + if (transport_->SendRtcp(data, length)) { bytes_sent_ += length; + if (event_log_) { + event_log_->LogRtcpPacket(kOutgoingPacket, MediaType::ANY, data, + length); + } + } } size_t SendPackets() { @@ -108,7 +115,10 @@ class PacketContainer : public rtcp::CompoundPacket, private: Transport* transport_; + RtcEventLog* const event_log_; size_t bytes_sent_; + + RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(PacketContainer); }; class RTCPSender::RtcpContext { @@ -148,11 +158,13 @@ RTCPSender::RTCPSender( Clock* clock, ReceiveStatistics* receive_statistics, RtcpPacketTypeCounterObserver* packet_type_counter_observer, + RtcEventLog* event_log, Transport* outgoing_transport) : audio_(audio), clock_(clock), random_(clock_->TimeInMicroseconds()), method_(RtcpMode::kOff), + event_log_(event_log), transport_(outgoing_transport), critical_section_rtcp_sender_( @@ -805,7 +817,7 @@ int32_t RTCPSender::SendCompoundRTCP( const uint16_t* nack_list, bool repeat, uint64_t pictureID) { - PacketContainer container(transport_); + PacketContainer container(transport_, event_log_); { CriticalSectionScoped lock(critical_section_rtcp_sender_.get()); if (method_ == RtcpMode::kOff) { @@ -1047,17 +1059,27 @@ bool RTCPSender::AllVolatileFlagsConsumed() const { bool RTCPSender::SendFeedbackPacket(const rtcp::TransportFeedback& packet) { class Sender : public rtcp::RtcpPacket::PacketReadyCallback { public: - explicit Sender(Transport* transport) - : transport_(transport), send_failure_(false) {} + Sender(Transport* transport, RtcEventLog* event_log) + : transport_(transport), event_log_(event_log), send_failure_(false) {} void OnPacketReady(uint8_t* data, size_t length) override { - if (!transport_->SendRtcp(data, length)) + if (transport_->SendRtcp(data, length)) { + if (event_log_) { + event_log_->LogRtcpPacket(kOutgoingPacket, MediaType::ANY, data, + length); + } + } else { send_failure_ = true; + } } Transport* const transport_; + RtcEventLog* const event_log_; bool send_failure_; - } sender(transport_); + // TODO(terelius): We would like to + // RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Sender); + // but we can't because of an incorrect warning (C4822) in MVS 2013. + } sender(transport_, event_log_); uint8_t buffer[IP_PACKET_SIZE]; return packet.BuildExternalBuffer(buffer, IP_PACKET_SIZE, &sender) && diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h index 3cc8f4a14d..e88a494f7d 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h @@ -36,6 +36,7 @@ namespace webrtc { class ModuleRtpRtcpImpl; class RTCPReceiver; +class RtcEventLog; class NACKStringBuilder { public: @@ -78,6 +79,7 @@ class RTCPSender { Clock* clock, ReceiveStatistics* receive_statistics, RtcpPacketTypeCounterObserver* packet_type_counter_observer, + RtcEventLog* event_log, Transport* outgoing_transport); virtual ~RTCPSender(); @@ -204,6 +206,7 @@ class RTCPSender { Random random_ GUARDED_BY(critical_section_rtcp_sender_); RtcpMode method_ GUARDED_BY(critical_section_rtcp_sender_); + RtcEventLog* const event_log_; Transport* const transport_; rtc::scoped_ptr critical_section_rtcp_sender_; @@ -297,6 +300,8 @@ class RTCPSender { typedef rtc::scoped_ptr (RTCPSender::*BuilderFunc)( const RtcpContext&); std::map builders_; + + RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RTCPSender); }; } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc index ba42c8dd50..b3ee1a6cb6 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc @@ -233,7 +233,7 @@ class RtcpSenderTest : public ::testing::Test { rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl(configuration)); rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), - nullptr, &test_transport_)); + nullptr, nullptr, &test_transport_)); rtcp_sender_->SetSSRC(kSenderSsrc); rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); } @@ -669,7 +669,7 @@ TEST_F(RtcpSenderTest, TestSendTimeOfXrRrtr) { TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) { RtcpPacketTypeCounterObserverImpl observer; rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), - &observer, &test_transport_)); + &observer, nullptr, &test_transport_)); rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli)); diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc index 450eed698e..33e23ec01a 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc @@ -43,7 +43,8 @@ RtpRtcp::Configuration::Configuration() transport_sequence_number_allocator(nullptr), send_bitrate_observer(nullptr), send_frame_count_observer(nullptr), - send_side_delay_observer(nullptr) {} + send_side_delay_observer(nullptr), + event_log(nullptr) {} RtpRtcp* RtpRtcp::CreateRtpRtcp(const RtpRtcp::Configuration& configuration) { if (configuration.clock) { @@ -68,11 +69,13 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration) configuration.transport_feedback_callback, configuration.send_bitrate_observer, configuration.send_frame_count_observer, - configuration.send_side_delay_observer), + configuration.send_side_delay_observer, + configuration.event_log), rtcp_sender_(configuration.audio, configuration.clock, configuration.receive_statistics, configuration.rtcp_packet_type_counter_observer, + configuration.event_log, configuration.outgoing_transport), rtcp_receiver_(configuration.clock, configuration.receiver_only, diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc index 19d53c5459..bd9314d5d7 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc @@ -17,6 +17,8 @@ #include "webrtc/base/checks.h" #include "webrtc/base/logging.h" #include "webrtc/base/trace_event.h" +#include "webrtc/call.h" +#include "webrtc/call/rtc_event_log.h" #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h" #include "webrtc/modules/rtp_rtcp/source/byte_io.h" #include "webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h" @@ -122,7 +124,8 @@ RTPSender::RTPSender( TransportFeedbackObserver* transport_feedback_observer, BitrateStatisticsObserver* bitrate_callback, FrameCountObserver* frame_count_observer, - SendSideDelayObserver* send_side_delay_observer) + SendSideDelayObserver* send_side_delay_observer, + RtcEventLog* event_log) : clock_(clock), // TODO(holmer): Remove this conversion when we remove the use of // TickTime. @@ -161,6 +164,7 @@ RTPSender::RTPSender( rtp_stats_callback_(NULL), frame_count_observer_(frame_count_observer), send_side_delay_observer_(send_side_delay_observer), + event_log_(event_log), // RTP variables start_timestamp_forced_(false), start_timestamp_(0), @@ -755,6 +759,9 @@ bool RTPSender::SendPacketToNetwork(const uint8_t* packet, bytes_sent = transport_->SendRtp(packet, size, options) ? static_cast(size) : -1; + if (event_log_ && bytes_sent > 0) { + event_log_->LogRtpHeader(kOutgoingPacket, MediaType::ANY, packet, size); + } } TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTPSender::SendPacketToNetwork", "size", size, "sent", @@ -1028,8 +1035,9 @@ int32_t RTPSender::SendToNetwork(uint8_t* buffer, int64_t capture_time_ms, StorageType storage, RtpPacketSender::Priority priority) { - RtpUtility::RtpHeaderParser rtp_parser(buffer, - payload_length + rtp_header_length); + size_t length = payload_length + rtp_header_length; + RtpUtility::RtpHeaderParser rtp_parser(buffer, length); + RTPHeader rtp_header; rtp_parser.Parse(&rtp_header); @@ -1039,16 +1047,15 @@ int32_t RTPSender::SendToNetwork(uint8_t* buffer, // TODO(holmer): This should be changed all over Video Engine so that negative // time is consider invalid, while 0 is considered a valid time. if (capture_time_ms > 0) { - UpdateTransmissionTimeOffset(buffer, payload_length + rtp_header_length, - rtp_header, now_ms - capture_time_ms); + UpdateTransmissionTimeOffset(buffer, length, rtp_header, + now_ms - capture_time_ms); } - UpdateAbsoluteSendTime(buffer, payload_length + rtp_header_length, - rtp_header, now_ms); + UpdateAbsoluteSendTime(buffer, length, rtp_header, now_ms); // Used for NACK and to spread out the transmission of packets. - if (packet_history_.PutRTPPacket(buffer, rtp_header_length + payload_length, - capture_time_ms, storage) != 0) { + if (packet_history_.PutRTPPacket(buffer, length, capture_time_ms, storage) != + 0) { return -1; } @@ -1072,7 +1079,6 @@ int32_t RTPSender::SendToNetwork(uint8_t* buffer, UpdateDelayStatistics(capture_time_ms, now_ms); } - size_t length = payload_length + rtp_header_length; bool sent = SendPacketToNetwork(buffer, length, PacketOptions()); // Mark the packet as sent in the history even if send failed. Dropping a diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.h b/webrtc/modules/rtp_rtcp/source/rtp_sender.h index 3c62336507..a672a06398 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.h @@ -34,6 +34,7 @@ class BitrateAggregator; class CriticalSectionWrapper; class RTPSenderAudio; class RTPSenderVideo; +class RtcEventLog; class RTPSenderInterface { public: @@ -96,7 +97,8 @@ class RTPSender : public RTPSenderInterface { TransportFeedbackObserver* transport_feedback_callback, BitrateStatisticsObserver* bitrate_callback, FrameCountObserver* frame_count_observer, - SendSideDelayObserver* send_side_delay_observer); + SendSideDelayObserver* send_side_delay_observer, + RtcEventLog* event_log); virtual ~RTPSender(); void ProcessBitrate(); @@ -433,6 +435,7 @@ class RTPSender : public RTPSenderInterface { StreamDataCountersCallback* rtp_stats_callback_ GUARDED_BY(statistics_crit_); FrameCountObserver* const frame_count_observer_; SendSideDelayObserver* const send_side_delay_observer_; + RtcEventLog* const event_log_; // RTP variables bool start_timestamp_forced_ GUARDED_BY(send_critsect_); @@ -464,6 +467,8 @@ class RTPSender : public RTPSenderInterface { // that the target bitrate is still valid. rtc::scoped_ptr target_bitrate_critsect_; uint32_t target_bitrate_ GUARDED_BY(target_bitrate_critsect_); + + RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RTPSender); }; } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc index 4e652d7b95..2bf0254111 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc @@ -19,6 +19,7 @@ #include "testing/gtest/include/gtest/gtest.h" #include "webrtc/base/buffer.h" #include "webrtc/base/scoped_ptr.h" +#include "webrtc/call/mock/mock_rtc_event_log.h" #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h" #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" @@ -120,6 +121,7 @@ class RtpSenderTest : public ::testing::Test { protected: RtpSenderTest() : fake_clock_(kStartTime), + mock_rtc_event_log_(), mock_paced_sender_(), rtp_sender_(), payload_(kPayload), @@ -132,12 +134,13 @@ class RtpSenderTest : public ::testing::Test { void SetUpRtpSender(bool pacer) { rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr, pacer ? &mock_paced_sender_ : nullptr, - nullptr, nullptr, nullptr, nullptr, - nullptr)); + nullptr, nullptr, nullptr, nullptr, nullptr, + &mock_rtc_event_log_)); rtp_sender_->SetSequenceNumber(kSeqNum); } SimulatedClock fake_clock_; + MockRtcEventLog mock_rtc_event_log_; MockRtpPacketSender mock_paced_sender_; rtc::scoped_ptr rtp_sender_; int payload_; @@ -666,6 +669,8 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) { TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) { EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _)); + EXPECT_CALL(mock_rtc_event_log_, + LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)); rtp_sender_->SetStorePacketsStatus(true, 10); EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( @@ -717,6 +722,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) { TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) { EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _)); + EXPECT_CALL(mock_rtc_event_log_, + LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)); rtp_sender_->SetStorePacketsStatus(true, 10); EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( @@ -778,6 +785,9 @@ TEST_F(RtpSenderTest, SendPadding) { // Make all (non-padding) packets go to send queue. EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _)); + EXPECT_CALL(mock_rtc_event_log_, + LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) + .Times(1 + 4 + 1); uint16_t seq_num = kSeqNum; uint32_t timestamp = kTimestamp; @@ -894,9 +904,9 @@ TEST_F(RtpSenderTest, SendPadding) { TEST_F(RtpSenderTest, SendRedundantPayloads) { MockTransport transport; - rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport, nullptr, - &mock_paced_sender_, nullptr, nullptr, - nullptr, nullptr, nullptr)); + rtp_sender_.reset(new RTPSender( + false, &fake_clock_, &transport, nullptr, &mock_paced_sender_, nullptr, + nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_)); rtp_sender_->SetSequenceNumber(kSeqNum); rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload); @@ -928,6 +938,10 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) { EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)) .Times(kNumPayloadSizes); + EXPECT_CALL(mock_rtc_event_log_, + LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) + .Times(kNumPayloadSizes); + // Send 10 packets of increasing size. for (size_t i = 0; i < kNumPayloadSizes; ++i) { int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); @@ -936,6 +950,11 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) { rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false); fake_clock_.AdvanceTimeMilliseconds(33); } + + EXPECT_CALL(mock_rtc_event_log_, + LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) + .Times(::testing::AtLeast(4)); + // The amount of padding to send it too small to send a payload packet. EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _)) .WillOnce(testing::Return(true)); @@ -1030,7 +1049,7 @@ TEST_F(RtpSenderTest, FrameCountCallbacks) { rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr, &mock_paced_sender_, nullptr, nullptr, - nullptr, &callback, nullptr)); + nullptr, &callback, nullptr, nullptr)); char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; const uint8_t payload_type = 127; @@ -1086,7 +1105,7 @@ TEST_F(RtpSenderTest, BitrateCallbacks) { } callback; rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr, &callback, nullptr, - nullptr)); + nullptr, nullptr)); // Simulate kNumPackets sent with kPacketInterval ms intervals. const uint32_t kNumPackets = 15; @@ -1139,7 +1158,7 @@ class RtpSenderAudioTest : public RtpSenderTest { payload_ = kAudioPayload; rtp_sender_.reset(new RTPSender(true, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, - nullptr)); + nullptr, nullptr)); rtp_sender_->SetSequenceNumber(kSeqNum); } }; diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc index f0f1ca4d2c..fd380feeb8 100644 --- a/webrtc/video/video_send_stream_tests.cc +++ b/webrtc/video/video_send_stream_tests.cc @@ -330,7 +330,7 @@ class FecObserver : public test::SendTest { VideoSendStreamTest::kVideoSendSsrcs[0], header.sequenceNumber, send_count_ / 2, 127); RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), - &lossy_receive_stats, nullptr, + &lossy_receive_stats, nullptr, nullptr, transport_adapter_.get()); rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize); @@ -457,7 +457,7 @@ void VideoSendStreamTest::TestNackRetransmission( nacked_sequence_number_ = nack_sequence_number; NullReceiveStatistics null_stats; RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), &null_stats, - nullptr, transport_adapter_.get()); + nullptr, nullptr, transport_adapter_.get()); rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize); rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]); @@ -644,7 +644,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format, FakeReceiveStatistics lossy_receive_stats( kVideoSendSsrcs[0], header.sequenceNumber, packet_count_ / 2, 127); RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), - &lossy_receive_stats, nullptr, + &lossy_receive_stats, nullptr, nullptr, transport_adapter_.get()); rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize); @@ -867,7 +867,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) { EXCLUSIVE_LOCKS_REQUIRED(crit_) { FakeReceiveStatistics receive_stats(kVideoSendSsrcs[0], last_sequence_number_, rtp_count_, 0); - RTCPSender rtcp_sender(false, clock_, &receive_stats, nullptr, + RTCPSender rtcp_sender(false, clock_, &receive_stats, nullptr, nullptr, transport_adapter_.get()); rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize); @@ -924,7 +924,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) { // Receive statistics reporting having lost 50% of the packets. FakeReceiveStatistics receive_stats(kVideoSendSsrcs[0], 1, 1, 0); RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), &receive_stats, - nullptr, transport_adapter_.get()); + nullptr, nullptr, transport_adapter_.get()); rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize); rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]); diff --git a/webrtc/voice_engine/channel.cc b/webrtc/voice_engine/channel.cc index b1b55e8acc..46e04ba882 100644 --- a/webrtc/voice_engine/channel.cc +++ b/webrtc/voice_engine/channel.cc @@ -922,6 +922,7 @@ Channel::Channel(int32_t channelId, configuration.transport_sequence_number_allocator = seq_num_allocator_proxy_.get(); configuration.transport_feedback_callback = feedback_observer_proxy_.get(); + configuration.event_log = event_log; _rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));