1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "media/cast/net/rtcp/rtcp.h"
6
7#include "media/cast/cast_config.h"
8#include "media/cast/cast_defines.h"
9#include "media/cast/cast_environment.h"
10#include "media/cast/net/cast_transport_defines.h"
11#include "media/cast/net/pacing/paced_sender.h"
12#include "media/cast/net/rtcp/rtcp_builder.h"
13#include "media/cast/net/rtcp/rtcp_defines.h"
14#include "media/cast/net/rtcp/rtcp_utility.h"
15
16using base::TimeDelta;
17
18namespace media {
19namespace cast {
20
21static const int32 kStatsHistoryWindowMs = 10000;  // 10 seconds.
22// Reject packets that are older than 0.5 seconds older than
23// the newest packet we've seen so far. This protect internal
24// states from crazy routers. (Based on RRTR)
25static const int32 kOutOfOrderMaxAgeMs = 500;
26
27namespace {
28
29// A receiver frame event is identified by frame RTP timestamp, event timestamp
30// and event type.
31// A receiver packet event is identified by all of the above plus packet id.
32// The key format is as follows:
33// First uint64:
34//   bits 0-11: zeroes (unused).
35//   bits 12-15: event type ID.
36//   bits 16-31: packet ID if packet event, 0 otherwise.
37//   bits 32-63: RTP timestamp.
38// Second uint64:
39//   bits 0-63: event TimeTicks internal value.
40std::pair<uint64, uint64> GetReceiverEventKey(
41    uint32 frame_rtp_timestamp,
42    const base::TimeTicks& event_timestamp,
43    uint8 event_type,
44    uint16 packet_id_or_zero) {
45  uint64 value1 = event_type;
46  value1 <<= 16;
47  value1 |= packet_id_or_zero;
48  value1 <<= 32;
49  value1 |= frame_rtp_timestamp;
50  return std::make_pair(
51      value1, static_cast<uint64>(event_timestamp.ToInternalValue()));
52}
53
54}  // namespace
55
56
57Rtcp::Rtcp(const RtcpCastMessageCallback& cast_callback,
58           const RtcpRttCallback& rtt_callback,
59           const RtcpLogMessageCallback& log_callback,
60           base::TickClock* clock,
61           PacedPacketSender* packet_sender,
62           uint32 local_ssrc,
63           uint32 remote_ssrc)
64    : cast_callback_(cast_callback),
65      rtt_callback_(rtt_callback),
66      log_callback_(log_callback),
67      clock_(clock),
68      rtcp_builder_(local_ssrc),
69      packet_sender_(packet_sender),
70      local_ssrc_(local_ssrc),
71      remote_ssrc_(remote_ssrc),
72      last_report_truncated_ntp_(0),
73      local_clock_ahead_by_(ClockDriftSmoother::GetDefaultTimeConstant()),
74      lip_sync_rtp_timestamp_(0),
75      lip_sync_ntp_timestamp_(0) {
76}
77
78Rtcp::~Rtcp() {}
79
80bool Rtcp::IsRtcpPacket(const uint8* packet, size_t length) {
81  if (length < kMinLengthOfRtcp) {
82    LOG(ERROR) << "Invalid RTCP packet received.";
83    return false;
84  }
85
86  uint8 packet_type = packet[1];
87  return packet_type >= kPacketTypeLow && packet_type <= kPacketTypeHigh;
88}
89
90uint32 Rtcp::GetSsrcOfSender(const uint8* rtcp_buffer, size_t length) {
91  if (length < kMinLengthOfRtcp)
92    return 0;
93  uint32 ssrc_of_sender;
94  base::BigEndianReader big_endian_reader(
95      reinterpret_cast<const char*>(rtcp_buffer), length);
96  big_endian_reader.Skip(4);  // Skip header.
97  big_endian_reader.ReadU32(&ssrc_of_sender);
98  return ssrc_of_sender;
99}
100
101bool Rtcp::IncomingRtcpPacket(const uint8* data, size_t length) {
102  // Check if this is a valid RTCP packet.
103  if (!IsRtcpPacket(data, length)) {
104    VLOG(1) << "Rtcp@" << this << "::IncomingRtcpPacket() -- "
105            << "Received an invalid (non-RTCP?) packet.";
106    return false;
107  }
108
109  // Check if this packet is to us.
110  uint32 ssrc_of_sender = GetSsrcOfSender(data, length);
111  if (ssrc_of_sender != remote_ssrc_) {
112    return false;
113  }
114
115  // Parse this packet.
116  RtcpParser parser(local_ssrc_, remote_ssrc_);
117  base::BigEndianReader reader(reinterpret_cast<const char*>(data), length);
118  if (parser.Parse(&reader)) {
119    if (parser.has_receiver_reference_time_report()) {
120      base::TimeTicks t = ConvertNtpToTimeTicks(
121          parser.receiver_reference_time_report().ntp_seconds,
122          parser.receiver_reference_time_report().ntp_fraction);
123      if (t > largest_seen_timestamp_) {
124        largest_seen_timestamp_ = t;
125      } else if ((largest_seen_timestamp_ - t).InMilliseconds() >
126                 kOutOfOrderMaxAgeMs) {
127        // Reject packet, it is too old.
128        VLOG(1) << "Rejecting RTCP packet as it is too old ("
129                << (largest_seen_timestamp_ - t).InMilliseconds()
130                << " ms)";
131        return true;
132      }
133
134      OnReceivedNtp(parser.receiver_reference_time_report().ntp_seconds,
135                    parser.receiver_reference_time_report().ntp_fraction);
136    }
137    if (parser.has_sender_report()) {
138      OnReceivedNtp(parser.sender_report().ntp_seconds,
139                    parser.sender_report().ntp_fraction);
140      OnReceivedLipSyncInfo(parser.sender_report().rtp_timestamp,
141                            parser.sender_report().ntp_seconds,
142                            parser.sender_report().ntp_fraction);
143    }
144    if (parser.has_receiver_log()) {
145      if (DedupeReceiverLog(parser.mutable_receiver_log())) {
146        OnReceivedReceiverLog(parser.receiver_log());
147      }
148    }
149    if (parser.has_last_report()) {
150      OnReceivedDelaySinceLastReport(parser.last_report(),
151                                     parser.delay_since_last_report());
152    }
153    if (parser.has_cast_message()) {
154      parser.mutable_cast_message()->ack_frame_id =
155          ack_frame_id_wrap_helper_.MapTo32bitsFrameId(
156              parser.mutable_cast_message()->ack_frame_id);
157      OnReceivedCastFeedback(parser.cast_message());
158    }
159  }
160  return true;
161}
162
163bool Rtcp::DedupeReceiverLog(RtcpReceiverLogMessage* receiver_log) {
164  RtcpReceiverLogMessage::iterator i = receiver_log->begin();
165  while (i != receiver_log->end()) {
166    RtcpReceiverEventLogMessages* messages = &i->event_log_messages_;
167    RtcpReceiverEventLogMessages::iterator j = messages->begin();
168    while (j != messages->end()) {
169      ReceiverEventKey key = GetReceiverEventKey(i->rtp_timestamp_,
170                                                 j->event_timestamp,
171                                                 j->type,
172                                                 j->packet_id);
173      RtcpReceiverEventLogMessages::iterator tmp = j;
174      ++j;
175      if (receiver_event_key_set_.insert(key).second) {
176        receiver_event_key_queue_.push(key);
177        if (receiver_event_key_queue_.size() > kReceiverRtcpEventHistorySize) {
178          receiver_event_key_set_.erase(receiver_event_key_queue_.front());
179          receiver_event_key_queue_.pop();
180        }
181      } else {
182        messages->erase(tmp);
183      }
184    }
185
186    RtcpReceiverLogMessage::iterator tmp = i;
187    ++i;
188    if (messages->empty()) {
189      receiver_log->erase(tmp);
190    }
191  }
192  return !receiver_log->empty();
193}
194
195void Rtcp::SendRtcpFromRtpReceiver(
196    const RtcpCastMessage* cast_message,
197    base::TimeDelta target_delay,
198    const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events,
199    RtpReceiverStatistics* rtp_receiver_statistics) {
200  base::TimeTicks now = clock_->NowTicks();
201  RtcpReportBlock report_block;
202  RtcpReceiverReferenceTimeReport rrtr;
203
204  // Attach our NTP to all RTCP packets; with this information a "smart" sender
205  // can make decisions based on how old the RTCP message is.
206  ConvertTimeTicksToNtp(now, &rrtr.ntp_seconds, &rrtr.ntp_fraction);
207  SaveLastSentNtpTime(now, rrtr.ntp_seconds, rrtr.ntp_fraction);
208
209  if (rtp_receiver_statistics) {
210    report_block.remote_ssrc = 0;            // Not needed to set send side.
211    report_block.media_ssrc = remote_ssrc_;  // SSRC of the RTP packet sender.
212    rtp_receiver_statistics->GetStatistics(
213        &report_block.fraction_lost, &report_block.cumulative_lost,
214        &report_block.extended_high_sequence_number, &report_block.jitter);
215
216    report_block.last_sr = last_report_truncated_ntp_;
217    if (!time_last_report_received_.is_null()) {
218      uint32 delay_seconds = 0;
219      uint32 delay_fraction = 0;
220      base::TimeDelta delta = now - time_last_report_received_;
221      ConvertTimeToFractions(delta.InMicroseconds(), &delay_seconds,
222                             &delay_fraction);
223      report_block.delay_since_last_sr =
224          ConvertToNtpDiff(delay_seconds, delay_fraction);
225    } else {
226      report_block.delay_since_last_sr = 0;
227    }
228  }
229  packet_sender_->SendRtcpPacket(
230      local_ssrc_,
231      rtcp_builder_.BuildRtcpFromReceiver(
232          rtp_receiver_statistics ? &report_block : NULL,
233          &rrtr,
234          cast_message,
235          rtcp_events,
236          target_delay));
237}
238
239void Rtcp::SendRtcpFromRtpSender(base::TimeTicks current_time,
240                                 uint32 current_time_as_rtp_timestamp,
241                                 uint32 send_packet_count,
242                                 size_t send_octet_count) {
243  uint32 current_ntp_seconds = 0;
244  uint32 current_ntp_fractions = 0;
245  ConvertTimeTicksToNtp(current_time, &current_ntp_seconds,
246                        &current_ntp_fractions);
247  SaveLastSentNtpTime(current_time, current_ntp_seconds,
248                      current_ntp_fractions);
249
250  RtcpSenderInfo sender_info;
251  sender_info.ntp_seconds = current_ntp_seconds;
252  sender_info.ntp_fraction = current_ntp_fractions;
253  sender_info.rtp_timestamp = current_time_as_rtp_timestamp;
254  sender_info.send_packet_count = send_packet_count;
255  sender_info.send_octet_count = send_octet_count;
256
257  packet_sender_->SendRtcpPacket(
258      local_ssrc_,
259      rtcp_builder_.BuildRtcpFromSender(sender_info));
260}
261
262void Rtcp::OnReceivedNtp(uint32 ntp_seconds, uint32 ntp_fraction) {
263  last_report_truncated_ntp_ = ConvertToNtpDiff(ntp_seconds, ntp_fraction);
264
265  const base::TimeTicks now = clock_->NowTicks();
266  time_last_report_received_ = now;
267
268  // TODO(miu): This clock offset calculation does not account for packet
269  // transit time over the network.  End2EndTest.EvilNetwork confirms that this
270  // contributes a very significant source of error here.  Determine whether
271  // RTT should be factored-in, and how that changes the rest of the
272  // calculation.
273  const base::TimeDelta measured_offset =
274      now - ConvertNtpToTimeTicks(ntp_seconds, ntp_fraction);
275  local_clock_ahead_by_.Update(now, measured_offset);
276  if (measured_offset < local_clock_ahead_by_.Current()) {
277    // Logically, the minimum offset between the clocks has to be the correct
278    // one.  For example, the time it took to transmit the current report may
279    // have been lower than usual, and so some of the error introduced by the
280    // transmission time can be eliminated.
281    local_clock_ahead_by_.Reset(now, measured_offset);
282  }
283  VLOG(1) << "Local clock is ahead of the remote clock by: "
284          << "measured=" << measured_offset.InMicroseconds() << " usec, "
285          << "filtered=" << local_clock_ahead_by_.Current().InMicroseconds()
286          << " usec.";
287}
288
289void Rtcp::OnReceivedLipSyncInfo(uint32 rtp_timestamp, uint32 ntp_seconds,
290                                 uint32 ntp_fraction) {
291  if (ntp_seconds == 0) {
292    NOTREACHED();
293    return;
294  }
295  lip_sync_rtp_timestamp_ = rtp_timestamp;
296  lip_sync_ntp_timestamp_ =
297      (static_cast<uint64>(ntp_seconds) << 32) | ntp_fraction;
298}
299
300bool Rtcp::GetLatestLipSyncTimes(uint32* rtp_timestamp,
301                                 base::TimeTicks* reference_time) const {
302  if (!lip_sync_ntp_timestamp_)
303    return false;
304
305  const base::TimeTicks local_reference_time =
306      ConvertNtpToTimeTicks(static_cast<uint32>(lip_sync_ntp_timestamp_ >> 32),
307                            static_cast<uint32>(lip_sync_ntp_timestamp_)) +
308      local_clock_ahead_by_.Current();
309
310  // Sanity-check: Getting regular lip sync updates?
311  DCHECK((clock_->NowTicks() - local_reference_time) <
312         base::TimeDelta::FromMinutes(1));
313
314  *rtp_timestamp = lip_sync_rtp_timestamp_;
315  *reference_time = local_reference_time;
316  return true;
317}
318
319void Rtcp::OnReceivedDelaySinceLastReport(uint32 last_report,
320                                          uint32 delay_since_last_report) {
321  RtcpSendTimeMap::iterator it = last_reports_sent_map_.find(last_report);
322  if (it == last_reports_sent_map_.end()) {
323    return;  // Feedback on another report.
324  }
325
326  const base::TimeDelta sender_delay = clock_->NowTicks() - it->second;
327  const base::TimeDelta receiver_delay =
328      ConvertFromNtpDiff(delay_since_last_report);
329  current_round_trip_time_ = sender_delay - receiver_delay;
330  // If the round trip time was computed as less than 1 ms, assume clock
331  // imprecision by one or both peers caused a bad value to be calculated.
332  // While plenty of networks do easily achieve less than 1 ms round trip time,
333  // such a level of precision cannot be measured with our approach; and 1 ms is
334  // good enough to represent "under 1 ms" for our use cases.
335  current_round_trip_time_ =
336      std::max(current_round_trip_time_, base::TimeDelta::FromMilliseconds(1));
337
338  if (!rtt_callback_.is_null())
339    rtt_callback_.Run(current_round_trip_time_);
340}
341
342void Rtcp::OnReceivedCastFeedback(const RtcpCastMessage& cast_message) {
343  if (cast_callback_.is_null())
344    return;
345  cast_callback_.Run(cast_message);
346}
347
348void Rtcp::SaveLastSentNtpTime(const base::TimeTicks& now,
349                               uint32 last_ntp_seconds,
350                               uint32 last_ntp_fraction) {
351  // Make sure |now| is always greater than the last element in
352  // |last_reports_sent_queue_|.
353  if (!last_reports_sent_queue_.empty())
354    DCHECK(now >= last_reports_sent_queue_.back().second);
355
356  uint32 last_report = ConvertToNtpDiff(last_ntp_seconds, last_ntp_fraction);
357  last_reports_sent_map_[last_report] = now;
358  last_reports_sent_queue_.push(std::make_pair(last_report, now));
359
360  const base::TimeTicks timeout =
361      now - TimeDelta::FromMilliseconds(kStatsHistoryWindowMs);
362
363  // Cleanup old statistics older than |timeout|.
364  while (!last_reports_sent_queue_.empty()) {
365    RtcpSendTimePair oldest_report = last_reports_sent_queue_.front();
366    if (oldest_report.second < timeout) {
367      last_reports_sent_map_.erase(oldest_report.first);
368      last_reports_sent_queue_.pop();
369    } else {
370      break;
371    }
372  }
373}
374
375void Rtcp::OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log) {
376  if (log_callback_.is_null())
377    return;
378  log_callback_.Run(receiver_log);
379}
380
381}  // namespace cast
382}  // namespace media
383