src/third_party/webrtc/modules/rtp_rtcp/source/rtp_sender.h

   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 <assert.h>
  15 #include <math.h>
  16
  17 #include <map>
  18
  19 #include "webrtc/base/thread_annotations.h"
  20 #include "webrtc/common_types.h"
  21 #include "webrtc/modules/pacing/include/paced_sender.h"
  22 #include "webrtc/modules/rtp_rtcp/interface/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/ssrc_database.h"
  28 #include "webrtc/modules/rtp_rtcp/source/video_codec_information.h"
  29
  30 #define MAX_INIT_RTP_SEQ_NUMBER 32767  // 2^15 -1.
  31
  32 namespace webrtc {
  33
  34 class BitrateAggregator;
  35 class CriticalSectionWrapper;
  36 class RTPSenderAudio;
  37 class RTPSenderVideo;
  38
  39 class RTPSenderInterface {
  40  public:
  41   RTPSenderInterface() {}
  42   virtual ~RTPSenderInterface() {}
  43
  44   virtual uint32_t SSRC() const = 0;
  45   virtual uint32_t Timestamp() const = 0;
  46
  47   virtual int32_t BuildRTPheader(uint8_t* data_buffer,
  48                                  const int8_t payload_type,
  49                                  const bool marker_bit,
  50                                  const uint32_t capture_timestamp,
  51                                  int64_t capture_time_ms,
  52                                  const bool timestamp_provided = true,
  53                                  const bool inc_sequence_number = true) = 0;
  54
  55   virtual uint16_t RTPHeaderLength() const = 0;
  56   virtual uint16_t IncrementSequenceNumber() = 0;
  57   virtual uint16_t SequenceNumber() const = 0;
  58   virtual uint16_t MaxPayloadLength() const = 0;
  59   virtual uint16_t MaxDataPayloadLength() const = 0;
  60   virtual uint16_t PacketOverHead() const = 0;
  61   virtual uint16_t ActualSendBitrateKbit() const = 0;
  62
  63   virtual int32_t SendToNetwork(
  64       uint8_t *data_buffer, int payload_length, int rtp_header_length,
  65       int64_t capture_time_ms, StorageType storage,
  66       PacedSender::Priority priority) = 0;
  67 };
  68
  69 class RTPSender : public RTPSenderInterface {
  70  public:
  71   RTPSender(const int32_t id, const bool audio, Clock *clock,
  72             Transport *transport, RtpAudioFeedback *audio_feedback,
  73             PacedSender *paced_sender,
  74             BitrateStatisticsObserver* bitrate_callback,
  75             FrameCountObserver* frame_count_observer,
  76             SendSideDelayObserver* send_side_delay_observer);
  77   virtual ~RTPSender();
  78
  79   void ProcessBitrate();
  80
  81   virtual uint16_t ActualSendBitrateKbit() const OVERRIDE;
  82
  83   uint32_t VideoBitrateSent() const;
  84   uint32_t FecOverheadRate() const;
  85   uint32_t NackOverheadRate() const;
  86
  87   // Returns true if the statistics have been calculated, and false if no frame
  88   // was sent within the statistics window.
  89   bool GetSendSideDelay(int* avg_send_delay_ms, int* max_send_delay_ms) const;
  90
  91   void SetTargetBitrate(uint32_t bitrate);
  92   uint32_t GetTargetBitrate();
  93
  94   virtual uint16_t MaxDataPayloadLength() const
  95       OVERRIDE;  // with RTP and FEC headers.
  96
  97   int32_t RegisterPayload(
  98       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
  99       const int8_t payload_type, const uint32_t frequency,
 100       const uint8_t channels, const uint32_t rate);
 101
 102   int32_t DeRegisterSendPayload(const int8_t payload_type);
 103
 104   void SetSendPayloadType(int8_t payload_type);
 105
 106   int8_t SendPayloadType() const;
 107
 108   int SendPayloadFrequency() const;
 109
 110   void SetSendingStatus(bool enabled);
 111
 112   void SetSendingMediaStatus(const bool enabled);
 113   bool SendingMedia() const;
 114
 115   void GetDataCounters(StreamDataCounters* rtp_stats,
 116                        StreamDataCounters* rtx_stats) const;
 117
 118   void ResetDataCounters();
 119
 120   uint32_t StartTimestamp() const;
 121   void SetStartTimestamp(uint32_t timestamp, bool force);
 122
 123   uint32_t GenerateNewSSRC();
 124   void SetSSRC(const uint32_t ssrc);
 125
 126   virtual uint16_t SequenceNumber() const OVERRIDE;
 127   void SetSequenceNumber(uint16_t seq);
 128
 129   int32_t CSRCs(uint32_t arr_of_csrc[kRtpCsrcSize]) const;
 130
 131   void SetCSRCStatus(const bool include);
 132
 133   void SetCSRCs(const uint32_t arr_of_csrc[kRtpCsrcSize],
 134                 const uint8_t arr_length);
 135
 136   int32_t SetMaxPayloadLength(const uint16_t length,
 137                               const uint16_t packet_over_head);
 138
 139   int32_t SendOutgoingData(const FrameType frame_type,
 140                            const int8_t payload_type,
 141                            const uint32_t timestamp,
 142                            int64_t capture_time_ms,
 143                            const uint8_t* payload_data,
 144                            const uint32_t payload_size,
 145                            const RTPFragmentationHeader* fragmentation,
 146                            VideoCodecInformation* codec_info = NULL,
 147                            const RTPVideoTypeHeader* rtp_type_hdr = NULL);
 148
 149   // RTP header extension
 150   int32_t SetTransmissionTimeOffset(
 151       const int32_t transmission_time_offset);
 152   int32_t SetAbsoluteSendTime(
 153       const uint32_t absolute_send_time);
 154
 155   int32_t RegisterRtpHeaderExtension(const RTPExtensionType type,
 156                                      const uint8_t id);
 157
 158   int32_t DeregisterRtpHeaderExtension(const RTPExtensionType type);
 159
 160   uint16_t RtpHeaderExtensionTotalLength() const;
 161
 162   uint16_t BuildRTPHeaderExtension(uint8_t* data_buffer) const;
 163
 164   uint8_t BuildTransmissionTimeOffsetExtension(uint8_t *data_buffer) const;
 165   uint8_t BuildAudioLevelExtension(uint8_t* data_buffer) const;
 166   uint8_t BuildAbsoluteSendTimeExtension(uint8_t* data_buffer) const;
 167
 168   bool UpdateAudioLevel(uint8_t *rtp_packet,
 169                         const uint16_t rtp_packet_length,
 170                         const RTPHeader &rtp_header,
 171                         const bool is_voiced,
 172                         const uint8_t dBov) const;
 173
 174   bool TimeToSendPacket(uint16_t sequence_number, int64_t capture_time_ms,
 175                         bool retransmission);
 176   int TimeToSendPadding(int bytes);
 177
 178   // NACK.
 179   int SelectiveRetransmissions() const;
 180   int SetSelectiveRetransmissions(uint8_t settings);
 181   void OnReceivedNACK(const std::list<uint16_t>& nack_sequence_numbers,
 182                       const uint16_t avg_rtt);
 183
 184   void SetStorePacketsStatus(const bool enable,
 185                              const uint16_t number_to_store);
 186
 187   bool StorePackets() const;
 188
 189   int32_t ReSendPacket(uint16_t packet_id, uint32_t min_resend_time = 0);
 190
 191   bool ProcessNACKBitRate(const uint32_t now);
 192
 193   // RTX.
 194   void SetRTXStatus(int mode);
 195
 196   void RTXStatus(int* mode, uint32_t* ssrc, int* payload_type) const;
 197
 198   uint32_t RtxSsrc() const;
 199   void SetRtxSsrc(uint32_t ssrc);
 200
 201   void SetRtxPayloadType(int payloadType);
 202
 203   // Functions wrapping RTPSenderInterface.
 204   virtual int32_t BuildRTPheader(
 205       uint8_t* data_buffer,
 206       const int8_t payload_type,
 207       const bool marker_bit,
 208       const uint32_t capture_timestamp,
 209       int64_t capture_time_ms,
 210       const bool timestamp_provided = true,
 211       const bool inc_sequence_number = true) OVERRIDE;
 212
 213   virtual uint16_t RTPHeaderLength() const OVERRIDE;
 214   virtual uint16_t IncrementSequenceNumber() OVERRIDE;
 215   virtual uint16_t MaxPayloadLength() const OVERRIDE;
 216   virtual uint16_t PacketOverHead() const OVERRIDE;
 217
 218   // Current timestamp.
 219   virtual uint32_t Timestamp() const OVERRIDE;
 220   virtual uint32_t SSRC() const OVERRIDE;
 221
 222   virtual int32_t SendToNetwork(
 223       uint8_t *data_buffer, int payload_length, int rtp_header_length,
 224       int64_t capture_time_ms, StorageType storage,
 225       PacedSender::Priority priority) OVERRIDE;
 226
 227   // Audio.
 228
 229   // Send a DTMF tone using RFC 2833 (4733).
 230   int32_t SendTelephoneEvent(const uint8_t key,
 231                              const uint16_t time_ms,
 232                              const uint8_t level);
 233
 234   bool SendTelephoneEventActive(int8_t *telephone_event) const;
 235
 236   // Set audio packet size, used to determine when it's time to send a DTMF
 237   // packet in silence (CNG).
 238   int32_t SetAudioPacketSize(const uint16_t packet_size_samples);
 239
 240   // Store the audio level in d_bov for
 241   // header-extension-for-audio-level-indication.
 242   int32_t SetAudioLevel(const uint8_t level_d_bov);
 243
 244   // Set payload type for Redundant Audio Data RFC 2198.
 245   int32_t SetRED(const int8_t payload_type);
 246
 247   // Get payload type for Redundant Audio Data RFC 2198.
 248   int32_t RED(int8_t *payload_type) const;
 249
 250   // Video.
 251   VideoCodecInformation *CodecInformationVideo();
 252
 253   RtpVideoCodecTypes VideoCodecType() const;
 254
 255   uint32_t MaxConfiguredBitrateVideo() const;
 256
 257   int32_t SendRTPIntraRequest();
 258
 259   // FEC.
 260   int32_t SetGenericFECStatus(const bool enable,
 261                               const uint8_t payload_type_red,
 262                               const uint8_t payload_type_fec);
 263
 264   int32_t GenericFECStatus(bool *enable, uint8_t *payload_type_red,
 265                            uint8_t *payload_type_fec) const;
 266
 267   int32_t SetFecParameters(const FecProtectionParams *delta_params,
 268                            const FecProtectionParams *key_params);
 269
 270   int SendPadData(uint32_t timestamp,
 271                   int64_t capture_time_ms,
 272                   int32_t bytes);
 273
 274   // Called on update of RTP statistics.
 275   void RegisterRtpStatisticsCallback(StreamDataCountersCallback* callback);
 276   StreamDataCountersCallback* GetRtpStatisticsCallback() const;
 277
 278   uint32_t BitrateSent() const;
 279
 280   void SetRtpState(const RtpState& rtp_state);
 281   RtpState GetRtpState() const;
 282   void SetRtxRtpState(const RtpState& rtp_state);
 283   RtpState GetRtxRtpState() const;
 284
 285  protected:
 286   int32_t CheckPayloadType(const int8_t payload_type,
 287                            RtpVideoCodecTypes *video_type);
 288
 289  private:
 290   // Maps capture time in milliseconds to send-side delay in milliseconds.
 291   // Send-side delay is the difference between transmission time and capture
 292   // time.
 293   typedef std::map<int64_t, int> SendDelayMap;
 294
 295   int CreateRTPHeader(uint8_t* header, int8_t payload_type,
 296                       uint32_t ssrc, bool marker_bit,
 297                       uint32_t timestamp, uint16_t sequence_number,
 298                       const uint32_t* csrcs, uint8_t csrcs_length) const;
 299
 300   void UpdateNACKBitRate(const uint32_t bytes, const uint32_t now);
 301
 302   bool PrepareAndSendPacket(uint8_t* buffer,
 303                             uint16_t length,
 304                             int64_t capture_time_ms,
 305                             bool send_over_rtx,
 306                             bool is_retransmit);
 307
 308   // Return the number of bytes sent.
 309   int TrySendRedundantPayloads(int bytes);
 310   int TrySendPadData(int bytes);
 311
 312   int BuildPaddingPacket(uint8_t* packet, int header_length, int32_t bytes);
 313
 314   void BuildRtxPacket(uint8_t* buffer, uint16_t* length,
 315                       uint8_t* buffer_rtx);
 316
 317   bool SendPacketToNetwork(const uint8_t *packet, uint32_t size);
 318
 319   void UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms);
 320
 321   void UpdateTransmissionTimeOffset(uint8_t *rtp_packet,
 322                                     const uint16_t rtp_packet_length,
 323                                     const RTPHeader &rtp_header,
 324                                     const int64_t time_diff_ms) const;
 325   void UpdateAbsoluteSendTime(uint8_t *rtp_packet,
 326                               const uint16_t rtp_packet_length,
 327                               const RTPHeader &rtp_header,
 328                               const int64_t now_ms) const;
 329
 330   void UpdateRtpStats(const uint8_t* buffer,
 331                       uint32_t size,
 332                       const RTPHeader& header,
 333                       bool is_rtx,
 334                       bool is_retransmit);
 335   bool IsFecPacket(const uint8_t* buffer, const RTPHeader& header) const;
 336
 337   Clock* clock_;
 338   int64_t clock_delta_ms_;
 339
 340   scoped_ptr<BitrateAggregator> bitrates_;
 341   Bitrate total_bitrate_sent_;
 342
 343   int32_t id_;
 344   const bool audio_configured_;
 345   RTPSenderAudio *audio_;
 346   RTPSenderVideo *video_;
 347
 348   PacedSender *paced_sender_;
 349   int64_t last_capture_time_ms_sent_;
 350   CriticalSectionWrapper *send_critsect_;
 351
 352   Transport *transport_;
 353   bool sending_media_ GUARDED_BY(send_critsect_);
 354
 355   uint16_t max_payload_length_;
 356   uint16_t packet_over_head_;
 357
 358   int8_t payload_type_ GUARDED_BY(send_critsect_);
 359   std::map<int8_t, RtpUtility::Payload*> payload_type_map_;
 360
 361   RtpHeaderExtensionMap rtp_header_extension_map_;
 362   int32_t transmission_time_offset_;
 363   uint32_t absolute_send_time_;
 364
 365   // NACK
 366   uint32_t nack_byte_count_times_[NACK_BYTECOUNT_SIZE];
 367   int32_t nack_byte_count_[NACK_BYTECOUNT_SIZE];
 368   Bitrate nack_bitrate_;
 369
 370   RTPPacketHistory packet_history_;
 371
 372   // Statistics
 373   scoped_ptr<CriticalSectionWrapper> statistics_crit_;
 374   SendDelayMap send_delays_ GUARDED_BY(statistics_crit_);
 375   std::map<FrameType, uint32_t> frame_counts_ GUARDED_BY(statistics_crit_);
 376   StreamDataCounters rtp_stats_ GUARDED_BY(statistics_crit_);
 377   StreamDataCounters rtx_rtp_stats_ GUARDED_BY(statistics_crit_);
 378   StreamDataCountersCallback* rtp_stats_callback_ GUARDED_BY(statistics_crit_);
 379   FrameCountObserver* const frame_count_observer_;
 380   SendSideDelayObserver* const send_side_delay_observer_;
 381
 382   // RTP variables
 383   bool start_timestamp_forced_ GUARDED_BY(send_critsect_);
 384   uint32_t start_timestamp_ GUARDED_BY(send_critsect_);
 385   SSRCDatabase& ssrc_db_ GUARDED_BY(send_critsect_);
 386   uint32_t remote_ssrc_ GUARDED_BY(send_critsect_);
 387   bool sequence_number_forced_ GUARDED_BY(send_critsect_);
 388   uint16_t sequence_number_ GUARDED_BY(send_critsect_);
 389   uint16_t sequence_number_rtx_ GUARDED_BY(send_critsect_);
 390   bool ssrc_forced_ GUARDED_BY(send_critsect_);
 391   uint32_t ssrc_ GUARDED_BY(send_critsect_);
 392   uint32_t timestamp_ GUARDED_BY(send_critsect_);
 393   int64_t capture_time_ms_ GUARDED_BY(send_critsect_);
 394   int64_t last_timestamp_time_ms_ GUARDED_BY(send_critsect_);
 395   bool media_has_been_sent_ GUARDED_BY(send_critsect_);
 396   bool last_packet_marker_bit_ GUARDED_BY(send_critsect_);
 397   uint8_t num_csrcs_ GUARDED_BY(send_critsect_);
 398   uint32_t csrcs_[kRtpCsrcSize] GUARDED_BY(send_critsect_);
 399   bool include_csrcs_ GUARDED_BY(send_critsect_);
 400   int rtx_ GUARDED_BY(send_critsect_);
 401   uint32_t ssrc_rtx_ GUARDED_BY(send_critsect_);
 402   int payload_type_rtx_ GUARDED_BY(send_critsect_);
 403
 404   // Note: Don't access this variable directly, always go through
 405   // SetTargetBitrateKbps or GetTargetBitrateKbps. Also remember
 406   // that by the time the function returns there is no guarantee
 407   // that the target bitrate is still valid.
 408   scoped_ptr<CriticalSectionWrapper> target_bitrate_critsect_;
 409   uint32_t target_bitrate_ GUARDED_BY(target_bitrate_critsect_);
 410 };
 411
 412 }  // namespace webrtc
 413
 414 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_SENDER_H_