Home | History | Annotate | Download | only in video 
      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_VIDEO_VIE_RECEIVER_H_
     12 #define WEBRTC_VIDEO_VIE_RECEIVER_H_
     13 
     14 #include <list>
     15 #include <vector>
     16 
     17 #include "webrtc/base/scoped_ptr.h"
     18 #include "webrtc/engine_configurations.h"
     19 #include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
     20 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
     21 #include "webrtc/typedefs.h"
     22 
     23 namespace webrtc {
     24 
     25 class CriticalSectionWrapper;
     26 class FecReceiver;
     27 class RemoteNtpTimeEstimator;
     28 class ReceiveStatistics;
     29 class RemoteBitrateEstimator;
     30 class RtpHeaderParser;
     31 class RTPPayloadRegistry;
     32 class RtpReceiver;
     33 class RtpRtcp;
     34 class VideoCodingModule;
     35 struct ReceiveBandwidthEstimatorStats;
     36 
     37 class ViEReceiver : public RtpData {
     38  public:
     39   ViEReceiver(VideoCodingModule* module_vcm,
     40               RemoteBitrateEstimator* remote_bitrate_estimator,
     41               RtpFeedback* rtp_feedback);
     42   ~ViEReceiver();
     43 
     44   bool SetReceiveCodec(const VideoCodec& video_codec);
     45   bool RegisterPayload(const VideoCodec& video_codec);
     46 
     47   void SetNackStatus(bool enable, int max_nack_reordering_threshold);
     48   void SetRtxPayloadType(int payload_type, int associated_payload_type);
     49   // If set to true, the RTX payload type mapping supplied in
     50   // |SetRtxPayloadType| will be used when restoring RTX packets. Without it,
     51   // RTX packets will always be restored to the last non-RTX packet payload type
     52   // received.
     53   void SetUseRtxPayloadMappingOnRestore(bool val);
     54   void SetRtxSsrc(uint32_t ssrc);
     55   bool GetRtxSsrc(uint32_t* ssrc) const;
     56 
     57   bool IsFecEnabled() const;
     58 
     59   uint32_t GetRemoteSsrc() const;
     60   int GetCsrcs(uint32_t* csrcs) const;
     61 
     62   void SetRtpRtcpModule(RtpRtcp* module);
     63 
     64   RtpReceiver* GetRtpReceiver() const;
     65 
     66   void RegisterRtpRtcpModules(const std::vector<RtpRtcp*>& rtp_modules);
     67 
     68   bool SetReceiveTimestampOffsetStatus(bool enable, int id);
     69   bool SetReceiveAbsoluteSendTimeStatus(bool enable, int id);
     70   bool SetReceiveVideoRotationStatus(bool enable, int id);
     71   bool SetReceiveTransportSequenceNumber(bool enable, int id);
     72 
     73   void StartReceive();
     74   void StopReceive();
     75 
     76   // Receives packets from external transport.
     77   int ReceivedRTPPacket(const void* rtp_packet, size_t rtp_packet_length,
     78                         const PacketTime& packet_time);
     79   int ReceivedRTCPPacket(const void* rtcp_packet, size_t rtcp_packet_length);
     80 
     81   // Implements RtpData.
     82   int32_t OnReceivedPayloadData(const uint8_t* payload_data,
     83                                 const size_t payload_size,
     84                                 const WebRtcRTPHeader* rtp_header) override;
     85   bool OnRecoveredPacket(const uint8_t* packet, size_t packet_length) override;
     86 
     87   ReceiveStatistics* GetReceiveStatistics() const;
     88 
     89  private:
     90   int InsertRTPPacket(const uint8_t* rtp_packet, size_t rtp_packet_length,
     91                       const PacketTime& packet_time);
     92   bool ReceivePacket(const uint8_t* packet,
     93                      size_t packet_length,
     94                      const RTPHeader& header,
     95                      bool in_order);
     96   // Parses and handles for instance RTX and RED headers.
     97   // This function assumes that it's being called from only one thread.
     98   bool ParseAndHandleEncapsulatingHeader(const uint8_t* packet,
     99                                          size_t packet_length,
    100                                          const RTPHeader& header);
    101   void NotifyReceiverOfFecPacket(const RTPHeader& header);
    102   int InsertRTCPPacket(const uint8_t* rtcp_packet, size_t rtcp_packet_length);
    103   bool IsPacketInOrder(const RTPHeader& header) const;
    104   bool IsPacketRetransmitted(const RTPHeader& header, bool in_order) const;
    105   void UpdateHistograms();
    106 
    107   rtc::scoped_ptr<CriticalSectionWrapper> receive_cs_;
    108   Clock* clock_;
    109   rtc::scoped_ptr<RtpHeaderParser> rtp_header_parser_;
    110   rtc::scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
    111   rtc::scoped_ptr<RtpReceiver> rtp_receiver_;
    112   const rtc::scoped_ptr<ReceiveStatistics> rtp_receive_statistics_;
    113   rtc::scoped_ptr<FecReceiver> fec_receiver_;
    114   RtpRtcp* rtp_rtcp_;
    115   std::vector<RtpRtcp*> rtp_rtcp_simulcast_;
    116   VideoCodingModule* vcm_;
    117   RemoteBitrateEstimator* remote_bitrate_estimator_;
    118 
    119   rtc::scoped_ptr<RemoteNtpTimeEstimator> ntp_estimator_;
    120 
    121   bool receiving_;
    122   uint8_t restored_packet_[IP_PACKET_SIZE];
    123   bool restored_packet_in_use_;
    124   bool receiving_ast_enabled_;
    125   bool receiving_cvo_enabled_;
    126   bool receiving_tsn_enabled_;
    127   int64_t last_packet_log_ms_;
    128 };
    129 
    130 }  // namespace webrtc
    131 
    132 #endif  // WEBRTC_VIDEO_VIE_RECEIVER_H_
    133