Revert of Replace IMFTransform with ID3D11VideoProcessor

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 482 matching lines @@
       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),
       use_dx11_(false),
       use_keyed_mutex_(false),
+      dx11_video_format_converter_media_type_needs_init_(true),
       using_angle_device_(false),
       enable_accelerated_vpx_decode_(
           gpu_preferences.enable_accelerated_vpx_decode),
       processing_config_changed_(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_));
   use_color_info_ = base::FeatureList::IsEnabled(kVideoBlitColorAccuracy);
 }
@@ skipping 348 matching lines @@
   hr = d3d11_device_manager_->ResetDevice(d3d11_device_.get(),
                                           dx11_dev_manager_reset_token_);
   RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
 
   D3D11_QUERY_DESC query_desc;
   query_desc.Query = D3D11_QUERY_EVENT;
   query_desc.MiscFlags = 0;
   hr = d3d11_device_->CreateQuery(&query_desc, d3d11_query_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to create DX11 device query", false);
 
-  hr = d3d11_device_.QueryInterface(video_device_.Receive());
-  RETURN_ON_HR_FAILURE(hr, "Failed to get video device", false);
+  HMODULE video_processor_dll = ::GetModuleHandle(L"msvproc.dll");
+  RETURN_ON_FAILURE(video_processor_dll, "Failed to load video processor",
+                    false);
 
-  hr = d3d11_device_context_.QueryInterface(video_context_.Receive());
-  RETURN_ON_HR_FAILURE(hr, "Failed to get video context", false);
+  hr = CreateCOMObjectFromDll(video_processor_dll, CLSID_VideoProcessorMFT,
+                              __uuidof(IMFTransform),
+                              video_format_converter_mft_.ReceiveVoid());
+  RETURN_ON_HR_FAILURE(hr, "Failed to create video format converter", false);
 
+  base::win::ScopedComPtr<IMFAttributes> converter_attributes;
+  hr = video_format_converter_mft_->GetAttributes(
+      converter_attributes.Receive());
+  RETURN_ON_HR_FAILURE(hr, "Failed to get converter attributes", false);
+
+  hr = converter_attributes->SetUINT32(MF_XVP_PLAYBACK_MODE, TRUE);
+  RETURN_ON_HR_FAILURE(
+      hr, "Failed to set MF_XVP_PLAYBACK_MODE attribute on converter", false);
+
+  hr = converter_attributes->SetUINT32(MF_LOW_LATENCY, FALSE);
+  RETURN_ON_HR_FAILURE(
+      hr, "Failed to set MF_LOW_LATENCY attribute on converter", false);
   return true;
 }
 
 void DXVAVideoDecodeAccelerator::Decode(
     const BitstreamBuffer& bitstream_buffer) {
   TRACE_EVENT0("media", "DXVAVideoDecodeAccelerator::Decode");
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   // SharedMemory will take over the ownership of handle.
   base::SharedMemory shm(bitstream_buffer.handle(), true);
@@ skipping 1056 matching lines @@
   // resolution changes. We already handle that in the
   // HandleResolutionChanged() function.
   if (GetState() != kConfigChange) {
     output_picture_buffers_.clear();
     stale_output_picture_buffers_.clear();
     // We want to continue processing pending input after detecting a config
     // change.
     pending_input_buffers_.clear();
     pictures_requested_ = false;
     if (use_dx11_) {
-      d3d11_processor_.Release();
-      enumerator_.Release();
-      video_context_.Release();
-      video_device_.Release();
+      if (video_format_converter_mft_.get()) {
+        video_format_converter_mft_->ProcessMessage(
+            MFT_MESSAGE_NOTIFY_END_STREAMING, 0);
+        video_format_converter_mft_.Release();
+      }
       d3d11_device_context_.Release();
       d3d11_device_.Release();
       d3d11_device_manager_.Release();
       d3d11_query_.Release();
       multi_threaded_.Release();
-      processor_width_ = processor_height_ = 0;
+      dx11_video_format_converter_media_type_needs_init_ = true;
     } else {
       d3d9_.Release();
       d3d9_device_ex_.Release();
       device_manager_.Release();
       query_.Release();
     }
   }
   sent_drain_message_ = false;
   SetState(kUninitialized);
 }
@@ skipping 280 matching lines @@
   // decoder to emit an output packet for every input packet.
   // http://code.google.com/p/chromium/issues/detail?id=108121
   // http://code.google.com/p/chromium/issues/detail?id=150925
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::NotifyInputBufferRead,
                             weak_ptr_, input_buffer_id));
 }
 
 void DXVAVideoDecodeAccelerator::HandleResolutionChanged(int width,
                                                          int height) {
+  dx11_video_format_converter_media_type_needs_init_ = true;
+
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::DismissStaleBuffers,
                             weak_ptr_, false));
 
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::RequestPictureBuffers,
                             weak_ptr_, width, height));
 }
 
 void DXVAVideoDecodeAccelerator::DismissStaleBuffers(bool force) {
@@ skipping 264 matching lines @@
   TRACE_EVENT0("media", "DXVAVideoDecodeAccelerator::CopyTexture");
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   DCHECK(use_dx11_);
 
   // The media foundation H.264 decoder outputs YUV12 textures which we
   // cannot copy into ANGLE as they expect ARGB textures. In D3D land
   // the StretchRect API in the IDirect3DDevice9Ex interface did the color
   // space conversion for us. Sadly in DX11 land the API does not provide
   // a straightforward way to do this.
+  // We use the video processor MFT.
+  // https://msdn.microsoft.com/en-us/library/hh162913(v=vs.85).aspx
+  // This object implements a media foundation transform (IMFTransform)
+  // which follows the same contract as the decoder. The color space
+  // conversion as per msdn is done in the GPU.
 
   D3D11_TEXTURE2D_DESC source_desc;
   src_texture->GetDesc(&source_desc);
-  if (!InitializeID3D11VideoProcessor(source_desc.Width, source_desc.Height,
-                                      color_space)) {
-    RETURN_AND_NOTIFY_ON_FAILURE(false,
-                                 "Failed to initialize D3D11 video processor.",
-                                 PLATFORM_FAILURE, );
+
+  // Set up the input and output types for the video processor MFT.
+  if (!InitializeDX11VideoFormatConverterMediaType(
+          source_desc.Width, source_desc.Height, color_space)) {
+    RETURN_AND_NOTIFY_ON_FAILURE(
+        false, "Failed to initialize media types for convesion.",
+        PLATFORM_FAILURE, );
   }
 
   // The input to the video processor is the output sample.
   base::win::ScopedComPtr<IMFSample> input_sample_for_conversion;
   {
     base::AutoLock lock(decoder_lock_);
     PendingSampleInfo& sample_info = pending_output_samples_.front();
     input_sample_for_conversion = sample_info.output_sample;
   }
 
@@ skipping 12 matching lines @@
     base::win::ScopedComPtr<IMFSample> input_sample,
     int picture_buffer_id,
     int input_buffer_id) {
   TRACE_EVENT0("media",
                "DXVAVideoDecodeAccelerator::CopyTextureOnDecoderThread");
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   HRESULT hr = E_FAIL;
 
   DCHECK(use_dx11_);
   DCHECK(!!input_sample);
-  DCHECK(d3d11_processor_.get());
+  DCHECK(video_format_converter_mft_.get());
 
   if (dest_keyed_mutex) {
     HRESULT hr =
         dest_keyed_mutex->AcquireSync(keyed_mutex_value, kAcquireSyncWaitMs);
     RETURN_AND_NOTIFY_ON_FAILURE(
         hr == S_OK, "D3D11 failed to acquire keyed mutex for texture.",
         PLATFORM_FAILURE, );
   }
+  // The video processor MFT requires output samples to be allocated by the
+  // caller. We create a sample with a buffer backed with the ID3D11Texture2D
+  // interface exposed by ANGLE. This works nicely as this ensures that the
+  // video processor coverts the color space of the output frame and copies
+  // the result into the ANGLE texture.
+  base::win::ScopedComPtr<IMFSample> output_sample;
+  hr = MFCreateSample(output_sample.Receive());
+  if (FAILED(hr)) {
+    RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to create output sample.",
+                                    PLATFORM_FAILURE, );
+  }
 
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
-  hr = input_sample->GetBufferByIndex(0, output_buffer.Receive());
-  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to get buffer from output sample",
-                                  PLATFORM_FAILURE, );
+  hr = MFCreateDXGISurfaceBuffer(__uuidof(ID3D11Texture2D), dest_texture, 0,
+                                 FALSE, output_buffer.Receive());
+  if (FAILED(hr)) {
+    RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to create output sample.",
+                                    PLATFORM_FAILURE, );
+  }
 
-  base::win::ScopedComPtr<IMFDXGIBuffer> dxgi_buffer;
-  hr = dxgi_buffer.QueryFrom(output_buffer.get());
-  RETURN_AND_NOTIFY_ON_HR_FAILURE(
-      hr, "Failed to get DXGIBuffer from output sample", PLATFORM_FAILURE, );
-  UINT index = 0;
-  hr = dxgi_buffer->GetSubresourceIndex(&index);
-  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to get resource index",
-                                  PLATFORM_FAILURE, );
+  output_sample->AddBuffer(output_buffer.get());
 
-  base::win::ScopedComPtr<ID3D11Texture2D> dx11_decoding_texture;
-  hr = dxgi_buffer->GetResource(IID_PPV_ARGS(dx11_decoding_texture.Receive()));
-  RETURN_AND_NOTIFY_ON_HR_FAILURE(
-      hr, "Failed to get resource from output sample", PLATFORM_FAILURE, );
+  hr = video_format_converter_mft_->ProcessInput(0, input_sample.get(), 0);
+  if (FAILED(hr)) {
+    DCHECK(false);
+    RETURN_AND_NOTIFY_ON_HR_FAILURE(
+        hr, "Failed to convert output sample format.", PLATFORM_FAILURE, );
+  }
 
-  D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC output_view_desc = {
-      D3D11_VPOV_DIMENSION_TEXTURE2D};
-  output_view_desc.Texture2D.MipSlice = 0;
-  base::win::ScopedComPtr<ID3D11VideoProcessorOutputView> output_view;
-  hr = video_device_->CreateVideoProcessorOutputView(
-      dest_texture, enumerator_.get(), &output_view_desc,
-      output_view.Receive());
-  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to get output view",
-                                  PLATFORM_FAILURE, );
+  input_sample.Release();
 
-  D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC input_view_desc = {0};
-  input_view_desc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
-  input_view_desc.Texture2D.ArraySlice = index;
-  input_view_desc.Texture2D.MipSlice = 0;
-  base::win::ScopedComPtr<ID3D11VideoProcessorInputView> input_view;
-  hr = video_device_->CreateVideoProcessorInputView(
-      dx11_decoding_texture.get(), enumerator_.get(), &input_view_desc,
-      input_view.Receive());
-  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to get input view",
-                                  PLATFORM_FAILURE, );
+  DWORD status = 0;
+  MFT_OUTPUT_DATA_BUFFER format_converter_output = {};
+  format_converter_output.pSample = output_sample.get();
+  hr = video_format_converter_mft_->ProcessOutput(
+      0,  // No flags
+      1,  // # of out streams to pull from
+      &format_converter_output, &status);
 
-  D3D11_VIDEO_PROCESSOR_STREAM streams = {0};
-  streams.Enable = TRUE;
-  streams.pInputSurface = input_view.get();
-
-  hr = video_context_->VideoProcessorBlt(d3d11_processor_.get(),
-                                         output_view.get(), 0, 1, &streams);
-
-  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "VideoProcessBlit failed",
-                                  PLATFORM_FAILURE, );
+  if (FAILED(hr)) {
+    DCHECK(false);
+    RETURN_AND_NOTIFY_ON_HR_FAILURE(
+        hr, "Failed to convert output sample format.", PLATFORM_FAILURE, );
+  }
 
   if (dest_keyed_mutex) {
     HRESULT hr = dest_keyed_mutex->ReleaseSync(keyed_mutex_value + 1);
     RETURN_AND_NOTIFY_ON_FAILURE(hr == S_OK, "Failed to release keyed mutex.",
                                  PLATFORM_FAILURE, );
 
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::CopySurfaceComplete, weak_ptr_,
                    nullptr, nullptr, picture_buffer_id, input_buffer_id));
@@ skipping 52 matching lines @@
         base::TimeDelta::FromMilliseconds(kFlushDecoderSurfaceTimeoutMs));
     return;
   }
 
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::CopySurfaceComplete,
                             weak_ptr_, src_surface, dest_surface,
                             picture_buffer_id, input_buffer_id));
 }
 
-bool DXVAVideoDecodeAccelerator::InitializeID3D11VideoProcessor(
+bool DXVAVideoDecodeAccelerator::InitializeDX11VideoFormatConverterMediaType(
     int width,
     int height,
     const gfx::ColorSpace& color_space) {
-  if (width < processor_width_ || height != processor_height_) {
-    d3d11_processor_.Release();
-    enumerator_.Release();
-    processor_width_ = 0;
-    processor_height_ = 0;
-
-    D3D11_VIDEO_PROCESSOR_CONTENT_DESC desc;
-    desc.InputFrameFormat = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
-    desc.InputFrameRate.Numerator = 60;
-    desc.InputFrameRate.Denominator = 1;
-    desc.InputWidth = width;
-    desc.InputHeight = height;
-    desc.OutputFrameRate.Numerator = 60;
-    desc.OutputFrameRate.Denominator = 1;
-    desc.OutputWidth = width;
-    desc.OutputHeight = height;
-    desc.Usage = D3D11_VIDEO_USAGE_PLAYBACK_NORMAL;
-
-    HRESULT hr = video_device_->CreateVideoProcessorEnumerator(
-        &desc, enumerator_.Receive());
-    RETURN_ON_HR_FAILURE(hr, "Failed to enumerate video processors", false);
-
-    // TODO(Hubbe): Find correct index
-    hr = video_device_->CreateVideoProcessor(enumerator_.get(), 0,
-                                             d3d11_processor_.Receive());
-    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 (!dx11_video_format_converter_media_type_needs_init_ &&
+      (!use_color_info_ || color_space == dx11_converter_color_space_)) {
+    return true;
   }
 
+  CHECK(video_format_converter_mft_.get());
+
+  HRESULT hr = video_format_converter_mft_->ProcessMessage(
+      MFT_MESSAGE_SET_D3D_MANAGER,
+      reinterpret_cast<ULONG_PTR>(d3d11_device_manager_.get()));
+
+  if (FAILED(hr))
+    DCHECK(false);
+
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+                                  "Failed to initialize video format converter",
+                                  PLATFORM_FAILURE, false);
+
+  video_format_converter_mft_->ProcessMessage(MFT_MESSAGE_NOTIFY_END_STREAMING,
+                                              0);
+
+  base::win::ScopedComPtr<IMFMediaType> media_type;
+  hr = MFCreateMediaType(media_type.Receive());
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "MFCreateMediaType failed",
+                                  PLATFORM_FAILURE, false);
+
+  hr = media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set major input type",
+                                  PLATFORM_FAILURE, false);
+
+  hr = media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_NV12);
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set input sub type",
+                                  PLATFORM_FAILURE, false);
+
+  hr = MFSetAttributeSize(media_type.get(), MF_MT_FRAME_SIZE, width, height);
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set media type attributes",
+                                  PLATFORM_FAILURE, false);
+
+  if (use_color_info_) {
+    DXVA2_ExtendedFormat format =
+        gfx::ColorSpaceWin::GetExtendedFormat(color_space);
+    media_type->SetUINT32(MF_MT_YUV_MATRIX, format.VideoTransferMatrix);
+    media_type->SetUINT32(MF_MT_VIDEO_NOMINAL_RANGE, format.NominalRange);
+    media_type->SetUINT32(MF_MT_VIDEO_PRIMARIES, format.VideoPrimaries);
+    media_type->SetUINT32(MF_MT_TRANSFER_FUNCTION,
+                          format.VideoTransferFunction);
+    dx11_converter_color_space_ = color_space;
+  }
+
+  hr = video_format_converter_mft_->SetInputType(0, media_type.get(), 0);
+  if (FAILED(hr))
+    DCHECK(false);
+
+  RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set converter input type",
+                                  PLATFORM_FAILURE, false);
+
+  // It appears that we fail to set MFVideoFormat_ARGB32 as the output media
+  // type in certain configurations. Try to fallback to MFVideoFormat_RGB32
+  // in such cases. If both fail, then bail.
+
+  bool media_type_set = false;
   if (copy_nv12_textures_) {
-    // 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;
+    media_type_set = SetTransformOutputType(video_format_converter_mft_.get(),
+                                            MFVideoFormat_NV12, width, height);
+    RETURN_AND_NOTIFY_ON_FAILURE(media_type_set,
+                                 "Failed to set NV12 converter output type",
+                                 PLATFORM_FAILURE, false);
+  }
 
-    video_context_->VideoProcessorSetOutputColorSpace(d3d11_processor_.get(),
-                                                      &d3d11_color_space);
+  if (!media_type_set) {
+    media_type_set = SetTransformOutputType(
+        video_format_converter_mft_.get(), MFVideoFormat_ARGB32, width, height);
+  }
+  if (!media_type_set) {
+    media_type_set = SetTransformOutputType(video_format_converter_mft_.get(),
+                                            MFVideoFormat_RGB32, width, height);
+  }
 
-    video_context_->VideoProcessorSetStreamColorSpace(d3d11_processor_.get(), 0,
-                                                      &d3d11_color_space);
-  } else {
-    // Not sure if this call is expensive, let's only do it if the color
-    // space changes.
-    gfx::ColorSpace output_color_space = gfx::ColorSpace::CreateSRGB();
-    if (use_color_info_ && dx11_converter_color_space_ != color_space) {
-      base::win::ScopedComPtr<ID3D11VideoContext1> video_context1;
-      HRESULT hr = video_context_.QueryInterface(video_context1.Receive());
-      if (SUCCEEDED(hr)) {
-        video_context1->VideoProcessorSetStreamColorSpace1(
-            d3d11_processor_.get(), 0,
-            gfx::ColorSpaceWin::GetDXGIColorSpace(color_space));
-        video_context1->VideoProcessorSetOutputColorSpace1(
-            d3d11_processor_.get(),
-            gfx::ColorSpaceWin::GetDXGIColorSpace(output_color_space));
-      } else {
-        D3D11_VIDEO_PROCESSOR_COLOR_SPACE d3d11_color_space =
-            gfx::ColorSpaceWin::GetD3D11ColorSpace(color_space);
-        video_context_->VideoProcessorSetStreamColorSpace(
-            d3d11_processor_.get(), 0, &d3d11_color_space);
-        d3d11_color_space =
-            gfx::ColorSpaceWin::GetD3D11ColorSpace(output_color_space);
-        video_context_->VideoProcessorSetOutputColorSpace(
-            d3d11_processor_.get(), &d3d11_color_space);
-      }
-      dx11_converter_color_space_ = color_space;
-    }
+  if (!media_type_set) {
+    LOG(ERROR) << "Failed to find a matching RGB output type in the converter";
+    return false;
   }
+
+  dx11_video_format_converter_media_type_needs_init_ = false;
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::GetVideoFrameDimensions(IMFSample* sample,
                                                          int* width,
                                                          int* height) {
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   HRESULT hr = sample->GetBufferByIndex(0, output_buffer.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from output sample", false);
 
@@ skipping 88 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