Use Microsoft's HMFT for VP9 decoding.

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 54 matching lines @@
 
 const wchar_t kVP9DecoderDLLName[] =
 #if defined(ARCH_CPU_X86)
     L"mfx_mft_vp9vd_32.dll";
 #elif defined(ARCH_CPU_X86_64)
     L"mfx_mft_vp9vd_64.dll";
 #else
 #error Unsupported Windows CPU Architecture
 #endif
 
+const wchar_t kMSVP9DecoderDLLName[] = L"MSVP9DEC.dll";
+
 const CLSID CLSID_WebmMfVp8Dec = {
     0x451e3cb7,
     0x2622,
     0x4ba5,
     {0x8e, 0x1d, 0x44, 0xb3, 0xc4, 0x1d, 0x09, 0x24}};
 
 const CLSID CLSID_WebmMfVp9Dec = {
     0x07ab4bd2,
     0x1979,
     0x4fcd,
@@ skipping 601 matching lines @@
                                "GL fences are unsupported", PLATFORM_FAILURE,
                                false);
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state == kUninitialized),
                                "Initialize: invalid state: " << state,
                                ILLEGAL_STATE, false);
 
   InitializeMediaFoundation();
 
+  config_ = config;
+
   RETURN_AND_NOTIFY_ON_FAILURE(InitDecoder(config.profile),
                                "Failed to initialize decoder", PLATFORM_FAILURE,
                                false);
 
   RETURN_AND_NOTIFY_ON_FAILURE(GetStreamsInfoAndBufferReqs(),
                                "Failed to get input/output stream info.",
                                PLATFORM_FAILURE, false);
 
   RETURN_AND_NOTIFY_ON_FAILURE(
       SendMFTMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0),
       "Send MFT_MESSAGE_NOTIFY_BEGIN_STREAMING notification failed",
       PLATFORM_FAILURE, false);
 
   RETURN_AND_NOTIFY_ON_FAILURE(
       SendMFTMessage(MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0),
       "Send MFT_MESSAGE_NOTIFY_START_OF_STREAM notification failed",
       PLATFORM_FAILURE, false);
 
-  config_ = config;
-
   config_change_detector_.reset(new H264ConfigChangeDetector);
 
   SetState(kNormal);
 
   StartDecoderThread();
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::CreateD3DDevManager() {
   TRACE_EVENT0("gpu", "DXVAVideoDecodeAccelerator_CreateD3DDevManager");
@@ skipping 679 matching lines @@
     base::string16 file_version = version_info->file_version();
     RETURN_ON_FAILURE(file_version.find(L"6.1.7140") == base::string16::npos,
                       "blacklisted version of msmpeg2vdec.dll 6.1.7140", false);
     codec_ = kCodecH264;
     clsid = __uuidof(CMSH264DecoderMFT);
   } else if (enable_accelerated_vpx_decode_ &&
              (profile == VP8PROFILE_ANY || profile == VP9PROFILE_PROFILE0 ||
               profile == VP9PROFILE_PROFILE1 ||
               profile == VP9PROFILE_PROFILE2 ||
               profile == VP9PROFILE_PROFILE3)) {
-    int program_files_key = base::DIR_PROGRAM_FILES;
-    if (base::win::OSInfo::GetInstance()->wow64_status() ==
-        base::win::OSInfo::WOW64_ENABLED) {
-      program_files_key = base::DIR_PROGRAM_FILES6432;
+    if (profile != VP8PROFILE_ANY) {
+      codec_ = kCodecVP9;
+      clsid = CLSID_MSVPxDecoder;
+      decoder_dll = ::LoadLibrary(kMSVP9DecoderDLLName);
+      if (decoder_dll)
+        using_ms_vp9_mft_ = true;
     }
+    if (!decoder_dll) {
+      int program_files_key = base::DIR_PROGRAM_FILES;
+      if (base::win::OSInfo::GetInstance()->wow64_status() ==
+          base::win::OSInfo::WOW64_ENABLED) {
+        program_files_key = base::DIR_PROGRAM_FILES6432;
+      }
 
-    base::FilePath dll_path;
-    RETURN_ON_FAILURE(PathService::Get(program_files_key, &dll_path),
-                      "failed to get path for Program Files", false);
+      base::FilePath dll_path;
+      RETURN_ON_FAILURE(PathService::Get(program_files_key, &dll_path),
+                        "failed to get path for Program Files", false);
 
-    dll_path = dll_path.Append(kVPXDecoderDLLPath);
-    if (profile == VP8PROFILE_ANY) {
-      codec_ = kCodecVP8;
-      dll_path = dll_path.Append(kVP8DecoderDLLName);
-      clsid = CLSID_WebmMfVp8Dec;
-    } else {
-      codec_ = kCodecVP9;
-      dll_path = dll_path.Append(kVP9DecoderDLLName);
-      clsid = CLSID_WebmMfVp9Dec;
+      dll_path = dll_path.Append(kVPXDecoderDLLPath);
+      if (profile == VP8PROFILE_ANY) {
+        codec_ = kCodecVP8;
+        dll_path = dll_path.Append(kVP8DecoderDLLName);
+        clsid = CLSID_WebmMfVp8Dec;
+      } else {
+        codec_ = kCodecVP9;
+        dll_path = dll_path.Append(kVP9DecoderDLLName);
+        clsid = CLSID_WebmMfVp9Dec;
+      }
+      decoder_dll = ::LoadLibraryEx(dll_path.value().data(), NULL,
+                                    LOAD_WITH_ALTERED_SEARCH_PATH);
     }
-    decoder_dll = ::LoadLibraryEx(dll_path.value().data(), NULL,
-                                  LOAD_WITH_ALTERED_SEARCH_PATH);
     RETURN_ON_FAILURE(decoder_dll, "vpx decoder dll is not loaded", false);
   } else {
     RETURN_ON_FAILURE(false, "Unsupported codec.", false);
   }
 
   HRESULT hr = CreateCOMObjectFromDll(
       decoder_dll, clsid, __uuidof(IMFTransform), decoder_.ReceiveVoid());
   RETURN_ON_HR_FAILURE(hr, "Failed to create decoder instance", false);
 
   RETURN_ON_FAILURE(CheckDecoderDxvaSupport(),
@@ skipping 111 matching lines @@
   } else if (codec_ == kCodecVP8) {
     hr = media_type->SetGUID(MF_MT_SUBTYPE, MEDIASUBTYPE_VP80);
   } else if (codec_ == kCodecVP9) {
     hr = media_type->SetGUID(MF_MT_SUBTYPE, MEDIASUBTYPE_VP90);
   } else {
     NOTREACHED();
     RETURN_ON_FAILURE(false, "Unsupported codec on input media type.", false);
   }
   RETURN_ON_HR_FAILURE(hr, "Failed to set subtype", false);
 
-  // Not sure about this. msdn recommends setting this value on the input
-  // media type.
-  hr = media_type->SetUINT32(MF_MT_INTERLACE_MODE,
-                             MFVideoInterlace_MixedInterlaceOrProgressive);
-  RETURN_ON_HR_FAILURE(hr, "Failed to set interlace mode", false);
+  if (using_ms_vp9_mft_) {
+    hr = MFSetAttributeSize(media_type.get(), MF_MT_FRAME_SIZE,
+                            config_.initial_expected_coded_size.width(),
+                            config_.initial_expected_coded_size.height());
+    RETURN_ON_HR_FAILURE(hr, "Failed to set attribute size", false);
+
+    hr = media_type->SetUINT32(MF_MT_INTERLACE_MODE,
+                               MFVideoInterlace_Progressive);
+    RETURN_ON_HR_FAILURE(hr, "Failed to set interlace mode", false);
+  } else {
+    // Not sure about this. msdn recommends setting this value on the input
+    // media type.
+    hr = media_type->SetUINT32(MF_MT_INTERLACE_MODE,
+                               MFVideoInterlace_MixedInterlaceOrProgressive);
+    RETURN_ON_HR_FAILURE(hr, "Failed to set interlace mode", false);
+  }
 
   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);
 
@@ skipping 1149 matching lines @@
   SetState(kConfigChange);
   Invalidate();
   Initialize(config_, client_);
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 }  // namespace media