First-order-FEC recoverability calculation

webrtc/test/fuzzers/transport_feedback_packet_loss_tracker_fuzzer.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <algorithm>
 
 #include "webrtc/base/array_view.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/voice_engine/transport_feedback_packet_loss_tracker.h"
 
 namespace webrtc {
 
 namespace {
 
+template <typename T>
+T FuzzInput(const uint8_t*& data, size_t& size) {
+  RTC_CHECK(size >= sizeof(T));
+  T rc = ByteReader<T>::ReadBigEndian(data);
+  data += sizeof(T);
+  size -= sizeof(T);
+  return rc;
+}
+
 using TransportFeedback = rtcp::TransportFeedback;
 
 class FuzzTransportFeedback final : public rtcp::TransportFeedbackInterface {
  public:
   explicit FuzzTransportFeedback(rtc::ArrayView<const uint8_t> data)
       : data_(data), ended_(false), data_idx_(0) {
     ParseNextTransportFeedback();
   }
 
   uint16_t GetBaseSequence() const override { return base_seq_num_; }
@@ skipping 77 matching lines @@
   const rtc::ArrayView<const uint8_t> data_;
   bool ended_;
   size_t data_idx_;
   uint16_t base_seq_num_;
   std::vector<TransportFeedback::StatusSymbol> statuses_;
 };
 
 }  // namespace
 
 void FuzzOneInput(const uint8_t* data, size_t size) {
-  if (size < sizeof(uint32_t)) {
+  if (size < 3 * sizeof(uint16_t)) {
     return;
   }
   constexpr size_t kSeqNumHalf = 0x8000u;
+
+  // Produce min-window, max-window and min_pairs_num_for_rplr, such that:
+  // a. min <= max <= kSeqNumHalf
+  // b. 1 <= min_pairs_num_for_rplr <= max - 1 (fencepost)
+  // Because of /b/, both min and max can't be below 2.
+
   const size_t window_size_1 = std::min(
       kSeqNumHalf,
-      static_cast<size_t>(std::max(static_cast<uint16_t>(1),
-                                   ByteReader<uint16_t>::ReadBigEndian(data))));
-  data += sizeof(uint16_t);
+      static_cast<size_t>(std::max(static_cast<uint16_t>(2),
+                                   FuzzInput<uint16_t>(data, size))));
   const size_t window_size_2 = std::min(
       kSeqNumHalf,
+      static_cast<size_t>(std::max(static_cast<uint16_t>(2),
+                                   FuzzInput<uint16_t>(data, size))));
+  const size_t min_window_size = std::min(window_size_1, window_size_2);
+  const size_t max_window_size = std::max(window_size_1, window_size_2);
+  const size_t min_pairs_num_for_rplr = std::min(
+      max_window_size - 1,
       static_cast<size_t>(std::max(static_cast<uint16_t>(1),
-                                   ByteReader<uint16_t>::ReadBigEndian(data))));
-  data += sizeof(uint16_t);
-  size -= 2 * sizeof(uint16_t);
+                                   FuzzInput<uint16_t>(data, size))));
 
   TransportFeedbackPacketLossTracker tracker(
-      std::min(window_size_1, window_size_2),
-      std::max(window_size_1, window_size_2));
+      min_window_size, max_window_size, min_pairs_num_for_rplr);
   FuzzTransportFeedback feedback(rtc::ArrayView<const uint8_t>(data, size));
   while (!feedback.ended()) {
     tracker.OnReceivedTransportFeedback(feedback);
     tracker.Validate();
     feedback.ParseNextTransportFeedback();
   }
 }
 
 }  // namespace webrtc