Bug Fix: Remote Video Hang For Apprtc Loopback

content/renderer/media/webmediaplayer_ms_compositor.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/webmediaplayer_ms_compositor.h"
 
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/hash.h"
@@ skipping 167 matching lines @@
   if (video_frame_provider_client_ && !stopped_)
     video_frame_provider_client_->StartRendering();
 }
 
 void WebMediaPlayerMSCompositor::EnqueueFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(current_frame_lock_);
   ++total_frame_count_;
 
+  // With algorithm off, just let |current_frame_| hold the incoming |frame|.
   if (!rendering_frame_buffer_) {
     SetCurrentFrame(frame);
     return;
   }
 
   // This is a signal frame saying that the stream is stopped.
   bool end_of_stream = false;
   if (frame->metadata()->GetBoolean(media::VideoFrameMetadata::END_OF_STREAM,
                                     &end_of_stream) &&
       end_of_stream) {
     rendering_frame_buffer_.reset();
     SetCurrentFrame(frame);
     return;
   }
 
+  // If we detect a bad frame without |render_time|, we switch off algorithm,
+  // because without |render_time|, algorithm cannot work.
+  // In general, this should not happen.
   base::TimeTicks render_time;
   if (!frame->metadata()->GetTimeTicks(
           media::VideoFrameMetadata::REFERENCE_TIME, &render_time)) {
     DLOG(WARNING)
         << "Incoming VideoFrames have no REFERENCE_TIME, switching off super "
            "sophisticated rendering algorithm";
     rendering_frame_buffer_.reset();
     SetCurrentFrame(frame);
     return;
   }
 
+  // The code below handles the case where UpdateCurrentFrame() callbacks stop.
+  // These callbacks can stop when the tab is hidden or the page area containing
+  // the video frame is scrolled out of view.
+  // Since some hardware decoders only have a limited number of output frames,
+  // we must aggressively release frames in this case.
+  const base::TimeTicks now = base::TimeTicks::Now();
+  if (now > last_deadline_max_) {
+    // Note: the frame in |rendering_frame_buffer_| with lowest index is the
+    // same as |current_frame_|. Function SetCurrentFrame() handles whether
+    // to increase |dropped_frame_count_| for that frame, so here we should
+    // increase |dropped_frame_count_| by the count of all other frames.
+    dropped_frame_count_ += rendering_frame_buffer_->frames_queued() - 1;
+    rendering_frame_buffer_->Reset();
+    timestamps_to_clock_times_.clear();
+    SetCurrentFrame(frame);
+  }
+
   timestamps_to_clock_times_[frame->timestamp()] = render_time;
-
   rendering_frame_buffer_->EnqueueFrame(frame);
-
-  const base::TimeTicks now = base::TimeTicks::Now();
-  if (now <= last_deadline_max_)
-    return;
-
-  // This shows vsyncs stops rendering frames. A probable cause is that the
-  // tab is not in the front. But we still have to let old frames go.
-  const base::TimeTicks deadline_max =
-      std::max(now, last_deadline_max_ + last_render_length_);
-
-  Render(deadline_max - last_render_length_, deadline_max);
 }
 
 bool WebMediaPlayerMSCompositor::UpdateCurrentFrame(
     base::TimeTicks deadline_min,
     base::TimeTicks deadline_max) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
 
   TRACE_EVENT_BEGIN2("webrtc", "WebMediaPlayerMS::UpdateCurrentFrame",
                      "Actual Render Begin", deadline_min.ToInternalValue(),
                      "Actual Render End", deadline_max.ToInternalValue());
@@ skipping 153 matching lines @@
   }
 
   if (!rendering_frame_buffer_) {
     rendering_frame_buffer_.reset(new media::VideoRendererAlgorithm(
         base::Bind(&WebMediaPlayerMSCompositor::MapTimestampsToRenderTimeTicks,
                    base::Unretained(this))));
   }
 }
 
 }  // namespace content