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