Skip to content

GitLab

T
tangled
Commit 9f7acae4 authored by hubbe's avatar hubbe Committed by Commit bot
Browse files
Options

Cast: Re-factor rtcp_sender.cc into rtcp_builder.cc and do some cleanup 

Review URL: https://codereview.chromium.org/513313004

Cr-Commit-Position: refs/heads/master@{#293787}
parent c4d26a44
Hide whitespace changes
Inline Side-by-side
Showing with 306 additions and 464 deletions
media/cast/BUILD.gn
View file @ 9f7acae4
......@@ -72,8 +72,8 @@ source_set("net") {
"net/rtcp/rtcp_defines.h",
"net/rtcp/rtcp.h",
"net/rtcp/rtcp.cc",
"net/rtcp/rtcp_sender.cc",
"net/rtcp/rtcp_sender.h",
"net/rtcp/rtcp_builder.cc",
"net/rtcp/rtcp_builder.h",
"net/rtcp/rtcp_utility.cc",
"net/rtcp/rtcp_utility.h",
"net/rtp/packet_storage.cc",
......@@ -230,7 +230,7 @@ test("cast_unittests") {
"net/pacing/mock_paced_packet_sender.cc",
"net/pacing/mock_paced_packet_sender.h",
"net/pacing/paced_sender_unittest.cc",
"net/rtcp/rtcp_sender_unittest.cc",
"net/rtcp/rtcp_builder_unittest.cc",
"net/rtcp/rtcp_unittest.cc",
"net/rtcp/rtcp_utility_unittest.cc",
"net/rtcp/receiver_rtcp_event_subscriber_unittest.cc",
......
media/cast/cast.gyp
View file @ 9f7acae4
......@@ -184,12 +184,12 @@
'net/pacing/paced_sender.cc',
'net/pacing/paced_sender.h',
'net/rtcp/receiver_rtcp_event_subscriber.cc',
'net/rtcp/rtcp_builder.cc',
'net/rtcp/rtcp_builder.h',
'net/rtcp/rtcp_defines.cc',
'net/rtcp/rtcp_defines.h',
'net/rtcp/rtcp.h',
'net/rtcp/rtcp.cc',
'net/rtcp/rtcp_sender.cc',
'net/rtcp/rtcp_sender.h',
'net/rtcp/rtcp_utility.cc',
'net/rtcp/rtcp_utility.h',
'net/rtp/packet_storage.cc',
......
media/cast/cast_testing.gypi
View file @ 9f7acae4
......@@ -86,7 +86,7 @@
'net/pacing/mock_paced_packet_sender.cc',
'net/pacing/mock_paced_packet_sender.h',
'net/pacing/paced_sender_unittest.cc',
'net/rtcp/rtcp_sender_unittest.cc',
'net/rtcp/rtcp_builder_unittest.cc',
'net/rtcp/rtcp_unittest.cc',
'net/rtcp/rtcp_utility_unittest.cc',
'net/rtcp/receiver_rtcp_event_subscriber_unittest.cc',
......
media/cast/net/rtcp/rtcp.cc
View file @ 9f7acae4
......@@ -8,8 +8,9 @@
#include "media/cast/cast_defines.h"
#include "media/cast/cast_environment.h"
#include "media/cast/net/cast_transport_defines.h"
#include "media/cast/net/pacing/paced_sender.h"
#include "media/cast/net/rtcp/rtcp_builder.h"
#include "media/cast/net/rtcp/rtcp_defines.h"
#include "media/cast/net/rtcp/rtcp_sender.h"
#include "media/cast/net/rtcp/rtcp_utility.h"
using base::TimeDelta;
......@@ -64,7 +65,8 @@ Rtcp::Rtcp(const RtcpCastMessageCallback& cast_callback,
rtt_callback_(rtt_callback),
log_callback_(log_callback),
clock_(clock),
rtcp_sender_(new RtcpSender(packet_sender, local_ssrc)),
rtcp_builder_(local_ssrc),
packet_sender_(packet_sender),
local_ssrc_(local_ssrc),
remote_ssrc_(remote_ssrc),
last_report_truncated_ntp_(0),
......@@ -228,12 +230,14 @@ void Rtcp::SendRtcpFromRtpReceiver(
report_block.delay_since_last_sr = 0;
}
}
rtcp_sender_->SendRtcpFromRtpReceiver(
rtp_receiver_statistics ? &report_block : NULL,
&rrtr,
cast_message,
rtcp_events,
target_delay);
packet_sender_->SendRtcpPacket(
local_ssrc_,
rtcp_builder_.BuildRtcpFromReceiver(
rtp_receiver_statistics ? &report_block : NULL,
&rrtr,
cast_message,
rtcp_events,
target_delay));
}
void Rtcp::SendRtcpFromRtpSender(base::TimeTicks current_time,
......@@ -254,7 +258,9 @@ void Rtcp::SendRtcpFromRtpSender(base::TimeTicks current_time,
sender_info.send_packet_count = send_packet_count;
sender_info.send_octet_count = send_octet_count;
rtcp_sender_->SendRtcpFromRtpSender(sender_info);
packet_sender_->SendRtcpPacket(
local_ssrc_,
rtcp_builder_.BuildRtcpFromSender(sender_info));
}
void Rtcp::OnReceivedNtp(uint32 ntp_seconds, uint32 ntp_fraction) {
......
media/cast/net/rtcp/rtcp.h
View file @ 9f7acae4
......@@ -23,6 +23,7 @@
#include "media/cast/net/cast_transport_defines.h"
#include "media/cast/net/cast_transport_sender.h"
#include "media/cast/net/rtcp/receiver_rtcp_event_subscriber.h"
#include "media/cast/net/rtcp/rtcp_builder.h"
#include "media/cast/net/rtcp/rtcp_defines.h"
namespace media {
......@@ -31,7 +32,7 @@ namespace cast {
class LocalRtcpReceiverFeedback;
class PacedPacketSender;
class RtcpReceiver;
class RtcpSender;
class RtcpBuilder;
typedef std::pair<uint32, base::TimeTicks> RtcpSendTimePair;
typedef std::map<uint32, base::TimeTicks> RtcpSendTimeMap;
......@@ -138,7 +139,8 @@ class Rtcp {
const RtcpRttCallback rtt_callback_;
const RtcpLogMessageCallback log_callback_;
base::TickClock* const clock_; // Not owned by this class.
const scoped_ptr<RtcpSender> rtcp_sender_;
RtcpBuilder rtcp_builder_;
PacedPacketSender* packet_sender_; // Not owned.
const uint32 local_ssrc_;
const uint32 remote_ssrc_;
......
media/cast/net/rtcp/rtcp_sender.cc → media/cast/net/rtcp/rtcp_builder.cc
View file @ 9f7acae4
......@@ -2,17 +2,15 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/cast/net/rtcp/rtcp_sender.h"
#include "media/cast/net/rtcp/rtcp_builder.h"
#include <stdint.h>
#include <algorithm>
#include <vector>
#include "base/big_endian.h"
#include "base/logging.h"
#include "media/cast/net/cast_transport_defines.h"
#include "media/cast/net/pacing/paced_sender.h"
#include "media/cast/net/rtcp/rtcp_defines.h"
#include "media/cast/net/rtcp/rtcp_utility.h"
......@@ -46,7 +44,7 @@ bool EventTimestampLessThan(const RtcpReceiverEventLogMessage& lhs,
return lhs.event_timestamp < rhs.event_timestamp;
}
void AddReceiverLog(
void AddReceiverLogEntries(
const RtcpReceiverLogMessage& redundancy_receiver_log_message,
RtcpReceiverLogMessage* receiver_log_message,
size_t* remaining_space,
......@@ -67,7 +65,7 @@ void AddReceiverLog(
*remaining_space -= kRtcpReceiverFrameLogSize +
event_log_messages.size() * kRtcpReceiverEventLogSize;
++*number_of_frames;
++number_of_frames;
*total_number_of_messages_to_send += event_log_messages.size();
++it;
}
......@@ -145,161 +143,139 @@ class NackStringBuilder {
};
} // namespace
RtcpSender::RtcpSender(PacedPacketSender* outgoing_transport,
uint32 sending_ssrc)
: ssrc_(sending_ssrc),
transport_(outgoing_transport) {
RtcpBuilder::RtcpBuilder(uint32 sending_ssrc)
: writer_(NULL, 0),
ssrc_(sending_ssrc),
ptr_of_length_(NULL) {
}
RtcpSender::~RtcpSender() {}
RtcpBuilder::~RtcpBuilder() {}
void RtcpBuilder::PatchLengthField() {
if (ptr_of_length_) {
// Back-patch the packet length. The client must have taken
// care of proper padding to 32-bit words.
int this_packet_length = (writer_.ptr() - ptr_of_length_ - 2);
DCHECK_EQ(0, this_packet_length % 4)
<< "Packets must be a multiple of 32 bits long";
*ptr_of_length_ = this_packet_length >> 10;
*(ptr_of_length_ + 1) = (this_packet_length >> 2) & 0xFF;
ptr_of_length_ = NULL;
}
}
// Set the 5-bit value in the 1st byte of the header
// and the payload type. Set aside room for the length field,
// and make provision for back-patching it.
void RtcpBuilder::AddRtcpHeader(RtcpPacketFields payload, int format_or_count) {
PatchLengthField();
writer_.WriteU8(0x80 | (format_or_count & 0x1F));
writer_.WriteU8(payload);
ptr_of_length_ = writer_.ptr();
// Initialize length to "clearly illegal".
writer_.WriteU16(0xDEAD);
}
void RtcpBuilder::Start() {
packet_ = new base::RefCountedData<Packet>;
packet_->data.resize(kMaxIpPacketSize);
writer_ = base::BigEndianWriter(
reinterpret_cast<char*>(&(packet_->data[0])), kMaxIpPacketSize);
}
void RtcpSender::SendRtcpFromRtpReceiver(
PacketRef RtcpBuilder::Finish() {
PatchLengthField();
packet_->data.resize(kMaxIpPacketSize - writer_.remaining());
writer_ = base::BigEndianWriter(NULL, 0);
PacketRef ret = packet_;
packet_ = NULL;
return ret;
}
PacketRef RtcpBuilder::BuildRtcpFromReceiver(
const RtcpReportBlock* report_block,
const RtcpReceiverReferenceTimeReport* rrtr,
const RtcpCastMessage* cast_message,
const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events,
base::TimeDelta target_delay) {
PacketRef packet(new base::RefCountedData<Packet>);
packet->data.reserve(kMaxIpPacketSize);
Start();
if (report_block)
BuildRR(report_block, &packet->data);
AddRR(report_block);
if (rrtr)
BuildRrtr(rrtr, &packet->data);
AddRrtr(rrtr);
if (cast_message)
BuildCast(cast_message, target_delay, &packet->data);
AddCast(cast_message, target_delay);
if (rtcp_events)
BuildReceiverLog(*rtcp_events, &packet->data);
if (packet->data.empty()) {
NOTREACHED() << "Empty packet.";
return; // Sanity don't send empty packets.
}
AddReceiverLog(*rtcp_events);
transport_->SendRtcpPacket(ssrc_, packet);
return Finish();
}
void RtcpSender::SendRtcpFromRtpSender(
const RtcpSenderInfo& sender_info) {
PacketRef packet(new base::RefCountedData<Packet>);
packet->data.reserve(kMaxIpPacketSize);
BuildSR(sender_info, &packet->data);
if (packet->data.empty()) {
NOTREACHED() << "Empty packet.";
return; // Sanity - don't send empty packets.
}
transport_->SendRtcpPacket(ssrc_, packet);
PacketRef RtcpBuilder::BuildRtcpFromSender(const RtcpSenderInfo& sender_info) {
Start();
AddSR(sender_info);
return Finish();
}
void RtcpSender::BuildRR(const RtcpReportBlock* report_block,
Packet* packet) const {
size_t start_size = packet->size();
DCHECK_LT(start_size + 32, kMaxIpPacketSize) << "Not enough buffer space";
if (start_size + 32 > kMaxIpPacketSize)
return;
uint16 number_of_rows = (report_block) ? 7 : 1;
packet->resize(start_size + 8);
base::BigEndianWriter big_endian_writer(
reinterpret_cast<char*>(&((*packet)[start_size])), 8);
big_endian_writer.WriteU8(0x80 + (report_block ? 1 : 0));
big_endian_writer.WriteU8(kPacketTypeReceiverReport);
big_endian_writer.WriteU16(number_of_rows);
big_endian_writer.WriteU32(ssrc_);
void RtcpBuilder::AddRR(const RtcpReportBlock* report_block) {
AddRtcpHeader(kPacketTypeReceiverReport, report_block ? 1 : 0);
writer_.WriteU32(ssrc_);
if (report_block) {
AddReportBlocks(*report_block, packet); // Adds 24 bytes.
AddReportBlocks(*report_block); // Adds 24 bytes.
}
}
void RtcpSender::AddReportBlocks(const RtcpReportBlock& report_block,
Packet* packet) const {
size_t start_size = packet->size();
DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
if (start_size + 24 > kMaxIpPacketSize)
return;
packet->resize(start_size + 24);
base::BigEndianWriter big_endian_writer(
reinterpret_cast<char*>(&((*packet)[start_size])), 24);
big_endian_writer.WriteU32(report_block.media_ssrc);
big_endian_writer.WriteU8(report_block.fraction_lost);
big_endian_writer.WriteU8(report_block.cumulative_lost >> 16);
big_endian_writer.WriteU8(report_block.cumulative_lost >> 8);
big_endian_writer.WriteU8(report_block.cumulative_lost);
void RtcpBuilder::AddReportBlocks(const RtcpReportBlock& report_block) {
writer_.WriteU32(report_block.media_ssrc);
writer_.WriteU8(report_block.fraction_lost);
writer_.WriteU8(report_block.cumulative_lost >> 16);
writer_.WriteU8(report_block.cumulative_lost >> 8);
writer_.WriteU8(report_block.cumulative_lost);
// Extended highest seq_no, contain the highest sequence number received.
big_endian_writer.WriteU32(report_block.extended_high_sequence_number);
big_endian_writer.WriteU32(report_block.jitter);
writer_.WriteU32(report_block.extended_high_sequence_number);
writer_.WriteU32(report_block.jitter);
// Last SR timestamp; our NTP time when we received the last report.
// This is the value that we read from the send report packet not when we
// received it.
big_endian_writer.WriteU32(report_block.last_sr);
writer_.WriteU32(report_block.last_sr);
// Delay since last received report, time since we received the report.
big_endian_writer.WriteU32(report_block.delay_since_last_sr);
writer_.WriteU32(report_block.delay_since_last_sr);
}
void RtcpSender::BuildRrtr(const RtcpReceiverReferenceTimeReport* rrtr,
Packet* packet) const {
size_t start_size = packet->size();
DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
if (start_size + 20 > kMaxIpPacketSize)
return;
packet->resize(start_size + 20);
base::BigEndianWriter big_endian_writer(
reinterpret_cast<char*>(&((*packet)[start_size])), 20);
big_endian_writer.WriteU8(0x80);
big_endian_writer.WriteU8(kPacketTypeXr);
big_endian_writer.WriteU16(4); // Length.
big_endian_writer.WriteU32(ssrc_); // Add our own SSRC.
big_endian_writer.WriteU8(4); // Add block type.
big_endian_writer.WriteU8(0); // Add reserved.
big_endian_writer.WriteU16(2); // Block length.
void RtcpBuilder::AddRrtr(const RtcpReceiverReferenceTimeReport* rrtr) {
AddRtcpHeader(kPacketTypeXr, 0);
writer_.WriteU32(ssrc_); // Add our own SSRC.
writer_.WriteU8(4); // Add block type.
writer_.WriteU8(0); // Add reserved.
writer_.WriteU16(2); // Block length.
// Add the media (received RTP) SSRC.
big_endian_writer.WriteU32(rrtr->ntp_seconds);
big_endian_writer.WriteU32(rrtr->ntp_fraction);
writer_.WriteU32(rrtr->ntp_seconds);
writer_.WriteU32(rrtr->ntp_fraction);
}
void RtcpSender::BuildCast(const RtcpCastMessage* cast,
base::TimeDelta target_delay,
Packet* packet) const {
size_t start_size = packet->size();
DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
if (start_size + 20 > kMaxIpPacketSize)
return;
packet->resize(start_size + 20);
base::BigEndianWriter big_endian_writer(
reinterpret_cast<char*>(&((*packet)[start_size])), 20);
uint8 FMT = 15; // Application layer feedback.
big_endian_writer.WriteU8(0x80 + FMT);
big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
big_endian_writer.WriteU8(0);
size_t cast_size_pos = start_size + 3; // Save length position.
big_endian_writer.WriteU8(4);
big_endian_writer.WriteU32(ssrc_); // Add our own SSRC.
big_endian_writer.WriteU32(cast->media_ssrc); // Remote SSRC.
big_endian_writer.WriteU32(kCast);
big_endian_writer.WriteU8(static_cast<uint8>(cast->ack_frame_id));
size_t cast_loss_field_pos = start_size + 17; // Save loss field position.
big_endian_writer.WriteU8(0); // Overwritten with number_of_loss_fields.
void RtcpBuilder::AddCast(const RtcpCastMessage* cast,
base::TimeDelta target_delay) {
// See RTC 4585 Section 6.4 for application specific feedback messages.
AddRtcpHeader(kPacketTypePayloadSpecific, 15);
writer_.WriteU32(ssrc_); // Add our own SSRC.
writer_.WriteU32(cast->media_ssrc); // Remote SSRC.
writer_.WriteU32(kCast);
writer_.WriteU8(static_cast<uint8>(cast->ack_frame_id));
uint8* cast_loss_field_pos = reinterpret_cast<uint8*>(writer_.ptr());
writer_.WriteU8(0); // Overwritten with number_of_loss_fields.
DCHECK_LE(target_delay.InMilliseconds(),
std::numeric_limits<uint16_t>::max());
big_endian_writer.WriteU16(target_delay.InMilliseconds());
writer_.WriteU16(target_delay.InMilliseconds());
size_t number_of_loss_fields = 0;
size_t max_number_of_loss_fields = std::min<size_t>(
kRtcpMaxCastLossFields, (kMaxIpPacketSize - packet->size()) / 4);
kRtcpMaxCastLossFields, writer_.remaining() / 4);
MissingFramesAndPacketsMap::const_iterator frame_it =
cast->missing_frames_and_packets.begin();
......@@ -312,28 +288,18 @@ void RtcpSender::BuildCast(const RtcpCastMessage* cast,
// Iterate through all frames with missing packets.
if (frame_it->second.empty()) {
// Special case all packets in a frame is missing.
start_size = packet->size();
packet->resize(start_size + 4);
base::BigEndianWriter big_endian_nack_writer(
reinterpret_cast<char*>(&((*packet)[start_size])), 4);
big_endian_nack_writer.WriteU8(static_cast<uint8>(frame_it->first));
big_endian_nack_writer.WriteU16(kRtcpCastAllPacketsLost);
big_endian_nack_writer.WriteU8(0);
writer_.WriteU8(static_cast<uint8>(frame_it->first));
writer_.WriteU16(kRtcpCastAllPacketsLost);
writer_.WriteU8(0);
nack_string_builder.PushPacket(kRtcpCastAllPacketsLost);
++number_of_loss_fields;
} else {
PacketIdSet::const_iterator packet_it = frame_it->second.begin();
while (packet_it != frame_it->second.end()) {
uint16 packet_id = *packet_it;
start_size = packet->size();
packet->resize(start_size + 4);
base::BigEndianWriter big_endian_nack_writer(
reinterpret_cast<char*>(&((*packet)[start_size])), 4);
// Write frame and packet id to buffer before calculating bitmask.
big_endian_nack_writer.WriteU8(static_cast<uint8>(frame_it->first));
big_endian_nack_writer.WriteU16(packet_id);
writer_.WriteU8(static_cast<uint8>(frame_it->first));
writer_.WriteU16(packet_id);
nack_string_builder.PushPacket(packet_id);
uint8 bitmask = 0;
......@@ -348,7 +314,7 @@ void RtcpSender::BuildCast(const RtcpCastMessage* cast,
break;
}
}
big_endian_nack_writer.WriteU8(bitmask);
writer_.WriteU8(bitmask);
++number_of_loss_fields;
}
}
......@@ -358,34 +324,17 @@ void RtcpSender::BuildCast(const RtcpCastMessage* cast,
<< ", ACK: " << cast->ack_frame_id
<< ", NACK: " << nack_string_builder.GetString();
DCHECK_LE(number_of_loss_fields, kRtcpMaxCastLossFields);
(*packet)[cast_size_pos] = static_cast<uint8>(4 + number_of_loss_fields);
(*packet)[cast_loss_field_pos] = static_cast<uint8>(number_of_loss_fields);
*cast_loss_field_pos = static_cast<uint8>(number_of_loss_fields);
}
void RtcpSender::BuildSR(const RtcpSenderInfo& sender_info,
Packet* packet) const {
// Sender report.
size_t start_size = packet->size();
if (start_size + 52 > kMaxIpPacketSize) {
DLOG(FATAL) << "Not enough buffer space";
return;
}
uint16 number_of_rows = 6;
packet->resize(start_size + 28);
base::BigEndianWriter big_endian_writer(
reinterpret_cast<char*>(&((*packet)[start_size])), 28);
big_endian_writer.WriteU8(0x80);
big_endian_writer.WriteU8(kPacketTypeSenderReport);
big_endian_writer.WriteU16(number_of_rows);
big_endian_writer.WriteU32(ssrc_);
big_endian_writer.WriteU32(sender_info.ntp_seconds);
big_endian_writer.WriteU32(sender_info.ntp_fraction);
big_endian_writer.WriteU32(sender_info.rtp_timestamp);
big_endian_writer.WriteU32(sender_info.send_packet_count);
big_endian_writer.WriteU32(static_cast<uint32>(sender_info.send_octet_count));
return;
void RtcpBuilder::AddSR(const RtcpSenderInfo& sender_info) {
AddRtcpHeader(kPacketTypeSenderReport, 0);
writer_.WriteU32(ssrc_);
writer_.WriteU32(sender_info.ntp_seconds);
writer_.WriteU32(sender_info.ntp_fraction);
writer_.WriteU32(sender_info.rtp_timestamp);
writer_.WriteU32(sender_info.send_packet_count);
writer_.WriteU32(static_cast<uint32>(sender_info.send_octet_count));
}
/*
......@@ -405,58 +354,31 @@ void RtcpSender::BuildSR(const RtcpSenderInfo& sender_info,
| delay since last RR (DLRR) |
+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
*/
void RtcpSender::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
Packet* packet) const {
size_t start_size = packet->size();
if (start_size + 24 > kMaxIpPacketSize) {
DLOG(FATAL) << "Not enough buffer space";
return;
}
packet->resize(start_size + 24);
base::BigEndianWriter big_endian_writer(
reinterpret_cast<char*>(&((*packet)[start_size])), 24);
big_endian_writer.WriteU8(0x80);
big_endian_writer.WriteU8(kPacketTypeXr);
big_endian_writer.WriteU16(5); // Length.
big_endian_writer.WriteU32(ssrc_); // Add our own SSRC.
big_endian_writer.WriteU8(5); // Add block type.
big_endian_writer.WriteU8(0); // Add reserved.
big_endian_writer.WriteU16(3); // Block length.
big_endian_writer.WriteU32(ssrc_); // Add the media (received RTP) SSRC.
big_endian_writer.WriteU32(dlrr.last_rr);
big_endian_writer.WriteU32(dlrr.delay_since_last_rr);
return;
void RtcpBuilder::AddDlrrRb(const RtcpDlrrReportBlock& dlrr) {
AddRtcpHeader(kPacketTypeXr, 0);
writer_.WriteU32(ssrc_); // Add our own SSRC.
writer_.WriteU8(5); // Add block type.
writer_.WriteU8(0); // Add reserved.
writer_.WriteU16(3); // Block length.
writer_.WriteU32(ssrc_); // Add the media (received RTP) SSRC.
writer_.WriteU32(dlrr.last_rr);
writer_.WriteU32(dlrr.delay_since_last_rr);
}
void RtcpSender::BuildReceiverLog(
const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events,
Packet* packet) {
const size_t packet_start_size = packet->size();
size_t number_of_frames = 0;
void RtcpBuilder::AddReceiverLog(
const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events) {
size_t total_number_of_messages_to_send = 0;
size_t rtcp_log_size = 0;
RtcpReceiverLogMessage receiver_log_message;
if (!BuildRtcpReceiverLogMessage(rtcp_events,
packet_start_size,
&receiver_log_message,
&number_of_frames,
&total_number_of_messages_to_send,
&rtcp_log_size)) {
if (!GetRtcpReceiverLogMessage(rtcp_events,
&receiver_log_message,
&total_number_of_messages_to_send)) {
return;
}
packet->resize(packet_start_size + rtcp_log_size);
base::BigEndianWriter big_endian_writer(
reinterpret_cast<char*>(&((*packet)[packet_start_size])), rtcp_log_size);
big_endian_writer.WriteU8(0x80 + kReceiverLogSubtype);
big_endian_writer.WriteU8(kPacketTypeApplicationDefined);
big_endian_writer.WriteU16(static_cast<uint16>(
2 + 2 * number_of_frames + total_number_of_messages_to_send));
big_endian_writer.WriteU32(ssrc_); // Add our own SSRC.
big_endian_writer.WriteU32(kCast);
AddRtcpHeader(kPacketTypeApplicationDefined, kReceiverLogSubtype);
writer_.WriteU32(ssrc_); // Add our own SSRC.
writer_.WriteU32(kCast);
while (!receiver_log_message.empty() &&
total_number_of_messages_to_send > 0) {
......@@ -464,7 +386,7 @@ void RtcpSender::BuildReceiverLog(
receiver_log_message.front());
// Add our frame header.
big_endian_writer.WriteU32(frame_log_messages.rtp_timestamp_);
writer_.WriteU32(frame_log_messages.rtp_timestamp_);
size_t messages_in_frame = frame_log_messages.event_log_messages_.size();
if (messages_in_frame > total_number_of_messages_to_send) {
// We are running out of space.
......@@ -474,15 +396,15 @@ void RtcpSender::BuildReceiverLog(
total_number_of_messages_to_send -= messages_in_frame;
// On the wire format is number of messages - 1.
big_endian_writer.WriteU8(static_cast<uint8>(messages_in_frame - 1));
writer_.WriteU8(static_cast<uint8>(messages_in_frame - 1));
base::TimeTicks event_timestamp_base =
frame_log_messages.event_log_messages_.front().event_timestamp;
uint32 base_timestamp_ms =
(event_timestamp_base - base::TimeTicks()).InMilliseconds();
big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms >> 16));
big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms >> 8));
big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms));
writer_.WriteU8(static_cast<uint8>(base_timestamp_ms >> 16));
writer_.WriteU8(static_cast<uint8>(base_timestamp_ms >> 8));
writer_.WriteU8(static_cast<uint8>(base_timestamp_ms));
while (!frame_log_messages.event_log_messages_.empty() &&
messages_in_frame > 0) {
......@@ -496,13 +418,13 @@ void RtcpSender::BuildReceiverLog(
case FRAME_ACK_SENT:
case FRAME_PLAYOUT:
case FRAME_DECODED:
big_endian_writer.WriteU16(
writer_.WriteU16(
static_cast<uint16>(event_message.delay_delta.InMilliseconds()));
big_endian_writer.WriteU16(event_type_and_timestamp_delta);
writer_.WriteU16(event_type_and_timestamp_delta);
break;
case PACKET_RECEIVED:
big_endian_writer.WriteU16(event_message.packet_id);
big_endian_writer.WriteU16(event_type_and_timestamp_delta);
writer_.WriteU16(event_message.packet_id);
writer_.WriteU16(event_type_and_timestamp_delta);
break;
default:
NOTREACHED();
......@@ -518,15 +440,13 @@ void RtcpSender::BuildReceiverLog(
DCHECK_EQ(total_number_of_messages_to_send, 0u);
}
bool RtcpSender::BuildRtcpReceiverLogMessage(
bool RtcpBuilder::GetRtcpReceiverLogMessage(
const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events,
size_t start_size,
RtcpReceiverLogMessage* receiver_log_message,
size_t* number_of_frames,
size_t* total_number_of_messages_to_send,
size_t* rtcp_log_size) {
size_t* total_number_of_messages_to_send) {
size_t number_of_frames = 0;
size_t remaining_space =
std::min(kMaxReceiverLogBytes, kMaxIpPacketSize - start_size);
std::min<size_t>(kMaxReceiverLogBytes, writer_.remaining());
if (remaining_space < kRtcpCastLogHeaderSize + kRtcpReceiverFrameLogSize +
kRtcpReceiverEventLogSize) {
return false;
......@@ -548,7 +468,7 @@ bool RtcpSender::BuildRtcpReceiverLogMessage(
const RtpTimestamp rtp_timestamp = rit->first;
RtcpReceiverFrameLogMessage frame_log(rtp_timestamp);
remaining_space -= kRtcpReceiverFrameLogSize;
++*number_of_frames;
++number_of_frames;
// Get all events of a single frame.
sorted_log_messages.clear();
......@@ -598,20 +518,20 @@ bool RtcpSender::BuildRtcpReceiverLogMessage(
// unlikely there will be a match anyway.
if (rtcp_events_history_.size() > kFirstRedundancyOffset) {
// Add first redundnacy messages, if enough space remaining
AddReceiverLog(rtcp_events_history_[kFirstRedundancyOffset],
receiver_log_message,
&remaining_space,
number_of_frames,
total_number_of_messages_to_send);
AddReceiverLogEntries(rtcp_events_history_[kFirstRedundancyOffset],
receiver_log_message,
&remaining_space,
&number_of_frames,
total_number_of_messages_to_send);
}
if (rtcp_events_history_.size() > kSecondRedundancyOffset) {
// Add second redundancy messages, if enough space remaining
AddReceiverLog(rtcp_events_history_[kSecondRedundancyOffset],
receiver_log_message,
&remaining_space,
number_of_frames,
total_number_of_messages_to_send);
AddReceiverLogEntries(rtcp_events_history_[kSecondRedundancyOffset],
receiver_log_message,
&remaining_space,
&number_of_frames,
total_number_of_messages_to_send);
}
if (rtcp_events_history_.size() > kReceiveLogMessageHistorySize) {
......@@ -620,16 +540,9 @@ bool RtcpSender::BuildRtcpReceiverLogMessage(
DCHECK_LE(rtcp_events_history_.size(), kReceiveLogMessageHistorySize);
*rtcp_log_size =
kRtcpCastLogHeaderSize + *number_of_frames * kRtcpReceiverFrameLogSize +
*total_number_of_messages_to_send * kRtcpReceiverEventLogSize;
DCHECK_GE(kMaxIpPacketSize, start_size + *rtcp_log_size)
<< "Not enough buffer space.";
VLOG(3) << "number of frames: " << *number_of_frames;
VLOG(3) << "number of frames: " << number_of_frames;
VLOG(3) << "total messages to send: " << *total_number_of_messages_to_send;
VLOG(3) << "rtcp log size: " << *rtcp_log_size;
return *number_of_frames > 0;
return number_of_frames > 0;
}
} // namespace cast
......
media/cast/net/rtcp/rtcp_sender.h → media/cast/net/rtcp/rtcp_builder.h
View file @ 9f7acae4
......@@ -2,13 +2,14 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef MEDIA_CAST_NET_RTCP_RTCP_SENDER_H_
#define MEDIA_CAST_NET_RTCP_RTCP_SENDER_H_
#ifndef MEDIA_CAST_NET_RTCP_RTCP_BUILDER_H_
#define MEDIA_CAST_NET_RTCP_RTCP_BUILDER_H_
#include <deque>
#include <list>
#include <string>
#include "base/big_endian.h"
#include "media/cast/cast_config.h"
#include "media/cast/cast_defines.h"
#include "media/cast/net/cast_transport_defines.h"
......@@ -38,67 +39,49 @@ COMPILE_ASSERT(kSecondRedundancyOffset >
kReceiveLogMessageHistorySize,
redundancy_offset_out_of_range);
class PacedPacketSender;
// TODO(hclam): This should be renamed to RtcpPacketBuilder. The function
// of this class is to only to build a RTCP packet but not to send it.
class RtcpSender {
class RtcpBuilder {
public:
RtcpSender(PacedPacketSender* outgoing_transport,
uint32 sending_ssrc);
~RtcpSender();
explicit RtcpBuilder(uint32 sending_ssrc);
~RtcpBuilder();
// TODO(hclam): This method should be to build a packet instead of
// sending it.
void SendRtcpFromRtpReceiver(
PacketRef BuildRtcpFromReceiver(
const RtcpReportBlock* report_block,
const RtcpReceiverReferenceTimeReport* rrtr,
const RtcpCastMessage* cast_message,
const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events,
base::TimeDelta target_delay);
// TODO(hclam): This method should be to build a packet instead of
// sending it.
void SendRtcpFromRtpSender(const RtcpSenderInfo& sender_info);
PacketRef BuildRtcpFromSender(const RtcpSenderInfo& sender_info);
private:
void BuildRR(const RtcpReportBlock* report_block,
Packet* packet) const;
void AddReportBlocks(const RtcpReportBlock& report_block,
Packet* packet) const;
void BuildRrtr(const RtcpReceiverReferenceTimeReport* rrtr,
Packet* packet) const;
void BuildCast(const RtcpCastMessage* cast_message,
base::TimeDelta target_delay,
Packet* packet) const;
void BuildSR(const RtcpSenderInfo& sender_info, Packet* packet) const;
void BuildDlrrRb(const RtcpDlrrReportBlock& dlrr, Packet* packet) const;
void BuildReceiverLog(
void AddRtcpHeader(RtcpPacketFields payload, int format_or_count);
void PatchLengthField();
void AddRR(const RtcpReportBlock* report_block);
void AddReportBlocks(const RtcpReportBlock& report_block);
void AddRrtr(const RtcpReceiverReferenceTimeReport* rrtr);
void AddCast(const RtcpCastMessage* cast_message,
base::TimeDelta target_delay);
void AddSR(const RtcpSenderInfo& sender_info);
void AddDlrrRb(const RtcpDlrrReportBlock& dlrr);
void AddReceiverLog(
const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events);
bool GetRtcpReceiverLogMessage(
const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events,
Packet* packet);
bool BuildRtcpReceiverLogMessage(
const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events,
size_t start_size,
RtcpReceiverLogMessage* receiver_log_message,
size_t* number_of_frames,
size_t* total_number_of_messages_to_send,
size_t* rtcp_log_size);
size_t* total_number_of_messages_to_send);
const uint32 ssrc_;
// Not owned by this class.
PacedPacketSender* const transport_;
void Start();
PacketRef Finish();
base::BigEndianWriter writer_;
const uint32 ssrc_;
char* ptr_of_length_;
PacketRef packet_;
std::deque<RtcpReceiverLogMessage> rtcp_events_history_;
DISALLOW_COPY_AND_ASSIGN(RtcpSender);
DISALLOW_COPY_AND_ASSIGN(RtcpBuilder);
};
} // namespace cast
......
media/cast/net/rtcp/rtcp_sender_unittest.cc → media/cast/net/rtcp/rtcp_builder_unittest.cc
View file @ 9f7acae4
......@@ -9,10 +9,9 @@
#include "media/cast/net/cast_transport_defines.h"
#include "media/cast/net/pacing/paced_sender.h"
#include "media/cast/net/rtcp/receiver_rtcp_event_subscriber.h"
#include "media/cast/net/rtcp/rtcp_sender.h"
#include "media/cast/net/rtcp/rtcp_builder.h"
#include "media/cast/net/rtcp/rtcp_utility.h"
#include "media/cast/net/rtcp/test_rtcp_packet_builder.h"
#include "media/cast/test/fake_single_thread_task_runner.h"
#include "testing/gmock/include/gmock/gmock.h"
namespace media {
......@@ -40,93 +39,50 @@ RtcpReportBlock GetReportBlock() {
} // namespace
class TestRtcpTransport : public PacedPacketSender {
public:
TestRtcpTransport() : packet_count_(0) {}
virtual bool SendRtcpPacket(uint32 ssrc,
PacketRef packet) OVERRIDE {
EXPECT_EQ(expected_packet_.size(), packet->data.size());
if (expected_packet_.size() != packet->data.size())
return false;
EXPECT_EQ(0, memcmp(&expected_packet_[0],
&packet->data[0],
packet->data.size()));
packet_count_++;
return true;
}
virtual bool SendPackets(
const SendPacketVector& packets) OVERRIDE {
return false;
}
virtual bool ResendPackets(
const SendPacketVector& packets,
const DedupInfo& dedup_info) OVERRIDE {
return false;
}
virtual void CancelSendingPacket(
const PacketKey& packet_key) OVERRIDE {
}
void SetExpectedRtcpPacket(scoped_ptr<Packet> packet) {
expected_packet_.swap(*packet);
class RtcpBuilderTest : public ::testing::Test {
protected:
RtcpBuilderTest()
: rtcp_builder_(new RtcpBuilder(kSendingSsrc)) {}
void ExpectPacketEQ(scoped_ptr<Packet> golden_packet,
PacketRef packet) {
EXPECT_EQ(golden_packet->size(), packet->data.size());
if (golden_packet->size() == packet->data.size()) {
for (size_t x = 0; x < golden_packet->size(); x++) {
EXPECT_EQ((*golden_packet)[x], packet->data[x]);
if ((*golden_packet)[x] != packet->data[x])
break;
}
}
}
int packet_count() const { return packet_count_; }
private:
Packet expected_packet_;
int packet_count_;
scoped_ptr<RtcpBuilder> rtcp_builder_;
DISALLOW_COPY_AND_ASSIGN(TestRtcpTransport);
};
class RtcpSenderTest : public ::testing::Test {
protected:
RtcpSenderTest()
: testing_clock_(new base::SimpleTestTickClock()),
task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
cast_environment_(new CastEnvironment(
scoped_ptr<base::TickClock>(testing_clock_).Pass(),
task_runner_,
task_runner_,
task_runner_)),
rtcp_sender_(new RtcpSender(&test_transport_, kSendingSsrc)) {}
base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment.
TestRtcpTransport test_transport_;
scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
scoped_refptr<CastEnvironment> cast_environment_;
scoped_ptr<RtcpSender> rtcp_sender_;
DISALLOW_COPY_AND_ASSIGN(RtcpSenderTest);
DISALLOW_COPY_AND_ASSIGN(RtcpBuilderTest);
};
TEST_F(RtcpSenderTest, RtcpReceiverReport) {
TEST_F(RtcpBuilderTest, RtcpReceiverReport) {
// Receiver report with report block.
TestRtcpPacketBuilder p2;
p2.AddRr(kSendingSsrc, 1);
p2.AddRb(kMediaSsrc);
test_transport_.SetExpectedRtcpPacket(p2.GetPacket().Pass());
RtcpReportBlock report_block = GetReportBlock();
rtcp_sender_->SendRtcpFromRtpReceiver(
&report_block, NULL, NULL, NULL, kDefaultDelay);
EXPECT_EQ(1, test_transport_.packet_count());
ExpectPacketEQ(
p2.GetPacket().Pass(),
rtcp_builder_->BuildRtcpFromReceiver(
&report_block, NULL, NULL, NULL, kDefaultDelay));
}
TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) {
TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtr) {
// Receiver report with report block.
TestRtcpPacketBuilder p;
p.AddRr(kSendingSsrc, 1);
p.AddRb(kMediaSsrc);
p.AddXrHeader(kSendingSsrc);
p.AddXrRrtrBlock();
test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
RtcpReportBlock report_block = GetReportBlock();
......@@ -134,23 +90,21 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) {
rrtr.ntp_seconds = kNtpHigh;
rrtr.ntp_fraction = kNtpLow;
rtcp_sender_->SendRtcpFromRtpReceiver(
&report_block,
&rrtr,
NULL,
NULL,
kDefaultDelay);
EXPECT_EQ(1, test_transport_.packet_count());
ExpectPacketEQ(p.GetPacket().Pass(),
rtcp_builder_->BuildRtcpFromReceiver(
&report_block,
&rrtr,
NULL,
NULL,
kDefaultDelay));
}
TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) {
TEST_F(RtcpBuilderTest, RtcpReceiverReportWithCast) {
// Receiver report with report block.
TestRtcpPacketBuilder p;
p.AddRr(kSendingSsrc, 1);
p.AddRb(kMediaSsrc);
p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
RtcpReportBlock report_block = GetReportBlock();
......@@ -165,24 +119,22 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) {
cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] =
missing_packets;
rtcp_sender_->SendRtcpFromRtpReceiver(
&report_block,
NULL,
&cast_message,
NULL,
kDefaultDelay);
EXPECT_EQ(1, test_transport_.packet_count());
ExpectPacketEQ(p.GetPacket().Pass(),
rtcp_builder_->BuildRtcpFromReceiver(
&report_block,
NULL,
&cast_message,
NULL,
kDefaultDelay));
}
TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtraAndCastMessage) {
TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtraAndCastMessage) {
TestRtcpPacketBuilder p;
p.AddRr(kSendingSsrc, 1);
p.AddRb(kMediaSsrc);
p.AddXrHeader(kSendingSsrc);
p.AddXrRrtrBlock();
p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
RtcpReportBlock report_block = GetReportBlock();
......@@ -201,17 +153,16 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtraAndCastMessage) {
cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] =
missing_packets;
rtcp_sender_->SendRtcpFromRtpReceiver(
&report_block,
&rrtr,
&cast_message,
NULL,
kDefaultDelay);
EXPECT_EQ(1, test_transport_.packet_count());
ExpectPacketEQ(p.GetPacket().Pass(),
rtcp_builder_->BuildRtcpFromReceiver(
&report_block,
&rrtr,
&cast_message,
NULL,
kDefaultDelay));
}
TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
static const uint32 kTimeBaseMs = 12345678;
static const uint32 kTimeDelayMs = 10;
......@@ -221,7 +172,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
p.AddXrHeader(kSendingSsrc);
p.AddXrRrtrBlock();
p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
RtcpReportBlock report_block = GetReportBlock();
......@@ -243,12 +193,13 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
rtcp_sender_->SendRtcpFromRtpReceiver(
&report_block,
&rrtr,
&cast_message,
&rtcp_events,
kDefaultDelay);
ExpectPacketEQ(p.GetPacket().Pass(),
rtcp_builder_->BuildRtcpFromReceiver(
&report_block,
&rrtr,
&cast_message,
&rtcp_events,
kDefaultDelay));
base::SimpleTestTickClock testing_clock;
testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
......@@ -258,8 +209,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs);
test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
FrameEvent frame_event;
frame_event.rtp_timestamp = kRtpTimestamp;
frame_event.type = FRAME_ACK_SENT;
......@@ -278,17 +227,17 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
EXPECT_EQ(2u, rtcp_events.size());
rtcp_sender_->SendRtcpFromRtpReceiver(
&report_block,
&rrtr,
&cast_message,
&rtcp_events,
kDefaultDelay);
EXPECT_EQ(2, test_transport_.packet_count());
ExpectPacketEQ(
p.GetPacket().Pass(),
rtcp_builder_->BuildRtcpFromReceiver(
&report_block,
&rrtr,
&cast_message,
&rtcp_events,
kDefaultDelay));
}
TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) {
TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOversizedFrameLog) {
static const uint32 kTimeBaseMs = 12345678;
static const uint32 kTimeDelayMs = 10;
......@@ -320,7 +269,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) {
static_cast<uint16>(kTimeDelayMs * i));
}
test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
FrameEvent frame_event;
......@@ -344,17 +292,16 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) {
ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
rtcp_sender_->SendRtcpFromRtpReceiver(
&report_block,
NULL,
NULL,
&rtcp_events,
kDefaultDelay);
EXPECT_EQ(1, test_transport_.packet_count());
ExpectPacketEQ(p.GetPacket().Pass(),
rtcp_builder_->BuildRtcpFromReceiver(
&report_block,
NULL,
NULL,
&rtcp_events,
kDefaultDelay));
}
TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) {
TEST_F(RtcpBuilderTest, RtcpReceiverReportWithTooManyLogFrames) {
static const uint32 kTimeBaseMs = 12345678;
static const uint32 kTimeDelayMs = 10;
......@@ -382,7 +329,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) {
p.AddReceiverFrameLog(kRtpTimestamp + i, 1, kTimeBaseMs + i * kTimeDelayMs);
p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
}
test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
......@@ -399,17 +345,16 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) {
ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
rtcp_sender_->SendRtcpFromRtpReceiver(
&report_block,
NULL,
NULL,
&rtcp_events,
kDefaultDelay);
EXPECT_EQ(1, test_transport_.packet_count());
ExpectPacketEQ(p.GetPacket().Pass(),
rtcp_builder_->BuildRtcpFromReceiver(
&report_block,
NULL,
NULL,
&rtcp_events,
kDefaultDelay));
}
TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) {
TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOldLogFrames) {
static const uint32 kTimeBaseMs = 12345678;
TestRtcpPacketBuilder p;
......@@ -431,7 +376,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) {
for (int i = 0; i < 10; ++i) {
p.AddReceiverEventLog(0, FRAME_ACK_SENT, i * kTimeBetweenEventsMs);
}
test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
for (int i = 0; i < 11; ++i) {
......@@ -448,17 +392,16 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) {
ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
rtcp_sender_->SendRtcpFromRtpReceiver(
&report_block,
NULL,
NULL,
&rtcp_events,
kDefaultDelay);
EXPECT_EQ(1, test_transport_.packet_count());
ExpectPacketEQ(p.GetPacket().Pass(),
rtcp_builder_->BuildRtcpFromReceiver(
&report_block,
NULL,
NULL,
&rtcp_events,
kDefaultDelay));
}
TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) {
TEST_F(RtcpBuilderTest, RtcpReceiverReportRedundancy) {
uint32 time_base_ms = 12345678;
int kTimeBetweenEventsMs = 10;
......@@ -493,8 +436,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) {
p.AddReceiverFrameLog(kRtpTimestamp, 1, time_base_ms);
p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
FrameEvent frame_event;
frame_event.rtp_timestamp = kRtpTimestamp;
frame_event.type = FRAME_ACK_SENT;
......@@ -505,22 +446,21 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) {
ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
rtcp_sender_->SendRtcpFromRtpReceiver(
&report_block,
NULL,
NULL,
&rtcp_events,
kDefaultDelay);
ExpectPacketEQ(p.GetPacket().Pass(),
rtcp_builder_->BuildRtcpFromReceiver(
&report_block,
NULL,
NULL,
&rtcp_events,
kDefaultDelay));
testing_clock.Advance(
base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
time_base_ms += kTimeBetweenEventsMs;
}
EXPECT_EQ(static_cast<int>(packet_count), test_transport_.packet_count());
}
TEST_F(RtcpSenderTest, RtcpSenderReport) {
TEST_F(RtcpBuilderTest, RtcpSenderReport) {
RtcpSenderInfo sender_info;
sender_info.ntp_seconds = kNtpHigh;
sender_info.ntp_fraction = kNtpLow;
......@@ -531,11 +471,9 @@ TEST_F(RtcpSenderTest, RtcpSenderReport) {
// Sender report.
TestRtcpPacketBuilder p;
p.AddSr(kSendingSsrc, 0);
test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
rtcp_sender_->SendRtcpFromRtpSender(sender_info);
EXPECT_EQ(1, test_transport_.packet_count());
ExpectPacketEQ(p.GetPacket().Pass(),
rtcp_builder_->BuildRtcpFromSender(sender_info));
}
} // namespace cast
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment