Simplify public interface of ProducerFec.

webrtc/modules/rtp_rtcp/source/producer_fec.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 83 matching lines @@
 
 ProducerFec::ProducerFec()
     : fec_(ForwardErrorCorrection::CreateUlpfec()),
       num_protected_frames_(0),
       num_important_packets_(0),
       min_num_media_packets_(1) {
   memset(&params_, 0, sizeof(params_));
   memset(&new_params_, 0, sizeof(new_params_));
 }
 
-ProducerFec::~ProducerFec() {
-  DeleteMediaPackets();
-}
+ProducerFec::~ProducerFec() = default;
 
 std::unique_ptr<RedPacket> ProducerFec::BuildRedPacket(
     const uint8_t* data_buffer,
     size_t payload_length,
     size_t rtp_header_length,
     int red_payload_type) {
   std::unique_ptr<RedPacket> red_packet(new RedPacket(
       payload_length + kRedForFecHeaderLength + rtp_header_length));
   int payload_type = data_buffer[1] & 0x7f;
   red_packet->CreateHeader(data_buffer, rtp_header_length, red_payload_type,
@@ skipping 56 matching lines @@
     // it is currently always disabled.
     //
     // Since unequal protection is disabled, the value of
     // |num_important_packets_| has no importance when calling GenerateFec().
     constexpr bool kUseUnequalProtection = false;
     int ret = fec_->EncodeFec(media_packets_, params_.fec_rate,
                               num_important_packets_, kUseUnequalProtection,
                               params_.fec_mask_type, &generated_fec_packets_);
     if (generated_fec_packets_.empty()) {
       num_protected_frames_ = 0;
-      DeleteMediaPackets();
+      media_packets_.clear();
     }
     return ret;
   }
   return 0;
 }
 
 bool ProducerFec::ExcessOverheadBelowMax() const {
   return ((Overhead() - params_.fec_rate) < kMaxExcessOverhead);
 }
 
 bool ProducerFec::MinimumMediaPacketsReached() const {
   float average_num_packets_per_frame =
       static_cast<float>(media_packets_.size()) / num_protected_frames_;
   int num_media_packets = static_cast<int>(media_packets_.size());
   if (average_num_packets_per_frame < kMinMediaPacketsAdaptationThreshold) {
     return num_media_packets >= min_num_media_packets_;
   } else {
     // For larger rates (more packets/frame), increase the threshold.
     // TODO(brandtr): Investigate what impact this adaptation has.
     return num_media_packets >= min_num_media_packets_ + 1;
   }
 }
 
-bool ProducerFec::FecAvailable() const {
-  return !generated_fec_packets_.empty();
-}
-
 size_t ProducerFec::NumAvailableFecPackets() const {
   return generated_fec_packets_.size();

[stefan-webrtc, 2016/09/05 14:50:20]

Since generated_fec_packets_ is a list, this method may run in linear time
compared to the one you removed which is constant. Maybe it's worth keeping it?
Or remove NumAvailableFecPackets instead?

[stefan-webrtc, 2016/09/05 14:52:36]

Or actually since it's only tests, I'm ok with doing as you've done.

[brandtr, 2016/09/05 14:58:38]

NumAvailableFecPackets() is used by RTPSenderVideo to allocate sequence numbers
for the RED packets, so that's needed. I'll remove FecAvailable() :)

[brandtr, 2016/09/26 14:09:27]

Sorry for the flip-flopping here, but I decided to keep the FecAvailable method
around. It will be used in the FlexfecSender/RTPSenderVideo integration, which
was not finalized when I submitted this CL.

 }
 
 size_t ProducerFec::MaxPacketOverhead() const {
   return fec_->MaxPacketOverhead();
 }
 
 std::vector<std::unique_ptr<RedPacket>> ProducerFec::GetFecPacketsAsRed(
     int red_payload_type,
     int ulpfec_payload_type,
     uint16_t first_seq_num,
@@ skipping 11 matching lines @@
     std::unique_ptr<RedPacket> red_packet(new RedPacket(
         fec_packet->length + kRedForFecHeaderLength + rtp_header_length));
     red_packet->CreateHeader(last_media_packet->data, rtp_header_length,
                              red_payload_type, ulpfec_payload_type);
     red_packet->SetSeqNum(seq_num++);
     red_packet->ClearMarkerBit();
     red_packet->AssignPayload(fec_packet->data, fec_packet->length);
     red_packets.push_back(std::move(red_packet));
   }
   // Reset state.
-  DeleteMediaPackets();
+  media_packets_.clear();
   generated_fec_packets_.clear();
   num_protected_frames_ = 0;
   return red_packets;
 }
 
 int ProducerFec::Overhead() const {
-  // Overhead is defined as relative to the number of media packets, and not
-  // relative to total number of packets. This definition is inherited from the
-  // protection factor produced by video_coding module and how the FEC
-  // generation is implemented.
   RTC_DCHECK(!media_packets_.empty());
   int num_fec_packets =
       fec_->NumFecPackets(media_packets_.size(), params_.fec_rate);
   // Return the overhead in Q8.
   return (num_fec_packets << 8) / media_packets_.size();
 }
 
-void ProducerFec::DeleteMediaPackets() {
-  media_packets_.clear();
-}
-
 }  // namespace webrtc