src/media/cast/transport/rtcp/rtcp_builder.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/cast/transport/rtcp/rtcp_builder.h"
   6
   7 #include <algorithm>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/logging.h"
  12 #include "media/cast/transport/cast_transport_defines.h"
  13 #include "media/cast/transport/pacing/paced_sender.h"
  14 #include "net/base/big_endian.h"
  15
  16 static const size_t kRtcpCastLogHeaderSize = 12;
  17 static const size_t kRtcpSenderFrameLogSize = 4;
  18
  19 namespace media {
  20 namespace cast {
  21 namespace transport {
  22
  23 namespace {
  24 // RFC 3550 page 44, including end null.
  25 static const uint32 kCast = ('C' << 24) + ('A' << 16) + ('S' << 8) + 'T';
  26 static const uint8 kSenderLogSubtype = 1;
  27 };
  28
  29 RtcpBuilder::RtcpBuilder(PacedSender* const outgoing_transport)
  30     : transport_(outgoing_transport),
  31       ssrc_(0) {
  32 }
  33
  34 RtcpBuilder::~RtcpBuilder() {}
  35
  36 void RtcpBuilder::SendRtcpFromRtpSender(
  37     uint32 packet_type_flags,
  38     const RtcpSenderInfo& sender_info,
  39     const RtcpDlrrReportBlock& dlrr,
  40     const RtcpSenderLogMessage& sender_log,
  41     uint32 sending_ssrc,
  42     const std::string& c_name) {
  43   if (packet_type_flags & kRtcpRr ||
  44       packet_type_flags & kRtcpPli ||
  45       packet_type_flags & kRtcpRrtr ||
  46       packet_type_flags & kRtcpCast ||
  47       packet_type_flags & kRtcpReceiverLog ||
  48       packet_type_flags & kRtcpRpsi ||
  49       packet_type_flags & kRtcpRemb ||
  50       packet_type_flags & kRtcpNack) {
  51     NOTREACHED() << "Invalid argument";
  52   }
  53   ssrc_ = sending_ssrc;
  54   c_name_ = c_name;
  55   Packet packet;
  56   packet.reserve(kMaxIpPacketSize);
  57   if (packet_type_flags & kRtcpSr) {
  58     BuildSR(sender_info, &packet);
  59     BuildSdec(&packet);
  60   }
  61   if (packet_type_flags & kRtcpBye) {
  62     BuildBye(&packet);
  63   }
  64   if (packet_type_flags & kRtcpDlrr) {
  65     BuildDlrrRb(dlrr, &packet);
  66   }
  67   if (packet_type_flags & kRtcpSenderLog) {
  68     BuildSenderLog(sender_log, &packet);
  69   }
  70   if (packet.empty())
  71     return;  // Sanity - don't send empty packets.
  72
  73   transport_->SendRtcpPacket(packet);
  74 }
  75
  76 void RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
  77                           Packet* packet) const {
  78   // Sender report.
  79   size_t start_size = packet->size();
  80   DCHECK_LT(start_size + 52, kMaxIpPacketSize) << "Not enough buffer space";
  81   if (start_size + 52 > kMaxIpPacketSize) return;
  82
  83   uint16 number_of_rows = 6;
  84   packet->resize(start_size + 28);
  85
  86   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 28);
  87   big_endian_writer.WriteU8(0x80);
  88   big_endian_writer.WriteU8(kPacketTypeSenderReport);
  89   big_endian_writer.WriteU16(number_of_rows);
  90   big_endian_writer.WriteU32(ssrc_);
  91   big_endian_writer.WriteU32(sender_info.ntp_seconds);
  92   big_endian_writer.WriteU32(sender_info.ntp_fraction);
  93   big_endian_writer.WriteU32(sender_info.rtp_timestamp);
  94   big_endian_writer.WriteU32(sender_info.send_packet_count);
  95   big_endian_writer.WriteU32(static_cast<uint32>(sender_info.send_octet_count));
  96 }
  97
  98 void RtcpBuilder::BuildSdec(Packet* packet) const {
  99   size_t start_size = packet->size();
 100   DCHECK_LT(start_size +  12 + c_name_.length(), kMaxIpPacketSize)
 101       << "Not enough buffer space";
 102   if (start_size + 12 > kMaxIpPacketSize) return;
 103
 104   // SDES Source Description.
 105   packet->resize(start_size + 10);
 106
 107   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 10);
 108   // We always need to add one SDES CNAME.
 109   big_endian_writer.WriteU8(0x80 + 1);
 110   big_endian_writer.WriteU8(kPacketTypeSdes);
 111
 112   // Handle SDES length later on.
 113   uint32 sdes_length_position = static_cast<uint32>(start_size) + 3;
 114   big_endian_writer.WriteU16(0);
 115   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 116   big_endian_writer.WriteU8(1);  // CNAME = 1
 117   big_endian_writer.WriteU8(static_cast<uint8>(c_name_.length()));
 118
 119   size_t sdes_length = 10 + c_name_.length();
 120   packet->insert(packet->end(), c_name_.c_str(),
 121                  c_name_.c_str() + c_name_.length());
 122
 123   size_t padding = 0;
 124
 125   // We must have a zero field even if we have an even multiple of 4 bytes.
 126   if ((packet->size() % 4) == 0) {
 127     padding++;
 128     packet->push_back(0);
 129   }
 130   while ((packet->size() % 4) != 0) {
 131     padding++;
 132     packet->push_back(0);
 133   }
 134   sdes_length += padding;
 135
 136   // In 32-bit words minus one and we don't count the header.
 137   uint8 buffer_length = static_cast<uint8>((sdes_length / 4) - 1);
 138   (*packet)[sdes_length_position] = buffer_length;
 139 }
 140
 141 void RtcpBuilder::BuildBye(Packet* packet) const {
 142   size_t start_size = packet->size();
 143   DCHECK_LT(start_size + 8, kMaxIpPacketSize) << "Not enough buffer space";
 144   if (start_size + 8 > kMaxIpPacketSize) return;
 145
 146   packet->resize(start_size + 8);
 147
 148   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
 149   big_endian_writer.WriteU8(0x80 + 1);
 150   big_endian_writer.WriteU8(kPacketTypeBye);
 151   big_endian_writer.WriteU16(1);  // Length.
 152   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 153 }
 154
 155 /*
 156    0                   1                   2                   3
 157    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 158   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 159   |V=2|P|reserved |   PT=XR=207   |             length            |
 160   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 161   |                              SSRC                             |
 162   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 163   |     BT=5      |   reserved    |         block length          |
 164   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 165   |                 SSRC_1 (SSRC of first receiver)               | sub-
 166   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block
 167   |                         last RR (LRR)                         |   1
 168   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 169   |                   delay since last RR (DLRR)                  |
 170   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 171 */
 172 void RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
 173                               Packet* packet) const {
 174   size_t start_size = packet->size();
 175   DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
 176   if (start_size + 24 > kMaxIpPacketSize) return;
 177
 178   packet->resize(start_size + 24);
 179
 180   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24);
 181   big_endian_writer.WriteU8(0x80);
 182   big_endian_writer.WriteU8(kPacketTypeXr);
 183   big_endian_writer.WriteU16(5);  // Length.
 184   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 185   big_endian_writer.WriteU8(5);  // Add block type.
 186   big_endian_writer.WriteU8(0);  // Add reserved.
 187   big_endian_writer.WriteU16(3);  // Block length.
 188   big_endian_writer.WriteU32(ssrc_);  // Add the media (received RTP) SSRC.
 189   big_endian_writer.WriteU32(dlrr.last_rr);
 190   big_endian_writer.WriteU32(dlrr.delay_since_last_rr);
 191 }
 192
 193 void RtcpBuilder::BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
 194                                  Packet* packet) const {
 195   DCHECK(packet);
 196   size_t start_size = packet->size();
 197   size_t remaining_space = kMaxIpPacketSize - start_size;
 198   DCHECK_GE(remaining_space, kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
 199        << "Not enough buffer space";
 200   if (remaining_space < kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
 201     return;
 202
 203   size_t space_for_x_messages =
 204       (remaining_space - kRtcpCastLogHeaderSize) / kRtcpSenderFrameLogSize;
 205   size_t number_of_messages = std::min(space_for_x_messages,
 206                                        sender_log_message.size());
 207
 208   size_t log_size = kRtcpCastLogHeaderSize +
 209       number_of_messages * kRtcpSenderFrameLogSize;
 210   packet->resize(start_size + log_size);
 211
 212   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), log_size);
 213   big_endian_writer.WriteU8(0x80 + kSenderLogSubtype);
 214   big_endian_writer.WriteU8(kPacketTypeApplicationDefined);
 215   big_endian_writer.WriteU16(static_cast<uint16>(2 + number_of_messages));
 216   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 217   big_endian_writer.WriteU32(kCast);
 218
 219   std::list<RtcpSenderFrameLogMessage>::const_iterator it =
 220       sender_log_message.begin();
 221   for (; number_of_messages > 0; --number_of_messages) {
 222     DCHECK(!sender_log_message.empty());
 223     const RtcpSenderFrameLogMessage& message = *it;
 224     big_endian_writer.WriteU8(static_cast<uint8>(message.frame_status));
 225     // We send the 24 east significant bits of the RTP timestamp.
 226     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 16));
 227     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 8));
 228     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp));
 229     ++it;
 230   }
 231 }
 232
 233 }  // namespace transport
 234 }  // namespace cast
 235 }  // namespace media