media/cast/rtcp/rtcp_sender.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/rtcp/rtcp_sender.h"
   6
   7 #include <stdint.h>
   8
   9 #include <algorithm>
  10 #include <vector>
  11
  12 #include "base/big_endian.h"
  13 #include "base/logging.h"
  14 #include "media/cast/cast_environment.h"
  15 #include "media/cast/rtcp/rtcp_defines.h"
  16 #include "media/cast/rtcp/rtcp_utility.h"
  17 #include "media/cast/transport/cast_transport_defines.h"
  18 #include "media/cast/transport/pacing/paced_sender.h"
  19
  20 namespace media {
  21 namespace cast {
  22 namespace {
  23
  24 // Max delta is 4095 milliseconds because we need to be able to encode it in
  25 // 12 bits.
  26 const int64 kMaxWireFormatTimeDeltaMs = INT64_C(0xfff);
  27
  28 uint16 MergeEventTypeAndTimestampForWireFormat(
  29     const CastLoggingEvent& event,
  30     const base::TimeDelta& time_delta) {
  31   int64 time_delta_ms = time_delta.InMilliseconds();
  32
  33   DCHECK_GE(time_delta_ms, 0);
  34   DCHECK_LE(time_delta_ms, kMaxWireFormatTimeDeltaMs);
  35
  36   uint16 time_delta_12_bits =
  37       static_cast<uint16>(time_delta_ms & kMaxWireFormatTimeDeltaMs);
  38
  39   uint16 event_type_4_bits = ConvertEventTypeToWireFormat(event);
  40   DCHECK(event_type_4_bits);
  41   DCHECK(~(event_type_4_bits & 0xfff0));
  42   return (event_type_4_bits << 12) | time_delta_12_bits;
  43 }
  44
  45 bool EventTimestampLessThan(const RtcpReceiverEventLogMessage& lhs,
  46                             const RtcpReceiverEventLogMessage& rhs) {
  47   return lhs.event_timestamp < rhs.event_timestamp;
  48 }
  49
  50 void AddReceiverLog(
  51     const RtcpReceiverLogMessage& redundancy_receiver_log_message,
  52     RtcpReceiverLogMessage* receiver_log_message,
  53     size_t* remaining_space,
  54     size_t* number_of_frames,
  55     size_t* total_number_of_messages_to_send) {
  56   RtcpReceiverLogMessage::const_iterator it =
  57       redundancy_receiver_log_message.begin();
  58   while (it != redundancy_receiver_log_message.end() &&
  59          *remaining_space >=
  60              kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize) {
  61     receiver_log_message->push_front(*it);
  62     size_t num_event_logs = (*remaining_space - kRtcpReceiverFrameLogSize) /
  63                             kRtcpReceiverEventLogSize;
  64     RtcpReceiverEventLogMessages& event_log_messages =
  65         receiver_log_message->front().event_log_messages_;
  66     if (num_event_logs < event_log_messages.size())
  67       event_log_messages.resize(num_event_logs);
  68
  69     *remaining_space -= kRtcpReceiverFrameLogSize +
  70                         event_log_messages.size() * kRtcpReceiverEventLogSize;
  71     ++*number_of_frames;
  72     *total_number_of_messages_to_send += event_log_messages.size();
  73     ++it;
  74   }
  75 }
  76
  77 // A class to build a string representing the NACK list in Cast message.
  78 //
  79 // The string will look like "23:3-6 25:1,5-6", meaning packets 3 to 6 in frame
  80 // 23 are being NACK'ed (i.e. they are missing from the receiver's point of
  81 // view) and packets 1, 5 and 6 are missing in frame 25. A frame that is
  82 // completely missing will show as "26:65535".
  83 class NackStringBuilder {
  84  public:
  85   NackStringBuilder()
  86       : frame_count_(0),
  87         packet_count_(0),
  88         last_frame_id_(-1),
  89         last_packet_id_(-1),
  90         contiguous_sequence_(false) {}
  91   ~NackStringBuilder() {}
  92
  93   bool Empty() const { return frame_count_ == 0; }
  94
  95   void PushFrame(int frame_id) {
  96     DCHECK_GE(frame_id, 0);
  97     if (frame_count_ > 0) {
  98       if (frame_id == last_frame_id_) {
  99         return;
 100       }
 101       if (contiguous_sequence_) {
 102         stream_ << "-" << last_packet_id_;
 103       }
 104       stream_ << ", ";
 105     }
 106     stream_ << frame_id;
 107     last_frame_id_ = frame_id;
 108     packet_count_ = 0;
 109     contiguous_sequence_ = false;
 110     ++frame_count_;
 111   }
 112
 113   void PushPacket(int packet_id) {
 114     DCHECK_GE(last_frame_id_, 0);
 115     DCHECK_GE(packet_id, 0);
 116     if (packet_count_ == 0) {
 117       stream_ << ":" << packet_id;
 118     } else if (packet_id == last_packet_id_ + 1) {
 119       contiguous_sequence_ = true;
 120     } else {
 121       if (contiguous_sequence_) {
 122         stream_ << "-" << last_packet_id_;
 123         contiguous_sequence_ = false;
 124       }
 125       stream_ << "," << packet_id;
 126     }
 127     ++packet_count_;
 128     last_packet_id_ = packet_id;
 129   }
 130
 131   std::string GetString() {
 132     if (contiguous_sequence_) {
 133       stream_ << "-" << last_packet_id_;
 134       contiguous_sequence_ = false;
 135     }
 136     return stream_.str();
 137   }
 138
 139  private:
 140   std::ostringstream stream_;
 141   int frame_count_;
 142   int packet_count_;
 143   int last_frame_id_;
 144   int last_packet_id_;
 145   bool contiguous_sequence_;
 146 };
 147 }  // namespace
 148
 149 // TODO(mikhal): This is only used by the receiver. Consider renaming.
 150 RtcpSender::RtcpSender(scoped_refptr<CastEnvironment> cast_environment,
 151                        transport::PacedPacketSender* outgoing_transport,
 152                        uint32 sending_ssrc,
 153                        const std::string& c_name)
 154     : ssrc_(sending_ssrc),
 155       c_name_(c_name),
 156       transport_(outgoing_transport),
 157       cast_environment_(cast_environment) {
 158   DCHECK_LT(c_name_.length(), kRtcpCnameSize) << "Invalid config";
 159 }
 160
 161 RtcpSender::~RtcpSender() {}
 162
 163 void RtcpSender::SendRtcpFromRtpReceiver(
 164     uint32 packet_type_flags,
 165     const transport::RtcpReportBlock* report_block,
 166     const RtcpReceiverReferenceTimeReport* rrtr,
 167     const RtcpCastMessage* cast_message,
 168     const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events,
 169     uint16 target_delay_ms) {
 170   if (packet_type_flags & transport::kRtcpSr ||
 171       packet_type_flags & transport::kRtcpDlrr ||
 172       packet_type_flags & transport::kRtcpSenderLog) {
 173     NOTREACHED() << "Invalid argument";
 174   }
 175   if (packet_type_flags & transport::kRtcpPli ||
 176       packet_type_flags & transport::kRtcpRpsi ||
 177       packet_type_flags & transport::kRtcpRemb ||
 178       packet_type_flags & transport::kRtcpNack) {
 179     // Implement these for webrtc interop.
 180     NOTIMPLEMENTED();
 181   }
 182   transport::PacketRef packet(new base::RefCountedData<Packet>);
 183   packet->data.reserve(kMaxIpPacketSize);
 184
 185   if (packet_type_flags & transport::kRtcpRr) {
 186     BuildRR(report_block, &packet->data);
 187     if (!c_name_.empty()) {
 188       BuildSdec(&packet->data);
 189     }
 190   }
 191   if (packet_type_flags & transport::kRtcpBye) {
 192     BuildBye(&packet->data);
 193   }
 194   if (packet_type_flags & transport::kRtcpRrtr) {
 195     DCHECK(rrtr) << "Invalid argument";
 196     BuildRrtr(rrtr, &packet->data);
 197   }
 198   if (packet_type_flags & transport::kRtcpCast) {
 199     DCHECK(cast_message) << "Invalid argument";
 200     BuildCast(cast_message, target_delay_ms, &packet->data);
 201   }
 202   if (packet_type_flags & transport::kRtcpReceiverLog) {
 203     DCHECK(rtcp_events) << "Invalid argument";
 204     BuildReceiverLog(*rtcp_events, &packet->data);
 205   }
 206
 207   if (packet->data.empty())
 208     return;  // Sanity don't send empty packets.
 209
 210   transport_->SendRtcpPacket(ssrc_, packet);
 211 }
 212
 213 void RtcpSender::BuildRR(const transport::RtcpReportBlock* report_block,
 214                          Packet* packet) const {
 215   size_t start_size = packet->size();
 216   DCHECK_LT(start_size + 32, kMaxIpPacketSize) << "Not enough buffer space";
 217   if (start_size + 32 > kMaxIpPacketSize)
 218     return;
 219
 220   uint16 number_of_rows = (report_block) ? 7 : 1;
 221   packet->resize(start_size + 8);
 222
 223   base::BigEndianWriter big_endian_writer(
 224       reinterpret_cast<char*>(&((*packet)[start_size])), 8);
 225   big_endian_writer.WriteU8(0x80 + (report_block ? 1 : 0));
 226   big_endian_writer.WriteU8(transport::kPacketTypeReceiverReport);
 227   big_endian_writer.WriteU16(number_of_rows);
 228   big_endian_writer.WriteU32(ssrc_);
 229
 230   if (report_block) {
 231     AddReportBlocks(*report_block, packet);  // Adds 24 bytes.
 232   }
 233 }
 234
 235 void RtcpSender::AddReportBlocks(const transport::RtcpReportBlock& report_block,
 236                                  Packet* packet) const {
 237   size_t start_size = packet->size();
 238   DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
 239   if (start_size + 24 > kMaxIpPacketSize)
 240     return;
 241
 242   packet->resize(start_size + 24);
 243
 244   base::BigEndianWriter big_endian_writer(
 245       reinterpret_cast<char*>(&((*packet)[start_size])), 24);
 246   big_endian_writer.WriteU32(report_block.media_ssrc);
 247   big_endian_writer.WriteU8(report_block.fraction_lost);
 248   big_endian_writer.WriteU8(report_block.cumulative_lost >> 16);
 249   big_endian_writer.WriteU8(report_block.cumulative_lost >> 8);
 250   big_endian_writer.WriteU8(report_block.cumulative_lost);
 251
 252   // Extended highest seq_no, contain the highest sequence number received.
 253   big_endian_writer.WriteU32(report_block.extended_high_sequence_number);
 254   big_endian_writer.WriteU32(report_block.jitter);
 255
 256   // Last SR timestamp; our NTP time when we received the last report.
 257   // This is the value that we read from the send report packet not when we
 258   // received it.
 259   big_endian_writer.WriteU32(report_block.last_sr);
 260
 261   // Delay since last received report, time since we received the report.
 262   big_endian_writer.WriteU32(report_block.delay_since_last_sr);
 263 }
 264
 265 void RtcpSender::BuildSdec(Packet* packet) const {
 266   size_t start_size = packet->size();
 267   DCHECK_LT(start_size + 12 + c_name_.length(), kMaxIpPacketSize)
 268       << "Not enough buffer space";
 269   if (start_size + 12 > kMaxIpPacketSize)
 270     return;
 271
 272   // SDES Source Description.
 273   packet->resize(start_size + 10);
 274
 275   base::BigEndianWriter big_endian_writer(
 276       reinterpret_cast<char*>(&((*packet)[start_size])), 10);
 277   // We always need to add one SDES CNAME.
 278   big_endian_writer.WriteU8(0x80 + 1);
 279   big_endian_writer.WriteU8(transport::kPacketTypeSdes);
 280
 281   // Handle SDES length later on.
 282   uint32 sdes_length_position = static_cast<uint32>(start_size) + 3;
 283   big_endian_writer.WriteU16(0);
 284   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 285   big_endian_writer.WriteU8(1);       // CNAME = 1
 286   big_endian_writer.WriteU8(static_cast<uint8>(c_name_.length()));
 287
 288   size_t sdes_length = 10 + c_name_.length();
 289   packet->insert(
 290       packet->end(), c_name_.c_str(), c_name_.c_str() + c_name_.length());
 291
 292   size_t padding = 0;
 293
 294   // We must have a zero field even if we have an even multiple of 4 bytes.
 295   if ((packet->size() % 4) == 0) {
 296     padding++;
 297     packet->push_back(0);
 298   }
 299   while ((packet->size() % 4) != 0) {
 300     padding++;
 301     packet->push_back(0);
 302   }
 303   sdes_length += padding;
 304
 305   // In 32-bit words minus one and we don't count the header.
 306   uint8 buffer_length = static_cast<uint8>((sdes_length / 4) - 1);
 307   (*packet)[sdes_length_position] = buffer_length;
 308 }
 309
 310 void RtcpSender::BuildPli(uint32 remote_ssrc, Packet* packet) const {
 311   size_t start_size = packet->size();
 312   DCHECK_LT(start_size + 12, kMaxIpPacketSize) << "Not enough buffer space";
 313   if (start_size + 12 > kMaxIpPacketSize)
 314     return;
 315
 316   packet->resize(start_size + 12);
 317
 318   base::BigEndianWriter big_endian_writer(
 319       reinterpret_cast<char*>(&((*packet)[start_size])), 12);
 320   uint8 FMT = 1;  // Picture loss indicator.
 321   big_endian_writer.WriteU8(0x80 + FMT);
 322   big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
 323   big_endian_writer.WriteU16(2);            // Used fixed length of 2.
 324   big_endian_writer.WriteU32(ssrc_);        // Add our own SSRC.
 325   big_endian_writer.WriteU32(remote_ssrc);  // Add the remote SSRC.
 326 }
 327
 328 /*
 329     0                   1                   2                   3
 330     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
 331    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 332    |      PB       |0| Payload Type|    Native Rpsi bit string     |
 333    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 334    |   defined per codec          ...                | Padding (0) |
 335    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 336 */
 337 void RtcpSender::BuildRpsi(const RtcpRpsiMessage* rpsi, Packet* packet) const {
 338   size_t start_size = packet->size();
 339   DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
 340   if (start_size + 24 > kMaxIpPacketSize)
 341     return;
 342
 343   packet->resize(start_size + 24);
 344
 345   base::BigEndianWriter big_endian_writer(
 346       reinterpret_cast<char*>(&((*packet)[start_size])), 24);
 347   uint8 FMT = 3;  // Reference Picture Selection Indication.
 348   big_endian_writer.WriteU8(0x80 + FMT);
 349   big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
 350
 351   // Calculate length.
 352   uint32 bits_required = 7;
 353   uint8 bytes_required = 1;
 354   while ((rpsi->picture_id >> bits_required) > 0) {
 355     bits_required += 7;
 356     bytes_required++;
 357   }
 358   uint8 size = 3;
 359   if (bytes_required > 6) {
 360     size = 5;
 361   } else if (bytes_required > 2) {
 362     size = 4;
 363   }
 364   big_endian_writer.WriteU8(0);
 365   big_endian_writer.WriteU8(size);
 366   big_endian_writer.WriteU32(ssrc_);
 367   big_endian_writer.WriteU32(rpsi->remote_ssrc);
 368
 369   uint8 padding_bytes = 4 - ((2 + bytes_required) % 4);
 370   if (padding_bytes == 4) {
 371     padding_bytes = 0;
 372   }
 373   // Add padding length in bits, padding can be 0, 8, 16 or 24.
 374   big_endian_writer.WriteU8(padding_bytes * 8);
 375   big_endian_writer.WriteU8(rpsi->payload_type);
 376
 377   // Add picture ID.
 378   for (int i = bytes_required - 1; i > 0; i--) {
 379     big_endian_writer.WriteU8(0x80 |
 380                               static_cast<uint8>(rpsi->picture_id >> (i * 7)));
 381   }
 382   // Add last byte of picture ID.
 383   big_endian_writer.WriteU8(static_cast<uint8>(rpsi->picture_id & 0x7f));
 384
 385   // Add padding.
 386   for (int j = 0; j < padding_bytes; ++j) {
 387     big_endian_writer.WriteU8(0);
 388   }
 389 }
 390
 391 void RtcpSender::BuildRemb(const RtcpRembMessage* remb, Packet* packet) const {
 392   size_t start_size = packet->size();
 393   size_t remb_size = 20 + 4 * remb->remb_ssrcs.size();
 394   DCHECK_LT(start_size + remb_size, kMaxIpPacketSize)
 395       << "Not enough buffer space";
 396   if (start_size + remb_size > kMaxIpPacketSize)
 397     return;
 398
 399   packet->resize(start_size + remb_size);
 400
 401   base::BigEndianWriter big_endian_writer(
 402       reinterpret_cast<char*>(&((*packet)[start_size])), remb_size);
 403
 404   // Add application layer feedback.
 405   uint8 FMT = 15;
 406   big_endian_writer.WriteU8(0x80 + FMT);
 407   big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
 408   big_endian_writer.WriteU8(0);
 409   big_endian_writer.WriteU8(static_cast<uint8>(remb->remb_ssrcs.size() + 4));
 410   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 411   big_endian_writer.WriteU32(0);      // Remote SSRC must be 0.
 412   big_endian_writer.WriteU32(kRemb);
 413   big_endian_writer.WriteU8(static_cast<uint8>(remb->remb_ssrcs.size()));
 414
 415   // 6 bit exponent and a 18 bit mantissa.
 416   uint8 bitrate_exponent;
 417   uint32 bitrate_mantissa;
 418   BitrateToRembExponentBitrate(
 419       remb->remb_bitrate, &bitrate_exponent, &bitrate_mantissa);
 420
 421   big_endian_writer.WriteU8(static_cast<uint8>(
 422       (bitrate_exponent << 2) + ((bitrate_mantissa >> 16) & 0x03)));
 423   big_endian_writer.WriteU8(static_cast<uint8>(bitrate_mantissa >> 8));
 424   big_endian_writer.WriteU8(static_cast<uint8>(bitrate_mantissa));
 425
 426   std::list<uint32>::const_iterator it = remb->remb_ssrcs.begin();
 427   for (; it != remb->remb_ssrcs.end(); ++it) {
 428     big_endian_writer.WriteU32(*it);
 429   }
 430 }
 431
 432 void RtcpSender::BuildNack(const RtcpNackMessage* nack, Packet* packet) const {
 433   size_t start_size = packet->size();
 434   DCHECK_LT(start_size + 16, kMaxIpPacketSize) << "Not enough buffer space";
 435   if (start_size + 16 > kMaxIpPacketSize)
 436     return;
 437
 438   packet->resize(start_size + 16);
 439
 440   base::BigEndianWriter big_endian_writer(
 441       reinterpret_cast<char*>(&((*packet)[start_size])), 16);
 442
 443   uint8 FMT = 1;
 444   big_endian_writer.WriteU8(0x80 + FMT);
 445   big_endian_writer.WriteU8(transport::kPacketTypeGenericRtpFeedback);
 446   big_endian_writer.WriteU8(0);
 447   size_t nack_size_pos = start_size + 3;
 448   big_endian_writer.WriteU8(3);
 449   big_endian_writer.WriteU32(ssrc_);              // Add our own SSRC.
 450   big_endian_writer.WriteU32(nack->remote_ssrc);  // Add the remote SSRC.
 451
 452   // Build NACK bitmasks and write them to the Rtcp message.
 453   // The nack list should be sorted and not contain duplicates.
 454   size_t number_of_nack_fields = 0;
 455   size_t max_number_of_nack_fields = std::min<size_t>(
 456       kRtcpMaxNackFields, (kMaxIpPacketSize - packet->size()) / 4);
 457
 458   std::list<uint16>::const_iterator it = nack->nack_list.begin();
 459   while (it != nack->nack_list.end() &&
 460          number_of_nack_fields < max_number_of_nack_fields) {
 461     uint16 nack_sequence_number = *it;
 462     uint16 bitmask = 0;
 463     ++it;
 464     while (it != nack->nack_list.end()) {
 465       int shift = static_cast<uint16>(*it - nack_sequence_number) - 1;
 466       if (shift >= 0 && shift <= 15) {
 467         bitmask |= (1 << shift);
 468         ++it;
 469       } else {
 470         break;
 471       }
 472     }
 473     // Write the sequence number and the bitmask to the packet.
 474     start_size = packet->size();
 475     DCHECK_LT(start_size + 4, kMaxIpPacketSize) << "Not enough buffer space";
 476     if (start_size + 4 > kMaxIpPacketSize)
 477       return;
 478
 479     packet->resize(start_size + 4);
 480     base::BigEndianWriter big_endian_nack_writer(
 481         reinterpret_cast<char*>(&((*packet)[start_size])), 4);
 482     big_endian_nack_writer.WriteU16(nack_sequence_number);
 483     big_endian_nack_writer.WriteU16(bitmask);
 484     number_of_nack_fields++;
 485   }
 486   DCHECK_GE(kRtcpMaxNackFields, number_of_nack_fields);
 487   (*packet)[nack_size_pos] = static_cast<uint8>(2 + number_of_nack_fields);
 488 }
 489
 490 void RtcpSender::BuildBye(Packet* packet) const {
 491   size_t start_size = packet->size();
 492   DCHECK_LT(start_size + 8, kMaxIpPacketSize) << "Not enough buffer space";
 493   if (start_size + 8 > kMaxIpPacketSize)
 494     return;
 495
 496   packet->resize(start_size + 8);
 497
 498   base::BigEndianWriter big_endian_writer(
 499       reinterpret_cast<char*>(&((*packet)[start_size])), 8);
 500   big_endian_writer.WriteU8(0x80 + 1);
 501   big_endian_writer.WriteU8(transport::kPacketTypeBye);
 502   big_endian_writer.WriteU16(1);      // Length.
 503   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 504 }
 505
 506 void RtcpSender::BuildRrtr(const RtcpReceiverReferenceTimeReport* rrtr,
 507                            Packet* packet) const {
 508   size_t start_size = packet->size();
 509   DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
 510   if (start_size + 20 > kMaxIpPacketSize)
 511     return;
 512
 513   packet->resize(start_size + 20);
 514
 515   base::BigEndianWriter big_endian_writer(
 516       reinterpret_cast<char*>(&((*packet)[start_size])), 20);
 517
 518   big_endian_writer.WriteU8(0x80);
 519   big_endian_writer.WriteU8(transport::kPacketTypeXr);
 520   big_endian_writer.WriteU16(4);      // Length.
 521   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 522   big_endian_writer.WriteU8(4);       // Add block type.
 523   big_endian_writer.WriteU8(0);       // Add reserved.
 524   big_endian_writer.WriteU16(2);      // Block length.
 525
 526   // Add the media (received RTP) SSRC.
 527   big_endian_writer.WriteU32(rrtr->ntp_seconds);
 528   big_endian_writer.WriteU32(rrtr->ntp_fraction);
 529 }
 530
 531 void RtcpSender::BuildCast(const RtcpCastMessage* cast,
 532                            uint16 target_delay_ms,
 533                            Packet* packet) const {
 534   size_t start_size = packet->size();
 535   DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
 536   if (start_size + 20 > kMaxIpPacketSize)
 537     return;
 538
 539   packet->resize(start_size + 20);
 540
 541   base::BigEndianWriter big_endian_writer(
 542       reinterpret_cast<char*>(&((*packet)[start_size])), 20);
 543   uint8 FMT = 15;  // Application layer feedback.
 544   big_endian_writer.WriteU8(0x80 + FMT);
 545   big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
 546   big_endian_writer.WriteU8(0);
 547   size_t cast_size_pos = start_size + 3;  // Save length position.
 548   big_endian_writer.WriteU8(4);
 549   big_endian_writer.WriteU32(ssrc_);              // Add our own SSRC.
 550   big_endian_writer.WriteU32(cast->media_ssrc_);  // Remote SSRC.
 551   big_endian_writer.WriteU32(kCast);
 552   big_endian_writer.WriteU8(static_cast<uint8>(cast->ack_frame_id_));
 553   size_t cast_loss_field_pos = start_size + 17;  // Save loss field position.
 554   big_endian_writer.WriteU8(0);  // Overwritten with number_of_loss_fields.
 555   big_endian_writer.WriteU16(target_delay_ms);
 556
 557   size_t number_of_loss_fields = 0;
 558   size_t max_number_of_loss_fields = std::min<size_t>(
 559       kRtcpMaxCastLossFields, (kMaxIpPacketSize - packet->size()) / 4);
 560
 561   MissingFramesAndPacketsMap::const_iterator frame_it =
 562       cast->missing_frames_and_packets_.begin();
 563
 564   NackStringBuilder nack_string_builder;
 565   for (; frame_it != cast->missing_frames_and_packets_.end() &&
 566              number_of_loss_fields < max_number_of_loss_fields;
 567        ++frame_it) {
 568     nack_string_builder.PushFrame(frame_it->first);
 569     // Iterate through all frames with missing packets.
 570     if (frame_it->second.empty()) {
 571       // Special case all packets in a frame is missing.
 572       start_size = packet->size();
 573       packet->resize(start_size + 4);
 574       base::BigEndianWriter big_endian_nack_writer(
 575           reinterpret_cast<char*>(&((*packet)[start_size])), 4);
 576       big_endian_nack_writer.WriteU8(static_cast<uint8>(frame_it->first));
 577       big_endian_nack_writer.WriteU16(kRtcpCastAllPacketsLost);
 578       big_endian_nack_writer.WriteU8(0);
 579       nack_string_builder.PushPacket(kRtcpCastAllPacketsLost);
 580       ++number_of_loss_fields;
 581     } else {
 582       PacketIdSet::const_iterator packet_it = frame_it->second.begin();
 583       while (packet_it != frame_it->second.end()) {
 584         uint16 packet_id = *packet_it;
 585
 586         start_size = packet->size();
 587         packet->resize(start_size + 4);
 588         base::BigEndianWriter big_endian_nack_writer(
 589             reinterpret_cast<char*>(&((*packet)[start_size])), 4);
 590
 591         // Write frame and packet id to buffer before calculating bitmask.
 592         big_endian_nack_writer.WriteU8(static_cast<uint8>(frame_it->first));
 593         big_endian_nack_writer.WriteU16(packet_id);
 594         nack_string_builder.PushPacket(packet_id);
 595
 596         uint8 bitmask = 0;
 597         ++packet_it;
 598         while (packet_it != frame_it->second.end()) {
 599           int shift = static_cast<uint8>(*packet_it - packet_id) - 1;
 600           if (shift >= 0 && shift <= 7) {
 601             nack_string_builder.PushPacket(*packet_it);
 602             bitmask |= (1 << shift);
 603             ++packet_it;
 604           } else {
 605             break;
 606           }
 607         }
 608         big_endian_nack_writer.WriteU8(bitmask);
 609         ++number_of_loss_fields;
 610       }
 611     }
 612   }
 613   VLOG_IF(1, !nack_string_builder.Empty())
 614       << "SSRC: " << cast->media_ssrc_
 615       << ", ACK: " << cast->ack_frame_id_
 616       << ", NACK: " << nack_string_builder.GetString();
 617   DCHECK_LE(number_of_loss_fields, kRtcpMaxCastLossFields);
 618   (*packet)[cast_size_pos] = static_cast<uint8>(4 + number_of_loss_fields);
 619   (*packet)[cast_loss_field_pos] = static_cast<uint8>(number_of_loss_fields);
 620 }
 621
 622 void RtcpSender::BuildReceiverLog(
 623     const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events,
 624     Packet* packet) {
 625   const size_t packet_start_size = packet->size();
 626   size_t number_of_frames = 0;
 627   size_t total_number_of_messages_to_send = 0;
 628   size_t rtcp_log_size = 0;
 629   RtcpReceiverLogMessage receiver_log_message;
 630
 631   if (!BuildRtcpReceiverLogMessage(rtcp_events,
 632                                    packet_start_size,
 633                                    &receiver_log_message,
 634                                    &number_of_frames,
 635                                    &total_number_of_messages_to_send,
 636                                    &rtcp_log_size)) {
 637     return;
 638   }
 639   packet->resize(packet_start_size + rtcp_log_size);
 640
 641   base::BigEndianWriter big_endian_writer(
 642       reinterpret_cast<char*>(&((*packet)[packet_start_size])), rtcp_log_size);
 643   big_endian_writer.WriteU8(0x80 + kReceiverLogSubtype);
 644   big_endian_writer.WriteU8(transport::kPacketTypeApplicationDefined);
 645   big_endian_writer.WriteU16(static_cast<uint16>(
 646       2 + 2 * number_of_frames + total_number_of_messages_to_send));
 647   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 648   big_endian_writer.WriteU32(kCast);
 649
 650   while (!receiver_log_message.empty() &&
 651          total_number_of_messages_to_send > 0) {
 652     RtcpReceiverFrameLogMessage& frame_log_messages(
 653         receiver_log_message.front());
 654
 655     // Add our frame header.
 656     big_endian_writer.WriteU32(frame_log_messages.rtp_timestamp_);
 657     size_t messages_in_frame = frame_log_messages.event_log_messages_.size();
 658     if (messages_in_frame > total_number_of_messages_to_send) {
 659       // We are running out of space.
 660       messages_in_frame = total_number_of_messages_to_send;
 661     }
 662     // Keep track of how many messages we have left to send.
 663     total_number_of_messages_to_send -= messages_in_frame;
 664
 665     // On the wire format is number of messages - 1.
 666     big_endian_writer.WriteU8(static_cast<uint8>(messages_in_frame - 1));
 667
 668     base::TimeTicks event_timestamp_base =
 669         frame_log_messages.event_log_messages_.front().event_timestamp;
 670     uint32 base_timestamp_ms =
 671         (event_timestamp_base - base::TimeTicks()).InMilliseconds();
 672     big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms >> 16));
 673     big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms >> 8));
 674     big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms));
 675
 676     while (!frame_log_messages.event_log_messages_.empty() &&
 677            messages_in_frame > 0) {
 678       const RtcpReceiverEventLogMessage& event_message =
 679           frame_log_messages.event_log_messages_.front();
 680       uint16 event_type_and_timestamp_delta =
 681           MergeEventTypeAndTimestampForWireFormat(
 682               event_message.type,
 683               event_message.event_timestamp - event_timestamp_base);
 684       switch (event_message.type) {
 685         case FRAME_ACK_SENT:
 686         case FRAME_PLAYOUT:
 687         case FRAME_DECODED:
 688           big_endian_writer.WriteU16(
 689               static_cast<uint16>(event_message.delay_delta.InMilliseconds()));
 690           big_endian_writer.WriteU16(event_type_and_timestamp_delta);
 691           break;
 692         case PACKET_RECEIVED:
 693           big_endian_writer.WriteU16(event_message.packet_id);
 694           big_endian_writer.WriteU16(event_type_and_timestamp_delta);
 695           break;
 696         default:
 697           NOTREACHED();
 698       }
 699       messages_in_frame--;
 700       frame_log_messages.event_log_messages_.pop_front();
 701     }
 702     if (frame_log_messages.event_log_messages_.empty()) {
 703       // We sent all messages on this frame; pop the frame header.
 704       receiver_log_message.pop_front();
 705     }
 706   }
 707   DCHECK_EQ(total_number_of_messages_to_send, 0u);
 708 }
 709
 710 bool RtcpSender::BuildRtcpReceiverLogMessage(
 711     const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events,
 712     size_t start_size,
 713     RtcpReceiverLogMessage* receiver_log_message,
 714     size_t* number_of_frames,
 715     size_t* total_number_of_messages_to_send,
 716     size_t* rtcp_log_size) {
 717   size_t remaining_space =
 718       std::min(kMaxReceiverLogBytes, kMaxIpPacketSize - start_size);
 719   if (remaining_space < kRtcpCastLogHeaderSize + kRtcpReceiverFrameLogSize +
 720                             kRtcpReceiverEventLogSize) {
 721     return false;
 722   }
 723
 724   // We use this to do event timestamp sorting and truncating for events of
 725   // a single frame.
 726   std::vector<RtcpReceiverEventLogMessage> sorted_log_messages;
 727
 728   // Account for the RTCP header for an application-defined packet.
 729   remaining_space -= kRtcpCastLogHeaderSize;
 730
 731   ReceiverRtcpEventSubscriber::RtcpEventMultiMap::const_reverse_iterator rit =
 732       rtcp_events.rbegin();
 733
 734   while (rit != rtcp_events.rend() &&
 735          remaining_space >=
 736              kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize) {
 737     const RtpTimestamp rtp_timestamp = rit->first;
 738     RtcpReceiverFrameLogMessage frame_log(rtp_timestamp);
 739     remaining_space -= kRtcpReceiverFrameLogSize;
 740     ++*number_of_frames;
 741
 742     // Get all events of a single frame.
 743     sorted_log_messages.clear();
 744     do {
 745       RtcpReceiverEventLogMessage event_log_message;
 746       event_log_message.type = rit->second.type;
 747       event_log_message.event_timestamp = rit->second.timestamp;
 748       event_log_message.delay_delta = rit->second.delay_delta;
 749       event_log_message.packet_id = rit->second.packet_id;
 750       sorted_log_messages.push_back(event_log_message);
 751       ++rit;
 752     } while (rit != rtcp_events.rend() && rit->first == rtp_timestamp);
 753
 754     std::sort(sorted_log_messages.begin(),
 755               sorted_log_messages.end(),
 756               &EventTimestampLessThan);
 757
 758     // From |sorted_log_messages|, only take events that are no greater than
 759     // |kMaxWireFormatTimeDeltaMs| seconds away from the latest event. Events
 760     // older than that cannot be encoded over the wire.
 761     std::vector<RtcpReceiverEventLogMessage>::reverse_iterator sorted_rit =
 762         sorted_log_messages.rbegin();
 763     base::TimeTicks first_event_timestamp = sorted_rit->event_timestamp;
 764     size_t events_in_frame = 0;
 765     while (sorted_rit != sorted_log_messages.rend() &&
 766            events_in_frame < kRtcpMaxReceiverLogMessages &&
 767            remaining_space >= kRtcpReceiverEventLogSize) {
 768       base::TimeDelta delta(first_event_timestamp -
 769                             sorted_rit->event_timestamp);
 770       if (delta.InMilliseconds() > kMaxWireFormatTimeDeltaMs)
 771         break;
 772       frame_log.event_log_messages_.push_front(*sorted_rit);
 773       ++events_in_frame;
 774       ++*total_number_of_messages_to_send;
 775       remaining_space -= kRtcpReceiverEventLogSize;
 776       ++sorted_rit;
 777     }
 778
 779     receiver_log_message->push_front(frame_log);
 780   }
 781
 782   rtcp_events_history_.push_front(*receiver_log_message);
 783
 784   // We don't try to match RTP timestamps of redundancy frame logs with those
 785   // from the newest set (which would save the space of an extra RTP timestamp
 786   // over the wire). Unless the redundancy frame logs are very recent, it's
 787   // unlikely there will be a match anyway.
 788   if (rtcp_events_history_.size() > kFirstRedundancyOffset) {
 789     // Add first redundnacy messages, if enough space remaining
 790     AddReceiverLog(rtcp_events_history_[kFirstRedundancyOffset],
 791                    receiver_log_message,
 792                    &remaining_space,
 793                    number_of_frames,
 794                    total_number_of_messages_to_send);
 795   }
 796
 797   if (rtcp_events_history_.size() > kSecondRedundancyOffset) {
 798     // Add second redundancy messages, if enough space remaining
 799     AddReceiverLog(rtcp_events_history_[kSecondRedundancyOffset],
 800                    receiver_log_message,
 801                    &remaining_space,
 802                    number_of_frames,
 803                    total_number_of_messages_to_send);
 804   }
 805
 806   if (rtcp_events_history_.size() > kReceiveLogMessageHistorySize) {
 807     rtcp_events_history_.pop_back();
 808   }
 809
 810   DCHECK_LE(rtcp_events_history_.size(), kReceiveLogMessageHistorySize);
 811
 812   *rtcp_log_size =
 813       kRtcpCastLogHeaderSize + *number_of_frames * kRtcpReceiverFrameLogSize +
 814       *total_number_of_messages_to_send * kRtcpReceiverEventLogSize;
 815   DCHECK_GE(kMaxIpPacketSize, start_size + *rtcp_log_size)
 816       << "Not enough buffer space.";
 817
 818   VLOG(3) << "number of frames: " << *number_of_frames;
 819   VLOG(3) << "total messages to send: " << *total_number_of_messages_to_send;
 820   VLOG(3) << "rtcp log size: " << *rtcp_log_size;
 821   return *number_of_frames > 0;
 822 }
 823
 824 }  // namespace cast
 825 }  // namespace media