New jitter buffer experiment.

webrtc/modules/video_coding/packet_buffer.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.
  */
 
@@ skipping 82 matching lines @@
     last_seq_num_ = seq_num;
 
   sequence_buffer_[index].frame_begin = packet.isFirstPacket;
   sequence_buffer_[index].frame_end = packet.markerBit;
   sequence_buffer_[index].seq_num = packet.seqNum;
   sequence_buffer_[index].continuous = false;
   sequence_buffer_[index].frame_created = false;
   sequence_buffer_[index].used = true;
   data_buffer_[index] = packet;
 
   FindFrames(seq_num);

[stefan-webrtc, 2016/11/08 14:49:27]

This shouldn't be called from within crit_ now as we'll take crit_ twice.

I think it would have been better to return a list of frames from FindFrames.
That's also what it sounds like the method does. :)

[philipel, 2016/11/10 16:13:53]

FindFrames now return a vector of found frames.

   return true;
 }
 
 void PacketBuffer::ClearTo(uint16_t seq_num) {
   rtc::CritScope lock(&crit_);
 
   // If the packet buffer was cleared between a frame was created and returned.
   if (!first_packet_received_)
     return;
 
@@ skipping 67 matching lines @@
       sequence_buffer_[index].seq_num - 1) {
     return false;
   }
   if (sequence_buffer_[prev_index].continuous)
     return true;
 
   return false;
 }
 
 void PacketBuffer::FindFrames(uint16_t seq_num) {
-  while (PotentialNewFrame(seq_num)) {
-    size_t index = seq_num % size_;
-    sequence_buffer_[index].continuous = true;
+  std::vector<std::unique_ptr<RtpFrameObject>> found_frames;
+  {
+    rtc::CritScope lock(&crit_);
+    while (PotentialNewFrame(seq_num)) {
+      size_t index = seq_num % size_;
+      sequence_buffer_[index].continuous = true;
 
-    // If all packets of the frame is continuous, find the first packet of the
-    // frame and create an RtpFrameObject.
-    if (sequence_buffer_[index].frame_end) {
-      size_t frame_size = 0;
-      int max_nack_count = -1;
-      uint16_t start_seq_num = seq_num;
+      // If all packets of the frame is continuous, find the first packet of the
+      // frame and create an RtpFrameObject.
+      if (sequence_buffer_[index].frame_end) {
+        size_t frame_size = 0;
+        int max_nack_count = -1;
+        uint16_t start_seq_num = seq_num;
 
-      // Find the start index by searching backward until the packet with
-      // the |frame_begin| flag is set.
-      int start_index = index;
-      while (true) {
-        frame_size += data_buffer_[start_index].sizeBytes;
-        max_nack_count = std::max(
-            max_nack_count, data_buffer_[start_index].timesNacked);
-        sequence_buffer_[start_index].frame_created = true;
+        // Find the start index by searching backward until the packet with
+        // the |frame_begin| flag is set.
+        int start_index = index;
+        while (true) {
+          frame_size += data_buffer_[start_index].sizeBytes;
+          max_nack_count =
+              std::max(max_nack_count, data_buffer_[start_index].timesNacked);
+          sequence_buffer_[start_index].frame_created = true;
 
-        if (sequence_buffer_[start_index].frame_begin)
-          break;
+          if (sequence_buffer_[start_index].frame_begin)
+            break;
 
-        start_index = start_index > 0 ? start_index - 1 : size_ - 1;
-        start_seq_num--;
+          start_index = start_index > 0 ? start_index - 1 : size_ - 1;
+          start_seq_num--;
+        }
+
+        found_frames.emplace_back(
+            new RtpFrameObject(this, start_seq_num, seq_num, frame_size,
+                               max_nack_count, clock_->TimeInMilliseconds()));
       }
-
-      std::unique_ptr<RtpFrameObject> frame(
-          new RtpFrameObject(this, start_seq_num, seq_num, frame_size,
-                             max_nack_count, clock_->TimeInMilliseconds()));
-
-      received_frame_callback_->OnReceivedFrame(std::move(frame));
+      ++seq_num;
     }
-
-    ++seq_num;
   }
+  for (auto& frame : found_frames)
+    received_frame_callback_->OnReceivedFrame(std::move(frame));
 }
 
 void PacketBuffer::ReturnFrame(RtpFrameObject* frame) {
   rtc::CritScope lock(&crit_);
   size_t index = frame->first_seq_num() % size_;
   size_t end = (frame->last_seq_num() + 1) % size_;
   uint16_t seq_num = frame->first_seq_num();
   while (index != end) {
     if (sequence_buffer_[index].seq_num == seq_num) {
       delete[] data_buffer_[index].dataPtr;
@@ skipping 23 matching lines @@
     size_t length = data_buffer_[index].sizeBytes;
     memcpy(destination, source, length);
     destination += length;
     index = (index + 1) % size_;
     ++seq_num;
   }
   return true;
 }
 
 VCMPacket* PacketBuffer::GetPacket(uint16_t seq_num) {
-  rtc::CritScope lock(&crit_);
   size_t index = seq_num % size_;
   if (!sequence_buffer_[index].used ||
       seq_num != sequence_buffer_[index].seq_num) {
     return nullptr;
   }
   return &data_buffer_[index];
 }
 
 int PacketBuffer::AddRef() const {
   return rtc::AtomicOps::Increment(&ref_count_);
 }
 
 int PacketBuffer::Release() const {
   int count = rtc::AtomicOps::Decrement(&ref_count_);
   if (!count) {
     delete this;
   }
   return count;
 }
 
 }  // namespace video_coding
 }  // namespace webrtc