Add a GpuMemoryBuffer pool that creates hardware backed VideoFrames.

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"
 #include "base/location.h"
 #include "base/metrics/field_trial.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/buffers.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
+#include "media/renderers/gpu_video_accelerator_factories.h"
+#include "media/video/gpu_memory_buffer_video_frame_pool.h"
 
 namespace media {
 
 // TODO(dalecurtis): This experiment is temporary and should be removed once we
 // have enough data to support the primacy of the new video rendering path; see
 // http://crbug.com/485699 for details.
 static bool ShouldUseVideoRenderingPath() {
   // Note: It's important to query the field trial state first, to ensure that
   // UMA reports the correct group.
   const std::string group_name =
       base::FieldTrialList::FindFullName("NewVideoRendererTrial");
   const bool disabled_via_cli =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableNewVideoRenderer);
   return !disabled_via_cli && !StartsWithASCII(group_name, "Disabled", true);
 }
 
 VideoRendererImpl::VideoRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     VideoRendererSink* sink,
     ScopedVector<VideoDecoder> decoders,
     bool drop_frames,
+    scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories,
     const scoped_refptr<MediaLog>& media_log)
     : task_runner_(task_runner),
       use_new_video_renderering_path_(ShouldUseVideoRenderingPath()),
       sink_(sink),
       sink_started_(false),
       video_frame_stream_(
           new VideoFrameStream(task_runner, decoders.Pass(), media_log)),
+      gpu_memory_buffer_pool_(
+          new GpuMemoryBufferVideoFramePool(task_runner, gpu_factories)),
       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),
@@ skipping 429 matching lines @@
       if (use_new_video_renderering_path_)
         MaybeFireEndedCallback();
     } else {
       // Maintain the latest frame decoded so the correct frame is displayed
       // after prerolling has completed.
       if (frame->timestamp() <= start_timestamp_) {
         if (use_new_video_renderering_path_)
           algorithm_->Reset();
         ready_frames_.clear();
       }
+      // TODO(dcastagna): Enable GpuMemoryBuffer VideoFrames.

[DaleCurtis, 2015/05/12 17:23:20]

Some notes:
- To avoid blocking the media thread we might want to consider posting to the
worker pool for these copies. 
- In some cases the VideoRendererAlgorithm knows which frames we will always
drop, so say at 16x playback rate me may want to skip the uploading for frames
we know we'll never display.
- In the above case the code will let the frame pool grow to 12 frames, what
happens in OOM situations here?

[Daniele Castagna, 2015/05/12 21:21:29]

Good point. In our tests we noticed that the copy here blocks the media thread.
Overall the playback is still faster. Should we leave the copy in the worker
pool as a later optimization?
It'd be nice to skip the copy if the frame is going to be dropped.  Do you have
in mind a better place, after VideoRendererAlgorithm determined that we're not
dropping the frame, where we could do the copy?
If the original software frames are not needed for video decoding anymore, the
software frames will be dropped once we create the hardware frames, so the total
memory usage should be the same.
About this, we were planning to implement MemoryDumpProvider for the pool (the
ones in VpxVideoDecoder too) so we can better trace what's going on with memory
and pools.

[DaleCurtis, 2015/05/13 02:52:14]

Should be okay to do in a second pass, we can watch the telemetry scores to see
if it's necessary. To implement we could either refactor FrameReady slightly so
that the queuing portion can be posted to the worker pool. Or, we could have
GpuMemoryBufferPool immediately return a shell frame and have the copy happen in
the background on the worker pool thread. Though we'd need to make sure the copy
completes before the frame is actually displayed.
Well you'd need to integrate this code with the Algorithm instead somehow or
expose some information from the EnqueueFrame() call in AddReadyFrame_Locked()
which would indicate if it expects to use the frame.  There are reasons the
frame may still be used though, which would mean a copy happening on the
compositor thread sometimes.
Okay this was my confusion. I thought GPU memory might be more limited than
system memory, and thus fail in ways that we need to gracefully handle.

[Daniele Castagna, 2015/05/13 04:29:45]

Sounds good to me to do it in a second pass.
I'm going to delete these two lines since we need another cl in cc before we can
enable this.
I put the commented lines here here to start this kind of discussion.
I guess this would end up in the second pass too, right?

+      //AddReadyFrame_Locked(
+      //    gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(frame));
       AddReadyFrame_Locked(frame);
     }
 
     // Signal buffering state if we've met our conditions for having enough
     // data.
     if (buffering_state_ != BUFFERING_HAVE_ENOUGH && HaveEnoughData_Locked()) {
       TransitionToHaveEnough_Locked();
       if (use_new_video_renderering_path_ && !sink_started_ &&
           !rendered_end_of_stream_) {
         start_sink = true;
@@ skipping 225 matching lines @@
       (algorithm_->frames_queued() == 1u &&
        algorithm_->average_frame_duration() == base::TimeDelta())) {
     rendered_end_of_stream_ = true;
     task_runner_->PostTask(FROM_HERE, ended_cb_);
   }
 
   return effective_frames;
 }
 
 }  // namespace media