rtcp.h revision 116680a4aac90f2aa7413d9095a592090648e557 
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#ifndef MEDIA_CAST_RTCP_RTCP_H_
6#define MEDIA_CAST_RTCP_RTCP_H_
7
8#include <map>
9#include <queue>
10#include <string>
11
12#include "base/basictypes.h"
13#include "base/memory/scoped_ptr.h"
14#include "base/time/tick_clock.h"
15#include "base/time/time.h"
16#include "media/cast/cast_config.h"
17#include "media/cast/cast_defines.h"
18#include "media/cast/cast_environment.h"
19#include "media/cast/common/clock_drift_smoother.h"
20#include "media/cast/net/cast_transport_defines.h"
21#include "media/cast/net/cast_transport_sender.h"
22#include "media/cast/net/pacing/paced_sender.h"
23#include "media/cast/net/rtcp/receiver_rtcp_event_subscriber.h"
24#include "media/cast/net/rtcp/rtcp_defines.h"
25
26namespace media {
27namespace cast {
28
29class LocalRtcpReceiverFeedback;
30class LocalRtcpRttFeedback;
31class PacedPacketSender;
32class RtcpReceiver;
33class RtcpSender;
34
35typedef std::pair<uint32, base::TimeTicks> RtcpSendTimePair;
36typedef std::map<uint32, base::TimeTicks> RtcpSendTimeMap;
37typedef std::queue<RtcpSendTimePair> RtcpSendTimeQueue;
38
39class RtcpSenderFeedback {
40 public:
41  virtual void OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) = 0;
42
43  virtual ~RtcpSenderFeedback() {}
44};
45
46class RtpReceiverStatistics {
47 public:
48  virtual void GetStatistics(uint8* fraction_lost,
49                             uint32* cumulative_lost,  // 24 bits valid.
50                             uint32* extended_high_sequence_number,
51                             uint32* jitter) = 0;
52
53  virtual ~RtpReceiverStatistics() {}
54};
55
56class Rtcp {
57 public:
58  // Rtcp accepts two transports, one to be used by Cast senders
59  // (CastTransportSender) only, and the other (PacedPacketSender) should only
60  // be used by the Cast receivers and test applications.
61  Rtcp(scoped_refptr<CastEnvironment> cast_environment,
62       RtcpSenderFeedback* sender_feedback,
63       CastTransportSender* const transport_sender,  // Send-side.
64       PacedPacketSender* paced_packet_sender,       // Receive side.
65       RtpReceiverStatistics* rtp_receiver_statistics,
66       RtcpMode rtcp_mode,
67       const base::TimeDelta& rtcp_interval,
68       uint32 local_ssrc,
69       uint32 remote_ssrc,
70       const std::string& c_name,
71       EventMediaType event_media_type);
72
73  virtual ~Rtcp();
74
75  static bool IsRtcpPacket(const uint8* rtcp_buffer, size_t length);
76
77  static uint32 GetSsrcOfSender(const uint8* rtcp_buffer, size_t length);
78
79  base::TimeTicks TimeToSendNextRtcpReport();
80
81  // Send a RTCP sender report.
82  // |current_time| is the current time reported by a tick clock.
83  // |current_time_as_rtp_timestamp| is the corresponding RTP timestamp.
84  void SendRtcpFromRtpSender(base::TimeTicks current_time,
85                             uint32 current_time_as_rtp_timestamp);
86
87  // |cast_message| and |rtcp_events| is optional; if |cast_message| is
88  // provided the RTCP receiver report will append a Cast message containing
89  // Acks and Nacks; if |rtcp_events| is provided the RTCP receiver report
90  // will append the log messages.
91  void SendRtcpFromRtpReceiver(
92      const RtcpCastMessage* cast_message,
93      const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events);
94
95  void IncomingRtcpPacket(const uint8* rtcp_buffer, size_t length);
96
97  // TODO(miu): Clean up this method and downstream code: Only VideoSender uses
98  // this (for congestion control), and only the |rtt| and |avg_rtt| values, and
99  // it's not clear that any of the downstream code is doing the right thing
100  // with this data.
101  bool Rtt(base::TimeDelta* rtt,
102           base::TimeDelta* avg_rtt,
103           base::TimeDelta* min_rtt,
104           base::TimeDelta* max_rtt) const;
105
106  bool is_rtt_available() const { return number_of_rtt_in_avg_ > 0; }
107
108  // If available, returns true and sets the output arguments to the latest
109  // lip-sync timestamps gleaned from the sender reports.  While the sender
110  // provides reference NTP times relative to its own wall clock, the
111  // |reference_time| returned here has been translated to the local
112  // CastEnvironment clock.
113  bool GetLatestLipSyncTimes(uint32* rtp_timestamp,
114                             base::TimeTicks* reference_time) const;
115
116  // Set the history size to record Cast receiver events. The event history is
117  // used to remove duplicates. The history will store at most |size| events.
118  void SetCastReceiverEventHistorySize(size_t size);
119
120  // Update the target delay. Will be added to every report sent back to the
121  // sender.
122  // TODO(miu): Remove this deprecated functionality. The sender ignores this.
123  void SetTargetDelay(base::TimeDelta target_delay);
124
125  void OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log);
126
127 protected:
128  void OnReceivedNtp(uint32 ntp_seconds, uint32 ntp_fraction);
129  void OnReceivedLipSyncInfo(uint32 rtp_timestamp,
130                             uint32 ntp_seconds,
131                             uint32 ntp_fraction);
132
133 private:
134  friend class LocalRtcpRttFeedback;
135  friend class LocalRtcpReceiverFeedback;
136
137  void OnReceivedDelaySinceLastReport(uint32 receivers_ssrc,
138                                      uint32 last_report,
139                                      uint32 delay_since_last_report);
140
141  void OnReceivedSendReportRequest();
142
143  void UpdateRtt(const base::TimeDelta& sender_delay,
144                 const base::TimeDelta& receiver_delay);
145
146  void UpdateNextTimeToSendRtcp();
147
148  void SaveLastSentNtpTime(const base::TimeTicks& now,
149                           uint32 last_ntp_seconds,
150                           uint32 last_ntp_fraction);
151
152  scoped_refptr<CastEnvironment> cast_environment_;
153  CastTransportSender* const transport_sender_;
154  const base::TimeDelta rtcp_interval_;
155  const RtcpMode rtcp_mode_;
156  const uint32 local_ssrc_;
157  const uint32 remote_ssrc_;
158  const std::string c_name_;
159  const EventMediaType event_media_type_;
160
161  // Not owned by this class.
162  RtpReceiverStatistics* const rtp_receiver_statistics_;
163
164  scoped_ptr<LocalRtcpRttFeedback> rtt_feedback_;
165  scoped_ptr<LocalRtcpReceiverFeedback> receiver_feedback_;
166  scoped_ptr<RtcpSender> rtcp_sender_;
167  scoped_ptr<RtcpReceiver> rtcp_receiver_;
168
169  base::TimeTicks next_time_to_send_rtcp_;
170  RtcpSendTimeMap last_reports_sent_map_;
171  RtcpSendTimeQueue last_reports_sent_queue_;
172
173  // The truncated (i.e., 64-->32-bit) NTP timestamp provided in the last report
174  // from the remote peer, along with the local time at which the report was
175  // received.  These values are used for ping-pong'ing NTP timestamps between
176  // the peers so that they can estimate the network's round-trip time.
177  uint32 last_report_truncated_ntp_;
178  base::TimeTicks time_last_report_received_;
179
180  // Maintains a smoothed offset between the local clock and the remote clock.
181  // Calling this member's Current() method is only valid if
182  // |time_last_report_received_| is not "null."
183  ClockDriftSmoother local_clock_ahead_by_;
184
185  // Latest "lip sync" info from the sender.  The sender provides the RTP
186  // timestamp of some frame of its choosing and also a corresponding reference
187  // NTP timestamp sampled from a clock common to all media streams.  It is
188  // expected that the sender will update this data regularly and in a timely
189  // manner (e.g., about once per second).
190  uint32 lip_sync_rtp_timestamp_;
191  uint64 lip_sync_ntp_timestamp_;
192
193  base::TimeDelta rtt_;
194  base::TimeDelta min_rtt_;
195  base::TimeDelta max_rtt_;
196  int number_of_rtt_in_avg_;
197  base::TimeDelta avg_rtt_;
198  base::TimeDelta target_delay_;
199
200  DISALLOW_COPY_AND_ASSIGN(Rtcp);
201};
202
203}  // namespace cast
204}  // namespace media
205
206#endif  // MEDIA_CAST_RTCP_RTCP_H_
207