Copy NV12 picture buffers on demand on the main thread.

media/gpu/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 "media/gpu/dxva_video_decode_accelerator_win.h"
 
 #include <memory>
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
@@ skipping 478 matching lines @@
       pictures_requested_(false),
       inputs_before_decode_(0),
       sent_drain_message_(false),
       get_gl_context_cb_(get_gl_context_cb),
       make_context_current_cb_(make_context_current_cb),
       bind_image_cb_(bind_image_cb),
       codec_(kUnknownVideoCodec),
       decoder_thread_("DXVAVideoDecoderThread"),
       pending_flush_(false),
       enable_low_latency_(gpu_preferences.enable_low_latency_dxva),
-      share_nv12_textures_(gpu_preferences.enable_zero_copy_dxgi_video &&
-                           !workarounds.disable_dxgi_zero_copy_video),
-      copy_nv12_textures_(gpu_preferences.enable_nv12_dxgi_video &&
-                          !workarounds.disable_nv12_dxgi_video),
+      support_share_nv12_textures_(
+          gpu_preferences.enable_zero_copy_dxgi_video &&
+          !workarounds.disable_dxgi_zero_copy_video),
+      support_copy_nv12_textures_(gpu_preferences.enable_nv12_dxgi_video &&
+                                  !workarounds.disable_nv12_dxgi_video),
       use_dx11_(false),
       use_keyed_mutex_(false),
       using_angle_device_(false),
       enable_accelerated_vpx_decode_(
           workarounds.disable_accelerated_vpx_decode
               ? gpu::GpuPreferences::VpxDecodeVendors::VPX_VENDOR_NONE
               : gpu_preferences.enable_accelerated_vpx_decode),
       processing_config_changed_(false),
       weak_this_factory_(this) {
   weak_ptr_ = weak_this_factory_.GetWeakPtr();
@@ skipping 23 matching lines @@
     return false;
   }
 
   client_ = client;
 
   main_thread_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   if (!config.supported_output_formats.empty() &&
       !base::ContainsValue(config.supported_output_formats,
                            PIXEL_FORMAT_NV12)) {
-    share_nv12_textures_ = false;
-    copy_nv12_textures_ = false;
+    support_share_nv12_textures_ = false;
+    support_copy_nv12_textures_ = false;
   }
 
   bool profile_supported = false;
   for (const auto& supported_profile : kSupportedProfiles) {
     if (config.profile == supported_profile) {
       profile_supported = true;
       break;
     }
   }
   if (!profile_supported) {
@@ skipping 241 matching lines @@
 
 bool DXVAVideoDecodeAccelerator::CreateDX11DevManager() {
   // The device may exist if the last state was a config change.
   if (D3D11Device())
     return true;
   HRESULT hr = create_dxgi_device_manager_(
       &dx11_dev_manager_reset_token_, d3d11_device_manager_.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "MFCreateDXGIDeviceManager failed", false);
 
   angle_device_ = gl::QueryD3D11DeviceObjectFromANGLE();
-  if (!angle_device_)
-    copy_nv12_textures_ = false;
-  if (share_nv12_textures_) {
+  if (!angle_device_) {
+    support_copy_nv12_textures_ = false;
+  }
+  if (ShouldUseANGLEDevice()) {
     RETURN_ON_FAILURE(angle_device_.Get(), "Failed to get d3d11 device", false);
 
     using_angle_device_ = true;
-  }
+    DCHECK(!use_fp16_);
+    angle_device_->GetImmediateContext(d3d11_device_context_.GetAddressOf());
 
-  if (use_fp16_ || !share_nv12_textures_) {
+    hr = angle_device_.CopyTo(video_device_.GetAddressOf());
+    RETURN_ON_HR_FAILURE(hr, "Failed to get video device", false);
+  } else {
     // This array defines the set of DirectX hardware feature levels we support.
     // The ordering MUST be preserved. All applications are assumed to support
     // 9.1 unless otherwise stated by the application.
     D3D_FEATURE_LEVEL feature_levels[] = {
         D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1,
         D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_3,  D3D_FEATURE_LEVEL_9_2,
         D3D_FEATURE_LEVEL_9_1};
 
     UINT flags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
 
@@ skipping 18 matching lines @@
       hr = D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, flags,
                              feature_levels, arraysize(feature_levels),
                              D3D11_SDK_VERSION, d3d11_device_.GetAddressOf(),
                              &feature_level_out,
                              d3d11_device_context_.GetAddressOf());
       RETURN_ON_HR_FAILURE(hr, "Failed to create DX11 device", false);
     }
 
     hr = d3d11_device_.CopyTo(video_device_.GetAddressOf());
     RETURN_ON_HR_FAILURE(hr, "Failed to get video device", false);
+  }
 
-    hr = d3d11_device_context_.CopyTo(video_context_.GetAddressOf());
-    RETURN_ON_HR_FAILURE(hr, "Failed to get video context", false);
-  }
+  hr = d3d11_device_context_.CopyTo(video_context_.GetAddressOf());
+  RETURN_ON_HR_FAILURE(hr, "Failed to get video context", false);
 
   D3D11_FEATURE_DATA_D3D11_OPTIONS options;
   hr = D3D11Device()->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS, &options,
                                           sizeof(options));
   RETURN_ON_HR_FAILURE(hr, "Failed to retrieve D3D11 options", false);
 
   // Need extended resource sharing so we can share the NV12 texture between
   // ANGLE and the decoder context.
   if (!options.ExtendedResourceSharing)
-    copy_nv12_textures_ = false;
+    support_copy_nv12_textures_ = false;
 
   UINT nv12_format_support = 0;
   hr =
       D3D11Device()->CheckFormatSupport(DXGI_FORMAT_NV12, &nv12_format_support);
   RETURN_ON_HR_FAILURE(hr, "Failed to check NV12 format support", false);
 
   if (!(nv12_format_support & D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_OUTPUT))
-    copy_nv12_textures_ = false;
+    support_copy_nv12_textures_ = false;
 
   UINT fp16_format_support = 0;
   hr = D3D11Device()->CheckFormatSupport(DXGI_FORMAT_R16G16B16A16_FLOAT,
                                          &fp16_format_support);
   if (FAILED(hr) ||
       !(fp16_format_support & D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_OUTPUT))
     use_fp16_ = false;
 
   // Enable multithreaded mode on the device. This ensures that accesses to
   // context are synchronized across threads. We have multiple threads
@@ skipping 84 matching lines @@
         DXVAPictureBuffer::Create(*this, buffers[buffer_index], egl_config_);
     RETURN_AND_NOTIFY_ON_FAILURE(picture_buffer.get(),
                                  "Failed to allocate picture buffer",
                                  PLATFORM_FAILURE, );
     if (bind_image_cb_) {
       for (uint32_t client_id : buffers[buffer_index].client_texture_ids()) {
         // The picture buffer handles the actual binding of its contents to
         // texture ids. This call just causes the texture manager to hold a
         // reference to the GLImage as long as either texture exists.
         bind_image_cb_.Run(client_id, GetTextureTarget(),
-                           picture_buffer->gl_image(), true);
+                           picture_buffer->gl_image(), false);
       }
     }
 
     bool inserted =
         output_picture_buffers_
             .insert(std::make_pair(buffers[buffer_index].id(), picture_buffer))
             .second;
     DCHECK(inserted);
   }
 
@@ skipping 40 matching lines @@
   if (it->second->available() || it->second->waiting_to_reuse())
     return;
 
   RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_cb_.Run(),
                                "Failed to make context current",
                                PLATFORM_FAILURE, );
   if (use_keyed_mutex_ || using_angle_device_) {
     RETURN_AND_NOTIFY_ON_FAILURE(it->second->ReusePictureBuffer(),
                                  "Failed to reuse picture buffer",
                                  PLATFORM_FAILURE, );
+    if (bind_image_cb_ && (GetPictureBufferMechanism() ==
+                           PictureBufferMechanism::DELAYED_COPY_TO_NV12)) {
+      // Unbind the image to ensure it will be copied again the next time it's
+      // needed.
+      for (uint32_t client_id :
+           it->second->picture_buffer().client_texture_ids()) {
+        bind_image_cb_.Run(client_id, GetTextureTarget(),
+                           it->second->gl_image(), false);
+      }
+    }
 
     ProcessPendingSamples();
     if (pending_flush_) {
       decoder_thread_task_runner_->PostTask(
           FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                                 base::Unretained(this)));
     }
   } else {
     it->second->ResetReuseFence();
 
@@ skipping 530 matching lines @@
         }
         return false;
       }
     }
 
     break;
   }
 
   if (use_fp16_) {
     // TODO(hubbe): Share/copy P010/P016 textures.
-    share_nv12_textures_ = false;
-    copy_nv12_textures_ = false;
+    support_share_nv12_textures_ = false;
+    support_copy_nv12_textures_ = false;
   }
 
   return SetDecoderMediaTypes();
 }
 
 bool DXVAVideoDecodeAccelerator::CheckDecoderDxvaSupport() {
   base::win::ScopedComPtr<IMFAttributes> attributes;
   HRESULT hr = decoder_->GetAttributes(attributes.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "Failed to get decoder attributes", false);
 
@@ skipping 31 matching lines @@
   }
 
   use_keyed_mutex_ =
       use_dx11_ && gl::GLSurfaceEGL::HasEGLExtension("EGL_ANGLE_keyed_mutex");
 
   if (!use_dx11_ ||
       !gl::g_driver_egl.ext.b_EGL_ANGLE_stream_producer_d3d_texture_nv12 ||
       !gl::g_driver_egl.ext.b_EGL_KHR_stream ||
       !gl::g_driver_egl.ext.b_EGL_KHR_stream_consumer_gltexture ||
       !gl::g_driver_egl.ext.b_EGL_NV_stream_consumer_gltexture_yuv) {
-    share_nv12_textures_ = false;
-    copy_nv12_textures_ = false;
+    support_share_nv12_textures_ = false;
+    support_copy_nv12_textures_ = false;
   }
 
   // The MS VP9 MFT doesn't pass through the bind flags we specify, so
   // textures aren't created with D3D11_BIND_SHADER_RESOURCE and can't be used
   // from ANGLE.
   if (using_ms_vp9_mft_)
-    share_nv12_textures_ = false;
+    support_share_nv12_textures_ = false;
 
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderMediaTypes() {
   RETURN_ON_FAILURE(SetDecoderInputMediaType(),
                     "Failed to set decoder input media type", false);
   return SetDecoderOutputMediaType(MFVideoFormat_NV12) ||
          SetDecoderOutputMediaType(MFVideoFormat_P010) ||
          SetDecoderOutputMediaType(MFVideoFormat_P016);
@@ skipping 38 matching lines @@
 
   hr = decoder_->SetInputType(0, media_type.Get(), 0);  // No flags
   RETURN_ON_HR_FAILURE(hr, "Failed to set decoder input type", false);
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderOutputMediaType(
     const GUID& subtype) {
   bool result = SetTransformOutputType(decoder_.Get(), subtype, 0, 0);
 
-  if (share_nv12_textures_) {
+  if (GetPictureBufferMechanism() == PictureBufferMechanism::BIND) {
     base::win::ScopedComPtr<IMFAttributes> out_attributes;
     HRESULT hr =
         decoder_->GetOutputStreamAttributes(0, out_attributes.GetAddressOf());
     RETURN_ON_HR_FAILURE(hr, "Failed to get stream attributes", false);
     out_attributes->SetUINT32(MF_SA_D3D11_BINDFLAGS,
                               D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_DECODER);
     // For some reason newer Intel drivers need D3D11_BIND_DECODER textures to
     // be created with a share handle or they'll crash in
     // CreateShaderResourceView.  Technically MF_SA_D3D11_SHARED_WITHOUT_MUTEX
     // is only honored by the sample allocator, not by the media foundation
@@ skipping 207 matching lines @@
       if (width != index->second->size().width() ||
           height != index->second->size().height()) {
         HandleResolutionChanged(width, height);
         return;
       }
 
       pending_sample->picture_buffer_id = index->second->id();
       index->second->set_bound();
       index->second->set_color_space(pending_sample->color_space);
 
-      if (share_nv12_textures_) {
+      if (index->second->CanBindSamples()) {
         main_thread_task_runner_->PostTask(
             FROM_HERE,
             base::Bind(&DXVAVideoDecodeAccelerator::BindPictureBufferToSample,
                        weak_ptr_, pending_sample->output_sample,
                        pending_sample->picture_buffer_id,
                        pending_sample->input_buffer_id));
         continue;
       }
 
       base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
@@ skipping 150 matching lines @@
 }
 
 void DXVAVideoDecodeAccelerator::RequestPictureBuffers(int width, int height) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   // This task could execute after the decoder has been torn down.
   if (GetState() != kUninitialized && client_) {
     // When sharing NV12 textures, the client needs to provide 2 texture IDs
     // per picture buffer, 1 for the Y channel and 1 for the UV channels.
     // They're shared to ANGLE using EGL_NV_stream_consumer_gltexture_yuv, so
     // they need to be GL_TEXTURE_EXTERNAL_OES.
-    bool provide_nv12_textures = share_nv12_textures_ || copy_nv12_textures_;
+    bool provide_nv12_textures =
+        GetPictureBufferMechanism() != PictureBufferMechanism::COPY_TO_RGB;
     client_->ProvidePictureBuffers(
         kNumPictureBuffers,
         provide_nv12_textures ? PIXEL_FORMAT_NV12 : PIXEL_FORMAT_UNKNOWN,
         provide_nv12_textures ? 2 : 1, gfx::Size(width, height),
         GetTextureTarget());
   }
 }
 
 void DXVAVideoDecodeAccelerator::NotifyPictureReady(
     int picture_buffer_id,
@@ skipping 459 matching lines @@
   DXVAPictureBuffer* picture_buffer = it->second.get();
   if (picture_buffer->available())
     return;
 
   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->BindSampleToTexture(sample);
+  bool result = picture_buffer->BindSampleToTexture(this, sample);
   RETURN_AND_NOTIFY_ON_FAILURE(result, "Failed to complete copying surface",
                                PLATFORM_FAILURE, );
 
   NotifyPictureReady(picture_buffer->id(), input_buffer_id,
                      picture_buffer->color_space(),
                      picture_buffer->AllowOverlay());
 
   {
     base::AutoLock lock(decoder_lock_);
     if (!pending_output_samples_.empty())
@@ skipping 237 matching lines @@
     hr = video_device_->CreateVideoProcessor(enumerator_.Get(), 0,
                                              d3d11_processor_.GetAddressOf());
     RETURN_ON_HR_FAILURE(hr, "Failed to create video processor.", false);
     processor_width_ = width;
     processor_height_ = height;
 
     video_context_->VideoProcessorSetStreamAutoProcessingMode(
         d3d11_processor_.Get(), 0, false);
   }
 
-  if (copy_nv12_textures_) {
+  if (GetPictureBufferMechanism() == PictureBufferMechanism::COPY_TO_NV12 ||
+      GetPictureBufferMechanism() ==
+          PictureBufferMechanism::DELAYED_COPY_TO_NV12) {
     // If we're copying NV12 textures, make sure we set the same
     // color space on input and output.
     D3D11_VIDEO_PROCESSOR_COLOR_SPACE d3d11_color_space = {0};
     d3d11_color_space.RGB_Range = 1;
     d3d11_color_space.Nominal_Range = D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_0_255;
 
     video_context_->VideoProcessorSetOutputColorSpace(d3d11_processor_.Get(),
                                                       &d3d11_color_space);
 
     video_context_->VideoProcessorSetStreamColorSpace(d3d11_processor_.Get(), 0,
@@ skipping 154 matching lines @@
   SetState(kConfigChange);
   Invalidate();
   Initialize(config_, client_);
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 uint32_t DXVAVideoDecodeAccelerator::GetTextureTarget() const {
-  bool provide_nv12_textures = share_nv12_textures_ || copy_nv12_textures_;
-  return provide_nv12_textures ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
+  switch (GetPictureBufferMechanism()) {
+    case PictureBufferMechanism::BIND:
+    case PictureBufferMechanism::DELAYED_COPY_TO_NV12:
+    case PictureBufferMechanism::COPY_TO_NV12:
+      return GL_TEXTURE_EXTERNAL_OES;
+    case PictureBufferMechanism::COPY_TO_RGB:
+      return GL_TEXTURE_2D;
+  }
+  NOTREACHED();
+  return 0;
 }
 
+DXVAVideoDecodeAccelerator::PictureBufferMechanism
+DXVAVideoDecodeAccelerator::GetPictureBufferMechanism() const {
+  if (use_fp16_)
+    return PictureBufferMechanism::COPY_TO_RGB;
+  if (support_share_nv12_textures_)
+    return PictureBufferMechanism::BIND;
+  if (base::FeatureList::IsEnabled(kDelayCopyNV12Textures) &&
+      support_copy_nv12_textures_)
+    return PictureBufferMechanism::DELAYED_COPY_TO_NV12;
+  if (support_copy_nv12_textures_)
+    return PictureBufferMechanism::COPY_TO_NV12;
+  return PictureBufferMechanism::COPY_TO_RGB;
+}
+
+bool DXVAVideoDecodeAccelerator::ShouldUseANGLEDevice() const {
+  switch (GetPictureBufferMechanism()) {
+    case PictureBufferMechanism::BIND:
+    case PictureBufferMechanism::DELAYED_COPY_TO_NV12:
+      return true;
+    case PictureBufferMechanism::COPY_TO_NV12:
+    case PictureBufferMechanism::COPY_TO_RGB:
+      return false;
+  }
+  NOTREACHED();
+  return false;
+}
 ID3D11Device* DXVAVideoDecodeAccelerator::D3D11Device() const {
-  return share_nv12_textures_ ? angle_device_.Get() : d3d11_device_.Get();
+  return ShouldUseANGLEDevice() ? angle_device_.Get() : d3d11_device_.Get();
 }
 
 }  // namespace media