Line data    Source code

       1             : /*
       2             :  *  Copyright (c) 2016 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_INCLUDE_FLEXFEC_RECEIVER_H_
      12             : #define WEBRTC_MODULES_RTP_RTCP_INCLUDE_FLEXFEC_RECEIVER_H_
      13             : 
      14             : #include <memory>
      15             : 
      16             : #include "webrtc/base/basictypes.h"
      17             : #include "webrtc/base/sequenced_task_checker.h"
      18             : #include "webrtc/call/call.h"
      19             : #include "webrtc/modules/rtp_rtcp/include/ulpfec_receiver.h"
      20             : #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
      21             : #include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
      22             : #include "webrtc/system_wrappers/include/clock.h"
      23             : 
      24             : namespace webrtc {
      25             : 
      26             : // Callback interface for packets recovered by FlexFEC. The implementation
      27             : // should be able to demultiplex the recovered RTP packets based on SSRC.
      28           0 : class RecoveredPacketReceiver {
      29             :  public:
      30             :   virtual bool OnRecoveredPacket(const uint8_t* packet, size_t length) = 0;
      31             : 
      32             :  protected:
      33           0 :   virtual ~RecoveredPacketReceiver() = default;
      34             : };
      35             : 
      36           0 : class FlexfecReceiver {
      37             :  public:
      38             :   FlexfecReceiver(uint32_t ssrc,
      39             :                   uint32_t protected_media_ssrc,
      40             :                   RecoveredPacketReceiver* recovered_packet_receiver);
      41             :   ~FlexfecReceiver();
      42             : 
      43             :   // Inserts a received packet (can be either media or FlexFEC) into the
      44             :   // internal buffer, and sends the received packets to the erasure code.
      45             :   // All newly recovered packets are sent back through the callback.
      46             :   bool AddAndProcessReceivedPacket(const RtpPacketReceived& packet);
      47             : 
      48             :   // Returns a counter describing the added and recovered packets.
      49             :   FecPacketCounter GetPacketCounter() const;
      50             : 
      51             :  private:
      52             :   bool AddReceivedPacket(const RtpPacketReceived& packet);
      53             :   bool ProcessReceivedPackets();
      54             : 
      55             :   // Config.
      56             :   const uint32_t ssrc_;
      57             :   const uint32_t protected_media_ssrc_;
      58             : 
      59             :   // Erasure code interfacing and callback.
      60             :   std::unique_ptr<ForwardErrorCorrection> erasure_code_
      61             :       GUARDED_BY(sequence_checker_);
      62             :   ForwardErrorCorrection::ReceivedPacketList received_packets_
      63             :       GUARDED_BY(sequence_checker_);
      64             :   ForwardErrorCorrection::RecoveredPacketList recovered_packets_
      65             :       GUARDED_BY(sequence_checker_);
      66             :   RecoveredPacketReceiver* const recovered_packet_receiver_;
      67             : 
      68             :   // Logging and stats.
      69             :   Clock* const clock_;
      70             :   int64_t last_recovered_packet_ms_ GUARDED_BY(sequence_checker_);
      71             :   FecPacketCounter packet_counter_ GUARDED_BY(sequence_checker_);
      72             : 
      73             :   rtc::SequencedTaskChecker sequence_checker_;
      74             : };
      75             : 
      76             : }  // namespace webrtc
      77             : 
      78             : #endif  // WEBRTC_MODULES_RTP_RTCP_INCLUDE_FLEXFEC_RECEIVER_H_