Reland of Make the new jitter buffer the default jitter buffer.

webrtc/video/rtp_stream_receiver.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 181 matching lines @@
   }
 
   if (config_.rtp.rtcp_xr.receiver_reference_time_report)
     rtp_rtcp_->SetRtcpXrRrtrStatus(true);
 
   // Stats callback for CNAME changes.
   rtp_rtcp_->RegisterRtcpStatisticsCallback(receive_stats_proxy);
 
   process_thread_->RegisterModule(rtp_rtcp_.get());
 
-  jitter_buffer_experiment_ =
-      field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled";
+  nack_module_.reset(
+      new NackModule(clock_, nack_sender, keyframe_request_sender));
+  if (config_.rtp.nack.rtp_history_ms == 0)
+    nack_module_->Stop();
+  process_thread_->RegisterModule(nack_module_.get());
 
-  if (jitter_buffer_experiment_) {
-    nack_module_.reset(
-        new NackModule(clock_, nack_sender, keyframe_request_sender));
-    process_thread_->RegisterModule(nack_module_.get());
-
-    packet_buffer_ = video_coding::PacketBuffer::Create(
-        clock_, kPacketBufferStartSize, kPacketBufferMaxSixe, this);
-    reference_finder_.reset(new video_coding::RtpFrameReferenceFinder(this));
-  }
+  packet_buffer_ = video_coding::PacketBuffer::Create(
+      clock_, kPacketBufferStartSize, kPacketBufferMaxSixe, this);
+  reference_finder_.reset(new video_coding::RtpFrameReferenceFinder(this));
 }
 
 RtpStreamReceiver::~RtpStreamReceiver() {
   process_thread_->DeRegisterModule(rtp_rtcp_.get());
 
-  if (jitter_buffer_experiment_)
-    process_thread_->DeRegisterModule(nack_module_.get());
+  process_thread_->DeRegisterModule(nack_module_.get());
 
   packet_router_->RemoveRtpModule(rtp_rtcp_.get());
   rtp_rtcp_->SetREMBStatus(false);
   remb_->RemoveReceiveChannel(rtp_rtcp_.get());
   UpdateHistograms();
 }
 
 bool RtpStreamReceiver::AddReceiveCodec(
     const VideoCodec& video_codec,
     const std::map<std::string, std::string>& codec_params) {
@@ skipping 23 matching lines @@
 }
 
 int32_t RtpStreamReceiver::OnReceivedPayloadData(
     const uint8_t* payload_data,
     size_t payload_size,
     const WebRtcRTPHeader* rtp_header) {
   RTC_DCHECK(video_receiver_);
   WebRtcRTPHeader rtp_header_with_ntp = *rtp_header;
   rtp_header_with_ntp.ntp_time_ms =
       ntp_estimator_.Estimate(rtp_header->header.timestamp);
-  if (jitter_buffer_experiment_) {
-    VCMPacket packet(payload_data, payload_size, rtp_header_with_ntp);
-    timing_->IncomingTimestamp(packet.timestamp, clock_->TimeInMilliseconds());
-    packet.timesNacked = nack_module_->OnReceivedPacket(packet);
+  VCMPacket packet(payload_data, payload_size, rtp_header_with_ntp);
+  timing_->IncomingTimestamp(packet.timestamp, clock_->TimeInMilliseconds());
+  packet.timesNacked = nack_module_->OnReceivedPacket(packet);
 
-    if (packet.codec == kVideoCodecH264) {
-      // Only when we start to receive packets will we know what payload type
-      // that will be used. When we know the payload type insert the correct
-      // sps/pps into the tracker.
-      if (packet.payloadType != last_payload_type_) {
-        last_payload_type_ = packet.payloadType;
-        InsertSpsPpsIntoTracker(packet.payloadType);
-      }
-
-      switch (tracker_.CopyAndFixBitstream(&packet)) {
-        case video_coding::H264SpsPpsTracker::kRequestKeyframe:
-          keyframe_request_sender_->RequestKeyFrame();
-          FALLTHROUGH();
-        case video_coding::H264SpsPpsTracker::kDrop:
-          return 0;
-        case video_coding::H264SpsPpsTracker::kInsert:
-          break;
-      }
-    } else {
-      uint8_t* data = new uint8_t[packet.sizeBytes];
-      memcpy(data, packet.dataPtr, packet.sizeBytes);
-      packet.dataPtr = data;
+  if (packet.codec == kVideoCodecH264) {
+    // Only when we start to receive packets will we know what payload type
+    // that will be used. When we know the payload type insert the correct
+    // sps/pps into the tracker.
+    if (packet.payloadType != last_payload_type_) {
+      last_payload_type_ = packet.payloadType;
+      InsertSpsPpsIntoTracker(packet.payloadType);
     }
 
-    packet_buffer_->InsertPacket(&packet);
+    switch (tracker_.CopyAndFixBitstream(&packet)) {
+      case video_coding::H264SpsPpsTracker::kRequestKeyframe:
+        keyframe_request_sender_->RequestKeyFrame();
+        FALLTHROUGH();
+      case video_coding::H264SpsPpsTracker::kDrop:
+        return 0;
+      case video_coding::H264SpsPpsTracker::kInsert:
+        break;
+    }
   } else {
-    if (video_receiver_->IncomingPacket(payload_data, payload_size,
-                                        rtp_header_with_ntp) != 0) {
-      // Check this...
-      return -1;
-    }
+    uint8_t* data = new uint8_t[packet.sizeBytes];
+    memcpy(data, packet.dataPtr, packet.sizeBytes);
+    packet.dataPtr = data;
   }
+
+  packet_buffer_->InsertPacket(&packet);
   return 0;
 }
 
 bool RtpStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
                                           size_t rtp_packet_length) {
   RTPHeader header;
   if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) {
     return false;
   }
   header.payload_type_frequency = kVideoPayloadTypeFrequency;
@@ skipping 116 matching lines @@
   {
     rtc::CritScope lock(&last_seq_num_cs_);
     video_coding::RtpFrameObject* rtp_frame =
         static_cast<video_coding::RtpFrameObject*>(frame.get());
     last_seq_num_for_pic_id_[rtp_frame->picture_id] = rtp_frame->last_seq_num();
   }
   complete_frame_callback_->OnCompleteFrame(std::move(frame));
 }
 
 void RtpStreamReceiver::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
-  if (jitter_buffer_experiment_)
-    nack_module_->UpdateRtt(max_rtt_ms);
+  nack_module_->UpdateRtt(max_rtt_ms);
 }
 
 bool RtpStreamReceiver::ReceivePacket(const uint8_t* packet,
                                       size_t packet_length,
                                       const RTPHeader& header,
                                       bool in_order) {
   if (rtp_payload_registry_.IsEncapsulated(header)) {
     return ParseAndHandleEncapsulatingHeader(packet, packet_length, header);
   }
   const uint8_t* payload = packet + header.headerLength;
@@ skipping 107 matching lines @@
                            &rtp_timestamp) != 0) {
     // Waiting for RTCP.
     return true;
   }
   ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
 
   return true;
 }
 
 void RtpStreamReceiver::FrameContinuous(uint16_t picture_id) {
-  if (jitter_buffer_experiment_) {
-    int seq_num = -1;
-    {
-      rtc::CritScope lock(&last_seq_num_cs_);
-      auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id);
-      if (seq_num_it != last_seq_num_for_pic_id_.end())
-        seq_num = seq_num_it->second;
-    }
-    if (seq_num != -1)
-      nack_module_->ClearUpTo(seq_num);
+  int seq_num = -1;
+  {
+    rtc::CritScope lock(&last_seq_num_cs_);
+    auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id);
+    if (seq_num_it != last_seq_num_for_pic_id_.end())
+      seq_num = seq_num_it->second;
   }
+  if (seq_num != -1)
+    nack_module_->ClearUpTo(seq_num);
 }
 
 void RtpStreamReceiver::FrameDecoded(uint16_t picture_id) {
-  if (jitter_buffer_experiment_) {
-    int seq_num = -1;
-    {
-      rtc::CritScope lock(&last_seq_num_cs_);
-      auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id);
-      if (seq_num_it != last_seq_num_for_pic_id_.end()) {
-        seq_num = seq_num_it->second;
-        last_seq_num_for_pic_id_.erase(last_seq_num_for_pic_id_.begin(),
-                                       ++seq_num_it);
-      }
+  int seq_num = -1;
+  {
+    rtc::CritScope lock(&last_seq_num_cs_);
+    auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id);
+    if (seq_num_it != last_seq_num_for_pic_id_.end()) {
+      seq_num = seq_num_it->second;
+      last_seq_num_for_pic_id_.erase(last_seq_num_for_pic_id_.begin(),
+                                     ++seq_num_it);
     }
-    if (seq_num != -1) {
-      packet_buffer_->ClearTo(seq_num);
-      reference_finder_->ClearTo(seq_num);
-    }
+  }
+  if (seq_num != -1) {
+    packet_buffer_->ClearTo(seq_num);
+    reference_finder_->ClearTo(seq_num);
   }
 }
 
 void RtpStreamReceiver::SignalNetworkState(NetworkState state) {
   rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode
                                                : RtcpMode::kOff);
 }
 
 void RtpStreamReceiver::StartReceive() {
   rtc::CritScope lock(&receive_cs_);
@@ skipping 76 matching lines @@
   if (sprop_base64_it == codec_params_it->second.end())
     return;
 
   if (!sprop_decoder.DecodeSprop(sprop_base64_it->second))
     return;
 
   tracker_.InsertSpsPps(sprop_decoder.sps_nalu(), sprop_decoder.pps_nalu());
 }
 
 }  // namespace webrtc