Use video profile to decide if we should produce fp16 textures.

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 538 matching lines @@
       profile_supported = true;
       break;
     }
   }
   if (!profile_supported) {
     RETURN_AND_NOTIFY_ON_FAILURE(false,
                                  "Unsupported h.264, vp8, or vp9 profile",
                                  PLATFORM_FAILURE, false);
   }
 
+  if (config.profile == VP9PROFILE_PROFILE2 ||
+      config.profile == VP9PROFILE_PROFILE3 ||
+      config.profile == H264PROFILE_HIGH10PROFILE) {
+    // Input file has more than 8 bits per channel.
+    use_fp16_ = true;
+  }
+
   // Not all versions of Windows 7 and later include Media Foundation DLLs.
   // Instead of crashing while delay loading the DLL when calling MFStartup()
   // below, probe whether we can successfully load the DLL now.
   // See http://crbug.com/339678 for details.
   HMODULE dxgi_manager_dll = ::GetModuleHandle(L"MFPlat.dll");
   RETURN_ON_FAILURE(dxgi_manager_dll, "MFPlat.dll is required for decoding",
                     false);
 
 // On Windows 8+ mfplat.dll provides the MFCreateDXGIDeviceManager API.
 // On Windows 7 mshtmlmedia.dll provides it.
@@ skipping 279 matching lines @@
     copy_nv12_textures_ = false;
 
   UINT nv12_format_support = 0;
   hr =
       d3d11_device_->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;
 
+  UINT fp16_format_support = 0;
+  hr = d3d11_device_->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
   // accessing the context, the media foundation decoder threads and the
   // decoder thread via the video format conversion transform.
   hr = multi_threaded_.QueryFrom(d3d11_device_.get());
   RETURN_ON_HR_FAILURE(hr, "Failed to query ID3D10Multithread", false);
   multi_threaded_->SetMultithreadProtected(TRUE);
 
   hr = d3d11_device_manager_->ResetDevice(d3d11_device_.get(),
                                           dx11_dev_manager_reset_token_);
@@ skipping 642 matching lines @@
   hr = decoder_->ProcessMessage(MFT_MESSAGE_SET_D3D_MANAGER,
                                 device_manager_to_use);
   if (use_dx11_) {
     RETURN_ON_HR_FAILURE(hr, "Failed to pass DX11 manager to decoder", false);
   } else {
     RETURN_ON_HR_FAILURE(hr, "Failed to pass D3D manager to decoder", false);
   }
 
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
 
-  EGLint config_attribs[] = {EGL_BUFFER_SIZE,  32,
-                             EGL_RED_SIZE,     8,
-                             EGL_GREEN_SIZE,   8,
-                             EGL_BLUE_SIZE,    8,
-                             EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
-                             EGL_ALPHA_SIZE,   0,
-                             EGL_NONE};
+  LOG(ERROR) << "EGL...";

[jbauman, 2017/02/23 02:01:46]

Remove.

[hubbe, 2017/02/23 19:26:09]

Done.

+  while (true) {
+    EGLint config_attribs[] = {EGL_BUFFER_SIZE,  32,
+                               EGL_RED_SIZE,     use_fp16_ ? 16 : 8,
+                               EGL_GREEN_SIZE,   use_fp16_ ? 16 : 8,
+                               EGL_BLUE_SIZE,    use_fp16_ ? 16 : 8,
+                               EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+                               EGL_ALPHA_SIZE,   0,
+                               EGL_NONE};
 
-  EGLint num_configs;
+    EGLint num_configs;
 
-  if (!eglChooseConfig(egl_display, config_attribs, &egl_config_, 1,
-                       &num_configs))
-    return false;
+    if (!eglChooseConfig(egl_display, config_attribs, &egl_config_, 1,

[jbauman, 2017/02/23 02:01:46]

I think this should check if num_configs == 0 as well.

[hubbe, 2017/02/23 19:26:09]

Done.

+                         &num_configs)) {
+      if (use_fp16_) {
+        // Try again, but without use_fp16_
+        use_fp16_ = false;
+        continue;
+      }
+      return false;
+    }
+
+    break;
+  }
+
+  if (use_fp16_) {
+    // TODO(hubbe): Share/copy P010/P016 textures.
+    share_nv12_textures_ = false;
+    copy_nv12_textures_ = false;
+  }
 
   return SetDecoderMediaTypes();
 }
 
 bool DXVAVideoDecodeAccelerator::CheckDecoderDxvaSupport() {
   base::win::ScopedComPtr<IMFAttributes> attributes;
   HRESULT hr = decoder_->GetAttributes(attributes.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get decoder attributes", false);
 
   UINT32 dxva = 0;
@@ skipping 47 matching lines @@
   if (using_ms_vp9_mft_)
     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_P010) ||
+         SetDecoderOutputMediaType(MFVideoFormat_P016);
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderInputMediaType() {
   base::win::ScopedComPtr<IMFMediaType> media_type;
   HRESULT hr = MFCreateMediaType(media_type.Receive());
   RETURN_ON_HR_FAILURE(hr, "MFCreateMediaType failed", false);
 
   hr = media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
   RETURN_ON_HR_FAILURE(hr, "Failed to set major input type", false);
 
@@ skipping 124 matching lines @@
     DVLOG(1) << "Got events from ProcessOuput, but discarding";
     events->Release();
   }
   base::win::ScopedComPtr<IMFSample> output_sample;
   output_sample.Attach(output_data_buffer.pSample);
   if (FAILED(hr)) {
     // A stream change needs further ProcessInput calls to get back decoder
     // output which is why we need to set the state to stopped.
     if (hr == MF_E_TRANSFORM_STREAM_CHANGE) {
       if (!SetDecoderOutputMediaType(MFVideoFormat_NV12) &&
-          !SetDecoderOutputMediaType(MFVideoFormat_P010)) {
+          !SetDecoderOutputMediaType(MFVideoFormat_P010) &&
+          !SetDecoderOutputMediaType(MFVideoFormat_P016)) {
         // Decoder didn't let us set NV12 output format. Not sure as to why
         // this can happen. Give up in disgust.
         NOTREACHED() << "Failed to set decoder output media type to NV12";
         SetState(kStopped);
       } else {
         DVLOG(1) << "Received output format change from the decoder."
                     " Recursively invoking DoDecode";
         DoDecode(color_space);
       }
       return;
@@ skipping 1147 matching lines @@
       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;
 }
 
 }  // namespace media