zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make sure rtp_rtcp module doesn't directly reference anything in the pacer module, and remove build dependencies on it.

Browse Source 
BUG=

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

Cr-Commit-Position: refs/heads/master@{#10005}
This commit is contained in:
sprang
2015-09-21 15:11:14 -07:00
committed by Commit bot
parent 04ac81f2fd
commit ebbf8a805b
23 changed files with 161 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/modules/pacing/BUILD.gn
View File

@ -28,5 +28,6 @@ source_set("pacing") {
deps = [
"../../system_wrappers",
"../bitrate_controller",
"../rtp_rtcp",
]
}

5
webrtc/modules/pacing/bitrate_prober.cc
View File

@ -15,6 +15,7 @@
#include <limits>
#include <sstream>
#include "webrtc/modules/pacing/include/paced_sender.h"
#include "webrtc/system_wrappers/interface/logging.h"
namespace webrtc {
@ -29,8 +30,6 @@ int ComputeDeltaFromBitrate(size_t packet_size, int bitrate_bps) {
}
} // namespace
const size_t BitrateProber::kMinProbePacketSize = 200;
BitrateProber::BitrateProber()
: probing_state_(kDisabled),
packet_size_last_send_(0),
@ -90,7 +89,7 @@ int BitrateProber::TimeUntilNextProbe(int64_t now_ms) {
// We will send the first probe packet immediately if no packet has been
// sent before.
int time_until_probe_ms = 0;
if (packet_size_last_send_ > kMinProbePacketSize &&
if (packet_size_last_send_ > PacedSender::kMinProbePacketSize &&
probing_state_ == kProbing) {
int next_delta_ms = ComputeDeltaFromBitrate(packet_size_last_send_,
probe_bitrates_.front());

2
webrtc/modules/pacing/bitrate_prober.h
View File

@ -22,8 +22,6 @@ namespace webrtc {
// on being protected by the caller.
class BitrateProber {
public:
static const size_t kMinProbePacketSize;
BitrateProber();
void SetEnabled(bool enable);

25
webrtc/modules/pacing/include/paced_sender.h
View File

@ -17,6 +17,7 @@
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/thread_annotations.h"
#include "webrtc/modules/interface/module.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
#include "webrtc/typedefs.h"
namespace webrtc {
@ -30,16 +31,8 @@ struct Packet;
class PacketQueue;
} // namespace paced_sender
class PacedSender : public Module {
class PacedSender : public Module, public RtpPacketSender {
public:
enum Priority {
kHighPriority = 0, // Pass through; will be sent immediately.
kNormalPriority = 2, // Put in back of the line.
kLowPriority = 3, // Put in back of the low priority line.
};
// Low priority packets are mixed with the normal priority packets
// while we are paused.
class Callback {
public:
// Note: packets sent as a result of a callback should not pass by this
@ -68,6 +61,8 @@ class PacedSender : public Module {
// overshoots from the encoder.
static const float kDefaultPaceMultiplier;
static const size_t kMinProbePacketSize = 200;
PacedSender(Clock* clock,
Callback* callback,
int bitrate_kbps,
@ -103,12 +98,12 @@ class PacedSender : public Module {
// Returns true if we send the packet now, else it will add the packet
// information to the queue and call TimeToSendPacket when it's time to send.
virtual bool SendPacket(Priority priority,
uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_time_ms,
size_t bytes,
bool retransmission);
bool SendPacket(RtpPacketSender::Priority priority,
uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_time_ms,
size_t bytes,
bool retransmission) override;
// Returns the time since the oldest queued packet was enqueued.
virtual int64_t QueueInMs() const;

10
webrtc/modules/pacing/include/packet_router.h
View File

@ -19,15 +19,19 @@
#include "webrtc/base/thread_annotations.h"
#include "webrtc/common_types.h"
#include "webrtc/modules/pacing/include/paced_sender.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
namespace webrtc {
class RtpRtcp;
namespace rtcp {
class TransportFeedback;
} // namespace rtcp
// PacketRouter routes outgoing data to the correct sending RTP module, based
// on the simulcast layer in RTPVideoHeader.
class PacketRouter : public PacedSender::Callback {
class PacketRouter : public PacedSender::Callback,
public TransportSequenceNumberAllocator {
public:
PacketRouter();
virtual ~PacketRouter();
@ -44,7 +48,7 @@ class PacketRouter : public PacedSender::Callback {
size_t TimeToSendPadding(size_t bytes) override;
void SetTransportWideSequenceNumber(uint16_t sequence_number);
uint16_t AllocateSequenceNumber();
uint16_t AllocateSequenceNumber() override;
// Send transport feedback packet to send-side.
virtual bool SendFeedback(rtcp::TransportFeedback* packet);

13
webrtc/modules/pacing/paced_sender.cc
View File

@ -36,7 +36,7 @@ const int64_t kMaxIntervalTimeMs = 30;
namespace webrtc {
namespace paced_sender {
struct Packet {
Packet(PacedSender::Priority priority,
Packet(RtpPacketSender::Priority priority,
uint32_t ssrc,
uint16_t seq_number,
int64_t capture_time_ms,
@ -53,7 +53,7 @@ struct Packet {
retransmission(retransmission),
enqueue_order(enqueue_order) {}
PacedSender::Priority priority;
RtpPacketSender::Priority priority;
uint32_t ssrc;
uint16_t sequence_number;
int64_t capture_time_ms;
@ -268,9 +268,12 @@ void PacedSender::UpdateBitrate(int bitrate_kbps,
bitrate_bps_ = 1000 * bitrate_kbps;
}
bool PacedSender::SendPacket(Priority priority, uint32_t ssrc,
uint16_t sequence_number, int64_t capture_time_ms, size_t bytes,
bool retransmission) {
bool PacedSender::SendPacket(RtpPacketSender::Priority priority,
uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_time_ms,
size_t bytes,
bool retransmission) {
CriticalSectionScoped cs(critsect_.get());
if (!enabled_) {

1
webrtc/modules/pacing/pacing.gypi
View File

@ -14,6 +14,7 @@
'dependencies': [
'<(webrtc_root)/system_wrappers/system_wrappers.gyp:system_wrappers',
'<(webrtc_root)/modules/modules.gyp:bitrate_controller',
'<(webrtc_root)/modules/modules.gyp:rtp_rtcp',
],
'sources': [
'include/paced_sender.h',

4
webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc
View File

@ -16,7 +16,7 @@
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/thread_annotations.h"
#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
#include "webrtc/modules/pacing/bitrate_prober.h"
#include "webrtc/modules/pacing/include/paced_sender.h"
#include "webrtc/system_wrappers/interface/clock.h"
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
#include "webrtc/system_wrappers/interface/logging.h"
@ -272,7 +272,7 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
// For now only try to detect probes while we don't have a valid estimate, and
// make sure the packet was paced. We currently assume that only packets
// larger than 200 bytes are paced by the sender.
was_paced = was_paced && payload_size > BitrateProber::kMinProbePacketSize;
was_paced = was_paced && payload_size > PacedSender::kMinProbePacketSize;
if (was_paced &&
(!remote_rate_.ValidEstimate() ||
now_ms - first_packet_time_ms_ < kInitialProbingIntervalMs)) {

1
webrtc/modules/rtp_rtcp/BUILD.gn
View File

@ -110,7 +110,6 @@ source_set("rtp_rtcp") {
deps = [
"../..:webrtc_common",
"../../system_wrappers",
"../pacing",
"../remote_bitrate_estimator",
]

6
webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
View File

@ -19,8 +19,6 @@
namespace webrtc {
// Forward declarations.
class PacedSender;
class PacketRouter;
class ReceiveStatistics;
class RemoteBitrateEstimator;
class RtpReceiver;
@ -69,8 +67,8 @@ class RtpRtcp : public Module {
RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer;
RtpAudioFeedback* audio_messages;
RemoteBitrateEstimator* remote_bitrate_estimator;
PacedSender* paced_sender;
PacketRouter* packet_router;
RtpPacketSender* paced_sender;
TransportSequenceNumberAllocator* transport_sequence_number_allocator;
BitrateStatisticsObserver* send_bitrate_observer;
FrameCountObserver* send_frame_count_observer;
SendSideDelayObserver* send_side_delay_observer;

31
webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
View File

@ -395,5 +395,36 @@ struct RtpPacketLossStats {
uint64_t multiple_packet_loss_packet_count;
};
class RtpPacketSender {
public:
RtpPacketSender() {}
virtual ~RtpPacketSender() {}
enum Priority {
kHighPriority = 0, // Pass through; will be sent immediately.
kNormalPriority = 2, // Put in back of the line.
kLowPriority = 3, // Put in back of the low priority line.
};
// Low priority packets are mixed with the normal priority packets
// while we are paused.
// Returns true if we send the packet now, else it will add the packet
// information to the queue and call TimeToSendPacket when it's time to send.
virtual bool SendPacket(Priority priority,
uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_time_ms,
size_t bytes,
bool retransmission) = 0;
};
class TransportSequenceNumberAllocator {
public:
TransportSequenceNumberAllocator() {}
virtual ~TransportSequenceNumberAllocator() {}
virtual uint16_t AllocateSequenceNumber() = 0;
};
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_DEFINES_H_

1
webrtc/modules/rtp_rtcp/rtp_rtcp.gypi
View File

@ -13,7 +13,6 @@
'type': 'static_library',
'dependencies': [
'<(webrtc_root)/system_wrappers/system_wrappers.gyp:system_wrappers',
'<(webrtc_root)/modules/modules.gyp:paced_sender',
'<(webrtc_root)/modules/modules.gyp:remote_bitrate_estimator',
],
'sources': [

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

@ -40,7 +40,7 @@ RtpRtcp::Configuration::Configuration()
audio_messages(NullObjectRtpAudioFeedback()),
remote_bitrate_estimator(nullptr),
paced_sender(nullptr),
packet_router(nullptr),
transport_sequence_number_allocator(nullptr),
send_bitrate_observer(nullptr),
send_frame_count_observer(nullptr),
send_side_delay_observer(nullptr) {}
@ -64,7 +64,7 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
configuration.outgoing_transport,
configuration.audio_messages,
configuration.paced_sender,
configuration.packet_router,
configuration.transport_sequence_number_allocator,
configuration.transport_feedback_callback,
configuration.send_bitrate_observer,
configuration.send_frame_count_observer,

1
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@ -12,7 +12,6 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/common_types.h"
#include "webrtc/modules/pacing/include/mock/mock_paced_sender.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"

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

@ -97,16 +97,17 @@ class BitrateAggregator {
uint32_t ssrc_;
};
RTPSender::RTPSender(bool audio,
Clock* clock,
Transport* transport,
RtpAudioFeedback* audio_feedback,
PacedSender* paced_sender,
PacketRouter* packet_router,
TransportFeedbackObserver* transport_feedback_observer,
BitrateStatisticsObserver* bitrate_callback,
FrameCountObserver* frame_count_observer,
SendSideDelayObserver* send_side_delay_observer)
RTPSender::RTPSender(
bool audio,
Clock* clock,
Transport* transport,
RtpAudioFeedback* audio_feedback,
RtpPacketSender* paced_sender,
TransportSequenceNumberAllocator* sequence_number_allocator,
TransportFeedbackObserver* transport_feedback_observer,
BitrateStatisticsObserver* bitrate_callback,
FrameCountObserver* frame_count_observer,
SendSideDelayObserver* send_side_delay_observer)
: clock_(clock),
// TODO(holmer): Remove this conversion when we remove the use of
// TickTime.
@ -118,7 +119,7 @@ RTPSender::RTPSender(bool audio,
audio_(audio ? new RTPSenderAudio(clock, this, audio_feedback) : nullptr),
video_(audio ? nullptr : new RTPSenderVideo(clock, this)),
paced_sender_(paced_sender),
packet_router_(packet_router),
transport_sequence_number_allocator_(sequence_number_allocator),
transport_feedback_observer_(transport_feedback_observer),
last_capture_time_ms_sent_(0),
send_critsect_(CriticalSectionWrapper::CreateCriticalSection()),
@ -586,7 +587,8 @@ size_t RTPSender::SendPadData(size_t bytes,
bool timestamp_provided,
uint32_t timestamp,
int64_t capture_time_ms) {
// Always send full padding packets. This is accounted for by the PacedSender,
// Always send full padding packets. This is accounted for by the
// RtpPacketSender,
// which will make sure we don't send too much padding even if a single packet
// is larger than requested.
size_t padding_bytes_in_packet =
@ -594,7 +596,7 @@ size_t RTPSender::SendPadData(size_t bytes,
size_t bytes_sent = 0;
bool using_transport_seq = rtp_header_extension_map_.IsRegistered(
kRtpExtensionTransportSequenceNumber) &&
packet_router_;
transport_sequence_number_allocator_;
for (; bytes > 0; bytes -= padding_bytes_in_packet) {
if (bytes < padding_bytes_in_packet)
bytes = padding_bytes_in_packet;
@ -711,7 +713,7 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id, int64_t min_resend_time) {
// TickTime.
int64_t corrected_capture_tims_ms = capture_time_ms + clock_delta_ms_;
if (!paced_sender_->SendPacket(
PacedSender::kHighPriority, header.ssrc, header.sequenceNumber,
RtpPacketSender::kHighPriority, header.ssrc, header.sequenceNumber,
corrected_capture_tims_ms, length - header.headerLength, true)) {
// We can't send the packet right now.
// We will be called when it is time.
@ -917,7 +919,8 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
// TODO(sprang): Potentially too much overhead in IsRegistered()?
bool using_transport_seq = rtp_header_extension_map_.IsRegistered(
kRtpExtensionTransportSequenceNumber) &&
packet_router_ && !is_retransmit;
transport_sequence_number_allocator_ &&
!is_retransmit;
if (using_transport_seq) {
transport_seq =
UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header);
@ -1000,10 +1003,12 @@ size_t RTPSender::TimeToSendPadding(size_t bytes) {
}
// TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again.
int32_t RTPSender::SendToNetwork(
uint8_t *buffer, size_t payload_length, size_t rtp_header_length,
int64_t capture_time_ms, StorageType storage,
PacedSender::Priority priority) {
int32_t RTPSender::SendToNetwork(uint8_t* buffer,
size_t payload_length,
size_t rtp_header_length,
int64_t capture_time_ms,
StorageType storage,
RtpPacketSender::Priority priority) {
RtpUtility::RtpHeaderParser rtp_parser(buffer,
payload_length + rtp_header_length);
RTPHeader rtp_header;
@ -1615,7 +1620,7 @@ uint16_t RTPSender::UpdateTransportSequenceNumber(
RTC_NOTREACHED();
}
uint16_t seq = packet_router_->AllocateSequenceNumber();
uint16_t seq = transport_sequence_number_allocator_->AllocateSequenceNumber();
BuildTransportSequenceNumberExtension(rtp_packet + offset, seq);
return seq;
}

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

@ -17,8 +17,6 @@
#include "webrtc/base/thread_annotations.h"
#include "webrtc/common_types.h"
#include "webrtc/modules/pacing/include/paced_sender.h"
#include "webrtc/modules/pacing/include/packet_router.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/bitrate.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
@ -71,10 +69,12 @@ class RTPSenderInterface {
virtual uint16_t PacketOverHead() const = 0;
virtual uint16_t ActualSendBitrateKbit() const = 0;
virtual int32_t SendToNetwork(
uint8_t *data_buffer, size_t payload_length, size_t rtp_header_length,
int64_t capture_time_ms, StorageType storage,
PacedSender::Priority priority) = 0;
virtual int32_t SendToNetwork(uint8_t* data_buffer,
size_t payload_length,
size_t rtp_header_length,
int64_t capture_time_ms,
StorageType storage,
RtpPacketSender::Priority priority) = 0;
virtual bool UpdateVideoRotation(uint8_t* rtp_packet,
size_t rtp_packet_length,
@ -90,8 +90,8 @@ class RTPSender : public RTPSenderInterface {
Clock* clock,
Transport* transport,
RtpAudioFeedback* audio_feedback,
PacedSender* paced_sender,
PacketRouter* packet_router,
RtpPacketSender* paced_sender,
TransportSequenceNumberAllocator* sequence_number_allocator,
TransportFeedbackObserver* transport_feedback_callback,
BitrateStatisticsObserver* bitrate_callback,
FrameCountObserver* frame_count_observer,
@ -257,7 +257,7 @@ class RTPSender : public RTPSenderInterface {
size_t rtp_header_length,
int64_t capture_time_ms,
StorageType storage,
PacedSender::Priority priority) override;
RtpPacketSender::Priority priority) override;
// Audio.
@ -370,8 +370,8 @@ class RTPSender : public RTPSenderInterface {
const RTPHeader& rtp_header,
int64_t now_ms) const;
// Update the transport sequence number of the packet using a new sequence
// number allocated by PacketRouter. Returns the assigned sequence number,
// or 0 if extension could not be updated.
// number allocated by SequenceNumberAllocator. Returns the assigned sequence
// number, or 0 if extension could not be updated.
uint16_t UpdateTransportSequenceNumber(uint8_t* rtp_packet,
size_t rtp_packet_length,
const RTPHeader& rtp_header) const;
@ -393,8 +393,8 @@ class RTPSender : public RTPSenderInterface {
rtc::scoped_ptr<RTPSenderAudio> audio_;
rtc::scoped_ptr<RTPSenderVideo> video_;
PacedSender* const paced_sender_;
PacketRouter* const packet_router_;
RtpPacketSender* const paced_sender_;
TransportSequenceNumberAllocator* const transport_sequence_number_allocator_;
TransportFeedbackObserver* const transport_feedback_observer_;
int64_t last_capture_time_ms_sent_;
rtc::scoped_ptr<CriticalSectionWrapper> send_critsect_;

5
webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc
View File

@ -13,6 +13,7 @@
#include <assert.h> //assert
#include <string.h> //memcpy
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
#include "webrtc/system_wrappers/interface/trace_event.h"
@ -368,7 +369,7 @@ int32_t RTPSenderAudio::SendAudio(
_rtpSender->SequenceNumber());
return _rtpSender->SendToNetwork(dataBuffer, payloadSize, rtpHeaderLength,
-1, kAllowRetransmission,
PacedSender::kHighPriority);
RtpPacketSender::kHighPriority);
}
// Audio level magnitude and voice activity flag are set for each RTP packet
@ -477,7 +478,7 @@ RTPSenderAudio::SendTelephoneEventPacket(bool ended,
_rtpSender->SequenceNumber());
retVal = _rtpSender->SendToNetwork(dtmfbuffer, 4, 12, -1,
kAllowRetransmission,
PacedSender::kHighPriority);
RtpPacketSender::kHighPriority);
sendCount--;
}while (sendCount > 0 && retVal == 0);

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

@ -12,11 +12,11 @@
* This file includes unit tests for the RTPSender.
*/
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/buffer.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/pacing/include/mock/mock_paced_sender.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_cvo.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
@ -100,6 +100,20 @@ class LoopbackTransportTest : public webrtc::Transport {
} // namespace
class MockRtpPacketSender : public RtpPacketSender {
public:
MockRtpPacketSender() {}
virtual ~MockRtpPacketSender() {}
MOCK_METHOD6(SendPacket,
bool(Priority priority,
uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_time_ms,
size_t bytes,
bool retransmission));
};
class RtpSenderTest : public ::testing::Test {
protected:
RtpSenderTest()
@ -121,7 +135,7 @@ class RtpSenderTest : public ::testing::Test {
}
SimulatedClock fake_clock_;
MockPacedSender mock_paced_sender_;
MockRtpPacketSender mock_paced_sender_;
rtc::scoped_ptr<RTPSender> rtp_sender_;
int payload_;
LoopbackTransportTest transport_;
@ -152,12 +166,9 @@ class RtpSenderTest : public ::testing::Test {
ASSERT_GE(rtp_length, 0);
// Packet should be stored in a send bucket.
EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
payload_length,
rtp_length,
capture_time_ms,
kAllowRetransmission,
PacedSender::kNormalPriority));
EXPECT_EQ(0, rtp_sender_->SendToNetwork(
packet_, payload_length, rtp_length, capture_time_ms,
kAllowRetransmission, RtpPacketSender::kNormalPriority));
}
};
@ -593,8 +604,8 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithHeaderExtensions) {
TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
EXPECT_CALL(mock_paced_sender_,
SendPacket(PacedSender::kNormalPriority, _, kSeqNum, _, _, _)).
WillOnce(testing::Return(false));
SendPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _))
.WillOnce(testing::Return(false));
rtp_sender_->SetStorePacketsStatus(true, 10);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@ -609,12 +620,9 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
size_t rtp_length = static_cast<size_t>(rtp_length_int);
// Packet should be stored in a send bucket.
EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
0,
rtp_length,
capture_time_ms,
kAllowRetransmission,
PacedSender::kNormalPriority));
EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
capture_time_ms, kAllowRetransmission,
RtpPacketSender::kNormalPriority));
EXPECT_EQ(0, transport_.packets_sent_);
@ -646,8 +654,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
EXPECT_CALL(mock_paced_sender_,
SendPacket(PacedSender::kNormalPriority, _, kSeqNum, _, _, _)).
WillOnce(testing::Return(false));
SendPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _))
.WillOnce(testing::Return(false));
rtp_sender_->SetStorePacketsStatus(true, 10);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@ -662,18 +670,15 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
size_t rtp_length = static_cast<size_t>(rtp_length_int);
// Packet should be stored in a send bucket.
EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
0,
rtp_length,
capture_time_ms,
kAllowRetransmission,
PacedSender::kNormalPriority));
EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
capture_time_ms, kAllowRetransmission,
RtpPacketSender::kNormalPriority));
EXPECT_EQ(0, transport_.packets_sent_);
EXPECT_CALL(mock_paced_sender_,
SendPacket(PacedSender::kHighPriority, _, kSeqNum, _, _, _)).
WillOnce(testing::Return(false));
SendPacket(RtpPacketSender::kHighPriority, _, kSeqNum, _, _, _))
.WillOnce(testing::Return(false));
const int kStoredTimeInMs = 100;
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
@ -710,8 +715,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
TEST_F(RtpSenderTest, SendPadding) {
// Make all (non-padding) packets go to send queue.
EXPECT_CALL(mock_paced_sender_,
SendPacket(PacedSender::kNormalPriority, _, _, _, _, _)).
WillRepeatedly(testing::Return(false));
SendPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
.WillRepeatedly(testing::Return(false));
uint16_t seq_num = kSeqNum;
uint32_t timestamp = kTimestamp;
@ -744,12 +749,9 @@ TEST_F(RtpSenderTest, SendPadding) {
size_t rtp_length = static_cast<size_t>(rtp_length_int);
// Packet should be stored in a send bucket.
EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
0,
rtp_length,
capture_time_ms,
kAllowRetransmission,
PacedSender::kNormalPriority));
EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
capture_time_ms, kAllowRetransmission,
RtpPacketSender::kNormalPriority));
int total_packets_sent = 0;
EXPECT_EQ(total_packets_sent, transport_.packets_sent_);
@ -802,12 +804,9 @@ TEST_F(RtpSenderTest, SendPadding) {
rtp_length = static_cast<size_t>(rtp_length_int);
// Packet should be stored in a send bucket.
EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
0,
rtp_length,
capture_time_ms,
kAllowRetransmission,
PacedSender::kNormalPriority));
EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
capture_time_ms, kAllowRetransmission,
RtpPacketSender::kNormalPriority));
rtp_sender_->TimeToSendPacket(seq_num, capture_time_ms, false);
// Process send bucket.
@ -836,8 +835,8 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
// Make all packets go through the pacer.
EXPECT_CALL(mock_paced_sender_,
SendPacket(PacedSender::kNormalPriority, _, _, _, _, _)).
WillRepeatedly(testing::Return(false));
SendPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
.WillRepeatedly(testing::Return(false));
uint16_t seq_num = kSeqNum;
rtp_sender_->SetStorePacketsStatus(true, 10);

10
webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -104,7 +104,7 @@ void RTPSenderVideo::SendVideoPacket(uint8_t* data_buffer,
StorageType storage) {
if (_rtpSender.SendToNetwork(data_buffer, payload_length, rtp_header_length,
capture_time_ms, storage,
PacedSender::kNormalPriority) == 0) {
RtpPacketSender::kNormalPriority) == 0) {
_videoBitrate.Update(payload_length + rtp_header_length);
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"Video::PacketNormal", "timestamp", capture_timestamp,
@ -150,7 +150,7 @@ void RTPSenderVideo::SendVideoPacketAsRed(uint8_t* data_buffer,
if (_rtpSender.SendToNetwork(
red_packet->data(), red_packet->length() - rtp_header_length,
rtp_header_length, capture_time_ms, media_packet_storage,
PacedSender::kNormalPriority) == 0) {
RtpPacketSender::kNormalPriority) == 0) {
_videoBitrate.Update(red_packet->length());
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"Video::PacketRed", "timestamp", capture_timestamp,
@ -162,7 +162,7 @@ void RTPSenderVideo::SendVideoPacketAsRed(uint8_t* data_buffer,
if (_rtpSender.SendToNetwork(
fec_packet->data(), fec_packet->length() - rtp_header_length,
rtp_header_length, capture_time_ms, fec_storage,
PacedSender::kNormalPriority) == 0) {
RtpPacketSender::kNormalPriority) == 0) {
_fecOverheadRate.Update(fec_packet->length());
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"Video::PacketFec", "timestamp", capture_timestamp,
@ -192,8 +192,8 @@ int32_t RTPSenderVideo::SendRTPIntraRequest() {
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
"Video::IntraRequest", "seqnum",
_rtpSender.SequenceNumber());
return _rtpSender.SendToNetwork(
data, 0, length, -1, kDontStore, PacedSender::kNormalPriority);
return _rtpSender.SendToNetwork(data, 0, length, -1, kDontStore,
RtpPacketSender::kNormalPriority);
}
void RTPSenderVideo::SetGenericFECStatus(const bool enable,

1
webrtc/video/BUILD.gn
View File

@ -70,6 +70,7 @@ source_set("video") {
"..:webrtc_common",
"../common_video",
"../modules/bitrate_controller",
"../modules/pacing",
"../modules/rtp_rtcp",
"../modules/utility",
"../modules/video_capture:video_capture_module",

1
webrtc/video/webrtc_video.gypi
View File

@ -12,6 +12,7 @@
'<(webrtc_root)/common.gyp:webrtc_common',
'<(webrtc_root)/common_video/common_video.gyp:common_video',
'<(webrtc_root)/modules/modules.gyp:bitrate_controller',
'<(webrtc_root)/modules/modules.gyp:paced_sender',
'<(webrtc_root)/modules/modules.gyp:rtp_rtcp',
'<(webrtc_root)/modules/modules.gyp:video_capture_module',
'<(webrtc_root)/modules/modules.gyp:video_processing',

7
webrtc/video_engine/vie_channel.cc
View File

@ -1138,8 +1138,8 @@ std::vector<RtpRtcp*> ViEChannel::CreateRtpRtcpModules(
RtcpRttStats* rtt_stats,
RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
RemoteBitrateEstimator* remote_bitrate_estimator,
PacedSender* paced_sender,
PacketRouter* packet_router,
RtpPacketSender* paced_sender,
TransportSequenceNumberAllocator* transport_sequence_number_allocator,
BitrateStatisticsObserver* send_bitrate_observer,
FrameCountObserver* send_frame_count_observer,
SendSideDelayObserver* send_side_delay_observer,
@ -1156,7 +1156,8 @@ std::vector<RtpRtcp*> ViEChannel::CreateRtpRtcpModules(
configuration.rtcp_packet_type_counter_observer =
rtcp_packet_type_counter_observer;
configuration.paced_sender = paced_sender;
configuration.packet_router = packet_router;
configuration.transport_sequence_number_allocator =
transport_sequence_number_allocator;
configuration.send_bitrate_observer = send_bitrate_observer;
configuration.send_frame_count_observer = send_frame_count_observer;
configuration.send_side_delay_observer = send_side_delay_observer;

4
webrtc/video_engine/vie_channel.h
View File

@ -298,8 +298,8 @@ class ViEChannel : public VCMFrameTypeCallback,
RtcpRttStats* rtt_stats,
RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
RemoteBitrateEstimator* remote_bitrate_estimator,
PacedSender* paced_sender,
PacketRouter* packet_router,
RtpPacketSender* paced_sender,
TransportSequenceNumberAllocator* transport_sequence_number_allocator,
BitrateStatisticsObserver* send_bitrate_observer,
FrameCountObserver* send_frame_count_observer,
SendSideDelayObserver* send_side_delay_observer,