Cast: Restructure RTCP interface to better fit our usage.

media/cast/rtcp/rtcp.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.h"
 
 #include "base/debug/trace_event.h"
 #include "base/rand_util.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
@@ skipping 34 matching lines @@
     : media_ssrc_(media_ssrc) {}
 
 RtcpCastMessage::~RtcpCastMessage() {}
 
 RtcpNackMessage::RtcpNackMessage() {}
 RtcpNackMessage::~RtcpNackMessage() {}
 
 RtcpRembMessage::RtcpRembMessage() {}
 RtcpRembMessage::~RtcpRembMessage() {}
 
+RtcpReceiverFrameLogMessage::RtcpReceiverFrameLogMessage() {}
+RtcpReceiverFrameLogMessage::~RtcpReceiverFrameLogMessage() {}
 
 class LocalRtcpReceiverFeedback : public RtcpReceiverFeedback {
  public:
   explicit LocalRtcpReceiverFeedback(Rtcp* rtcp)
       : rtcp_(rtcp) {
   }
 
   virtual void OnReceivedSenderReport(
       const RtcpSenderInfo& remote_sender_info) OVERRIDE {
     rtcp_->OnReceivedNtp(remote_sender_info.ntp_seconds,
                          remote_sender_info.ntp_fraction);
     if (remote_sender_info.send_packet_count != 0) {
       rtcp_->OnReceivedLipSyncInfo(remote_sender_info.rtp_timestamp,
                                    remote_sender_info.ntp_seconds,
                                    remote_sender_info.ntp_fraction);
     }
   }
 
   virtual void OnReceiverReferenceTimeReport(
       const RtcpReceiverReferenceTimeReport& remote_time_report) OVERRIDE {
     rtcp_->OnReceivedNtp(remote_time_report.ntp_seconds,
                          remote_time_report.ntp_fraction);
   }
 
   virtual void OnReceivedSendReportRequest() OVERRIDE {
     rtcp_->OnReceivedSendReportRequest();
   }
 
+  virtual void OnReceivedReceiverLog(
+      const RtcpReceiverLogMessage& receiver_log) OVERRIDE {
+    // TODO(pwestin): Implement.
+    // Add received log messages into our log system.
+    NOTIMPLEMENTED();
+  }
+
+  virtual void OnReceivedSenderLog(
+    const RtcpSenderLogMessage& sender_log)  OVERRIDE {
+    // TODO(pwestin): Implement.
+    // Add received log messages into our log system.
+    NOTIMPLEMENTED();
+  }
+
  private:
   Rtcp* rtcp_;
 };
 
 Rtcp::Rtcp(base::TickClock* clock,
            RtcpSenderFeedback* sender_feedback,
            PacedPacketSender* paced_packet_sender,
            RtpSenderStatistics* rtp_sender_statistics,
            RtpReceiverStatistics* rtp_receiver_statistics,
            RtcpMode rtcp_mode,
            const base::TimeDelta& rtcp_interval,
-           bool sending_media,
            uint32 local_ssrc,
+           uint32 remote_ssrc,
            const std::string& c_name)
     : rtcp_interval_(rtcp_interval),
       rtcp_mode_(rtcp_mode),
-      sending_media_(sending_media),
       local_ssrc_(local_ssrc),
+      remote_ssrc_(remote_ssrc),
       rtp_sender_statistics_(rtp_sender_statistics),
       rtp_receiver_statistics_(rtp_receiver_statistics),
       receiver_feedback_(new LocalRtcpReceiverFeedback(this)),
       rtt_feedback_(new LocalRtcpRttFeedback(this)),
       rtcp_sender_(new RtcpSender(paced_packet_sender, local_ssrc, c_name)),
       last_report_received_(0),
       last_received_rtp_timestamp_(0),
       last_received_ntp_seconds_(0),
       last_received_ntp_fraction_(0),
       min_rtt_(base::TimeDelta::FromMilliseconds(kMaxRttMs)),
       number_of_rtt_in_avg_(0),
       clock_(clock) {
   rtcp_receiver_.reset(new RtcpReceiver(sender_feedback,
                                         receiver_feedback_.get(),
                                         rtt_feedback_.get(),
                                         local_ssrc));
+  rtcp_receiver_->SetRemoteSSRC(remote_ssrc);
 }
 
 Rtcp::~Rtcp() {}
 
 // static
 bool Rtcp::IsRtcpPacket(const uint8* packet, size_t length) {
   DCHECK_GE(length, kMinLengthOfRtcp) << "Invalid RTCP packet";
   if (length < kMinLengthOfRtcp) return false;
 
   uint8 packet_type = packet[1];
@@ skipping 13 matching lines @@
   return ssrc_of_sender;
 }
 
 base::TimeTicks Rtcp::TimeToSendNextRtcpReport() {
   if (next_time_to_send_rtcp_.is_null()) {
     UpdateNextTimeToSendRtcp();
   }
   return next_time_to_send_rtcp_;
 }
 
-void Rtcp::SetRemoteSSRC(uint32 ssrc) {
-  rtcp_receiver_->SetRemoteSSRC(ssrc);
-}
-
 void Rtcp::IncomingRtcpPacket(const uint8* rtcp_buffer, size_t length) {
   RtcpParser rtcp_parser(rtcp_buffer, length);
   if (!rtcp_parser.IsValid()) {
     // Silently ignore packet.
     DLOG(ERROR) << "Received invalid RTCP packet";
     return;
   }
   rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser);
 }
 
-void Rtcp::SendRtcpCast(const RtcpCastMessage& cast_message) {
+void Rtcp::SendRtcpFromRtpReceiver(const RtcpCastMessage* cast_message,
+                                   const RtcpReceiverLogMessage* receiver_log) {
   uint32 packet_type_flags = 0;
+
   base::TimeTicks now = clock_->NowTicks();
+  RtcpReportBlock report_block;
+  RtcpReceiverReferenceTimeReport rrtr;
 
+  if (cast_message) {
+    packet_type_flags |= RtcpSender::kRtcpCast;
+  }
+  if (receiver_log) {
+    packet_type_flags |= RtcpSender::kRtcpReceiverLog;
+  }
   if (rtcp_mode_ == kRtcpCompound || now >= next_time_to_send_rtcp_) {
-    if (sending_media_) {
-      packet_type_flags = RtcpSender::kRtcpSr;
-    } else {
-      packet_type_flags = RtcpSender::kRtcpRr;
-    }
-  }
-  packet_type_flags |= RtcpSender::kRtcpCast;
+    packet_type_flags |= RtcpSender::kRtcpRr;
 
-  SendRtcp(now, packet_type_flags, 0, &cast_message);
-}
-
-void Rtcp::SendRtcpPli(uint32 pli_remote_ssrc) {
-  uint32 packet_type_flags = 0;
-  base::TimeTicks now = clock_->NowTicks();
-
-  if (rtcp_mode_ == kRtcpCompound || now >= next_time_to_send_rtcp_) {
-    if (sending_media_) {
-      packet_type_flags = RtcpSender::kRtcpSr;
-    } else {
-      packet_type_flags = RtcpSender::kRtcpRr;
-    }
-  }
-  packet_type_flags |= RtcpSender::kRtcpPli;
-  SendRtcp(now, packet_type_flags, pli_remote_ssrc, NULL);
-}
-
-void Rtcp::SendRtcpReport(uint32 media_ssrc) {
-  uint32 packet_type_flags;
-  base::TimeTicks now = clock_->NowTicks();
-  if (sending_media_) {
-    packet_type_flags = RtcpSender::kRtcpSr;
-  } else {
-    packet_type_flags = RtcpSender::kRtcpRr;
-  }
-  SendRtcp(now, packet_type_flags, media_ssrc, NULL);
-}
-
-void Rtcp::SendRtcp(const base::TimeTicks& now,
-                    uint32 packet_type_flags,
-                    uint32 media_ssrc,
-                    const RtcpCastMessage* cast_message) {
-  if (packet_type_flags & RtcpSender::kRtcpSr ||
-      packet_type_flags & RtcpSender::kRtcpRr) {
-    UpdateNextTimeToSendRtcp();
-  }
-  if (packet_type_flags & RtcpSender::kRtcpSr) {
-    RtcpSenderInfo sender_info;
-
-    if (rtp_sender_statistics_) {
-      rtp_sender_statistics_->GetStatistics(now, &sender_info);
-    } else {
-      memset(&sender_info, 0, sizeof(sender_info));
-    }
-    SaveLastSentNtpTime(now, sender_info.ntp_seconds, sender_info.ntp_fraction);
-
-    RtcpDlrrReportBlock dlrr;
-    if (!time_last_report_received_.is_null()) {
-      packet_type_flags |= RtcpSender::kRtcpDlrr;
-      dlrr.last_rr = last_report_received_;
-      uint32 delay_seconds = 0;
-      uint32 delay_fraction = 0;
-      base::TimeDelta delta = now - time_last_report_received_;
-      ConvertTimeToFractions(delta.InMicroseconds(),
-                             &delay_seconds,
-                             &delay_fraction);
-
-      dlrr.delay_since_last_rr =
-         ConvertToNtpDiff(delay_seconds, delay_fraction);
-    }
-    rtcp_sender_->SendRtcp(packet_type_flags,
-                           &sender_info,
-                           NULL,
-                           media_ssrc,
-                           &dlrr,
-                           NULL,
-                           NULL);
-  } else {
-    RtcpReportBlock report_block;
     report_block.remote_ssrc = 0;  // Not needed to set send side.
-    report_block.media_ssrc = media_ssrc;  // SSRC of the RTP packet sender.
+    report_block.media_ssrc = remote_ssrc_;  // SSRC of the RTP packet sender.
     if (rtp_receiver_statistics_) {
       rtp_receiver_statistics_->GetStatistics(
           &report_block.fraction_lost,
           &report_block.cumulative_lost,
           &report_block.extended_high_sequence_number,
           &report_block.jitter);
     }
 
     report_block.last_sr = last_report_received_;
     if (!time_last_report_received_.is_null()) {
       uint32 delay_seconds = 0;
       uint32 delay_fraction = 0;
       base::TimeDelta delta = now - time_last_report_received_;
       ConvertTimeToFractions(delta.InMicroseconds(),
                              &delay_seconds,
                              &delay_fraction);
       report_block.delay_since_last_sr =
           ConvertToNtpDiff(delay_seconds, delay_fraction);
     } else {
       report_block.delay_since_last_sr = 0;
     }
 
     packet_type_flags |= RtcpSender::kRtcpRrtr;
-    RtcpReceiverReferenceTimeReport rrtr;
     ConvertTimeTicksToNtp(now, &rrtr.ntp_seconds, &rrtr.ntp_fraction);
     SaveLastSentNtpTime(now, rrtr.ntp_seconds, rrtr.ntp_fraction);
+    UpdateNextTimeToSendRtcp();
+  }
+  rtcp_sender_->SendRtcpFromRtpReceiver(packet_type_flags,
+                                        &report_block,
+                                        &rrtr,
+                                        cast_message,
+                                        receiver_log);
+}
 
-    rtcp_sender_->SendRtcp(packet_type_flags,
-                           NULL,
-                           &report_block,
-                           media_ssrc,
-                           NULL,
-                           &rrtr,
-                           cast_message);
+void Rtcp::SendRtcpFromRtpSender(
+    const RtcpSenderLogMessage* sender_log_message) {
+  uint32 packet_type_flags = RtcpSender::kRtcpSr;
+  base::TimeTicks now = clock_->NowTicks();
+
+  RtcpSenderInfo sender_info;
+  RtcpDlrrReportBlock dlrr;
+
+  if (sender_log_message) packet_type_flags |= RtcpSender::kRtcpSenderLog;
+
+  if (rtp_sender_statistics_) {
+    rtp_sender_statistics_->GetStatistics(now, &sender_info);
+  } else {
+    memset(&sender_info, 0, sizeof(sender_info));
   }
+  SaveLastSentNtpTime(now, sender_info.ntp_seconds, sender_info.ntp_fraction);
+
+  if (!time_last_report_received_.is_null()) {
+    packet_type_flags |= RtcpSender::kRtcpDlrr;
+    dlrr.last_rr = last_report_received_;
+    uint32 delay_seconds = 0;
+    uint32 delay_fraction = 0;
+    base::TimeDelta delta = now - time_last_report_received_;
+    ConvertTimeToFractions(delta.InMicroseconds(),
+                           &delay_seconds,
+                           &delay_fraction);
+
+    dlrr.delay_since_last_rr = ConvertToNtpDiff(delay_seconds, delay_fraction);
+  }
+
+  rtcp_sender_->SendRtcpFromRtpSender(packet_type_flags,
+                                      &sender_info,
+                                      &dlrr,
+                                      sender_log_message);
+  UpdateNextTimeToSendRtcp();
 }
 
 void Rtcp::OnReceivedNtp(uint32 ntp_seconds, uint32 ntp_fraction) {
   last_report_received_ = (ntp_seconds << 16) + (ntp_fraction >> 16);
 
   base::TimeTicks now = clock_->NowTicks();
   time_last_report_received_ = now;
 }
 
 void Rtcp::OnReceivedLipSyncInfo(uint32 rtp_timestamp,
@@ skipping 138 matching lines @@
   int random = base::RandInt(0, 999);
   base::TimeDelta time_to_next = (rtcp_interval_ / 2) +
       (rtcp_interval_ * random / 1000);
 
   base::TimeTicks now = clock_->NowTicks();
   next_time_to_send_rtcp_ = now + time_to_next;
 }
 
 }  // namespace cast
 }  // namespace media