Cast: Reshuffle files under media/cast

media/cast/rtcp/rtcp.cc

Index: media/cast/rtcp/rtcp.cc
diff --git a/media/cast/rtcp/rtcp.cc b/media/cast/rtcp/rtcp.cc
deleted file mode 100644
index 74a4689d321dae215f1ae3dcb44ae67b4aa994f9..0000000000000000000000000000000000000000
--- a/media/cast/rtcp/rtcp.cc
+++ /dev/null
@@ -1,430 +0,0 @@
-// 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 "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"
-
-using base::TimeDelta;
-
-namespace media {
-namespace cast {
-
-static const int32 kMaxRttMs = 10000;  // 10 seconds.
-static const int32 kMaxDelayMs = 2000;  // 2 seconds.
-
-class LocalRtcpRttFeedback : public RtcpRttFeedback {
- public:
-  explicit LocalRtcpRttFeedback(Rtcp* rtcp) : rtcp_(rtcp) {}
-
-  virtual void OnReceivedDelaySinceLastReport(
-      uint32 receivers_ssrc, uint32 last_report,
-      uint32 delay_since_last_report) OVERRIDE {
-    rtcp_->OnReceivedDelaySinceLastReport(receivers_ssrc, last_report,
-                                          delay_since_last_report);
-  }
-
- private:
-  Rtcp* rtcp_;
-};
-
-class LocalRtcpReceiverFeedback : public RtcpReceiverFeedback {
- public:
-  LocalRtcpReceiverFeedback(Rtcp* rtcp,
-                            scoped_refptr<CastEnvironment> cast_environment)
-      : rtcp_(rtcp), cast_environment_(cast_environment) {}
-
-  virtual void OnReceivedSenderReport(
-      const transport::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 {
-    rtcp_->OnReceivedReceiverLog(receiver_log);
-  }
-
- private:
-  Rtcp* rtcp_;
-  scoped_refptr<CastEnvironment> cast_environment_;
-};
-
-Rtcp::Rtcp(scoped_refptr<CastEnvironment> cast_environment,
-           RtcpSenderFeedback* sender_feedback,
-           transport::CastTransportSender* const transport_sender,
-           transport::PacedPacketSender* paced_packet_sender,
-           RtpReceiverStatistics* rtp_receiver_statistics, RtcpMode rtcp_mode,
-           const base::TimeDelta& rtcp_interval, uint32 local_ssrc,
-           uint32 remote_ssrc, const std::string& c_name,
-           EventMediaType event_media_type)
-    : cast_environment_(cast_environment),
-      transport_sender_(transport_sender),
-      rtcp_interval_(rtcp_interval),
-      rtcp_mode_(rtcp_mode),
-      local_ssrc_(local_ssrc),
-      remote_ssrc_(remote_ssrc),
-      c_name_(c_name),
-      event_media_type_(event_media_type),
-      rtp_receiver_statistics_(rtp_receiver_statistics),
-      rtt_feedback_(new LocalRtcpRttFeedback(this)),
-      receiver_feedback_(new LocalRtcpReceiverFeedback(this, cast_environment)),
-      rtcp_sender_(new RtcpSender(cast_environment, paced_packet_sender,
-                                  local_ssrc, c_name)),
-      last_report_truncated_ntp_(0),
-      local_clock_ahead_by_(ClockDriftSmoother::GetDefaultTimeConstant()),
-      lip_sync_rtp_timestamp_(0),
-      lip_sync_ntp_timestamp_(0),
-      min_rtt_(TimeDelta::FromMilliseconds(kMaxRttMs)),
-      number_of_rtt_in_avg_(0) {
-  rtcp_receiver_.reset(new RtcpReceiver(cast_environment, 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];
-  if (packet_type >= transport::kPacketTypeLow &&
-      packet_type <= transport::kPacketTypeHigh) {
-    return true;
-  }
-  return false;
-}
-
-// static
-uint32 Rtcp::GetSsrcOfSender(const uint8* rtcp_buffer, size_t length) {
-  DCHECK_GE(length, kMinLengthOfRtcp) << "Invalid RTCP packet";
-  uint32 ssrc_of_sender;
-  base::BigEndianReader big_endian_reader(
-      reinterpret_cast<const char*>(rtcp_buffer), length);
-  big_endian_reader.Skip(4);  // Skip header
-  big_endian_reader.ReadU32(&ssrc_of_sender);
-  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::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::SendRtcpFromRtpReceiver(
-    const RtcpCastMessage* cast_message,
-    const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events) {
-  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 |= transport::kRtcpRrtr;
-  ConvertTimeTicksToNtp(now, &rrtr.ntp_seconds, &rrtr.ntp_fraction);
-  SaveLastSentNtpTime(now, rrtr.ntp_seconds, rrtr.ntp_fraction);
-
-  if (cast_message) {
-    packet_type_flags |= transport::kRtcpCast;
-  }
-  if (rtcp_events) {
-    packet_type_flags |= transport::kRtcpReceiverLog;
-  }
-  if (rtcp_mode_ == kRtcpCompound || now >= next_time_to_send_rtcp_) {
-    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);
-    }
-
-    report_block.last_sr = last_report_truncated_ntp_;
-    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,
-                                        rtcp_events,
-                                        target_delay_);
-}
-
-void Rtcp::SendRtcpFromRtpSender(base::TimeTicks current_time,
-                                 uint32 current_time_as_rtp_timestamp) {
-  DCHECK(transport_sender_);
-  uint32 packet_type_flags = transport::kRtcpSr;
-  uint32 current_ntp_seconds = 0;
-  uint32 current_ntp_fractions = 0;
-  ConvertTimeTicksToNtp(current_time, &current_ntp_seconds,
-                        &current_ntp_fractions);
-  SaveLastSentNtpTime(current_time, current_ntp_seconds,
-                      current_ntp_fractions);
-
-  transport::RtcpDlrrReportBlock dlrr;
-  if (!time_last_report_received_.is_null()) {
-    packet_type_flags |= transport::kRtcpDlrr;
-    dlrr.last_rr = last_report_truncated_ntp_;
-    uint32 delay_seconds = 0;
-    uint32 delay_fraction = 0;
-    base::TimeDelta delta = current_time - time_last_report_received_;
-    ConvertTimeToFractions(delta.InMicroseconds(), &delay_seconds,
-                           &delay_fraction);
-
-    dlrr.delay_since_last_rr = ConvertToNtpDiff(delay_seconds, delay_fraction);
-  }
-
-  transport_sender_->SendRtcpFromRtpSender(
-      packet_type_flags, current_ntp_seconds, current_ntp_fractions,
-      current_time_as_rtp_timestamp, dlrr, local_ssrc_, c_name_);
-  UpdateNextTimeToSendRtcp();
-}
-
-void Rtcp::OnReceivedNtp(uint32 ntp_seconds, uint32 ntp_fraction) {
-  last_report_truncated_ntp_ = ConvertToNtpDiff(ntp_seconds, ntp_fraction);
-
-  const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-  time_last_report_received_ = now;
-
-  // TODO(miu): This clock offset calculation does not account for packet
-  // transit time over the network.  End2EndTest.EvilNetwork confirms that this
-  // contributes a very significant source of error here.  Fix this along with
-  // the RTT clean-up.
-  const base::TimeDelta measured_offset =
-      now - ConvertNtpToTimeTicks(ntp_seconds, ntp_fraction);
-  local_clock_ahead_by_.Update(now, measured_offset);
-  if (measured_offset < local_clock_ahead_by_.Current()) {
-    // Logically, the minimum offset between the clocks has to be the correct
-    // one.  For example, the time it took to transmit the current report may
-    // have been lower than usual, and so some of the error introduced by the
-    // transmission time can be eliminated.
-    local_clock_ahead_by_.Reset(now, measured_offset);
-  }
-  VLOG(1) << "Local clock is ahead of the remote clock by: "
-          << "measured=" << measured_offset.InMicroseconds() << " usec, "
-          << "filtered=" << local_clock_ahead_by_.Current().InMicroseconds()
-          << " usec.";
-}
-
-void Rtcp::OnReceivedLipSyncInfo(uint32 rtp_timestamp, uint32 ntp_seconds,
-                                 uint32 ntp_fraction) {
-  if (ntp_seconds == 0) {
-    NOTREACHED();
-    return;
-  }
-  lip_sync_rtp_timestamp_ = rtp_timestamp;
-  lip_sync_ntp_timestamp_ =
-      (static_cast<uint64>(ntp_seconds) << 32) | ntp_fraction;
-}
-
-bool Rtcp::GetLatestLipSyncTimes(uint32* rtp_timestamp,
-                                 base::TimeTicks* reference_time) const {
-  if (!lip_sync_ntp_timestamp_)
-    return false;
-
-  const base::TimeTicks local_reference_time =
-      ConvertNtpToTimeTicks(static_cast<uint32>(lip_sync_ntp_timestamp_ >> 32),
-                            static_cast<uint32>(lip_sync_ntp_timestamp_)) +
-      local_clock_ahead_by_.Current();
-
-  // Sanity-check: Getting regular lip sync updates?
-  DCHECK((cast_environment_->Clock()->NowTicks() - local_reference_time) <
-             base::TimeDelta::FromMinutes(1));
-
-  *rtp_timestamp = lip_sync_rtp_timestamp_;
-  *reference_time = local_reference_time;
-  return true;
-}
-
-void Rtcp::OnReceivedSendReportRequest() {
-  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-
-  // Trigger a new RTCP report at next timer.
-  next_time_to_send_rtcp_ = now;
-}
-
-void Rtcp::SetCastReceiverEventHistorySize(size_t size) {
-  rtcp_receiver_->SetCastReceiverEventHistorySize(size);
-}
-
-void Rtcp::SetTargetDelay(base::TimeDelta target_delay) {
-  DCHECK(target_delay < TimeDelta::FromMilliseconds(kMaxDelayMs));
-  target_delay_ = target_delay;
-}
-
-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;
-  UpdateRtt(sender_delay, ConvertFromNtpDiff(delay_since_last_report));
-}
-
-void Rtcp::SaveLastSentNtpTime(const base::TimeTicks& now,
-                               uint32 last_ntp_seconds,
-                               uint32 last_ntp_fraction) {
-  // Make sure |now| is always greater than the last element in
-  // |last_reports_sent_queue_|.
-  if (!last_reports_sent_queue_.empty())
-    DCHECK(now >= last_reports_sent_queue_.back().second);
-
-  uint32 last_report = ConvertToNtpDiff(last_ntp_seconds, last_ntp_fraction);
-  last_reports_sent_map_[last_report] = now;
-  last_reports_sent_queue_.push(std::make_pair(last_report, now));
-
-  base::TimeTicks timeout = now - TimeDelta::FromMilliseconds(kMaxRttMs);
-
-  // Cleanup old statistics older than |timeout|.
-  while (!last_reports_sent_queue_.empty()) {
-    RtcpSendTimePair oldest_report = last_reports_sent_queue_.front();
-    if (oldest_report.second < timeout) {
-      last_reports_sent_map_.erase(oldest_report.first);
-      last_reports_sent_queue_.pop();
-    } else {
-      break;
-    }
-  }
-}
-
-void Rtcp::UpdateRtt(const base::TimeDelta& sender_delay,
-                     const base::TimeDelta& receiver_delay) {
-  base::TimeDelta rtt = sender_delay - receiver_delay;
-  // TODO(miu): Find out why this must be >= 1 ms, and remove the fudge if it's
-  // bogus.
-  rtt = std::max(rtt, base::TimeDelta::FromMilliseconds(1));
-  rtt_ = rtt;
-  min_rtt_ = std::min(min_rtt_, rtt);
-  max_rtt_ = std::max(max_rtt_, rtt);
-
-  // TODO(miu): Replace "average for all time" with an EWMA, or suitable
-  // "average over recent past" mechanism.
-  if (number_of_rtt_in_avg_ != 0) {
-    // Integer math equivalent of (ac/(ac+1.0))*avg_rtt_ + (1.0/(ac+1.0))*rtt).
-    // (TimeDelta only supports math with other TimeDeltas and int64s.)
-    avg_rtt_ = (avg_rtt_ * number_of_rtt_in_avg_ + rtt) /
-        (number_of_rtt_in_avg_ + 1);
-  } else {
-    avg_rtt_ = rtt;
-  }
-  number_of_rtt_in_avg_++;
-}
-
-bool Rtcp::Rtt(base::TimeDelta* rtt, base::TimeDelta* avg_rtt,
-               base::TimeDelta* min_rtt, base::TimeDelta* max_rtt) const {
-  DCHECK(rtt) << "Invalid argument";
-  DCHECK(avg_rtt) << "Invalid argument";
-  DCHECK(min_rtt) << "Invalid argument";
-  DCHECK(max_rtt) << "Invalid argument";
-
-  if (number_of_rtt_in_avg_ == 0) return false;
-
-  *rtt = rtt_;
-  *avg_rtt = avg_rtt_;
-  *min_rtt = min_rtt_;
-  *max_rtt = max_rtt_;
-  return true;
-}
-
-void Rtcp::UpdateNextTimeToSendRtcp() {
-  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-  next_time_to_send_rtcp_ = now + rtcp_interval_;
-}
-
-void Rtcp::OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log) {
-  // Add received log messages into our log system.
-  RtcpReceiverLogMessage::const_iterator it = receiver_log.begin();
-  for (; it != receiver_log.end(); ++it) {
-    uint32 rtp_timestamp = it->rtp_timestamp_;
-
-    RtcpReceiverEventLogMessages::const_iterator event_it =
-        it->event_log_messages_.begin();
-    for (; event_it != it->event_log_messages_.end(); ++event_it) {
-      switch (event_it->type) {
-        case PACKET_RECEIVED:
-          cast_environment_->Logging()->InsertPacketEvent(
-              event_it->event_timestamp, event_it->type,
-              event_media_type_, rtp_timestamp,
-              kFrameIdUnknown, event_it->packet_id, 0, 0);
-          break;
-        case FRAME_ACK_SENT:
-        case FRAME_DECODED:
-          cast_environment_->Logging()->InsertFrameEvent(
-              event_it->event_timestamp, event_it->type, event_media_type_,
-              rtp_timestamp, kFrameIdUnknown);
-          break;
-        case FRAME_PLAYOUT:
-          cast_environment_->Logging()->InsertFrameEventWithDelay(
-              event_it->event_timestamp, event_it->type, event_media_type_,
-              rtp_timestamp, kFrameIdUnknown, event_it->delay_delta);
-          break;
-        default:
-          VLOG(2) << "Received log message via RTCP that we did not expect: "
-                  << static_cast<int>(event_it->type);
-          break;
-      }
-    }
-  }
-}
-
-}  // namespace cast
-}  // namespace media