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_RTP_SENDER_H_
12#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_SENDER_H_
13
14#include <list>
15#include <map>
16#include <utility>
17#include <vector>
18
19#include "webrtc/base/random.h"
20#include "webrtc/base/thread_annotations.h"
21#include "webrtc/common_types.h"
22#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
23#include "webrtc/modules/rtp_rtcp/source/bitrate.h"
24#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
25#include "webrtc/modules/rtp_rtcp/source/rtp_packet_history.h"
26#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h"
27#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
28#include "webrtc/modules/rtp_rtcp/source/ssrc_database.h"
29#include "webrtc/transport.h"
30
31namespace webrtc {
32
33class BitrateAggregator;
34class CriticalSectionWrapper;
35class RTPSenderAudio;
36class RTPSenderVideo;
37
38class RTPSenderInterface {
39 public:
40  RTPSenderInterface() {}
41  virtual ~RTPSenderInterface() {}
42
43  enum CVOMode {
44    kCVONone,
45    kCVOInactive,  // CVO rtp header extension is registered but haven't
46                   // received any frame with rotation pending.
47    kCVOActivated,  // CVO rtp header extension will be present in the rtp
48                    // packets.
49  };
50
51  virtual uint32_t SSRC() const = 0;
52  virtual uint32_t Timestamp() const = 0;
53
54  virtual int32_t BuildRTPheader(uint8_t* data_buffer,
55                                 int8_t payload_type,
56                                 bool marker_bit,
57                                 uint32_t capture_timestamp,
58                                 int64_t capture_time_ms,
59                                 bool timestamp_provided = true,
60                                 bool inc_sequence_number = true) = 0;
61
62  virtual size_t RTPHeaderLength() const = 0;
63  // Returns the next sequence number to use for a packet and allocates
64  // 'packets_to_send' number of sequence numbers. It's important all allocated
65  // sequence numbers are used in sequence to avoid perceived packet loss.
66  virtual uint16_t AllocateSequenceNumber(uint16_t packets_to_send) = 0;
67  virtual uint16_t SequenceNumber() const = 0;
68  virtual size_t MaxPayloadLength() const = 0;
69  virtual size_t MaxDataPayloadLength() const = 0;
70  virtual uint16_t PacketOverHead() const = 0;
71  virtual uint16_t ActualSendBitrateKbit() const = 0;
72
73  virtual int32_t SendToNetwork(uint8_t* data_buffer,
74                                size_t payload_length,
75                                size_t rtp_header_length,
76                                int64_t capture_time_ms,
77                                StorageType storage,
78                                RtpPacketSender::Priority priority) = 0;
79
80  virtual bool UpdateVideoRotation(uint8_t* rtp_packet,
81                                   size_t rtp_packet_length,
82                                   const RTPHeader& rtp_header,
83                                   VideoRotation rotation) const = 0;
84  virtual bool IsRtpHeaderExtensionRegistered(RTPExtensionType type) = 0;
85  virtual CVOMode ActivateCVORtpHeaderExtension() = 0;
86};
87
88class RTPSender : public RTPSenderInterface {
89 public:
90  RTPSender(bool audio,
91            Clock* clock,
92            Transport* transport,
93            RtpAudioFeedback* audio_feedback,
94            RtpPacketSender* paced_sender,
95            TransportSequenceNumberAllocator* sequence_number_allocator,
96            TransportFeedbackObserver* transport_feedback_callback,
97            BitrateStatisticsObserver* bitrate_callback,
98            FrameCountObserver* frame_count_observer,
99            SendSideDelayObserver* send_side_delay_observer);
100  virtual ~RTPSender();
101
102  void ProcessBitrate();
103
104  uint16_t ActualSendBitrateKbit() const override;
105
106  uint32_t VideoBitrateSent() const;
107  uint32_t FecOverheadRate() const;
108  uint32_t NackOverheadRate() const;
109
110  void SetTargetBitrate(uint32_t bitrate);
111  uint32_t GetTargetBitrate();
112
113  // Includes size of RTP and FEC headers.
114  size_t MaxDataPayloadLength() const override;
115
116  int32_t RegisterPayload(
117      const char payload_name[RTP_PAYLOAD_NAME_SIZE],
118      const int8_t payload_type, const uint32_t frequency,
119      const size_t channels, const uint32_t rate);
120
121  int32_t DeRegisterSendPayload(const int8_t payload_type);
122
123  void SetSendPayloadType(int8_t payload_type);
124
125  int8_t SendPayloadType() const;
126
127  int SendPayloadFrequency() const;
128
129  void SetSendingStatus(bool enabled);
130
131  void SetSendingMediaStatus(bool enabled);
132  bool SendingMedia() const;
133
134  void GetDataCounters(StreamDataCounters* rtp_stats,
135                       StreamDataCounters* rtx_stats) const;
136
137  uint32_t StartTimestamp() const;
138  void SetStartTimestamp(uint32_t timestamp, bool force);
139
140  uint32_t GenerateNewSSRC();
141  void SetSSRC(uint32_t ssrc);
142
143  uint16_t SequenceNumber() const override;
144  void SetSequenceNumber(uint16_t seq);
145
146  void SetCsrcs(const std::vector<uint32_t>& csrcs);
147
148  int32_t SetMaxPayloadLength(size_t length, uint16_t packet_over_head);
149
150  int32_t SendOutgoingData(FrameType frame_type,
151                           int8_t payload_type,
152                           uint32_t timestamp,
153                           int64_t capture_time_ms,
154                           const uint8_t* payload_data,
155                           size_t payload_size,
156                           const RTPFragmentationHeader* fragmentation,
157                           const RTPVideoHeader* rtp_hdr = NULL);
158
159  // RTP header extension
160  int32_t SetTransmissionTimeOffset(int32_t transmission_time_offset);
161  int32_t SetAbsoluteSendTime(uint32_t absolute_send_time);
162  void SetVideoRotation(VideoRotation rotation);
163  int32_t SetTransportSequenceNumber(uint16_t sequence_number);
164
165  int32_t RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id);
166  bool IsRtpHeaderExtensionRegistered(RTPExtensionType type) override;
167  int32_t DeregisterRtpHeaderExtension(RTPExtensionType type);
168
169  size_t RtpHeaderExtensionTotalLength() const;
170
171  uint16_t BuildRTPHeaderExtension(uint8_t* data_buffer, bool marker_bit) const;
172
173  uint8_t BuildTransmissionTimeOffsetExtension(uint8_t *data_buffer) const;
174  uint8_t BuildAudioLevelExtension(uint8_t* data_buffer) const;
175  uint8_t BuildAbsoluteSendTimeExtension(uint8_t* data_buffer) const;
176  uint8_t BuildVideoRotationExtension(uint8_t* data_buffer) const;
177  uint8_t BuildTransportSequenceNumberExtension(uint8_t* data_buffer,
178                                                uint16_t sequence_number) const;
179
180  // Verifies that the specified extension is registered, and that it is
181  // present in rtp packet. If extension is not registered kNotRegistered is
182  // returned. If extension cannot be found in the rtp header, or if it is
183  // malformed, kError is returned. Otherwise *extension_offset is set to the
184  // offset of the extension from the beginning of the rtp packet and kOk is
185  // returned.
186  enum class ExtensionStatus {
187    kNotRegistered,
188    kOk,
189    kError,
190  };
191  ExtensionStatus VerifyExtension(RTPExtensionType extension_type,
192                                  uint8_t* rtp_packet,
193                                  size_t rtp_packet_length,
194                                  const RTPHeader& rtp_header,
195                                  size_t extension_length_bytes,
196                                  size_t* extension_offset) const
197      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_.get());
198
199  bool UpdateAudioLevel(uint8_t* rtp_packet,
200                        size_t rtp_packet_length,
201                        const RTPHeader& rtp_header,
202                        bool is_voiced,
203                        uint8_t dBov) const;
204
205  bool UpdateVideoRotation(uint8_t* rtp_packet,
206                           size_t rtp_packet_length,
207                           const RTPHeader& rtp_header,
208                           VideoRotation rotation) const override;
209
210  bool TimeToSendPacket(uint16_t sequence_number, int64_t capture_time_ms,
211                        bool retransmission);
212  size_t TimeToSendPadding(size_t bytes);
213
214  // NACK.
215  int SelectiveRetransmissions() const;
216  int SetSelectiveRetransmissions(uint8_t settings);
217  void OnReceivedNACK(const std::list<uint16_t>& nack_sequence_numbers,
218                      int64_t avg_rtt);
219
220  void SetStorePacketsStatus(bool enable, uint16_t number_to_store);
221
222  bool StorePackets() const;
223
224  int32_t ReSendPacket(uint16_t packet_id, int64_t min_resend_time = 0);
225
226  bool ProcessNACKBitRate(uint32_t now);
227
228  // RTX.
229  void SetRtxStatus(int mode);
230  int RtxStatus() const;
231
232  uint32_t RtxSsrc() const;
233  void SetRtxSsrc(uint32_t ssrc);
234
235  void SetRtxPayloadType(int payload_type, int associated_payload_type);
236  std::pair<int, int> RtxPayloadType() const;
237
238  // Functions wrapping RTPSenderInterface.
239  int32_t BuildRTPheader(uint8_t* data_buffer,
240                         int8_t payload_type,
241                         bool marker_bit,
242                         uint32_t capture_timestamp,
243                         int64_t capture_time_ms,
244                         const bool timestamp_provided = true,
245                         const bool inc_sequence_number = true) override;
246
247  size_t RTPHeaderLength() const override;
248  uint16_t AllocateSequenceNumber(uint16_t packets_to_send) override;
249  size_t MaxPayloadLength() const override;
250  uint16_t PacketOverHead() const override;
251
252  // Current timestamp.
253  uint32_t Timestamp() const override;
254  uint32_t SSRC() const override;
255
256  int32_t SendToNetwork(uint8_t* data_buffer,
257                        size_t payload_length,
258                        size_t rtp_header_length,
259                        int64_t capture_time_ms,
260                        StorageType storage,
261                        RtpPacketSender::Priority priority) override;
262
263  // Audio.
264
265  // Send a DTMF tone using RFC 2833 (4733).
266  int32_t SendTelephoneEvent(uint8_t key, uint16_t time_ms, uint8_t level);
267
268  // Set audio packet size, used to determine when it's time to send a DTMF
269  // packet in silence (CNG).
270  int32_t SetAudioPacketSize(uint16_t packet_size_samples);
271
272  // Store the audio level in d_bov for
273  // header-extension-for-audio-level-indication.
274  int32_t SetAudioLevel(uint8_t level_d_bov);
275
276  // Set payload type for Redundant Audio Data RFC 2198.
277  int32_t SetRED(int8_t payload_type);
278
279  // Get payload type for Redundant Audio Data RFC 2198.
280  int32_t RED(int8_t *payload_type) const;
281
282  RtpVideoCodecTypes VideoCodecType() const;
283
284  uint32_t MaxConfiguredBitrateVideo() const;
285
286  // FEC.
287  void SetGenericFECStatus(bool enable,
288                           uint8_t payload_type_red,
289                           uint8_t payload_type_fec);
290
291  void GenericFECStatus(bool* enable,
292                        uint8_t* payload_type_red,
293                        uint8_t* payload_type_fec) const;
294
295  int32_t SetFecParameters(const FecProtectionParams *delta_params,
296                           const FecProtectionParams *key_params);
297
298  size_t SendPadData(size_t bytes,
299                     bool timestamp_provided,
300                     uint32_t timestamp,
301                     int64_t capture_time_ms);
302
303  // Called on update of RTP statistics.
304  void RegisterRtpStatisticsCallback(StreamDataCountersCallback* callback);
305  StreamDataCountersCallback* GetRtpStatisticsCallback() const;
306
307  uint32_t BitrateSent() const;
308
309  void SetRtpState(const RtpState& rtp_state);
310  RtpState GetRtpState() const;
311  void SetRtxRtpState(const RtpState& rtp_state);
312  RtpState GetRtxRtpState() const;
313  CVOMode ActivateCVORtpHeaderExtension() override;
314
315 protected:
316  int32_t CheckPayloadType(int8_t payload_type, RtpVideoCodecTypes* video_type);
317
318 private:
319  // Maps capture time in milliseconds to send-side delay in milliseconds.
320  // Send-side delay is the difference between transmission time and capture
321  // time.
322  typedef std::map<int64_t, int> SendDelayMap;
323
324  size_t CreateRtpHeader(uint8_t* header,
325                         int8_t payload_type,
326                         uint32_t ssrc,
327                         bool marker_bit,
328                         uint32_t timestamp,
329                         uint16_t sequence_number,
330                         const std::vector<uint32_t>& csrcs) const;
331
332  void UpdateNACKBitRate(uint32_t bytes, int64_t now);
333
334  bool PrepareAndSendPacket(uint8_t* buffer,
335                            size_t length,
336                            int64_t capture_time_ms,
337                            bool send_over_rtx,
338                            bool is_retransmit);
339
340  // Return the number of bytes sent.  Note that both of these functions may
341  // return a larger value that their argument.
342  size_t TrySendRedundantPayloads(size_t bytes);
343
344  void BuildPaddingPacket(uint8_t* packet,
345                          size_t header_length,
346                          size_t padding_length);
347
348  void BuildRtxPacket(uint8_t* buffer, size_t* length,
349                      uint8_t* buffer_rtx);
350
351  bool SendPacketToNetwork(const uint8_t* packet,
352                           size_t size,
353                           const PacketOptions& options);
354
355  void UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms);
356
357  // Find the byte position of the RTP extension as indicated by |type| in
358  // |rtp_packet|. Return false if such extension doesn't exist.
359  bool FindHeaderExtensionPosition(RTPExtensionType type,
360                                   const uint8_t* rtp_packet,
361                                   size_t rtp_packet_length,
362                                   const RTPHeader& rtp_header,
363                                   size_t* position) const;
364
365  void UpdateTransmissionTimeOffset(uint8_t* rtp_packet,
366                                    size_t rtp_packet_length,
367                                    const RTPHeader& rtp_header,
368                                    int64_t time_diff_ms) const;
369  void UpdateAbsoluteSendTime(uint8_t* rtp_packet,
370                              size_t rtp_packet_length,
371                              const RTPHeader& rtp_header,
372                              int64_t now_ms) const;
373  // Update the transport sequence number of the packet using a new sequence
374  // number allocated by SequenceNumberAllocator. Returns the assigned sequence
375  // number, or 0 if extension could not be updated.
376  uint16_t UpdateTransportSequenceNumber(uint8_t* rtp_packet,
377                                         size_t rtp_packet_length,
378                                         const RTPHeader& rtp_header) const;
379
380  void UpdateRtpStats(const uint8_t* buffer,
381                      size_t packet_length,
382                      const RTPHeader& header,
383                      bool is_rtx,
384                      bool is_retransmit);
385  bool IsFecPacket(const uint8_t* buffer, const RTPHeader& header) const;
386
387  Clock* clock_;
388  int64_t clock_delta_ms_;
389  Random random_ GUARDED_BY(send_critsect_);
390
391  rtc::scoped_ptr<BitrateAggregator> bitrates_;
392  Bitrate total_bitrate_sent_;
393
394  const bool audio_configured_;
395  rtc::scoped_ptr<RTPSenderAudio> audio_;
396  rtc::scoped_ptr<RTPSenderVideo> video_;
397
398  RtpPacketSender* const paced_sender_;
399  TransportSequenceNumberAllocator* const transport_sequence_number_allocator_;
400  TransportFeedbackObserver* const transport_feedback_observer_;
401  int64_t last_capture_time_ms_sent_;
402  rtc::scoped_ptr<CriticalSectionWrapper> send_critsect_;
403
404  Transport *transport_;
405  bool sending_media_ GUARDED_BY(send_critsect_);
406
407  size_t max_payload_length_;
408  uint16_t packet_over_head_;
409
410  int8_t payload_type_ GUARDED_BY(send_critsect_);
411  std::map<int8_t, RtpUtility::Payload*> payload_type_map_;
412
413  RtpHeaderExtensionMap rtp_header_extension_map_;
414  int32_t transmission_time_offset_;
415  uint32_t absolute_send_time_;
416  VideoRotation rotation_;
417  CVOMode cvo_mode_;
418  uint16_t transport_sequence_number_;
419
420  // NACK
421  uint32_t nack_byte_count_times_[NACK_BYTECOUNT_SIZE];
422  size_t nack_byte_count_[NACK_BYTECOUNT_SIZE];
423  Bitrate nack_bitrate_;
424
425  RTPPacketHistory packet_history_;
426
427  // Statistics
428  rtc::scoped_ptr<CriticalSectionWrapper> statistics_crit_;
429  SendDelayMap send_delays_ GUARDED_BY(statistics_crit_);
430  FrameCounts frame_counts_ GUARDED_BY(statistics_crit_);
431  StreamDataCounters rtp_stats_ GUARDED_BY(statistics_crit_);
432  StreamDataCounters rtx_rtp_stats_ GUARDED_BY(statistics_crit_);
433  StreamDataCountersCallback* rtp_stats_callback_ GUARDED_BY(statistics_crit_);
434  FrameCountObserver* const frame_count_observer_;
435  SendSideDelayObserver* const send_side_delay_observer_;
436
437  // RTP variables
438  bool start_timestamp_forced_ GUARDED_BY(send_critsect_);
439  uint32_t start_timestamp_ GUARDED_BY(send_critsect_);
440  SSRCDatabase& ssrc_db_ GUARDED_BY(send_critsect_);
441  uint32_t remote_ssrc_ GUARDED_BY(send_critsect_);
442  bool sequence_number_forced_ GUARDED_BY(send_critsect_);
443  uint16_t sequence_number_ GUARDED_BY(send_critsect_);
444  uint16_t sequence_number_rtx_ GUARDED_BY(send_critsect_);
445  bool ssrc_forced_ GUARDED_BY(send_critsect_);
446  uint32_t ssrc_ GUARDED_BY(send_critsect_);
447  uint32_t timestamp_ GUARDED_BY(send_critsect_);
448  int64_t capture_time_ms_ GUARDED_BY(send_critsect_);
449  int64_t last_timestamp_time_ms_ GUARDED_BY(send_critsect_);
450  bool media_has_been_sent_ GUARDED_BY(send_critsect_);
451  bool last_packet_marker_bit_ GUARDED_BY(send_critsect_);
452  std::vector<uint32_t> csrcs_ GUARDED_BY(send_critsect_);
453  int rtx_ GUARDED_BY(send_critsect_);
454  uint32_t ssrc_rtx_ GUARDED_BY(send_critsect_);
455  // TODO(changbin): Remove rtx_payload_type_ once interop with old clients that
456  // only understand one RTX PT is no longer needed.
457  int rtx_payload_type_ GUARDED_BY(send_critsect_);
458  // Mapping rtx_payload_type_map_[associated] = rtx.
459  std::map<int8_t, int8_t> rtx_payload_type_map_ GUARDED_BY(send_critsect_);
460
461  // Note: Don't access this variable directly, always go through
462  // SetTargetBitrateKbps or GetTargetBitrateKbps. Also remember
463  // that by the time the function returns there is no guarantee
464  // that the target bitrate is still valid.
465  rtc::scoped_ptr<CriticalSectionWrapper> target_bitrate_critsect_;
466  uint32_t target_bitrate_ GUARDED_BY(target_bitrate_critsect_);
467};
468
469}  // namespace webrtc
470
471#endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_SENDER_H_
472