First-order-FEC recoverability calculation

webrtc/voice_engine/transport_feedback_packet_loss_tracker.h

Index: webrtc/voice_engine/transport_feedback_packet_loss_tracker.h
diff --git a/webrtc/voice_engine/transport_feedback_packet_loss_tracker.h b/webrtc/voice_engine/transport_feedback_packet_loss_tracker.h
index e5626eb9b22a44d7961809f7f9a32f2f74938602..0ab909839c0d9ecdc15a0c6992be09fe1bf89167 100644
--- a/webrtc/voice_engine/transport_feedback_packet_loss_tracker.h
+++ b/webrtc/voice_engine/transport_feedback_packet_loss_tracker.h
@@ -26,19 +26,23 @@ class TransportFeedbackPacketLossTracker final {
  public:
   // Up to |max_window_size| latest packet statuses wil be used for calculating
   // the packet loss metrics. When less than |min_window_size| samples are
-  // available for making a reliable estimation, GetPacketLossRates() will
-  // return false to indicate packet loss metrics are not ready.
+  // available for making a reliable estimation, neither PLR nor RPLR would
+  // be considered validly computable.
+  // When |rplr_min_num_pairs| pairs or more are available, RPLR is reliably
+  // computable. This is independent of PLR being computable.
   TransportFeedbackPacketLossTracker(size_t min_window_size,
-                                     size_t max_window_size);
+                                     size_t max_window_size,
+                                     size_t rplr_min_num_pairs);

[stefan-webrtc, 2017/01/25 16:27:48]

May want to define rplr above.

[elad.alon_webrtc.org, 2017/01/25 18:28:43]

Please explain? You mean to make the order min-x, min-y, max-y?

 
   void OnReceivedTransportFeedback(const rtcp::TransportFeedback& feedback);
 
-  // Returns true if packet loss rate and packet loss episode duration are ready
-  // and assigns respective values to |*packet_loss_rate| and
-  // |*consecutive_packet_loss_rate|. Continuous packet loss rate is defined as
-  // the probability of losing two adjacent packets.
-  bool GetPacketLossRates(float* packet_loss_rate,
-                          float* consecutive_packet_loss_rate) const;
+  // Returns the packet loss rate, if the window has enough data to
+  // reliably compute it.
+  rtc::Optional<float> GetPacketLossRate() const;
+
+  // Returns the first-order-FEC recoverable packet loss rate, if the window
+  // has enough data to reliably compute it.
+  rtc::Optional<float> GetRecoverablePacketLossRate() const;
 
   // Verifies that the internal states are correct. Only used for tests.
   void Validate() const;
@@ -51,6 +55,7 @@ class TransportFeedbackPacketLossTracker final {
   typedef PacketStatus::const_iterator PacketStatusIterator;
 
   void Reset();
+
   // ReferenceSequenceNumber() provides a sequence number that defines the
   // order of packet reception info stored in |packet_status_window_|. In
   // particular, given any sequence number |x|,
@@ -60,22 +65,51 @@ class TransportFeedbackPacketLossTracker final {
   bool IsOldSequenceNumber(uint16_t seq_num) const;
   void InsertPacketStatus(uint16_t seq_num, bool received);
   void RemoveOldestPacketStatus();
-  void ApplyPacketStatus(PacketStatusIterator it);
-  void UndoPacketStatus(PacketStatusIterator it);
+
+  void UpdateMetrics(PacketStatusIterator it, bool apply /* false = undo */);
+  void UpdatePlr(PacketStatusIterator it, bool apply /* false = undo */);
+  void UpdateRplr(PacketStatusIterator it, bool apply /* false = undo */);
+
   PacketStatusIterator PreviousPacketStatus(PacketStatusIterator it);
   PacketStatusIterator NextPacketStatus(PacketStatusIterator it);
 
-  const size_t min_window_size_;
   const size_t max_window_size_;
 
   PacketStatus packet_status_window_;
   // |ref_packet_status_| points to the oldest item in |packet_status_window_|.
   PacketStatusIterator ref_packet_status_;
 
-  size_t num_received_packets_;
-  size_t num_lost_packets_;
-  size_t num_consecutive_losses_;
-  size_t num_consecutive_old_reports_;
+  struct PlrState {
+    PlrState(size_t min_window_size)
+        : min_window_size_(min_window_size) {
+      Reset();
+    }
+    void Reset() {

[stefan-webrtc, 2017/01/25 16:27:48]

Instead of using a Reset() method, how about creating a new instance instead?

plr_state_ = Plrstate(min_window_size);

[elad.alon_webrtc.org, 2017/01/25 18:28:43]

That would rely on bitwise copy being appropriate here. Are we sure we want to
add this assumption? It does hold at the moment. But I am not sure it saves CPU
or on binary size, since machine code for a non-trivial ctor - one which sets
the values to zero - would still need to be produced.

Alternatively, we could hold a std::unique_ptr<PlrState> instead, but that seems
to me like overkill.

Thoughts?

+      num_received_packets_ = 0;
+      num_lost_packets_ = 0;
+    }
+    rtc::Optional<float> GetMetric() const;
+    const size_t min_window_size_;
+    size_t num_received_packets_;
+    size_t num_lost_packets_;
+  } plr_state_;
+
+  struct RplrState {
+    RplrState(size_t min_num_pairs)
+        : min_num_pairs_(min_num_pairs) {
+      Reset();
+    }
+    void Reset() {
+      num_known_pairs_ = 0;
+      num_loss_followed_by_reception_pairs_ = 0;
+    }
+    rtc::Optional<float> GetMetric() const;
+    const size_t min_num_pairs_;
+    size_t num_known_pairs_;
+    size_t num_loss_followed_by_reception_pairs_;
+  } rplr_state_;
+
+  size_t num_consecutive_old_reports_;  // TODO(elad.alon): Upcoming CL removes.
 };
 
 }  // namespace webrtc