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     if (!BuildSR(sender_info, &packet)) return;
  59     if (!BuildSdec(&packet)) return;
  60   }
  61   if (packet_type_flags & kRtcpBye) {
  62     if (!BuildBye(&packet)) return;
  63   }
  64   if (packet_type_flags & kRtcpDlrr) {
  65     if (!BuildDlrrRb(dlrr, &packet)) return;
  66   }
  67   if (packet_type_flags & kRtcpSenderLog) {
  68     if (!BuildSenderLog(sender_log, &packet)) return;
  69   }
  70   if (packet.empty())
  71     return;  // Sanity - don't send empty packets.
  72
  73   transport_->SendRtcpPacket(packet);
  74 }
  75
  76 bool RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
  77                           Packet* packet) const {
  78   // Sender report.
  79   size_t start_size = packet->size();
  80   if (start_size + 52 > kMaxIpPacketSize) {
  81     DLOG(FATAL) << "Not enough buffer space";
  82     return false;
  83   }
  84
  85   uint16 number_of_rows = 6;
  86   packet->resize(start_size + 28);
  87
  88   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 28);
  89   big_endian_writer.WriteU8(0x80);
  90   big_endian_writer.WriteU8(kPacketTypeSenderReport);
  91   big_endian_writer.WriteU16(number_of_rows);
  92   big_endian_writer.WriteU32(ssrc_);
  93   big_endian_writer.WriteU32(sender_info.ntp_seconds);
  94   big_endian_writer.WriteU32(sender_info.ntp_fraction);
  95   big_endian_writer.WriteU32(sender_info.rtp_timestamp);
  96   big_endian_writer.WriteU32(sender_info.send_packet_count);
  97   big_endian_writer.WriteU32(static_cast<uint32>(sender_info.send_octet_count));
  98   return true;
  99 }
 100
 101 bool RtcpBuilder::BuildSdec(Packet* packet) const {
 102   size_t start_size = packet->size();
 103   if (start_size + 12 + c_name_.length() > kMaxIpPacketSize) {
 104     DLOG(FATAL) << "Not enough buffer space";
 105     return false;
 106   }
 107
 108   // SDES Source Description.
 109   packet->resize(start_size + 10);
 110
 111   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 10);
 112   // We always need to add one SDES CNAME.
 113   big_endian_writer.WriteU8(0x80 + 1);
 114   big_endian_writer.WriteU8(kPacketTypeSdes);
 115
 116   // Handle SDES length later on.
 117   uint32 sdes_length_position = static_cast<uint32>(start_size) + 3;
 118   big_endian_writer.WriteU16(0);
 119   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 120   big_endian_writer.WriteU8(1);  // CNAME = 1
 121   big_endian_writer.WriteU8(static_cast<uint8>(c_name_.length()));
 122
 123   size_t sdes_length = 10 + c_name_.length();
 124   packet->insert(packet->end(), c_name_.c_str(),
 125                  c_name_.c_str() + c_name_.length());
 126
 127   size_t padding = 0;
 128
 129   // We must have a zero field even if we have an even multiple of 4 bytes.
 130   if ((packet->size() % 4) == 0) {
 131     padding++;
 132     packet->push_back(0);
 133   }
 134   while ((packet->size() % 4) != 0) {
 135     padding++;
 136     packet->push_back(0);
 137   }
 138   sdes_length += padding;
 139
 140   // In 32-bit words minus one and we don't count the header.
 141   uint8 buffer_length = static_cast<uint8>((sdes_length / 4) - 1);
 142   (*packet)[sdes_length_position] = buffer_length;
 143   return true;
 144 }
 145
 146 bool RtcpBuilder::BuildBye(Packet* packet) const {
 147   size_t start_size = packet->size();
 148   if (start_size + 8 > kMaxIpPacketSize) {
 149     DLOG(FATAL) << "Not enough buffer space";
 150     return false;
 151   }
 152
 153   packet->resize(start_size + 8);
 154
 155   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
 156   big_endian_writer.WriteU8(0x80 + 1);
 157   big_endian_writer.WriteU8(kPacketTypeBye);
 158   big_endian_writer.WriteU16(1);  // Length.
 159   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 160   return true;
 161 }
 162
 163 /*
 164    0                   1                   2                   3
 165    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
 166   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 167   |V=2|P|reserved |   PT=XR=207   |             length            |
 168   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 169   |                              SSRC                             |
 170   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 171   |     BT=5      |   reserved    |         block length          |
 172   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 173   |                 SSRC_1 (SSRC of first receiver)               | sub-
 174   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block
 175   |                         last RR (LRR)                         |   1
 176   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 177   |                   delay since last RR (DLRR)                  |
 178   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 179 */
 180 bool RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
 181                               Packet* packet) const {
 182   size_t start_size = packet->size();
 183   if (start_size + 24 > kMaxIpPacketSize) {
 184     DLOG(FATAL) << "Not enough buffer space";
 185     return false;
 186   }
 187
 188   packet->resize(start_size + 24);
 189
 190   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24);
 191   big_endian_writer.WriteU8(0x80);
 192   big_endian_writer.WriteU8(kPacketTypeXr);
 193   big_endian_writer.WriteU16(5);  // Length.
 194   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 195   big_endian_writer.WriteU8(5);  // Add block type.
 196   big_endian_writer.WriteU8(0);  // Add reserved.
 197   big_endian_writer.WriteU16(3);  // Block length.
 198   big_endian_writer.WriteU32(ssrc_);  // Add the media (received RTP) SSRC.
 199   big_endian_writer.WriteU32(dlrr.last_rr);
 200   big_endian_writer.WriteU32(dlrr.delay_since_last_rr);
 201   return true;
 202 }
 203
 204 bool RtcpBuilder::BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
 205                                  Packet* packet) const {
 206   DCHECK(packet);
 207   size_t start_size = packet->size();
 208   size_t remaining_space = kMaxIpPacketSize - start_size;
 209   if (remaining_space < kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize) {
 210     DLOG(FATAL) << "Not enough buffer space";
 211     return false;
 212   }
 213
 214   size_t space_for_x_messages =
 215       (remaining_space - kRtcpCastLogHeaderSize) / kRtcpSenderFrameLogSize;
 216   size_t number_of_messages = std::min(space_for_x_messages,
 217                                        sender_log_message.size());
 218
 219   size_t log_size = kRtcpCastLogHeaderSize +
 220       number_of_messages * kRtcpSenderFrameLogSize;
 221   packet->resize(start_size + log_size);
 222
 223   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), log_size);
 224   big_endian_writer.WriteU8(0x80 + kSenderLogSubtype);
 225   big_endian_writer.WriteU8(kPacketTypeApplicationDefined);
 226   big_endian_writer.WriteU16(static_cast<uint16>(2 + number_of_messages));
 227   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 228   big_endian_writer.WriteU32(kCast);
 229
 230   std::vector<RtcpSenderFrameLogMessage>::const_iterator it =
 231       sender_log_message.begin();
 232   for (; number_of_messages > 0; --number_of_messages) {
 233     DCHECK(!sender_log_message.empty());
 234     const RtcpSenderFrameLogMessage& message = *it;
 235     big_endian_writer.WriteU8(static_cast<uint8>(message.frame_status));
 236     // We send the 24 east significant bits of the RTP timestamp.
 237     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 16));
 238     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 8));
 239     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp));
 240     ++it;
 241   }
 242   return true;
 243 }
 244
 245 }  // namespace transport
 246 }  // namespace cast
 247 }  // namespace media