Cast:Adding signaling and infrastructure for adjustable delay

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/big_endian.h"
 #include "base/rand_util.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/rtcp/rtcp_defines.h"
 #include "media/cast/rtcp/rtcp_receiver.h"
 #include "media/cast/rtcp/rtcp_sender.h"
 #include "media/cast/rtcp/rtcp_utility.h"
 #include "media/cast/transport/cast_transport_defines.h"
 
 namespace media {
 namespace cast {
 
 static const int kMaxRttMs = 10000;  // 10 seconds.
+static const uint16 kMaxDelay = 2000;
 
 // Time limit for received RTCP messages when we stop using it for lip-sync.
 static const int64 kMaxDiffSinceReceivedRtcpMs = 100000;  // 100 seconds.
 
 class LocalRtcpRttFeedback : public RtcpRttFeedback {
  public:
   explicit LocalRtcpRttFeedback(Rtcp* rtcp) : rtcp_(rtcp) {}
 
   virtual void OnReceivedDelaySinceLastReport(
       uint32 receivers_ssrc, uint32 last_report,
@@ skipping 202 matching lines @@
     const ReceiverRtcpEventSubscriber* event_subscriber) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   uint32 packet_type_flags = 0;
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   transport::RtcpReportBlock report_block;
   RtcpReceiverReferenceTimeReport rrtr;
 
   // Attach our NTP to all RTCP packets; with this information a "smart" sender
   // can make decisions based on how old the RTCP message is.
-  packet_type_flags |= RtcpSender::kRtcpRrtr;
+  packet_type_flags |= transport::kRtcpRrtr;
   ConvertTimeTicksToNtp(now, &rrtr.ntp_seconds, &rrtr.ntp_fraction);
   SaveLastSentNtpTime(now, rrtr.ntp_seconds, rrtr.ntp_fraction);
 
   if (cast_message) {
-    packet_type_flags |= RtcpSender::kRtcpCast;
+    packet_type_flags |= transport::kRtcpCast;
   }
   if (event_subscriber) {
-    packet_type_flags |= RtcpSender::kRtcpReceiverLog;
+    packet_type_flags |= transport::kRtcpReceiverLog;
   }
   if (rtcp_mode_ == kRtcpCompound || now >= next_time_to_send_rtcp_) {
-    packet_type_flags |= RtcpSender::kRtcpRr;
+    packet_type_flags |= transport::kRtcpRr;
 
     report_block.remote_ssrc = 0;            // Not needed to set send side.
     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);
       cast_environment_->Logging()->InsertGenericEvent(now, kJitterMs,
                                                        report_block.jitter);
       cast_environment_->Logging()->InsertGenericEvent(
           now, kPacketLoss, report_block.fraction_lost);
     }
 
     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;
     }
     UpdateNextTimeToSendRtcp();
   }
   rtcp_sender_->SendRtcpFromRtpReceiver(
-      packet_type_flags, &report_block, &rrtr, cast_message, event_subscriber);
+      packet_type_flags, &report_block, &rrtr, cast_message, event_subscriber,
+      target_delay_ms_);
 }
 
 void Rtcp::SendRtcpFromRtpSender(
     const transport::RtcpSenderLogMessage& sender_log_message) {
   DCHECK(transport_sender_);
-  uint32 packet_type_flags = RtcpSender::kRtcpSr;
+  uint32 packet_type_flags = transport::kRtcpSr;
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
   if (sender_log_message.size()) {
-    packet_type_flags |= RtcpSender::kRtcpSenderLog;
+    packet_type_flags |= transport::kRtcpSenderLog;
   }
 
   transport::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);
 
   transport::RtcpDlrrReportBlock dlrr;
   if (!time_last_report_received_.is_null()) {
-    packet_type_flags |= RtcpSender::kRtcpDlrr;
+    packet_type_flags |= transport::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);
   }
 
@@ skipping 67 matching lines @@
   *rtp_timestamp_in_ticks = ConvertNtpToTimeTicks(last_received_ntp_seconds_,
                                                   last_received_ntp_fraction_) +
                             base::TimeDelta::FromMilliseconds(rtp_time_diff_ms);
   return true;
 }
 
 void Rtcp::SetCastReceiverEventHistorySize(size_t size) {
   rtcp_receiver_->SetCastReceiverEventHistorySize(size);
 }
 
+void Rtcp::SetTargetDelay(base::TimeDelta target_delay) {
+  target_delay_ms_ = static_cast<uint16>(target_delay.InMilliseconds());
+  DCHECK(target_delay_ms_ < kMaxDelay);
+}
+
 void Rtcp::OnReceivedDelaySinceLastReport(uint32 receivers_ssrc,
                                           uint32 last_report,
                                           uint32 delay_since_last_report) {
   RtcpSendTimeMap::iterator it = last_reports_sent_map_.find(last_report);
   if (it == last_reports_sent_map_.end()) {
     return;  // Feedback on another report.
   }
 
   base::TimeDelta sender_delay =
       cast_environment_->Clock()->NowTicks() - it->second;
@@ skipping 84 matching lines @@
   int random = base::RandInt(0, 999);
   base::TimeDelta time_to_next =
       (rtcp_interval_ / 2) + (rtcp_interval_ * random / 1000);
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   next_time_to_send_rtcp_ = now + time_to_next;
 }
 
 }  // namespace cast
 }  // namespace media