Dont request keyframes if the stream is inactive or if we are currently receiving a keyframe.

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 41 matching lines @@
 }
 
 PacketBuffer::~PacketBuffer() {
   Clear();
 }
 
 bool PacketBuffer::InsertPacket(VCMPacket* packet) {
   std::vector<std::unique_ptr<RtpFrameObject>> found_frames;
   {
     rtc::CritScope lock(&crit_);
+
     uint16_t seq_num = packet->seqNum;
     size_t index = seq_num % size_;
 
     if (!first_packet_received_) {
       first_seq_num_ = seq_num;
       first_packet_received_ = true;
     } else if (AheadOf(first_seq_num_, seq_num)) {
       // If we have explicitly cleared past this packet then it's old,
       // don't insert it.
       if (is_cleared_to_first_seq_num_) {
@@ skipping 28 matching lines @@
 
     sequence_buffer_[index].frame_begin = packet->is_first_packet_in_frame;
     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;
     packet->dataPtr = nullptr;
 
+    int64_t now_ms = clock_->TimeInMilliseconds();
+    last_received_packet_ms_ = rtc::Optional<int64_t>(now_ms);
+    if (packet->frameType == kVideoFrameKey)
+      last_received_keyframe_packet_ms_ = rtc::Optional<int64_t>(now_ms);
+
     found_frames = FindFrames(seq_num);
   }
 
   for (std::unique_ptr<RtpFrameObject>& frame : found_frames)
     received_frame_callback_->OnReceivedFrame(std::move(frame));
 
   return true;
 }
 
 void PacketBuffer::ClearTo(uint16_t seq_num) {
@@ skipping 16 matching lines @@
 void PacketBuffer::Clear() {
   rtc::CritScope lock(&crit_);
   for (size_t i = 0; i < size_; ++i) {
     delete[] data_buffer_[i].dataPtr;
     data_buffer_[i].dataPtr = nullptr;
     sequence_buffer_[i].used = false;
   }
 
   first_packet_received_ = false;
   is_cleared_to_first_seq_num_ = false;
+  last_received_packet_ms_ = rtc::Optional<int64_t>();
+  last_received_keyframe_packet_ms_ = rtc::Optional<int64_t>();
+}
+
+rtc::Optional<int64_t> PacketBuffer::LastReceivedPacketMs() const {

[stefan-webrtc, 2017/05/17 06:32:11]

I think it would be good to add thread checks to ensure that the methods which
are called from the decode thread are actually called from there,and vice versa.

[philipel, 2017/05/18 09:23:40]

I'm not sure I understand why we should do that. We will need synchronization
since the timestamps are updated by the network thread and read by the decoding
thread.

We could use atomic for these variables of course but I don't think we would
gain anything by doing it.

[holmer, 2017/05/18 09:25:52]

The main reason would be to ensure we get calls from only the threads we expect,
for documentation.

+  rtc::CritScope lock(&crit_);
+  return last_received_packet_ms_;
+}
+
+rtc::Optional<int64_t> PacketBuffer::LastReceivedKeyframePacketMs() const {
+  rtc::CritScope lock(&crit_);
+  return last_received_keyframe_packet_ms_;
 }
 
 bool PacketBuffer::ExpandBufferSize() {
   if (size_ == max_size_) {
     LOG(LS_WARNING) << "PacketBuffer is already at max size (" << max_size_
                     << "), failed to increase size. Clearing PacketBuffer.";
     Clear();
     return false;
   }
 
@@ skipping 156 matching lines @@
 int PacketBuffer::Release() const {
   int count = rtc::AtomicOps::Decrement(&ref_count_);
   if (!count) {
     delete this;
   }
   return count;
 }
 
 }  // namespace video_coding
 }  // namespace webrtc