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 <sstream>
16#include <string>
17
18#include "webrtc/base/thread_annotations.h"
19#include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
20#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
21#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
22#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
23#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
24#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
25#include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h"
26#include "webrtc/system_wrappers/interface/scoped_ptr.h"
27#include "webrtc/typedefs.h"
28
29namespace webrtc {
30
31class ModuleRtpRtcpImpl;
32class RTCPReceiver;
33
34class NACKStringBuilder
35{
36public:
37    NACKStringBuilder();
38    ~NACKStringBuilder();
39
40    void PushNACK(uint16_t nack);
41    std::string GetResult();
42
43private:
44    std::ostringstream _stream;
45    int _count;
46    uint16_t _prevNack;
47    bool _consecutive;
48};
49
50class RTCPSender
51{
52public:
53 struct FeedbackState {
54   FeedbackState();
55
56   uint8_t send_payload_type;
57   uint32_t frequency_hz;
58   uint32_t packets_sent;
59   uint32_t media_bytes_sent;
60   uint32_t send_bitrate;
61
62   uint32_t last_rr_ntp_secs;
63   uint32_t last_rr_ntp_frac;
64   uint32_t remote_sr;
65
66   bool has_last_xr_rr;
67   RtcpReceiveTimeInfo last_xr_rr;
68
69   // Used when generating TMMBR.
70   ModuleRtpRtcpImpl* module;
71 };
72    RTCPSender(const int32_t id, const bool audio,
73               Clock* clock,
74               ReceiveStatistics* receive_statistics);
75    virtual ~RTCPSender();
76
77    int32_t RegisterSendTransport(Transport* outgoingTransport);
78
79    RTCPMethod Status() const;
80    int32_t SetRTCPStatus(const RTCPMethod method);
81
82    bool Sending() const;
83    int32_t SetSendingStatus(const FeedbackState& feedback_state,
84                             bool enabled);  // combine the functions
85
86    int32_t SetNackStatus(const bool enable);
87
88    void SetStartTimestamp(uint32_t start_timestamp);
89
90    void SetLastRtpTime(uint32_t rtp_timestamp,
91                        int64_t capture_time_ms);
92
93    void SetSSRC( const uint32_t ssrc);
94
95    void SetRemoteSSRC(uint32_t ssrc);
96
97    int32_t SetCameraDelay(const int32_t delayMS);
98
99    int32_t SetCNAME(const char cName[RTCP_CNAME_SIZE]);
100
101    int32_t AddMixedCNAME(const uint32_t SSRC,
102                          const char cName[RTCP_CNAME_SIZE]);
103
104    int32_t RemoveMixedCNAME(const uint32_t SSRC);
105
106    uint32_t SendTimeOfSendReport(const uint32_t sendReport);
107
108    bool SendTimeOfXrRrReport(uint32_t mid_ntp, int64_t* time_ms) const;
109
110    bool TimeToSendRTCPReport(const bool sendKeyframeBeforeRTP = false) const;
111
112    uint32_t LastSendReport(uint32_t& lastRTCPTime);
113
114    int32_t SendRTCP(
115        const FeedbackState& feedback_state,
116        uint32_t rtcpPacketTypeFlags,
117        int32_t nackSize = 0,
118        const uint16_t* nackList = 0,
119        bool repeat = false,
120        uint64_t pictureID = 0);
121
122    int32_t AddExternalReportBlock(
123            uint32_t SSRC,
124            const RTCPReportBlock* receiveBlock);
125
126    int32_t RemoveExternalReportBlock(uint32_t SSRC);
127
128    /*
129    *  REMB
130    */
131    bool REMB() const;
132
133    int32_t SetREMBStatus(const bool enable);
134
135    int32_t SetREMBData(const uint32_t bitrate,
136                        const uint8_t numberOfSSRC,
137                        const uint32_t* SSRC);
138
139    /*
140    *   TMMBR
141    */
142    bool TMMBR() const;
143
144    int32_t SetTMMBRStatus(const bool enable);
145
146    int32_t SetTMMBN(const TMMBRSet* boundingSet,
147                     const uint32_t maxBitrateKbit);
148
149    /*
150    *   Extended jitter report
151    */
152    bool IJ() const;
153
154    int32_t SetIJStatus(const bool enable);
155
156    /*
157    *
158    */
159
160    int32_t SetApplicationSpecificData(const uint8_t subType,
161                                       const uint32_t name,
162                                       const uint8_t* data,
163                                       const uint16_t length);
164
165    int32_t SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric);
166
167    void SendRtcpXrReceiverReferenceTime(bool enable);
168
169    bool RtcpXrReceiverReferenceTime() const;
170
171    int32_t SetCSRCs(const uint32_t arrOfCSRC[kRtpCsrcSize],
172                     const uint8_t arrLength);
173
174    int32_t SetCSRCStatus(const bool include);
175
176    void SetTargetBitrate(unsigned int target_bitrate);
177
178    void GetPacketTypeCounter(RtcpPacketTypeCounter* packet_counter) const;
179
180private:
181    int32_t SendToNetwork(const uint8_t* dataBuffer, const uint16_t length);
182
183    int32_t WriteAllReportBlocksToBuffer(uint8_t* rtcpbuffer,
184                            int pos,
185                            uint8_t& numberOfReportBlocks,
186                            const uint32_t NTPsec,
187                            const uint32_t NTPfrac)
188        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
189
190    int32_t WriteReportBlocksToBuffer(
191        uint8_t* rtcpbuffer,
192        int32_t position,
193        const std::map<uint32_t, RTCPReportBlock*>& report_blocks);
194
195    int32_t AddReportBlock(
196        uint32_t SSRC,
197        std::map<uint32_t, RTCPReportBlock*>* report_blocks,
198        const RTCPReportBlock* receiveBlock);
199
200    bool PrepareReport(const FeedbackState& feedback_state,
201                       StreamStatistician* statistician,
202                       RTCPReportBlock* report_block,
203                       uint32_t* ntp_secs, uint32_t* ntp_frac);
204
205    int32_t BuildSR(const FeedbackState& feedback_state,
206                    uint8_t* rtcpbuffer,
207                    int& pos,
208                    uint32_t NTPsec,
209                    uint32_t NTPfrac)
210        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
211
212    int32_t BuildRR(uint8_t* rtcpbuffer,
213                    int& pos,
214                    const uint32_t NTPsec,
215                    const uint32_t NTPfrac)
216        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
217
218    int PrepareRTCP(
219        const FeedbackState& feedback_state,
220        uint32_t packetTypeFlags,
221        int32_t nackSize,
222        const uint16_t* nackList,
223        bool repeat,
224        uint64_t pictureID,
225        uint8_t* rtcp_buffer,
226        int buffer_size);
227
228    bool ShouldSendReportBlocks(uint32_t rtcp_packet_type) const;
229
230    int32_t BuildExtendedJitterReport(
231        uint8_t* rtcpbuffer,
232        int& pos,
233        const uint32_t jitterTransmissionTimeOffset)
234        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
235
236    int32_t BuildSDEC(uint8_t* rtcpbuffer, int& pos)
237        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
238    int32_t BuildPLI(uint8_t* rtcpbuffer, int& pos)
239        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
240    int32_t BuildREMB(uint8_t* rtcpbuffer, int& pos)
241        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
242    int32_t BuildTMMBR(ModuleRtpRtcpImpl* module, uint8_t* rtcpbuffer, int& pos)
243        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
244    int32_t BuildTMMBN(uint8_t* rtcpbuffer, int& pos)
245        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
246    int32_t BuildAPP(uint8_t* rtcpbuffer, int& pos)
247        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
248    int32_t BuildVoIPMetric(uint8_t* rtcpbuffer, int& pos)
249        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
250    int32_t BuildBYE(uint8_t* rtcpbuffer, int& pos)
251        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
252    int32_t BuildFIR(uint8_t* rtcpbuffer, int& pos, bool repeat)
253        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
254    int32_t BuildSLI(uint8_t* rtcpbuffer, int& pos, const uint8_t pictureID)
255        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
256    int32_t BuildRPSI(uint8_t* rtcpbuffer,
257                      int& pos,
258                      const uint64_t pictureID,
259                      const uint8_t payloadType)
260        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
261
262    int32_t BuildNACK(uint8_t* rtcpbuffer,
263                      int& pos,
264                      const int32_t nackSize,
265                      const uint16_t* nackList,
266                      std::string* nackString)
267        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
268    int32_t BuildReceiverReferenceTime(uint8_t* buffer,
269                                       int& pos,
270                                       uint32_t ntp_sec,
271                                       uint32_t ntp_frac)
272        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
273    int32_t BuildDlrr(uint8_t* buffer,
274                      int& pos,
275                      const RtcpReceiveTimeInfo& info)
276        EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
277
278private:
279    const int32_t            _id;
280    const bool               _audio;
281    Clock* const             _clock;
282    RTCPMethod               _method GUARDED_BY(_criticalSectionRTCPSender);
283
284    CriticalSectionWrapper* _criticalSectionTransport;
285    Transport*              _cbTransport GUARDED_BY(_criticalSectionTransport);
286
287    CriticalSectionWrapper* _criticalSectionRTCPSender;
288    bool                    _usingNack GUARDED_BY(_criticalSectionRTCPSender);
289    bool                    _sending GUARDED_BY(_criticalSectionRTCPSender);
290    bool                    _sendTMMBN GUARDED_BY(_criticalSectionRTCPSender);
291    bool                    _REMB GUARDED_BY(_criticalSectionRTCPSender);
292    bool                    _sendREMB GUARDED_BY(_criticalSectionRTCPSender);
293    bool                    _TMMBR GUARDED_BY(_criticalSectionRTCPSender);
294    bool                    _IJ GUARDED_BY(_criticalSectionRTCPSender);
295
296    int64_t        _nextTimeToSendRTCP GUARDED_BY(_criticalSectionRTCPSender);
297
298    uint32_t start_timestamp_ GUARDED_BY(_criticalSectionRTCPSender);
299    uint32_t last_rtp_timestamp_ GUARDED_BY(_criticalSectionRTCPSender);
300    int64_t last_frame_capture_time_ms_ GUARDED_BY(_criticalSectionRTCPSender);
301    uint32_t _SSRC GUARDED_BY(_criticalSectionRTCPSender);
302    // SSRC that we receive on our RTP channel
303    uint32_t _remoteSSRC GUARDED_BY(_criticalSectionRTCPSender);
304    char _CNAME[RTCP_CNAME_SIZE] GUARDED_BY(_criticalSectionRTCPSender);
305
306    ReceiveStatistics* receive_statistics_
307        GUARDED_BY(_criticalSectionRTCPSender);
308    std::map<uint32_t, RTCPReportBlock*> internal_report_blocks_
309        GUARDED_BY(_criticalSectionRTCPSender);
310    std::map<uint32_t, RTCPReportBlock*> external_report_blocks_
311        GUARDED_BY(_criticalSectionRTCPSender);
312    std::map<uint32_t, RTCPUtility::RTCPCnameInformation*> _csrcCNAMEs
313        GUARDED_BY(_criticalSectionRTCPSender);
314
315    int32_t         _cameraDelayMS GUARDED_BY(_criticalSectionRTCPSender);
316
317    // Sent
318    uint32_t _lastSendReport[RTCP_NUMBER_OF_SR] GUARDED_BY(
319        _criticalSectionRTCPSender);  // allow packet loss and RTT above 1 sec
320    uint32_t _lastRTCPTime[RTCP_NUMBER_OF_SR] GUARDED_BY(
321        _criticalSectionRTCPSender);
322
323    // Sent XR receiver reference time report.
324    // <mid ntp (mid 32 bits of the 64 bits NTP timestamp), send time in ms>.
325    std::map<uint32_t, int64_t> last_xr_rr_
326        GUARDED_BY(_criticalSectionRTCPSender);
327
328    // send CSRCs
329    uint8_t         _CSRCs GUARDED_BY(_criticalSectionRTCPSender);
330    uint32_t        _CSRC[kRtpCsrcSize] GUARDED_BY(_criticalSectionRTCPSender);
331    bool                _includeCSRCs GUARDED_BY(_criticalSectionRTCPSender);
332
333    // Full intra request
334    uint8_t         _sequenceNumberFIR GUARDED_BY(_criticalSectionRTCPSender);
335
336    // REMB
337    uint8_t       _lengthRembSSRC GUARDED_BY(_criticalSectionRTCPSender);
338    uint8_t       _sizeRembSSRC GUARDED_BY(_criticalSectionRTCPSender);
339    uint32_t*     _rembSSRC GUARDED_BY(_criticalSectionRTCPSender);
340    uint32_t      _rembBitrate GUARDED_BY(_criticalSectionRTCPSender);
341
342    TMMBRHelp           _tmmbrHelp GUARDED_BY(_criticalSectionRTCPSender);
343    uint32_t      _tmmbr_Send GUARDED_BY(_criticalSectionRTCPSender);
344    uint32_t      _packetOH_Send GUARDED_BY(_criticalSectionRTCPSender);
345
346    // APP
347    bool                 _appSend GUARDED_BY(_criticalSectionRTCPSender);
348    uint8_t        _appSubType GUARDED_BY(_criticalSectionRTCPSender);
349    uint32_t       _appName GUARDED_BY(_criticalSectionRTCPSender);
350    uint8_t*       _appData GUARDED_BY(_criticalSectionRTCPSender);
351    uint16_t       _appLength GUARDED_BY(_criticalSectionRTCPSender);
352
353    // True if sending of XR Receiver reference time report is enabled.
354    bool xrSendReceiverReferenceTimeEnabled_
355        GUARDED_BY(_criticalSectionRTCPSender);
356
357    // XR VoIP metric
358    bool _xrSendVoIPMetric GUARDED_BY(_criticalSectionRTCPSender);
359    RTCPVoIPMetric _xrVoIPMetric GUARDED_BY(_criticalSectionRTCPSender);
360
361    RtcpPacketTypeCounter packet_type_counter_
362        GUARDED_BY(_criticalSectionRTCPSender);
363};
364}  // namespace webrtc
365
366#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_
367