LCOV - code coverage report
Current view: top level - media/webrtc/trunk/webrtc/modules/video_coding - nack_module.h (source / functions) Hit Total Coverage
Test: output.info Lines: 0 1 0.0 %
Date: 2017-07-14 16:53:18 Functions: 0 2 0.0 %
Legend: Lines: hit not hit

          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_VIDEO_CODING_NACK_MODULE_H_
      12             : #define WEBRTC_MODULES_VIDEO_CODING_NACK_MODULE_H_
      13             : 
      14             : #include <map>
      15             : #include <vector>
      16             : #include <set>
      17             : 
      18             : #include "webrtc/base/criticalsection.h"
      19             : #include "webrtc/base/thread_annotations.h"
      20             : #include "webrtc/modules/include/module.h"
      21             : #include "webrtc/modules/video_coding/include/video_coding_defines.h"
      22             : #include "webrtc/modules/video_coding/packet.h"
      23             : #include "webrtc/modules/video_coding/histogram.h"
      24             : #include "webrtc/modules/video_coding/sequence_number_util.h"
      25             : #include "webrtc/system_wrappers/include/clock.h"
      26             : 
      27             : namespace webrtc {
      28             : 
      29           0 : class NackModule : public Module {
      30             :  public:
      31             :   NackModule(Clock* clock,
      32             :              NackSender* nack_sender,
      33             :              KeyFrameRequestSender* keyframe_request_sender);
      34             : 
      35             :   int OnReceivedPacket(const VCMPacket& packet);
      36             :   void ClearUpTo(uint16_t seq_num);
      37             :   void UpdateRtt(int64_t rtt_ms);
      38             :   void Clear();
      39             :   void Stop();
      40             : 
      41             :   // Module implementation
      42             :   int64_t TimeUntilNextProcess() override;
      43             :   void Process() override;
      44             : 
      45             :  private:
      46             :   // Which fields to consider when deciding which packet to nack in
      47             :   // GetNackBatch.
      48             :   enum NackFilterOptions { kSeqNumOnly, kTimeOnly, kSeqNumAndTime };
      49             : 
      50             :   // This class holds the sequence number of the packet that is in the nack list
      51             :   // as well as the meta data about when it should be nacked and how many times
      52             :   // we have tried to nack this packet.
      53             :   struct NackInfo {
      54             :     NackInfo();
      55             :     NackInfo(uint16_t seq_num, uint16_t send_at_seq_num);
      56             : 
      57             :     uint16_t seq_num;
      58             :     uint16_t send_at_seq_num;
      59             :     int64_t sent_at_time;
      60             :     int retries;
      61             :   };
      62             :   void AddPacketsToNack(uint16_t seq_num_start, uint16_t seq_num_end)
      63             :       EXCLUSIVE_LOCKS_REQUIRED(crit_);
      64             : 
      65             :   // Removes packets from the nack list until the next keyframe. Returns true
      66             :   // if packets were removed.
      67             :   bool RemovePacketsUntilKeyFrame() EXCLUSIVE_LOCKS_REQUIRED(crit_);
      68             :   std::vector<uint16_t> GetNackBatch(NackFilterOptions options)
      69             :       EXCLUSIVE_LOCKS_REQUIRED(crit_);
      70             : 
      71             :   // Update the reordering distribution.
      72             :   void UpdateReorderingStatistics(uint16_t seq_num)
      73             :       EXCLUSIVE_LOCKS_REQUIRED(crit_);
      74             : 
      75             :   // Returns how many packets we have to wait in order to receive the packet
      76             :   // with probability |probabilty| or higher.
      77             :   int WaitNumberOfPackets(float probability) const
      78             :       EXCLUSIVE_LOCKS_REQUIRED(crit_);
      79             : 
      80             :   rtc::CriticalSection crit_;
      81             :   Clock* const clock_;
      82             :   NackSender* const nack_sender_;
      83             :   KeyFrameRequestSender* const keyframe_request_sender_;
      84             : 
      85             :   std::map<uint16_t, NackInfo, DescendingSeqNumComp<uint16_t>> nack_list_
      86             :       GUARDED_BY(crit_);
      87             :   std::set<uint16_t, DescendingSeqNumComp<uint16_t>> keyframe_list_
      88             :       GUARDED_BY(crit_);
      89             :   video_coding::Histogram reordering_histogram_ GUARDED_BY(crit_);
      90             :   bool running_ GUARDED_BY(crit_);
      91             :   bool initialized_ GUARDED_BY(crit_);
      92             :   int64_t rtt_ms_ GUARDED_BY(crit_);
      93             :   uint16_t newest_seq_num_ GUARDED_BY(crit_);
      94             :   int64_t next_process_time_ms_ GUARDED_BY(crit_);
      95             : };
      96             : 
      97             : }  // namespace webrtc
      98             : 
      99             : #endif  // WEBRTC_MODULES_VIDEO_CODING_NACK_MODULE_H_

Generated by: LCOV version 1.13