Introduce GpuVideoDecodeAcceleratorFactory.

content/common/gpu/media/video_decode_accelerator_unittest.cc

 // Copyright (c) 2012 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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11/{EGL/GLES2,GLX/GL} or
 //   Win/EGL.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
@@ skipping 29 matching lines @@
 #include "base/strings/stringize_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "content/common/gpu/media/fake_video_decode_accelerator.h"
+#include "content/common/gpu/media/gpu_video_decode_accelerator_factory_impl.h"
 #include "content/common/gpu/media/rendering_helper.h"
 #include "content/common/gpu/media/video_accelerator_unittest_helpers.h"
 #include "content/public/common/content_switches.h"
+#include "gpu/command_buffer/service/gpu_preferences.h"
 #include "media/filters/h264_parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gl/gl_image.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "content/common/gpu/media/dxva_video_decode_accelerator_win.h"
 #elif defined(OS_CHROMEOS)
 #if defined(USE_V4L2_CODEC)
@@ skipping 289 matching lines @@
   int num_queued_fragments() { return num_queued_fragments_; }
   int num_decoded_frames() { return num_decoded_frames_; }
   double frames_per_second();
   // Return the median of the decode time of all decoded frames.
   base::TimeDelta decode_time_median();
   bool decoder_deleted() { return !decoder_.get(); }
 
  private:
   typedef std::map<int32_t, scoped_refptr<TextureRef>> TextureRefMap;
 
-  scoped_ptr<media::VideoDecodeAccelerator> CreateFakeVDA();
-  scoped_ptr<media::VideoDecodeAccelerator> CreateDXVAVDA();
-  scoped_ptr<media::VideoDecodeAccelerator> CreateV4L2VDA();
-  scoped_ptr<media::VideoDecodeAccelerator> CreateV4L2SliceVDA();
-  scoped_ptr<media::VideoDecodeAccelerator> CreateVaapiVDA();
-
-  void BindImage(uint32_t client_texture_id,
-                 uint32_t texture_target,
-                 scoped_refptr<gl::GLImage> image);
-
   void SetState(ClientState new_state);
   void FinishInitialization();
   void ReturnPicture(int32_t picture_buffer_id);
 
   // Delete the associated decoder helper.
   void DeleteDecoder();
 
   // Compute & return the first encoded bytes (including a start frame) to send
   // to the decoder, starting at |start_pos| and returning one fragment. Skips
   // to the first decodable position.
@@ skipping 12 matching lines @@
   size_t window_id_;
   RenderingHelper* rendering_helper_;
   gfx::Size frame_size_;
   std::string encoded_data_;
   const int num_in_flight_decodes_;
   int outstanding_decodes_;
   size_t encoded_data_next_pos_to_decode_;
   int next_bitstream_buffer_id_;
   ClientStateNotification<ClientState>* note_;
   scoped_ptr<VideoDecodeAccelerator> decoder_;
-  scoped_ptr<base::WeakPtrFactory<VideoDecodeAccelerator> >
-      weak_decoder_factory_;
+  base::WeakPtr<VideoDecodeAccelerator> weak_vda_;
+  scoped_ptr<base::WeakPtrFactory<VideoDecodeAccelerator>>
+      weak_vda_ptr_factory_;
+  scoped_ptr<GpuVideoDecodeAcceleratorFactory> vda_factory_;
   int remaining_play_throughs_;
   int reset_after_frame_num_;
   int delete_decoder_state_;
   ClientState state_;
   int num_skipped_fragments_;
   int num_queued_fragments_;
   int num_decoded_frames_;
   int num_done_bitstream_buffers_;
   base::TimeTicks initialize_done_ticks_;
   media::VideoCodecProfile profile_;
@@ skipping 17 matching lines @@
   // textures.
   TextureRefMap active_textures_;
 
   // A map of the textures that are still pending in the renderer.
   // We check this to ensure all frames are rendered before entering the
   // CS_RESET_State.
   TextureRefMap pending_textures_;
 
   int32_t next_picture_buffer_id_;
 
+  base::WeakPtr<GLRenderingVDAClient> weak_this_;
+  base::WeakPtrFactory<GLRenderingVDAClient> weak_this_factory_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(GLRenderingVDAClient);
 };
 
+static bool DoNothingReturnTrue() {
+  return true;
+}
+
+static bool DummyBindImage(uint32_t client_texture_id,
+                           uint32_t texture_target,
+                           const scoped_refptr<gl::GLImage>& image) {
+  return true;
+}
+
 GLRenderingVDAClient::GLRenderingVDAClient(
     size_t window_id,
     RenderingHelper* rendering_helper,
     ClientStateNotification<ClientState>* note,
     const std::string& encoded_data,
     int num_in_flight_decodes,
     int num_play_throughs,
     int reset_after_frame_num,
     int delete_decoder_state,
     int frame_width,
@@ skipping 20 matching lines @@
       num_skipped_fragments_(0),
       num_queued_fragments_(0),
       num_decoded_frames_(0),
       num_done_bitstream_buffers_(0),
       fake_decoder_(fake_decoder),
       texture_target_(0),
       suppress_rendering_(suppress_rendering),
       delay_reuse_after_frame_num_(delay_reuse_after_frame_num),
       decode_calls_per_second_(decode_calls_per_second),
       render_as_thumbnails_(render_as_thumbnails),
-      next_picture_buffer_id_(1) {
+      next_picture_buffer_id_(1),
+      weak_this_factory_(this) {
   LOG_ASSERT(num_in_flight_decodes > 0);
   LOG_ASSERT(num_play_throughs > 0);
   // |num_in_flight_decodes_| is unsupported if |decode_calls_per_second_| > 0.
   if (decode_calls_per_second_ > 0)
     LOG_ASSERT(1 == num_in_flight_decodes_);
 
   // Default to H264 baseline if no profile provided.
   profile_ = (profile != media::VIDEO_CODEC_PROFILE_UNKNOWN
                   ? profile
                   : media::H264PROFILE_BASELINE);
+
+  weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 GLRenderingVDAClient::~GLRenderingVDAClient() {
   DeleteDecoder();  // Clean up in case of expected error.
   LOG_ASSERT(decoder_deleted());
   SetState(CS_DESTROYED);
 }
 
-static bool DoNothingReturnTrue() { return true; }
-
-scoped_ptr<media::VideoDecodeAccelerator>
-GLRenderingVDAClient::CreateFakeVDA() {
-  scoped_ptr<media::VideoDecodeAccelerator> decoder;
-  if (fake_decoder_) {
-    decoder.reset(new FakeVideoDecodeAccelerator(
-        static_cast<gfx::GLContext*> (rendering_helper_->GetGLContextHandle()),
-        frame_size_,
-        base::Bind(&DoNothingReturnTrue)));
-  }
-  return decoder;
-}
-
-scoped_ptr<media::VideoDecodeAccelerator>
-GLRenderingVDAClient::CreateDXVAVDA() {
-  scoped_ptr<media::VideoDecodeAccelerator> decoder;
-#if defined(OS_WIN)
-  if (base::win::GetVersion() >= base::win::VERSION_WIN7) {
-    const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
-    const bool enable_accelerated_vpx_decode =
-        cmd_line->HasSwitch(switches::kEnableAcceleratedVpxDecode);
-    decoder.reset(new DXVAVideoDecodeAccelerator(
-        base::Bind(&DoNothingReturnTrue),
-        rendering_helper_->GetGLContext().get(),
-        enable_accelerated_vpx_decode));
-  }
-#endif
-  return decoder;
-}
-
-scoped_ptr<media::VideoDecodeAccelerator>
-GLRenderingVDAClient::CreateV4L2VDA() {
-  scoped_ptr<media::VideoDecodeAccelerator> decoder;
-#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
-  scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
-  if (device.get()) {
-    base::WeakPtr<VideoDecodeAccelerator::Client> weak_client = AsWeakPtr();
-    decoder.reset(new V4L2VideoDecodeAccelerator(
-        static_cast<EGLDisplay>(rendering_helper_->GetGLDisplay()),
-        static_cast<EGLContext>(rendering_helper_->GetGLContextHandle()),
-        weak_client, base::Bind(&DoNothingReturnTrue), device,
-        base::ThreadTaskRunnerHandle::Get()));
-  }
-#endif
-  return decoder;
-}
-
-scoped_ptr<media::VideoDecodeAccelerator>
-GLRenderingVDAClient::CreateV4L2SliceVDA() {
-  scoped_ptr<media::VideoDecodeAccelerator> decoder;
-#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
-  scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
-  if (device.get()) {
-    base::WeakPtr<VideoDecodeAccelerator::Client> weak_client = AsWeakPtr();
-    decoder.reset(new V4L2SliceVideoDecodeAccelerator(
-        device, static_cast<EGLDisplay>(rendering_helper_->GetGLDisplay()),
-        static_cast<EGLContext>(rendering_helper_->GetGLContextHandle()),
-        weak_client, base::Bind(&DoNothingReturnTrue),
-        base::ThreadTaskRunnerHandle::Get()));
-  }
-#endif
-  return decoder;
-}
-
-scoped_ptr<media::VideoDecodeAccelerator>
-GLRenderingVDAClient::CreateVaapiVDA() {
-  scoped_ptr<media::VideoDecodeAccelerator> decoder;
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-  decoder.reset(new VaapiVideoDecodeAccelerator(
-      base::Bind(&DoNothingReturnTrue),
-      base::Bind(&GLRenderingVDAClient::BindImage, base::Unretained(this))));
-#endif
-  return decoder;
-}
-
-void GLRenderingVDAClient::BindImage(uint32_t client_texture_id,
-                                     uint32_t texture_target,
-                                     scoped_refptr<gl::GLImage> image) {}
-
 void GLRenderingVDAClient::CreateAndStartDecoder() {
   LOG_ASSERT(decoder_deleted());
   LOG_ASSERT(!decoder_.get());
 
-  VideoDecodeAccelerator::Client* client = this;
+  if (fake_decoder_) {
+    decoder_.reset(new FakeVideoDecodeAccelerator(
+        frame_size_, base::Bind(&DoNothingReturnTrue)));
+    LOG_ASSERT(decoder_->Initialize(profile_, this));
+  } else {
+    if (!vda_factory_) {
+      vda_factory_ = GpuVideoDecodeAcceleratorFactoryImpl::Create(
+          base::Bind(&RenderingHelper::GetGLContext,
+                     base::Unretained(rendering_helper_)),
+          base::Bind(&DoNothingReturnTrue), base::Bind(&DummyBindImage));
+      LOG_ASSERT(vda_factory_);
+    }
 
-  scoped_ptr<media::VideoDecodeAccelerator> decoders[] = {
-    CreateFakeVDA(),
-    CreateDXVAVDA(),
-    CreateV4L2VDA(),
-    CreateV4L2SliceVDA(),
-    CreateVaapiVDA(),
-  };
+    VideoDecodeAccelerator::Config config(profile_);
+    gpu::GpuPreferences gpu_preferences;
+#if defined(OS_WIN)
+    const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+    gpu_preferences.enable_accelerated_vpx_decode =
+        cmd_line->HasSwitch(switches::kEnableAcceleratedVpxDecode);
+#endif
+    decoder_ = vda_factory_->CreateVDA(this, config, gpu_preferences);
+  }
 
-  for (size_t i = 0; i < arraysize(decoders); ++i) {
-    if (!decoders[i])
-      continue;
-    decoder_ = std::move(decoders[i]);
-    weak_decoder_factory_.reset(
-        new base::WeakPtrFactory<VideoDecodeAccelerator>(decoder_.get()));
-    if (decoder_->Initialize(profile_, client)) {
-      SetState(CS_DECODER_SET);
-      FinishInitialization();
-      return;
-    }
-  }
-  // Decoders are all initialize failed.
-  LOG(ERROR) << "VideoDecodeAccelerator::Initialize() failed";
-  LOG_ASSERT(false);
+  LOG_ASSERT(decoder_) << "Failed creating a VDA";
+
+  decoder_->TryToSetupDecodeOnSeparateThread(
+      weak_this_, base::ThreadTaskRunnerHandle::Get());
+
+  SetState(CS_DECODER_SET);
+  FinishInitialization();
 }
 
 void GLRenderingVDAClient::ProvidePictureBuffers(
     uint32_t requested_num_of_buffers,
     const gfx::Size& dimensions,
     uint32_t texture_target) {
   if (decoder_deleted())
     return;
   std::vector<media::PictureBuffer> buffers;
 
@@ skipping 83 matching lines @@
   LOG_ASSERT(1U == pending_textures_.erase(picture_buffer_id));
 
   if (pending_textures_.empty() && state_ == CS_RESETTING) {
     SetState(CS_RESET);
     DeleteDecoder();
     return;
   }
 
   if (num_decoded_frames_ > delay_reuse_after_frame_num_) {
     base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&VideoDecodeAccelerator::ReusePictureBuffer,
-                   weak_decoder_factory_->GetWeakPtr(),
-                   picture_buffer_id),
+        FROM_HERE, base::Bind(&VideoDecodeAccelerator::ReusePictureBuffer,
+                              weak_vda_, picture_buffer_id),
         kReuseDelay);
   } else {
     decoder_->ReusePictureBuffer(picture_buffer_id);
   }
 }
 
 void GLRenderingVDAClient::NotifyEndOfBitstreamBuffer(
     int32_t bitstream_buffer_id) {
   // TODO(fischman): this test currently relies on this notification to make
   // forward progress during a Reset().  But the VDA::Reset() API doesn't
@@ skipping 101 matching lines @@
   }
 
   for (int i = 0; i < num_in_flight_decodes_; ++i)
     DecodeNextFragment();
   DCHECK_EQ(outstanding_decodes_, num_in_flight_decodes_);
 }
 
 void GLRenderingVDAClient::DeleteDecoder() {
   if (decoder_deleted())
     return;
-  weak_decoder_factory_.reset();
+  weak_vda_ptr_factory_.reset();
   decoder_.reset();
   STLClearObject(&encoded_data_);
   active_textures_.clear();
 
   // Cascade through the rest of the states to simplify test code below.
   for (int i = state_ + 1; i < CS_MAX; ++i)
     SetState(static_cast<ClientState>(i));
 }
 
 std::string GLRenderingVDAClient::GetBytesForFirstFragment(
@@ skipping 794 matching lines @@
   content::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   content::g_env =
       reinterpret_cast<content::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoDecodeAcceleratorTestEnvironment()));
 
   return RUN_ALL_TESTS();
 }