Cast: Refactor RTCP handling

media/cast/net/rtcp/rtcp_sender.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // 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 <stdint.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/logging.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_defines.h"
 #include "media/cast/net/rtcp/rtcp_utility.h"
 
 namespace media {
 namespace cast {
 namespace {
 
 // Max delta is 4095 milliseconds because we need to be able to encode it in
@@ skipping 114 matching lines @@
  private:
   std::ostringstream stream_;
   int frame_count_;
   int packet_count_;
   int last_frame_id_;
   int last_packet_id_;
   bool contiguous_sequence_;
 };
 }  // namespace
 
-// TODO(mikhal): This is only used by the receiver. Consider renaming.
-RtcpSender::RtcpSender(scoped_refptr<CastEnvironment> cast_environment,
-                       PacedPacketSender* outgoing_transport,
+RtcpSender::RtcpSender(PacedPacketSender* outgoing_transport,
                        uint32 sending_ssrc,
                        const std::string& c_name)
     : ssrc_(sending_ssrc),
       c_name_(c_name),
-      transport_(outgoing_transport),
-      cast_environment_(cast_environment) {
+      transport_(outgoing_transport) {
   DCHECK_LT(c_name_.length(), kRtcpCnameSize) << "Invalid config";
 }
 
 RtcpSender::~RtcpSender() {}
 
 void RtcpSender::SendRtcpFromRtpReceiver(
     uint32 packet_type_flags,
     const RtcpReportBlock* report_block,
     const RtcpReceiverReferenceTimeReport* rrtr,
     const RtcpCastMessage* cast_message,
     const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events,
     base::TimeDelta target_delay) {
   if (packet_type_flags & kRtcpSr ||
       packet_type_flags & kRtcpDlrr ||
       packet_type_flags & kRtcpSenderLog) {
     NOTREACHED() << "Invalid argument";
   }
   if (packet_type_flags & kRtcpPli ||
       packet_type_flags & kRtcpRpsi ||
       packet_type_flags & kRtcpRemb ||
       packet_type_flags & kRtcpNack) {
     // Implement these for webrtc interop.
     NOTIMPLEMENTED();
   }
   PacketRef packet(new base::RefCountedData<Packet>);
   packet->data.reserve(kMaxIpPacketSize);
-
   if (packet_type_flags & kRtcpRr) {
     BuildRR(report_block, &packet->data);
     if (!c_name_.empty()) {
       BuildSdec(&packet->data);
     }
   }
   if (packet_type_flags & kRtcpBye) {
     BuildBye(&packet->data);
   }
   if (packet_type_flags & kRtcpRrtr) {
     DCHECK(rrtr) << "Invalid argument";
     BuildRrtr(rrtr, &packet->data);
   }
   if (packet_type_flags & kRtcpCast) {
     DCHECK(cast_message) << "Invalid argument";
     BuildCast(cast_message, target_delay, &packet->data);
   }
   if (packet_type_flags & kRtcpReceiverLog) {
     DCHECK(rtcp_events) << "Invalid argument";
     BuildReceiverLog(*rtcp_events, &packet->data);
   }
 
-  if (packet->data.empty())
+  if (packet->data.empty()) {
+    NOTREACHED() << "Empty packet.";
     return;  // Sanity don't send empty packets.
+  }
 
   transport_->SendRtcpPacket(ssrc_, packet);
 }
+
+void RtcpSender::SendRtcpFromRtpSender(
+    uint32 packet_type_flags,
+    const RtcpSenderInfo& sender_info,
+    const RtcpDlrrReportBlock& dlrr) {
+  if (packet_type_flags & kRtcpRr ||
+      packet_type_flags & kRtcpPli ||
+      packet_type_flags & kRtcpRrtr ||
+      packet_type_flags & kRtcpCast ||
+      packet_type_flags & kRtcpReceiverLog ||
+      packet_type_flags & kRtcpRpsi ||
+      packet_type_flags & kRtcpRemb ||
+      packet_type_flags & kRtcpNack) {
+    NOTREACHED() << "Invalid argument";
+  }
+  PacketRef packet(new base::RefCountedData<Packet>);
+  packet->data.reserve(kMaxIpPacketSize);
+  if (packet_type_flags & kRtcpSr) {
+    BuildSR(sender_info, &packet->data);
+    BuildSdec(&packet->data);
+  }
+  if (packet_type_flags & kRtcpBye) {
+    BuildBye(&packet->data);
+  }
+  if (packet_type_flags & kRtcpDlrr) {
+    BuildDlrrRb(dlrr, &packet->data);
+  }
+  if (packet->data.empty()) {
+    NOTREACHED() << "Empty packet.";
+    return;  // Sanity - don't send empty packets.
+  }
+
+  transport_->SendRtcpPacket(ssrc_, packet);
+}
 
 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);
@@ skipping 105 matching lines @@
 
 /*
     0                   1                   2                   3
     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
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |      PB       |0| Payload Type|    Native Rpsi bit string     |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |   defined per codec          ...                | Padding (0) |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
-void RtcpSender::BuildRpsi(const RtcpRpsiMessage* rpsi, Packet* packet) const {
+void RtcpSender::BuildRpsi(const RtcpRpsiMessage* rpsi,
+                           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);
   uint8 FMT = 3;  // Reference Picture Selection Indication.
@@ skipping 33 matching lines @@
   }
   // Add last byte of picture ID.
   big_endian_writer.WriteU8(static_cast<uint8>(rpsi->picture_id & 0x7f));
 
   // Add padding.
   for (int j = 0; j < padding_bytes; ++j) {
     big_endian_writer.WriteU8(0);
   }
 }
 
-void RtcpSender::BuildRemb(const RtcpRembMessage* remb, Packet* packet) const {
+void RtcpSender::BuildRemb(const RtcpRembMessage* remb,
+                           Packet* packet) const {
   size_t start_size = packet->size();
   size_t remb_size = 20 + 4 * remb->remb_ssrcs.size();
   DCHECK_LT(start_size + remb_size, kMaxIpPacketSize)
       << "Not enough buffer space";
   if (start_size + remb_size > kMaxIpPacketSize)
     return;
 
   packet->resize(start_size + remb_size);
 
   base::BigEndianWriter big_endian_writer(
@@ skipping 20 matching lines @@
       (bitrate_exponent << 2) + ((bitrate_mantissa >> 16) & 0x03)));
   big_endian_writer.WriteU8(static_cast<uint8>(bitrate_mantissa >> 8));
   big_endian_writer.WriteU8(static_cast<uint8>(bitrate_mantissa));
 
   std::list<uint32>::const_iterator it = remb->remb_ssrcs.begin();
   for (; it != remb->remb_ssrcs.end(); ++it) {
     big_endian_writer.WriteU32(*it);
   }
 }
 
-void RtcpSender::BuildNack(const RtcpNackMessage* nack, Packet* packet) const {
+void RtcpSender::BuildNack(const RtcpNackMessage* nack,
+                           Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 16, kMaxIpPacketSize) << "Not enough buffer space";
   if (start_size + 16 > kMaxIpPacketSize)
     return;
 
   packet->resize(start_size + 16);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[start_size])), 16);
 
@@ skipping 97 matching lines @@
 
   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(cast->media_ssrc);  // Remote SSRC.
   big_endian_writer.WriteU32(kCast);
-  big_endian_writer.WriteU8(static_cast<uint8>(cast->ack_frame_id_));
+  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.
   DCHECK_LE(target_delay.InMilliseconds(),
             std::numeric_limits<uint16_t>::max());
   big_endian_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);
 
   MissingFramesAndPacketsMap::const_iterator frame_it =
-      cast->missing_frames_and_packets_.begin();
+      cast->missing_frames_and_packets.begin();
 
   NackStringBuilder nack_string_builder;
-  for (; frame_it != cast->missing_frames_and_packets_.end() &&
+  for (; frame_it != cast->missing_frames_and_packets.end() &&
              number_of_loss_fields < max_number_of_loss_fields;
        ++frame_it) {
     nack_string_builder.PushFrame(frame_it->first);
     // 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);
@@ skipping 28 matching lines @@
           } else {
             break;
           }
         }
         big_endian_nack_writer.WriteU8(bitmask);
         ++number_of_loss_fields;
       }
     }
   }
   VLOG_IF(1, !nack_string_builder.Empty())
-      << "SSRC: " << cast->media_ssrc_
-      << ", ACK: " << cast->ack_frame_id_
+      << "SSRC: " << cast->media_ssrc
+      << ", 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);
 }
 
+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;
+}
+
+/*
+   0                   1                   2                   3
+   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
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |V=2|P|reserved |   PT=XR=207   |             length            |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |                              SSRC                             |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |     BT=5      |   reserved    |         block length          |
+  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+  |                 SSRC1 (SSRC of first receiver)               | sub-
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block
+  |                         last RR (LRR)                         |   1
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |                   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 RtcpSender::BuildReceiverLog(
     const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events,
     Packet* packet) {
   const size_t packet_start_size = packet->size();
   size_t number_of_frames = 0;
   size_t total_number_of_messages_to_send = 0;
   size_t rtcp_log_size = 0;
   RtcpReceiverLogMessage receiver_log_message;
 
   if (!BuildRtcpReceiverLogMessage(rtcp_events,
@@ skipping 184 matching lines @@
       << "Not enough buffer space.";
 
   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;
 }
 
 }  // namespace cast
 }  // namespace media