media: Make GpuMemoryBuffers VideoFrame copies asynchronous.

media/renderers/video_renderer_impl.cc

 // Copyright 2013 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 "media/renderers/video_renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 26 matching lines @@
       base::FieldTrialList::FindFullName("NewVideoRendererTrial");
   const bool disabled_via_cli =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableNewVideoRenderer);
   return !disabled_via_cli &&
          !base::StartsWith(group_name, "Disabled",
                            base::CompareCase::SENSITIVE);
 }
 
 VideoRendererImpl::VideoRendererImpl(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
+    const scoped_refptr<base::TaskRunner>& worker_task_runner,
     VideoRendererSink* sink,
     ScopedVector<VideoDecoder> decoders,
     bool drop_frames,
     const scoped_refptr<GpuVideoAcceleratorFactories>& gpu_factories,
     const scoped_refptr<MediaLog>& media_log)
-    : task_runner_(task_runner),
+    : task_runner_(media_task_runner),
       use_new_video_renderering_path_(ShouldUseVideoRenderingPath()),
       sink_(sink),
       sink_started_(false),
       video_frame_stream_(
-          new VideoFrameStream(task_runner, decoders.Pass(), media_log)),
+          new VideoFrameStream(media_task_runner, decoders.Pass(), media_log)),
       gpu_memory_buffer_pool_(
-          new GpuMemoryBufferVideoFramePool(task_runner, gpu_factories)),
+          new GpuMemoryBufferVideoFramePool(media_task_runner,
+                                            worker_task_runner,
+                                            gpu_factories)),
       media_log_(media_log),
       low_delay_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(),
       pending_read_(false),
       drop_frames_(drop_frames),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       frames_decoded_(0),
       frames_dropped_(0),
       is_shutting_down_(false),
       tick_clock_(new base::DefaultTickClock()),
       was_background_rendering_(false),
       time_progressing_(false),
       render_first_frame_and_stop_(false),
       posted_maybe_stop_after_first_paint_(false),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 VideoRendererImpl::~VideoRendererImpl() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!use_new_video_renderering_path_) {
     base::AutoLock auto_lock(lock_);
     is_shutting_down_ = true;
     frame_available_.Signal();
   }
 
@@ skipping 376 matching lines @@
   last_media_time_ = ConvertMediaTimestamp(ready_frames_.front()->timestamp());
 
   ready_frames_.pop_front();
   frames_dropped_++;
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoRendererImpl::AttemptRead, weak_factory_.GetWeakPtr()));
 }
 
+void VideoRendererImpl::FrameReadyForCopyingToGpuMemoryBuffers(
+    VideoFrameStream::Status status,
+    const scoped_refptr<VideoFrame>& frame) {
+  if (status != VideoFrameStream::OK || start_timestamp_ > frame->timestamp()) {

[DaleCurtis, 2015/08/17 18:01:30]

Notably, the very first frame might not be in a GMB when playback starts. I.e.
if start time is 0.5 and we get frames 0, 1 you'll upload 1 but not zero, even
though the algorithm will keep 0 for display.

[Daniele Castagna, 2015/08/19 21:31:25]

Ack.

+    VideoRendererImpl::FrameReady(status, frame);
+    return;
+  }
+
+  DCHECK(frame);
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      frame, base::Bind(&VideoRendererImpl::FrameReady,
+                        weak_factory_.GetWeakPtr(), status));
+}
+
 void VideoRendererImpl::FrameReady(VideoFrameStream::Status status,
                                    const scoped_refptr<VideoFrame>& frame) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   bool start_sink = false;
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_NE(state_, kUninitialized);
     DCHECK_NE(state_, kFlushed);
 
     CHECK(pending_read_);
@@ skipping 191 matching lines @@
 
   if (pending_read_ || received_end_of_stream_)
     return;
 
   if (HaveReachedBufferingCap())
     return;
 
   switch (state_) {
     case kPlaying:
       pending_read_ = true;
-      video_frame_stream_->Read(base::Bind(&VideoRendererImpl::FrameReady,
-                                           weak_factory_.GetWeakPtr()));
+
+      video_frame_stream_->Read(
+          base::Bind(&VideoRendererImpl::FrameReadyForCopyingToGpuMemoryBuffers,
+                     weak_factory_.GetWeakPtr()));
       return;
 
     case kUninitialized:
     case kInitializing:
     case kFlushing:
     case kFlushed:
       return;
   }
 }
 
@@ skipping 104 matching lines @@
 base::TimeTicks VideoRendererImpl::ConvertMediaTimestamp(
     base::TimeDelta media_time) {
   std::vector<base::TimeDelta> media_times(1, media_time);
   std::vector<base::TimeTicks> wall_clock_times;
   if (!wall_clock_time_cb_.Run(media_times, &wall_clock_times))
     return base::TimeTicks();
   return wall_clock_times[0];
 }
 
 }  // namespace media