1/*
2 *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_
12#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_
13
14#include <map>
15#include <set>
16#include <sstream>
17#include <string>
18#include <vector>
19
20#include "webrtc/base/random.h"
21#include "webrtc/base/scoped_ptr.h"
22#include "webrtc/base/thread_annotations.h"
23#include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
24#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
25#include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
26#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
27#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
28#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
29#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
30#include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h"
31#include "webrtc/transport.h"
32#include "webrtc/typedefs.h"
33
34namespace webrtc {
35
36class ModuleRtpRtcpImpl;
37class RTCPReceiver;
38
39class NACKStringBuilder {
40 public:
41  NACKStringBuilder();
42  ~NACKStringBuilder();
43
44  void PushNACK(uint16_t nack);
45  std::string GetResult();
46
47 private:
48  std::ostringstream stream_;
49  int count_;
50  uint16_t prevNack_;
51  bool consecutive_;
52};
53
54class RTCPSender {
55 public:
56  struct FeedbackState {
57    FeedbackState();
58
59    uint8_t send_payload_type;
60    uint32_t frequency_hz;
61    uint32_t packets_sent;
62    size_t media_bytes_sent;
63    uint32_t send_bitrate;
64
65    uint32_t last_rr_ntp_secs;
66    uint32_t last_rr_ntp_frac;
67    uint32_t remote_sr;
68
69    bool has_last_xr_rr;
70    RtcpReceiveTimeInfo last_xr_rr;
71
72    // Used when generating TMMBR.
73    ModuleRtpRtcpImpl* module;
74  };
75
76  RTCPSender(bool audio,
77             Clock* clock,
78             ReceiveStatistics* receive_statistics,
79             RtcpPacketTypeCounterObserver* packet_type_counter_observer,
80             Transport* outgoing_transport);
81  virtual ~RTCPSender();
82
83  RtcpMode Status() const;
84  void SetRTCPStatus(RtcpMode method);
85
86  bool Sending() const;
87  int32_t SetSendingStatus(const FeedbackState& feedback_state,
88                           bool enabled);  // combine the functions
89
90  int32_t SetNackStatus(bool enable);
91
92  void SetStartTimestamp(uint32_t start_timestamp);
93
94  void SetLastRtpTime(uint32_t rtp_timestamp, int64_t capture_time_ms);
95
96  void SetSSRC(uint32_t ssrc);
97
98  void SetRemoteSSRC(uint32_t ssrc);
99
100  int32_t SetCNAME(const char* cName);
101
102  int32_t AddMixedCNAME(uint32_t SSRC, const char* c_name);
103
104  int32_t RemoveMixedCNAME(uint32_t SSRC);
105
106  int64_t SendTimeOfSendReport(uint32_t sendReport);
107
108  bool SendTimeOfXrRrReport(uint32_t mid_ntp, int64_t* time_ms) const;
109
110  bool TimeToSendRTCPReport(bool sendKeyframeBeforeRTP = false) const;
111
112  int32_t SendRTCP(const FeedbackState& feedback_state,
113                   RTCPPacketType packetType,
114                   int32_t nackSize = 0,
115                   const uint16_t* nackList = 0,
116                   bool repeat = false,
117                   uint64_t pictureID = 0);
118
119  int32_t SendCompoundRTCP(const FeedbackState& feedback_state,
120                           const std::set<RTCPPacketType>& packetTypes,
121                           int32_t nackSize = 0,
122                           const uint16_t* nackList = 0,
123                           bool repeat = false,
124                           uint64_t pictureID = 0);
125
126  bool REMB() const;
127
128  void SetREMBStatus(bool enable);
129
130  void SetREMBData(uint32_t bitrate, const std::vector<uint32_t>& ssrcs);
131
132  bool TMMBR() const;
133
134  void SetTMMBRStatus(bool enable);
135
136  int32_t SetTMMBN(const TMMBRSet* boundingSet, uint32_t maxBitrateKbit);
137
138  int32_t SetApplicationSpecificData(uint8_t subType,
139                                     uint32_t name,
140                                     const uint8_t* data,
141                                     uint16_t length);
142  int32_t SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric);
143
144  void SendRtcpXrReceiverReferenceTime(bool enable);
145
146  bool RtcpXrReceiverReferenceTime() const;
147
148  void SetCsrcs(const std::vector<uint32_t>& csrcs);
149
150  void SetTargetBitrate(unsigned int target_bitrate);
151  bool SendFeedbackPacket(const rtcp::TransportFeedback& packet);
152
153 private:
154  class RtcpContext;
155
156  // Determine which RTCP messages should be sent and setup flags.
157  void PrepareReport(const std::set<RTCPPacketType>& packetTypes,
158                     const FeedbackState& feedback_state)
159      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
160
161  bool AddReportBlock(const FeedbackState& feedback_state,
162                      uint32_t ssrc,
163                      StreamStatistician* statistician)
164      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
165
166  rtc::scoped_ptr<rtcp::RtcpPacket> BuildSR(const RtcpContext& context)
167      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
168  rtc::scoped_ptr<rtcp::RtcpPacket> BuildRR(const RtcpContext& context)
169      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
170  rtc::scoped_ptr<rtcp::RtcpPacket> BuildSDES(const RtcpContext& context)
171      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
172  rtc::scoped_ptr<rtcp::RtcpPacket> BuildPLI(const RtcpContext& context)
173      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
174  rtc::scoped_ptr<rtcp::RtcpPacket> BuildREMB(const RtcpContext& context)
175      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
176  rtc::scoped_ptr<rtcp::RtcpPacket> BuildTMMBR(const RtcpContext& context)
177      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
178  rtc::scoped_ptr<rtcp::RtcpPacket> BuildTMMBN(const RtcpContext& context)
179      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
180  rtc::scoped_ptr<rtcp::RtcpPacket> BuildAPP(const RtcpContext& context)
181      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
182  rtc::scoped_ptr<rtcp::RtcpPacket> BuildVoIPMetric(const RtcpContext& context)
183      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
184  rtc::scoped_ptr<rtcp::RtcpPacket> BuildBYE(const RtcpContext& context)
185      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
186  rtc::scoped_ptr<rtcp::RtcpPacket> BuildFIR(const RtcpContext& context)
187      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
188  rtc::scoped_ptr<rtcp::RtcpPacket> BuildSLI(const RtcpContext& context)
189      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
190  rtc::scoped_ptr<rtcp::RtcpPacket> BuildRPSI(const RtcpContext& context)
191      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
192  rtc::scoped_ptr<rtcp::RtcpPacket> BuildNACK(const RtcpContext& context)
193      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
194  rtc::scoped_ptr<rtcp::RtcpPacket> BuildReceiverReferenceTime(
195      const RtcpContext& context)
196      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
197  rtc::scoped_ptr<rtcp::RtcpPacket> BuildDlrr(const RtcpContext& context)
198      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
199
200 private:
201  const bool audio_;
202  Clock* const clock_;
203  Random random_ GUARDED_BY(critical_section_rtcp_sender_);
204  RtcpMode method_ GUARDED_BY(critical_section_rtcp_sender_);
205
206  Transport* const transport_;
207
208  rtc::scoped_ptr<CriticalSectionWrapper> critical_section_rtcp_sender_;
209  bool using_nack_ GUARDED_BY(critical_section_rtcp_sender_);
210  bool sending_ GUARDED_BY(critical_section_rtcp_sender_);
211  bool remb_enabled_ GUARDED_BY(critical_section_rtcp_sender_);
212
213  int64_t next_time_to_send_rtcp_ GUARDED_BY(critical_section_rtcp_sender_);
214
215  uint32_t start_timestamp_ GUARDED_BY(critical_section_rtcp_sender_);
216  uint32_t last_rtp_timestamp_ GUARDED_BY(critical_section_rtcp_sender_);
217  int64_t last_frame_capture_time_ms_ GUARDED_BY(critical_section_rtcp_sender_);
218  uint32_t ssrc_ GUARDED_BY(critical_section_rtcp_sender_);
219  // SSRC that we receive on our RTP channel
220  uint32_t remote_ssrc_ GUARDED_BY(critical_section_rtcp_sender_);
221  std::string cname_ GUARDED_BY(critical_section_rtcp_sender_);
222
223  ReceiveStatistics* receive_statistics_
224      GUARDED_BY(critical_section_rtcp_sender_);
225  std::map<uint32_t, rtcp::ReportBlock> report_blocks_
226      GUARDED_BY(critical_section_rtcp_sender_);
227  std::map<uint32_t, std::string> csrc_cnames_
228      GUARDED_BY(critical_section_rtcp_sender_);
229
230  // Sent
231  uint32_t last_send_report_[RTCP_NUMBER_OF_SR] GUARDED_BY(
232      critical_section_rtcp_sender_);  // allow packet loss and RTT above 1 sec
233  int64_t last_rtcp_time_[RTCP_NUMBER_OF_SR] GUARDED_BY(
234      critical_section_rtcp_sender_);
235
236  // Sent XR receiver reference time report.
237  // <mid ntp (mid 32 bits of the 64 bits NTP timestamp), send time in ms>.
238  std::map<uint32_t, int64_t> last_xr_rr_
239      GUARDED_BY(critical_section_rtcp_sender_);
240
241  // send CSRCs
242  std::vector<uint32_t> csrcs_ GUARDED_BY(critical_section_rtcp_sender_);
243
244  // Full intra request
245  uint8_t sequence_number_fir_ GUARDED_BY(critical_section_rtcp_sender_);
246
247  // REMB
248  uint32_t remb_bitrate_ GUARDED_BY(critical_section_rtcp_sender_);
249  std::vector<uint32_t> remb_ssrcs_ GUARDED_BY(critical_section_rtcp_sender_);
250
251  TMMBRHelp tmmbr_help_ GUARDED_BY(critical_section_rtcp_sender_);
252  uint32_t tmmbr_send_ GUARDED_BY(critical_section_rtcp_sender_);
253  uint32_t packet_oh_send_ GUARDED_BY(critical_section_rtcp_sender_);
254
255  // APP
256  uint8_t app_sub_type_ GUARDED_BY(critical_section_rtcp_sender_);
257  uint32_t app_name_ GUARDED_BY(critical_section_rtcp_sender_);
258  rtc::scoped_ptr<uint8_t[]> app_data_
259      GUARDED_BY(critical_section_rtcp_sender_);
260  uint16_t app_length_ GUARDED_BY(critical_section_rtcp_sender_);
261
262  // True if sending of XR Receiver reference time report is enabled.
263  bool xr_send_receiver_reference_time_enabled_
264      GUARDED_BY(critical_section_rtcp_sender_);
265
266  // XR VoIP metric
267  RTCPVoIPMetric xr_voip_metric_ GUARDED_BY(critical_section_rtcp_sender_);
268
269  RtcpPacketTypeCounterObserver* const packet_type_counter_observer_;
270  RtcpPacketTypeCounter packet_type_counter_
271      GUARDED_BY(critical_section_rtcp_sender_);
272
273  RTCPUtility::NackStats nack_stats_ GUARDED_BY(critical_section_rtcp_sender_);
274
275  void SetFlag(RTCPPacketType type, bool is_volatile)
276      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
277  void SetFlags(const std::set<RTCPPacketType>& types, bool is_volatile)
278      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
279  bool IsFlagPresent(RTCPPacketType type) const
280      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
281  bool ConsumeFlag(RTCPPacketType type, bool forced = false)
282      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
283  bool AllVolatileFlagsConsumed() const
284      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
285  struct ReportFlag {
286    ReportFlag(RTCPPacketType type, bool is_volatile)
287        : type(type), is_volatile(is_volatile) {}
288    bool operator<(const ReportFlag& flag) const { return type < flag.type; }
289    bool operator==(const ReportFlag& flag) const { return type == flag.type; }
290    const RTCPPacketType type;
291    const bool is_volatile;
292  };
293
294  std::set<ReportFlag> report_flags_ GUARDED_BY(critical_section_rtcp_sender_);
295
296  typedef rtc::scoped_ptr<rtcp::RtcpPacket> (RTCPSender::*BuilderFunc)(
297      const RtcpContext&);
298  std::map<RTCPPacketType, BuilderFunc> builders_;
299};
300}  // namespace webrtc
301
302#endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_
303