Home | History | Annotate | Download | only in source
      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_RTCP_IMPL_H_
     12 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL_H_
     13 
     14 #include <list>
     15 #include <vector>
     16 
     17 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
     18 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h"
     19 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
     20 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
     21 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
     22 #include "webrtc/test/testsupport/gtest_prod_util.h"
     23 
     24 namespace webrtc {
     25 
     26 class ModuleRtpRtcpImpl : public RtpRtcp {
     27  public:
     28   explicit ModuleRtpRtcpImpl(const RtpRtcp::Configuration& configuration);
     29 
     30   virtual ~ModuleRtpRtcpImpl();
     31 
     32   // Returns the number of milliseconds until the module want a worker thread to
     33   // call Process.
     34   virtual int32_t TimeUntilNextProcess() OVERRIDE;
     35 
     36   // Process any pending tasks such as timeouts.
     37   virtual int32_t Process() OVERRIDE;
     38 
     39   // Receiver part.
     40 
     41   // Called when we receive an RTCP packet.
     42   virtual int32_t IncomingRtcpPacket(const uint8_t* incoming_packet,
     43                                      uint16_t incoming_packet_length) OVERRIDE;
     44 
     45   virtual void SetRemoteSSRC(const uint32_t ssrc);
     46 
     47   // Sender part.
     48 
     49   virtual int32_t RegisterSendPayload(const CodecInst& voice_codec) OVERRIDE;
     50 
     51   virtual int32_t RegisterSendPayload(const VideoCodec& video_codec) OVERRIDE;
     52 
     53   virtual int32_t DeRegisterSendPayload(const int8_t payload_type) OVERRIDE;
     54 
     55   virtual int8_t SendPayloadType() const;
     56 
     57   // Register RTP header extension.
     58   virtual int32_t RegisterSendRtpHeaderExtension(
     59       const RTPExtensionType type,
     60       const uint8_t id) OVERRIDE;
     61 
     62   virtual int32_t DeregisterSendRtpHeaderExtension(
     63       const RTPExtensionType type) OVERRIDE;
     64 
     65   // Get start timestamp.
     66   virtual uint32_t StartTimestamp() const OVERRIDE;
     67 
     68   // Configure start timestamp, default is a random number.
     69   virtual int32_t SetStartTimestamp(const uint32_t timestamp) OVERRIDE;
     70 
     71   virtual uint16_t SequenceNumber() const OVERRIDE;
     72 
     73   // Set SequenceNumber, default is a random number.
     74   virtual int32_t SetSequenceNumber(const uint16_t seq) OVERRIDE;
     75 
     76   virtual uint32_t SSRC() const OVERRIDE;
     77 
     78   // Configure SSRC, default is a random number.
     79   virtual void SetSSRC(const uint32_t ssrc) OVERRIDE;
     80 
     81   virtual int32_t CSRCs(uint32_t arr_of_csrc[kRtpCsrcSize]) const OVERRIDE;
     82 
     83   virtual int32_t SetCSRCs(const uint32_t arr_of_csrc[kRtpCsrcSize],
     84                            const uint8_t arr_length) OVERRIDE;
     85 
     86   virtual int32_t SetCSRCStatus(const bool include) OVERRIDE;
     87 
     88   virtual uint32_t PacketCountSent() const;
     89 
     90   virtual int CurrentSendFrequencyHz() const;
     91 
     92   virtual uint32_t ByteCountSent() const;
     93 
     94   virtual void SetRTXSendStatus(const int mode) OVERRIDE;
     95 
     96   virtual void RTXSendStatus(int* mode, uint32_t* ssrc,
     97                              int* payloadType) const OVERRIDE;
     98 
     99   virtual void SetRtxSsrc(uint32_t ssrc) OVERRIDE;
    100 
    101   virtual void SetRtxSendPayloadType(int payload_type) OVERRIDE;
    102 
    103   // Sends kRtcpByeCode when going from true to false.
    104   virtual int32_t SetSendingStatus(const bool sending) OVERRIDE;
    105 
    106   virtual bool Sending() const OVERRIDE;
    107 
    108   // Drops or relays media packets.
    109   virtual int32_t SetSendingMediaStatus(const bool sending) OVERRIDE;
    110 
    111   virtual bool SendingMedia() const OVERRIDE;
    112 
    113   // Used by the codec module to deliver a video or audio frame for
    114   // packetization.
    115   virtual int32_t SendOutgoingData(
    116       const FrameType frame_type,
    117       const int8_t payload_type,
    118       const uint32_t time_stamp,
    119       int64_t capture_time_ms,
    120       const uint8_t* payload_data,
    121       const uint32_t payload_size,
    122       const RTPFragmentationHeader* fragmentation = NULL,
    123       const RTPVideoHeader* rtp_video_hdr = NULL) OVERRIDE;
    124 
    125   virtual bool TimeToSendPacket(uint32_t ssrc,
    126                                 uint16_t sequence_number,
    127                                 int64_t capture_time_ms,
    128                                 bool retransmission) OVERRIDE;
    129   // Returns the number of padding bytes actually sent, which can be more or
    130   // less than |bytes|.
    131   virtual int TimeToSendPadding(int bytes) OVERRIDE;
    132 
    133   virtual bool GetSendSideDelay(int* avg_send_delay_ms,
    134                                 int* max_send_delay_ms) const OVERRIDE;
    135 
    136   // RTCP part.
    137 
    138   // Get RTCP status.
    139   virtual RTCPMethod RTCP() const OVERRIDE;
    140 
    141   // Configure RTCP status i.e on/off.
    142   virtual int32_t SetRTCPStatus(const RTCPMethod method) OVERRIDE;
    143 
    144   // Set RTCP CName.
    145   virtual int32_t SetCNAME(const char c_name[RTCP_CNAME_SIZE]) OVERRIDE;
    146 
    147   // Get RTCP CName.
    148   virtual int32_t CNAME(char c_name[RTCP_CNAME_SIZE]) OVERRIDE;
    149 
    150   // Get remote CName.
    151   virtual int32_t RemoteCNAME(const uint32_t remote_ssrc,
    152                               char c_name[RTCP_CNAME_SIZE]) const OVERRIDE;
    153 
    154   // Get remote NTP.
    155   virtual int32_t RemoteNTP(uint32_t* received_ntp_secs,
    156                             uint32_t* received_ntp_frac,
    157                             uint32_t* rtcp_arrival_time_secs,
    158                             uint32_t* rtcp_arrival_time_frac,
    159                             uint32_t* rtcp_timestamp) const OVERRIDE;
    160 
    161   virtual int32_t AddMixedCNAME(const uint32_t ssrc,
    162                                 const char c_name[RTCP_CNAME_SIZE]) OVERRIDE;
    163 
    164   virtual int32_t RemoveMixedCNAME(const uint32_t ssrc) OVERRIDE;
    165 
    166   // Get RoundTripTime.
    167   virtual int32_t RTT(const uint32_t remote_ssrc,
    168                       uint16_t* rtt,
    169                       uint16_t* avg_rtt,
    170                       uint16_t* min_rtt,
    171                       uint16_t* max_rtt) const OVERRIDE;
    172 
    173   // Reset RoundTripTime statistics.
    174   virtual int32_t ResetRTT(const uint32_t remote_ssrc) OVERRIDE;
    175 
    176   // Force a send of an RTCP packet.
    177   // Normal SR and RR are triggered via the process function.
    178   virtual int32_t SendRTCP(uint32_t rtcp_packet_type = kRtcpReport) OVERRIDE;
    179 
    180   virtual int32_t ResetSendDataCountersRTP() OVERRIDE;
    181 
    182   // Statistics of the amount of data sent and received.
    183   virtual int32_t DataCountersRTP(uint32_t* bytes_sent,
    184                                   uint32_t* packets_sent) const OVERRIDE;
    185 
    186   // Get received RTCP report, sender info.
    187   virtual int32_t RemoteRTCPStat(RTCPSenderInfo* sender_info) OVERRIDE;
    188 
    189   // Get received RTCP report, report block.
    190   virtual int32_t RemoteRTCPStat(
    191       std::vector<RTCPReportBlock>* receive_blocks) const OVERRIDE;
    192 
    193   // Set received RTCP report block.
    194   virtual int32_t AddRTCPReportBlock(
    195       const uint32_t ssrc, const RTCPReportBlock* receive_block) OVERRIDE;
    196 
    197   virtual int32_t RemoveRTCPReportBlock(const uint32_t ssrc) OVERRIDE;
    198 
    199   virtual void GetRtcpPacketTypeCounters(
    200       RtcpPacketTypeCounter* packets_sent,
    201       RtcpPacketTypeCounter* packets_received) const OVERRIDE;
    202 
    203   // (REMB) Receiver Estimated Max Bitrate.
    204   virtual bool REMB() const OVERRIDE;
    205 
    206   virtual int32_t SetREMBStatus(const bool enable) OVERRIDE;
    207 
    208   virtual int32_t SetREMBData(const uint32_t bitrate,
    209                               const uint8_t number_of_ssrc,
    210                               const uint32_t* ssrc) OVERRIDE;
    211 
    212   // (IJ) Extended jitter report.
    213   virtual bool IJ() const OVERRIDE;
    214 
    215   virtual int32_t SetIJStatus(const bool enable) OVERRIDE;
    216 
    217   // (TMMBR) Temporary Max Media Bit Rate.
    218   virtual bool TMMBR() const OVERRIDE;
    219 
    220   virtual int32_t SetTMMBRStatus(const bool enable) OVERRIDE;
    221 
    222   int32_t SetTMMBN(const TMMBRSet* bounding_set);
    223 
    224   virtual uint16_t MaxPayloadLength() const OVERRIDE;
    225 
    226   virtual uint16_t MaxDataPayloadLength() const OVERRIDE;
    227 
    228   virtual int32_t SetMaxTransferUnit(const uint16_t size) OVERRIDE;
    229 
    230   virtual int32_t SetTransportOverhead(
    231       const bool tcp,
    232       const bool ipv6,
    233       const uint8_t authentication_overhead = 0) OVERRIDE;
    234 
    235   // (NACK) Negative acknowledgment part.
    236 
    237   virtual int SelectiveRetransmissions() const OVERRIDE;
    238 
    239   virtual int SetSelectiveRetransmissions(uint8_t settings) OVERRIDE;
    240 
    241   // Send a Negative acknowledgment packet.
    242   virtual int32_t SendNACK(const uint16_t* nack_list,
    243                            const uint16_t size) OVERRIDE;
    244 
    245   // Store the sent packets, needed to answer to a negative acknowledgment
    246   // requests.
    247   virtual int32_t SetStorePacketsStatus(
    248       const bool enable, const uint16_t number_to_store) OVERRIDE;
    249 
    250   virtual bool StorePackets() const OVERRIDE;
    251 
    252   // Called on receipt of RTCP report block from remote side.
    253   virtual void RegisterSendChannelRtcpStatisticsCallback(
    254       RtcpStatisticsCallback* callback) OVERRIDE;
    255   virtual RtcpStatisticsCallback*
    256       GetSendChannelRtcpStatisticsCallback() OVERRIDE;
    257 
    258   // (APP) Application specific data.
    259   virtual int32_t SetRTCPApplicationSpecificData(
    260       const uint8_t sub_type,
    261       const uint32_t name,
    262       const uint8_t* data,
    263       const uint16_t length) OVERRIDE;
    264 
    265   // (XR) VOIP metric.
    266   virtual int32_t SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric) OVERRIDE;
    267 
    268   // (XR) Receiver reference time report.
    269   virtual void SetRtcpXrRrtrStatus(bool enable) OVERRIDE;
    270 
    271   virtual bool RtcpXrRrtrStatus() const OVERRIDE;
    272 
    273   // Audio part.
    274 
    275   // Set audio packet size, used to determine when it's time to send a DTMF
    276   // packet in silence (CNG).
    277   virtual int32_t SetAudioPacketSize(
    278       const uint16_t packet_size_samples) OVERRIDE;
    279 
    280   virtual bool SendTelephoneEventActive(int8_t& telephone_event) const OVERRIDE;
    281 
    282   // Send a TelephoneEvent tone using RFC 2833 (4733).
    283   virtual int32_t SendTelephoneEventOutband(const uint8_t key,
    284                                             const uint16_t time_ms,
    285                                             const uint8_t level) OVERRIDE;
    286 
    287   // Set payload type for Redundant Audio Data RFC 2198.
    288   virtual int32_t SetSendREDPayloadType(const int8_t payload_type) OVERRIDE;
    289 
    290   // Get payload type for Redundant Audio Data RFC 2198.
    291   virtual int32_t SendREDPayloadType(int8_t& payload_type) const OVERRIDE;
    292 
    293   // Store the audio level in d_bov for header-extension-for-audio-level-
    294   // indication.
    295   virtual int32_t SetAudioLevel(const uint8_t level_d_bov) OVERRIDE;
    296 
    297   // Video part.
    298 
    299   virtual RtpVideoCodecTypes SendVideoCodec() const;
    300 
    301   virtual int32_t SendRTCPSliceLossIndication(
    302       const uint8_t picture_id) OVERRIDE;
    303 
    304   // Set method for requestion a new key frame.
    305   virtual int32_t SetKeyFrameRequestMethod(
    306       const KeyFrameRequestMethod method) OVERRIDE;
    307 
    308   // Send a request for a keyframe.
    309   virtual int32_t RequestKeyFrame() OVERRIDE;
    310 
    311   virtual int32_t SetCameraDelay(const int32_t delay_ms) OVERRIDE;
    312 
    313   virtual void SetTargetSendBitrate(
    314       const std::vector<uint32_t>& stream_bitrates) OVERRIDE;
    315 
    316   virtual int32_t SetGenericFECStatus(
    317       const bool enable,
    318       const uint8_t payload_type_red,
    319       const uint8_t payload_type_fec) OVERRIDE;
    320 
    321   virtual int32_t GenericFECStatus(
    322       bool& enable,
    323       uint8_t& payload_type_red,
    324       uint8_t& payload_type_fec) OVERRIDE;
    325 
    326   virtual int32_t SetFecParameters(
    327       const FecProtectionParams* delta_params,
    328       const FecProtectionParams* key_params) OVERRIDE;
    329 
    330   virtual int32_t LastReceivedNTP(uint32_t& NTPsecs,
    331                                   uint32_t& NTPfrac,
    332                                   uint32_t& remote_sr);
    333 
    334   virtual bool LastReceivedXrReferenceTimeInfo(RtcpReceiveTimeInfo* info) const;
    335 
    336   virtual int32_t BoundingSet(bool& tmmbr_owner, TMMBRSet*& bounding_set_rec);
    337 
    338   virtual void BitrateSent(uint32_t* total_rate,
    339                            uint32_t* video_rate,
    340                            uint32_t* fec_rate,
    341                            uint32_t* nackRate) const OVERRIDE;
    342 
    343   virtual void RegisterVideoBitrateObserver(BitrateStatisticsObserver* observer)
    344       OVERRIDE;
    345 
    346   virtual BitrateStatisticsObserver* GetVideoBitrateObserver() const OVERRIDE;
    347 
    348   virtual uint32_t SendTimeOfSendReport(const uint32_t send_report);
    349 
    350   virtual bool SendTimeOfXrRrReport(uint32_t mid_ntp, int64_t* time_ms) const;
    351 
    352   // Good state of RTP receiver inform sender.
    353   virtual int32_t SendRTCPReferencePictureSelection(
    354       const uint64_t picture_id) OVERRIDE;
    355 
    356   virtual void RegisterSendChannelRtpStatisticsCallback(
    357       StreamDataCountersCallback* callback);
    358   virtual StreamDataCountersCallback*
    359       GetSendChannelRtpStatisticsCallback() const;
    360 
    361   void OnReceivedTMMBR();
    362 
    363   // Bad state of RTP receiver request a keyframe.
    364   void OnRequestIntraFrame();
    365 
    366   // Received a request for a new SLI.
    367   void OnReceivedSliceLossIndication(const uint8_t picture_id);
    368 
    369   // Received a new reference frame.
    370   void OnReceivedReferencePictureSelectionIndication(
    371       const uint64_t picture_id);
    372 
    373   void OnReceivedNACK(const std::list<uint16_t>& nack_sequence_numbers);
    374 
    375   void OnRequestSendReport();
    376 
    377   virtual void RegisterSendFrameCountObserver(
    378       FrameCountObserver* observer) OVERRIDE;
    379   virtual FrameCountObserver* GetSendFrameCountObserver() const OVERRIDE;
    380 
    381  protected:
    382   void RegisterChildModule(RtpRtcp* module);
    383 
    384   void DeRegisterChildModule(RtpRtcp* module);
    385 
    386   bool UpdateRTCPReceiveInformationTimers();
    387 
    388   uint32_t BitrateReceivedNow() const;
    389 
    390   // Get remote SequenceNumber.
    391   uint16_t RemoteSequenceNumber() const;
    392 
    393   // Only for internal testing.
    394   uint32_t LastSendReport(uint32_t& last_rtcptime);
    395 
    396   RTPSender                 rtp_sender_;
    397 
    398   RTCPSender                rtcp_sender_;
    399   RTCPReceiver              rtcp_receiver_;
    400 
    401   Clock*                    clock_;
    402 
    403  private:
    404   FRIEND_TEST_ALL_PREFIXES(RtpRtcpImplTest, Rtt);
    405   FRIEND_TEST_ALL_PREFIXES(RtpRtcpImplTest, RttForReceiverOnly);
    406   int64_t RtcpReportInterval();
    407   void SetRtcpReceiverSsrcs(uint32_t main_ssrc);
    408 
    409   void set_rtt_ms(uint32_t rtt_ms);
    410   uint32_t rtt_ms() const;
    411 
    412   bool IsDefaultModule() const;
    413 
    414   int32_t             id_;
    415   const bool                audio_;
    416   bool                      collision_detected_;
    417   int64_t             last_process_time_;
    418   int64_t             last_bitrate_process_time_;
    419   int64_t             last_rtt_process_time_;
    420   uint16_t            packet_overhead_;
    421 
    422   scoped_ptr<CriticalSectionWrapper> critical_section_module_ptrs_;
    423   scoped_ptr<CriticalSectionWrapper> critical_section_module_ptrs_feedback_;
    424   ModuleRtpRtcpImpl*            default_module_;
    425   std::vector<ModuleRtpRtcpImpl*> child_modules_;
    426   size_t padding_index_;
    427 
    428   // Send side
    429   NACKMethod            nack_method_;
    430   uint32_t        nack_last_time_sent_full_;
    431   uint16_t        nack_last_seq_number_sent_;
    432 
    433   bool                  simulcast_;
    434   VideoCodec            send_video_codec_;
    435   KeyFrameRequestMethod key_frame_req_method_;
    436 
    437   RemoteBitrateEstimator* remote_bitrate_;
    438 
    439   RtcpRttStats* rtt_stats_;
    440 
    441   // The processed RTT from RtcpRttStats.
    442   scoped_ptr<CriticalSectionWrapper> critical_section_rtt_;
    443   uint32_t rtt_ms_;
    444 };
    445 
    446 }  // namespace webrtc
    447 
    448 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL_H_
    449