Experiment for the nack module.

webrtc/modules/video_coding/jitter_buffer.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.
  */
 #include "webrtc/modules/video_coding/jitter_buffer.h"
@@ skipping 10 matching lines @@
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_coding/frame_buffer.h"
 #include "webrtc/modules/video_coding/inter_frame_delay.h"
 #include "webrtc/modules/video_coding/internal_defines.h"
 #include "webrtc/modules/video_coding/jitter_buffer_common.h"
 #include "webrtc/modules/video_coding/jitter_estimator.h"
 #include "webrtc/modules/video_coding/packet.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
+#include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
-
 // Interval for updating SS data.
 static const uint32_t kSsCleanupIntervalSec = 60;
 
 // Use this rtt if no value has been reported.
 static const int64_t kDefaultRtt = 200;
 
 // Request a keyframe if no continuous frame has been received for this
 // number of milliseconds and NACKs are disabled.
 static const int64_t kMaxDiscontinuousFramesTime = 1000;
 
@@ skipping 163 matching lines @@
     if (Find(frame_it.second->TimeStamp(), &ss_it)) {
       if (gof_idx >= ss_it->second.num_frames_in_gof) {
         continue;  // Assume corresponding SS not yet received.
       }
       frame_it.second->SetGofInfo(ss_it->second, gof_idx);
     }
   }
 }
 
 VCMJitterBuffer::VCMJitterBuffer(Clock* clock,
-                                 std::unique_ptr<EventWrapper> event)
+                                 std::unique_ptr<EventWrapper> event,
+                                 NackSender* nack_sender,
+                                 KeyFrameRequestSender* keyframe_request_sender)
     : clock_(clock),
       running_(false),
       crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
       frame_event_(std::move(event)),
       max_number_of_frames_(kStartNumberOfFrames),
       free_frames_(),
       decodable_frames_(),
       incomplete_frames_(),
       last_decoded_state_(),
       first_packet_since_reset_(true),
@@ skipping 14 matching lines @@
       nack_mode_(kNoNack),
       low_rtt_nack_threshold_ms_(-1),
       high_rtt_nack_threshold_ms_(-1),
       missing_sequence_numbers_(SequenceNumberLessThan()),
       max_nack_list_size_(0),
       max_packet_age_to_nack_(0),
       max_incomplete_time_ms_(0),
       decode_error_mode_(kNoErrors),
       average_packets_per_frame_(0.0f),
       frame_counter_(0) {
+  if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
+    // Still need to check if the nack module should be created since
+    // a jitter buffer is created for the video send stream as well.

[stefan-webrtc, 2016/03/10 17:06:29]

Change this comment, since when the refactoring is done so that this isn't the
case, we shouldn't have a comment lying around saying so. Better to just say
"Only create a nack module if we are going to send nacks"

[philipel, 2016/03/11 09:24:14]

Done.

+    if (nack_sender) {
+    RTC_DCHECK(nack_sender);

[stefan-webrtc, 2016/03/10 17:06:30]

Indentation

[philipel, 2016/03/11 09:24:14]

Done.

+    RTC_DCHECK(keyframe_request_sender);
+
+    nack_module_.reset(
+        new NackModule(clock, nack_sender, keyframe_request_sender));
+    }
+  }
   for (int i = 0; i < kStartNumberOfFrames; i++)
     free_frames_.push_back(new VCMFrameBuffer());
 }
 
 VCMJitterBuffer::~VCMJitterBuffer() {
   Stop();
   for (UnorderedFrameList::iterator it = free_frames_.begin();
        it != free_frames_.end(); ++it) {
     delete *it;
   }
@@ skipping 59 matching lines @@
   first_packet_since_reset_ = true;
   rtt_ms_ = kDefaultRtt;
   last_decoded_state_.Reset();
 }
 
 void VCMJitterBuffer::Stop() {
   crit_sect_->Enter();
   UpdateHistograms();
   running_ = false;
   last_decoded_state_.Reset();
+  if (nack_module_)
+    nack_module_->Stop();
 
   // Make sure all frames are free and reset.
   for (FrameList::iterator it = decodable_frames_.begin();
        it != decodable_frames_.end(); ++it) {
     free_frames_.push_back(it->second);
   }
   for (FrameList::iterator it = incomplete_frames_.begin();
        it != incomplete_frames_.end(); ++it) {
     free_frames_.push_back(it->second);
   }
@@ skipping 20 matching lines @@
   last_decoded_state_.Reset();  // TODO(mikhal): sync reset.
   num_consecutive_old_packets_ = 0;
   // Also reset the jitter and delay estimates
   jitter_estimate_.Reset();
   inter_frame_delay_.Reset(clock_->TimeInMilliseconds());
   waiting_for_completion_.frame_size = 0;
   waiting_for_completion_.timestamp = 0;
   waiting_for_completion_.latest_packet_time = -1;
   first_packet_since_reset_ = true;
   missing_sequence_numbers_.clear();
+  if (nack_module_)
+    nack_module_->Flush();
 }
 
 // Get received key and delta frames
 FrameCounts VCMJitterBuffer::FrameStatistics() const {
   CriticalSectionScoped cs(crit_sect_);
   return receive_statistics_;
 }
 
 int VCMJitterBuffer::num_packets() const {
   CriticalSectionScoped cs(crit_sect_);
@@ skipping 216 matching lines @@
   // decoder. Propagates the missing_frame bit.
   frame->PrepareForDecode(continuous);
 
   // We have a frame - update the last decoded state and nack list.
   last_decoded_state_.SetState(frame);
   DropPacketsFromNackList(last_decoded_state_.sequence_num());
 
   if ((*frame).IsSessionComplete())
     UpdateAveragePacketsPerFrame(frame->NumPackets());
 
+  if (nack_module_)
+    nack_module_->ClearUpTo(frame->GetHighSeqNum());
   return frame;
 }
 
 // Release frame when done with decoding. Should never be used to release
 // frames from within the jitter buffer.
 void VCMJitterBuffer::ReleaseFrame(VCMEncodedFrame* frame) {
   CriticalSectionScoped cs(crit_sect_);
   VCMFrameBuffer* frame_buffer = static_cast<VCMFrameBuffer*>(frame);
   if (frame_buffer) {
     free_frames_.push_back(frame_buffer);
@@ skipping 40 matching lines @@
   const VCMFrameBuffer* frame_buffer =
       static_cast<const VCMFrameBuffer*>(frame);
   *retransmitted = (frame_buffer->GetNackCount() > 0);
   return frame_buffer->LatestPacketTimeMs();
 }
 
 VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(const VCMPacket& packet,
                                                  bool* retransmitted) {
   CriticalSectionScoped cs(crit_sect_);
 
+  if (nack_module_)
+    nack_module_->OnReceivedPacket(packet);
+
   ++num_packets_;
   if (num_packets_ == 1) {
     time_first_packet_ms_ = clock_->TimeInMilliseconds();
   }
   // Does this packet belong to an old frame?
   if (last_decoded_state_.IsOldPacket(&packet)) {
     // Account only for media packets.
     if (packet.sizeBytes > 0) {
       num_discarded_packets_++;
       num_consecutive_old_packets_++;
@@ skipping 242 matching lines @@
     // when waiting for retransmissions.
     rtt_mult = 0.0f;
   }
   return jitter_estimate_.GetJitterEstimate(rtt_mult);
 }
 
 void VCMJitterBuffer::UpdateRtt(int64_t rtt_ms) {
   CriticalSectionScoped cs(crit_sect_);
   rtt_ms_ = rtt_ms;
   jitter_estimate_.UpdateRtt(rtt_ms);
+  if (nack_module_)
+    nack_module_->UpdateRtt(rtt_ms);
 }
 
 void VCMJitterBuffer::SetNackMode(VCMNackMode mode,
                                   int64_t low_rtt_nack_threshold_ms,
                                   int64_t high_rtt_nack_threshold_ms) {
   CriticalSectionScoped cs(crit_sect_);
   nack_mode_ = mode;
   if (mode == kNoNack) {
     missing_sequence_numbers_.clear();
   }
@@ skipping 99 matching lines @@
       } else {
         // Skip to the last key frame. If it's incomplete we will start
         // NACKing it.
         // Note that the estimated low sequence number is correct for VP8
         // streams because only the first packet of a key frame is marked.
         last_decoded_state_.Reset();
         DropPacketsFromNackList(EstimatedLowSequenceNumber(*rit->second));
       }
     }
   }
+  // The experiment is running, the nack module will send Nacks.
+  if (nack_module_)
+    return std::vector<uint16_t>();
+
   std::vector<uint16_t> nack_list(missing_sequence_numbers_.begin(),
                                   missing_sequence_numbers_.end());
   return nack_list;
 }
 
 void VCMJitterBuffer::SetDecodeErrorMode(VCMDecodeErrorMode error_mode) {
   CriticalSectionScoped cs(crit_sect_);
   decode_error_mode_ = error_mode;
 }
 
@@ skipping 277 matching lines @@
     return false;
   }
   // Evaluate if the RTT is higher than |high_rtt_nack_threshold_ms_|, and in
   // that case we don't wait for retransmissions.
   if (high_rtt_nack_threshold_ms_ >= 0 &&
       rtt_ms_ >= high_rtt_nack_threshold_ms_) {
     return false;
   }
   return true;
 }
+
+int64_t VCMJitterBuffer::TimeUntilNextProcess() {
+  if (nack_module_)
+    return nack_module_->TimeUntilNextProcess();
+  return 100000;

[stefan-webrtc, 2016/03/10 17:06:29]

This is a bit ugly, but it might be necessary. Is it possible to return max of
int64_t? I have some memory that it might cause problems in ModuleProcessThread,
i.e., it will sleep for ever if this is the first module that is added... In
that case 100000 might not work well either.

[philipel, 2016/03/11 09:24:14]

Changed to int64_t max. Just testing using video_loopback I don't get any
strange (hanging) behavior.

+}
+
+void VCMJitterBuffer::Process() {
+  if (nack_module_)
+    nack_module_->Process();
+}
 }  // namespace webrtc