Cast:Splitting rtcp sender

media/cast/rtcp/rtcp_sender.cc

 // Copyright 2013 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/rtcp/rtcp_sender.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/logging.h"
 #include "media/cast/cast_environment.h"
+#include "media/cast/net/cast_net_defines.h"
 #include "media/cast/net/pacing/paced_sender.h"
 #include "media/cast/rtcp/rtcp_utility.h"
 #include "net/base/big_endian.h"
 
 static const size_t kRtcpCastLogHeaderSize = 12;
 static const size_t kRtcpSenderFrameLogSize = 4;
 static const size_t kRtcpReceiverFrameLogSize = 8;
 static const size_t kRtcpReceiverEventLogSize = 4;
 
 namespace {
@@ skipping 107 matching lines @@
                        const std::string& c_name)
      : ssrc_(sending_ssrc),
        c_name_(c_name),
        transport_(outgoing_transport),
        cast_environment_(cast_environment) {
   DCHECK_LT(c_name_.length(), kRtcpCnameSize) << "Invalid config";
 }
 
 RtcpSender::~RtcpSender() {}
 
-void RtcpSender::SendRtcpFromRtpSender(uint32 packet_type_flags,
-                                       const RtcpSenderInfo* sender_info,
-                                       const RtcpDlrrReportBlock* dlrr,
-                                       RtcpSenderLogMessage* sender_log) {
-  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";
-  }
-
-  std::vector<uint8> packet;
-  packet.reserve(kIpPacketSize);
-  if (packet_type_flags & kRtcpSr) {
-    DCHECK(sender_info) << "Invalid argument";
-    BuildSR(*sender_info, NULL, &packet);
-    BuildSdec(&packet);
-  }
-  if (packet_type_flags & kRtcpBye) {
-    BuildBye(&packet);
-  }
-  if (packet_type_flags & kRtcpDlrr) {
-    DCHECK(dlrr) << "Invalid argument";
-    BuildDlrrRb(dlrr, &packet);
-  }
-  if (packet_type_flags & kRtcpSenderLog) {
-    DCHECK(sender_log) << "Invalid argument";
-    BuildSenderLog(sender_log, &packet);
-  }
-  if (packet.empty())
-    return;  // Sanity don't send empty packets.
-
-  transport_->SendRtcpPacket(packet);
-}
-
 void RtcpSender::SendRtcpFromRtpReceiver(
     uint32 packet_type_flags,
     const RtcpReportBlock* report_block,
     const RtcpReceiverReferenceTimeReport* rrtr,
     const RtcpCastMessage* cast_message,
     RtcpReceiverLogMessage* receiver_log) {
   if (packet_type_flags & kRtcpSr ||
       packet_type_flags & kRtcpDlrr ||
       packet_type_flags & kRtcpSenderLog) {
     NOTREACHED() << "Invalid argument";
@@ skipping 27 matching lines @@
   }
   if (packet_type_flags & kRtcpReceiverLog) {
     DCHECK(receiver_log) << "Invalid argument";
     BuildReceiverLog(receiver_log, &packet);
   }
   if (packet.empty()) return;  // Sanity don't send empty packets.
 
   transport_->SendRtcpPacket(packet);
 }
 
-void RtcpSender::BuildSR(const RtcpSenderInfo& sender_info,
-                         const RtcpReportBlock* report_block,
-                         std::vector<uint8>* packet) const {
-  // Sender report.
-  size_t start_size = packet->size();
-  DCHECK_LT(start_size + 52, kIpPacketSize) << "Not enough buffer space";
-  if (start_size + 52 > kIpPacketSize) return;
-
-  uint16 number_of_rows = (report_block) ? 12 : 6;
-  packet->resize(start_size + 28);
-
-  net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 28);
-  big_endian_writer.WriteU8(0x80 + (report_block ? 1 : 0));
-  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));
-
-  if (report_block) {
-    AddReportBlocks(*report_block, packet);  // Adds 24 bytes.
-  }
-}
-
 void RtcpSender::BuildRR(const RtcpReportBlock* report_block,
                          std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 32, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 32 > kIpPacketSize) return;
 
   uint16 number_of_rows = (report_block) ? 7 : 1;
   packet->resize(start_size + 8);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
@@ skipping 263 matching lines @@
 
   packet->resize(start_size + 8);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
   big_endian_writer.WriteU8(0x80 + 1);
   big_endian_writer.WriteU8(kPacketTypeBye);
   big_endian_writer.WriteU16(1);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 }
 
-/*
-   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          |
-  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
-  |                 SSRC_1 (SSRC of first receiver)               | sub-
-  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block
-  |                         last RR (LRR)                         |   1
-  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-  |                   delay since last RR (DLRR)                  |
-  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
-*/
-void RtcpSender::BuildDlrrRb(const RtcpDlrrReportBlock* dlrr,
-                             std::vector<uint8>* packet) const {
-  size_t start_size = packet->size();
-  DCHECK_LT(start_size + 24, kIpPacketSize) << "Not enough buffer space";
-  if (start_size + 24 > kIpPacketSize) return;
-
-  packet->resize(start_size + 24);
-
-  net::BigEndianWriter big_endian_writer(&((*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);
-}
-
 void RtcpSender::BuildRrtr(const RtcpReceiverReferenceTimeReport* rrtr,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 20, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 20 > kIpPacketSize) return;
 
   packet->resize(start_size + 20);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 20);
 
@@ skipping 81 matching lines @@
         big_endian_nack_writer.WriteU8(bitmask);
         ++number_of_loss_fields;
       }
     }
   }
   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::BuildSenderLog(RtcpSenderLogMessage* sender_log_message,
-                                std::vector<uint8>* packet) const {
-  DCHECK(sender_log_message);
-  DCHECK(packet);
-  size_t start_size = packet->size();
-  size_t remaining_space = kIpPacketSize - start_size;
-  DCHECK_GE(remaining_space, kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
-       << "Not enough buffer space";
-  if (remaining_space < kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
-    return;
-
-  size_t space_for_x_messages =
-      (remaining_space - kRtcpCastLogHeaderSize) / kRtcpSenderFrameLogSize;
-  size_t number_of_messages = std::min(space_for_x_messages,
-                                       sender_log_message->size());
-
-  size_t log_size = kRtcpCastLogHeaderSize +
-      number_of_messages * kRtcpSenderFrameLogSize;
-  packet->resize(start_size + log_size);
-
-  net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), log_size);
-  big_endian_writer.WriteU8(0x80 + kSenderLogSubtype);
-  big_endian_writer.WriteU8(kPacketTypeApplicationDefined);
-  big_endian_writer.WriteU16(static_cast<uint16>(2 + number_of_messages));
-  big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
-  big_endian_writer.WriteU32(kCast);
-
-  for (; number_of_messages > 0; --number_of_messages) {
-    DCHECK(!sender_log_message->empty());
-    const RtcpSenderFrameLogMessage& message = sender_log_message->front();
-    big_endian_writer.WriteU8(static_cast<uint8>(message.frame_status));
-    // We send the 24 east significant bits of the RTP timestamp.
-    big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 16));
-    big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 8));
-    big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp));
-    sender_log_message->pop_front();
-  }
-}
-
 void RtcpSender::BuildReceiverLog(RtcpReceiverLogMessage* receiver_log_message,
                                   std::vector<uint8>* packet) const {
   DCHECK(receiver_log_message);
   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;
 
   if (!ScanRtcpReceiverLogMessage(*receiver_log_message,
                                   packet_start_size,
@@ skipping 68 matching lines @@
     if (frame_log_messages.event_log_messages_.empty()) {
       // We sent all messages on this frame; pop the frame header.
       receiver_log_message->pop_front();
     }
   }
   DCHECK_EQ(total_number_of_messages_to_send, 0);
 }
 
 }  // namespace cast
 }  // namespace media