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

Fixes a bug which incorrectly logs incoming RTCP as outgoing.

Browse Source 
Adds logging to RTPSender and RTCPSender, pushing an event log pointer from Channel through ModuleRtpRtcpImpl to the Sender objects.

BUG=webrtc:4741

Review URL: https://codereview.webrtc.org/1571283002

Cr-Commit-Position: refs/heads/master@{#11336}
This commit is contained in:
terelius 2016-01-21 05:42:04 -08:00 committed by Commit bot
parent b304e2686d
commit 429c345b02
16 changed files with 193 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
webrtc/call/call.cc
View File

@ -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;
}
}

61
webrtc/call/mock/mock_rtc_event_log.h Normal file
View File

@ -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 <string>
#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_

16
webrtc/call/rtc_event_log.cc
View File

@ -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;

6
webrtc/call/rtc_event_log.h
View File

@ -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;

19
webrtc/call/rtc_event_log_unittest.cc
View File

@ -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<uint32_t> 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());
}

5
webrtc/modules/rtp_rtcp/include/rtp_rtcp.h
View File

@ -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);
};
/*

2
webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
View File

@ -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() {

38
webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
View File

@ -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) &&

5
webrtc/modules/rtp_rtcp/source/rtcp_sender.h
View File

@ -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<CriticalSectionWrapper> critical_section_rtcp_sender_;
@ -297,6 +300,8 @@ class RTCPSender {
typedef rtc::scoped_ptr<rtcp::RtcpPacket> (RTCPSender::*BuilderFunc)(
const RtcpContext&);
std::map<RTCPPacketType, BuilderFunc> builders_;
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RTCPSender);
};
} // namespace webrtc

4
webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
View File

@ -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));

7
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@ -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,

26
webrtc/modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -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<int>(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

7
webrtc/modules/rtp_rtcp/source/rtp_sender.h
View File

@ -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<CriticalSectionWrapper> target_bitrate_critsect_;
uint32_t target_bitrate_ GUARDED_BY(target_bitrate_critsect_);
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RTPSender);
};
} // namespace webrtc

35
webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -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<RTPSender> 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);
}
};

10
webrtc/video/video_send_stream_tests.cc
View File

@ -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]);

1
webrtc/voice_engine/channel.cc
View File

@ -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));