Cast: Make receiver use cast_transport

media/cast/net/rtcp/rtcp_builder.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_builder.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 26 matching lines @@
   DCHECK(event_type_4_bits);
   DCHECK(~(event_type_4_bits & 0xfff0));
   return (event_type_4_bits << 12) | time_delta_12_bits;
 }
 
 bool EventTimestampLessThan(const RtcpReceiverEventLogMessage& lhs,
                             const RtcpReceiverEventLogMessage& rhs) {
   return lhs.event_timestamp < rhs.event_timestamp;
 }
 
-void AddReceiverLogEntries(
-    const RtcpReceiverLogMessage& redundancy_receiver_log_message,
-    RtcpReceiverLogMessage* receiver_log_message,
-    size_t* remaining_space,
-    size_t* number_of_frames,
-    size_t* total_number_of_messages_to_send) {
-  RtcpReceiverLogMessage::const_iterator it =
-      redundancy_receiver_log_message.begin();
-  while (it != redundancy_receiver_log_message.end() &&
-         *remaining_space >=
-             kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize) {
-    receiver_log_message->push_front(*it);
-    size_t num_event_logs = (*remaining_space - kRtcpReceiverFrameLogSize) /
-                            kRtcpReceiverEventLogSize;
-    RtcpReceiverEventLogMessages& event_log_messages =
-        receiver_log_message->front().event_log_messages_;
-    if (num_event_logs < event_log_messages.size())
-      event_log_messages.resize(num_event_logs);
-
-    *remaining_space -= kRtcpReceiverFrameLogSize +
-                        event_log_messages.size() * kRtcpReceiverEventLogSize;
-    ++number_of_frames;
-    *total_number_of_messages_to_send += event_log_messages.size();
-    ++it;
-  }
-}
-
 // A class to build a string representing the NACK list in Cast message.
 //
 // The string will look like "23:3-6 25:1,5-6", meaning packets 3 to 6 in frame
 // 23 are being NACK'ed (i.e. they are missing from the receiver's point of
 // view) and packets 1, 5 and 6 are missing in frame 25. A frame that is
 // completely missing will show as "26:65535".
 class NackStringBuilder {
  public:
   NackStringBuilder()
       : frame_count_(0),
@@ skipping 106 matching lines @@
   writer_ = base::BigEndianWriter(NULL, 0);
   PacketRef ret = packet_;
   packet_ = NULL;
   return ret;
 }
 
 PacketRef RtcpBuilder::BuildRtcpFromReceiver(
     const RtcpReportBlock* report_block,
     const RtcpReceiverReferenceTimeReport* rrtr,
     const RtcpCastMessage* cast_message,
-    const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events,
+    const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
     base::TimeDelta target_delay) {
   Start();
 
   if (report_block)
     AddRR(report_block);
   if (rrtr)
     AddRrtr(rrtr);
   if (cast_message)
     AddCast(cast_message, target_delay);
   if (rtcp_events)
@@ skipping 148 matching lines @@
   writer_.WriteU32(ssrc_);  // Add our own SSRC.
   writer_.WriteU8(5);  // Add block type.
   writer_.WriteU8(0);  // Add reserved.
   writer_.WriteU16(3);  // Block length.
   writer_.WriteU32(ssrc_);  // Add the media (received RTP) SSRC.
   writer_.WriteU32(dlrr.last_rr);
   writer_.WriteU32(dlrr.delay_since_last_rr);
 }
 
 void RtcpBuilder::AddReceiverLog(
-    const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events) {
+    const ReceiverRtcpEventSubscriber::RtcpEvents& rtcp_events) {
   size_t total_number_of_messages_to_send = 0;
   RtcpReceiverLogMessage receiver_log_message;
 
   if (!GetRtcpReceiverLogMessage(rtcp_events,
                                  &receiver_log_message,
                                  &total_number_of_messages_to_send)) {
     return;
   }
 
   AddRtcpHeader(kPacketTypeApplicationDefined, kReceiverLogSubtype);
@@ skipping 54 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, 0u);
 }
 
 bool RtcpBuilder::GetRtcpReceiverLogMessage(
-    const ReceiverRtcpEventSubscriber::RtcpEventMultiMap& rtcp_events,
+    const ReceiverRtcpEventSubscriber::RtcpEvents& rtcp_events,
     RtcpReceiverLogMessage* receiver_log_message,
     size_t* total_number_of_messages_to_send) {
   size_t number_of_frames = 0;
-  size_t remaining_space =
-      std::min<size_t>(kMaxReceiverLogBytes, writer_.remaining());
+  size_t remaining_space = writer_.remaining();
   if (remaining_space < kRtcpCastLogHeaderSize + kRtcpReceiverFrameLogSize +
                             kRtcpReceiverEventLogSize) {
     return false;
   }
 
   // We use this to do event timestamp sorting and truncating for events of
   // a single frame.
   std::vector<RtcpReceiverEventLogMessage> sorted_log_messages;
 
   // Account for the RTCP header for an application-defined packet.
   remaining_space -= kRtcpCastLogHeaderSize;
 
-  ReceiverRtcpEventSubscriber::RtcpEventMultiMap::const_reverse_iterator rit =
+  ReceiverRtcpEventSubscriber::RtcpEvents::const_reverse_iterator rit =
       rtcp_events.rbegin();
 
   while (rit != rtcp_events.rend() &&
          remaining_space >=
              kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize) {
     const RtpTimestamp rtp_timestamp = rit->first;
     RtcpReceiverFrameLogMessage frame_log(rtp_timestamp);
     remaining_space -= kRtcpReceiverFrameLogSize;
     ++number_of_frames;
 
@@ skipping 30 matching lines @@
       frame_log.event_log_messages_.push_front(*sorted_rit);
       ++events_in_frame;
       ++*total_number_of_messages_to_send;
       remaining_space -= kRtcpReceiverEventLogSize;
       ++sorted_rit;
     }
 
     receiver_log_message->push_front(frame_log);
   }
 
-  rtcp_events_history_.push_front(*receiver_log_message);
-
-  // We don't try to match RTP timestamps of redundancy frame logs with those
-  // from the newest set (which would save the space of an extra RTP timestamp
-  // over the wire). Unless the redundancy frame logs are very recent, it's
-  // unlikely there will be a match anyway.
-  if (rtcp_events_history_.size() > kFirstRedundancyOffset) {
-    // Add first redundnacy messages, if enough space remaining
-    AddReceiverLogEntries(rtcp_events_history_[kFirstRedundancyOffset],
-                          receiver_log_message,
-                          &remaining_space,
-                          &number_of_frames,
-                          total_number_of_messages_to_send);
-  }
-
-  if (rtcp_events_history_.size() > kSecondRedundancyOffset) {
-    // Add second redundancy messages, if enough space remaining
-    AddReceiverLogEntries(rtcp_events_history_[kSecondRedundancyOffset],
-                          receiver_log_message,
-                          &remaining_space,
-                          &number_of_frames,
-                          total_number_of_messages_to_send);
-  }
-
-  if (rtcp_events_history_.size() > kReceiveLogMessageHistorySize) {
-    rtcp_events_history_.pop_back();
-  }
-
-  DCHECK_LE(rtcp_events_history_.size(), kReceiveLogMessageHistorySize);
-
   VLOG(3) << "number of frames: " << number_of_frames;
   VLOG(3) << "total messages to send: " << *total_number_of_messages_to_send;
   return number_of_frames > 0;
 }
 
 }  // namespace cast
 }  // namespace media