Introduce GpuVideoDecodeAcceleratorFactory.

content/common/gpu/media/dxva_video_decode_accelerator_win.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.
 
 #include "content/common/gpu/media/dxva_video_decode_accelerator_win.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 657 matching lines @@
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     int32_t buffer_id,
     IMFSample* sample)
     : input_buffer_id(buffer_id), picture_buffer_id(-1) {
   output_sample.Attach(sample);
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::~PendingSampleInfo() {}
 
 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator(
-    const base::Callback<bool(void)>& make_context_current,
-    gfx::GLContext* gl_context)
+    const gpu_vda_helpers::GetGLContextCb& get_gl_context_cb,
+    const gpu_vda_helpers::MakeGLContextCurrentCb& make_context_current_cb)
     : client_(NULL),
       dev_manager_reset_token_(0),
       dx11_dev_manager_reset_token_(0),
       egl_config_(NULL),
       state_(kUninitialized),
       pictures_requested_(false),
       inputs_before_decode_(0),
       sent_drain_message_(false),
-      make_context_current_(make_context_current),
+      get_gl_context_cb_(get_gl_context_cb),
+      make_context_current_cb_(make_context_current_cb),
       codec_(media::kUnknownVideoCodec),
       decoder_thread_("DXVAVideoDecoderThread"),
       pending_flush_(false),
       use_dx11_(false),
       use_keyed_mutex_(false),
       dx11_video_format_converter_media_type_needs_init_(true),
-      gl_context_(gl_context),
       using_angle_device_(false),
       weak_this_factory_(this) {
   weak_ptr_ = weak_this_factory_.GetWeakPtr();
   memset(&input_stream_info_, 0, sizeof(input_stream_info_));
   memset(&output_stream_info_, 0, sizeof(output_stream_info_));
 }
 
 DXVAVideoDecodeAccelerator::~DXVAVideoDecodeAccelerator() {
   client_ = NULL;
 }
 
 bool DXVAVideoDecodeAccelerator::Initialize(const Config& config,
                                             Client* client) {
+  if (get_gl_context_cb_.is_null() || make_context_current_cb_.is_null()) {
+    NOTREACHED() << "GL callbacks are required for this VDA";
+    return false;
+  }
+
   if (config.is_encrypted) {
     NOTREACHED() << "Encrypted streams are not supported for this VDA";
     return false;
   }
 
   client_ = client;
 
   main_thread_task_runner_ = base::MessageLoop::current()->task_runner();
 
   bool profile_supported = false;
@@ skipping 340 matching lines @@
                                  "Failed to reuse picture buffer",
                                  PLATFORM_FAILURE, );
 
     ProcessPendingSamples();
     if (pending_flush_) {
       decoder_thread_task_runner_->PostTask(
           FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                                 base::Unretained(this)));
     }
   } else {
-    RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_.Run(),
+    RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_cb_.Run(),
                                  "Failed to make context current",
                                  PLATFORM_FAILURE, );
     it->second->ResetReuseFence();
 
     WaitForOutputBuffer(picture_buffer_id, 0);
   }
 }
 
 void DXVAVideoDecodeAccelerator::WaitForOutputBuffer(int32_t picture_buffer_id,
                                                      int count) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   OutputBuffers::iterator it = output_picture_buffers_.find(picture_buffer_id);
   if (it == output_picture_buffers_.end())
     return;
 
   DXVAPictureBuffer* picture_buffer = it->second.get();
 
   DCHECK(!picture_buffer->available());
   DCHECK(picture_buffer->waiting_to_reuse());
 
   gfx::GLFence* fence = picture_buffer->reuse_fence();
-  RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_.Run(),
+  RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_cb_.Run(),
                                "Failed to make context current",
                                PLATFORM_FAILURE, );
   if (count <= kMaxIterationsForANGLEReuseFlush && !fence->HasCompleted()) {
     main_thread_task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::WaitForOutputBuffer,
                               weak_this_factory_.GetWeakPtr(),
                               picture_buffer_id, count + 1),
         base::TimeDelta::FromMilliseconds(kFlushDecoderSurfaceTimeoutMs));
     return;
   }
@@ skipping 73 matching lines @@
   StartDecoderThread();
   SetState(kNormal);
 }
 
 void DXVAVideoDecodeAccelerator::Destroy() {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   Invalidate();
   delete this;
 }
 
-bool DXVAVideoDecodeAccelerator::CanDecodeOnIOThread() {
+bool DXVAVideoDecodeAccelerator::TryInitializeDecodeOnSeparateThread(
+    const base::WeakPtr<Client>& decode_client,
+    const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
 GLenum DXVAVideoDecodeAccelerator::GetSurfaceInternalFormat() const {
   return GL_BGRA_EXT;
 }
 
 // static
 media::VideoDecodeAccelerator::SupportedProfiles
 DXVAVideoDecodeAccelerator::GetSupportedProfiles() {
@@ skipping 164 matching lines @@
     RETURN_ON_HR_FAILURE(hr, "Failed to enable DXVA H/W decoding", false);
   }
 
   hr = attributes->SetUINT32(CODECAPI_AVLowLatencyMode, TRUE);
   if (SUCCEEDED(hr)) {
     DVLOG(1) << "Successfully set Low latency mode on decoder.";
   } else {
     DVLOG(1) << "Failed to set Low latency mode on decoder. Error: " << hr;
   }
 
+  auto gl_context = get_gl_context_cb_.Run();
+  RETURN_ON_FAILURE(gl_context, "Couldn't get GL context", false);
+
   // The decoder should use DX11 iff
   // 1. The underlying H/W decoder supports it.
   // 2. We have a pointer to the MFCreateDXGIDeviceManager function needed for
   //    this. This should always be true for Windows 8+.
   // 3. ANGLE is using DX11.
-  DCHECK(gl_context_);
   if (create_dxgi_device_manager_ &&
-      (gl_context_->GetGLRenderer().find("Direct3D11") !=
-           std::string::npos)) {
+      (gl_context->GetGLRenderer().find("Direct3D11") != std::string::npos)) {
     UINT32 dx11_aware = 0;
     attributes->GetUINT32(MF_SA_D3D11_AWARE, &dx11_aware);
     use_dx11_ = !!dx11_aware;
   }
 
   use_keyed_mutex_ =
       use_dx11_ && gfx::GLSurfaceEGL::HasEGLExtension("EGL_ANGLE_keyed_mutex");
 
   return true;
 }
@@ skipping 181 matching lines @@
   pictures_requested_ = true;
   return true;
 }
 
 void DXVAVideoDecodeAccelerator::ProcessPendingSamples() {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   if (!output_picture_buffers_.size())
     return;
 
-  RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_.Run(),
-      "Failed to make context current", PLATFORM_FAILURE,);
+  RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_cb_.Run(),
+                               "Failed to make context current",
+                               PLATFORM_FAILURE, );
 
   OutputBuffers::iterator index;
 
   for (index = output_picture_buffers_.begin();
        index != output_picture_buffers_.end() &&
        OutputSamplesPresent();
        ++index) {
     if (index->second->available()) {
       PendingSampleInfo* pending_sample = NULL;
       {
@@ skipping 477 matching lines @@
   OutputBuffers::iterator it = output_picture_buffers_.find(picture_buffer_id);
   if (it == output_picture_buffers_.end())
     return;
 
   // If the picture buffer is marked as available it probably means that there
   // was a Reset operation which dropped the output frame.
   DXVAPictureBuffer* picture_buffer = it->second.get();
   if (picture_buffer->available())
     return;
 
-  RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_.Run(),
-      "Failed to make context current", PLATFORM_FAILURE,);
+  RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_cb_.Run(),
+                               "Failed to make context current",
+                               PLATFORM_FAILURE, );
 
   DCHECK(!output_picture_buffers_.empty());
 
   bool result = picture_buffer->CopySurfaceComplete(src_surface, dest_surface);
   RETURN_AND_NOTIFY_ON_FAILURE(result, "Failed to complete copying surface",
                                PLATFORM_FAILURE, );
 
   NotifyPictureReady(picture_buffer->id(), input_buffer_id);
 
   {
@@ skipping 365 matching lines @@
       }
       RETURN_ON_HR_FAILURE(hr, "Failed to set output type", false);
       return true;
     }
     media_type.Release();
   }
   return false;
 }
 
 }  // namespace content