Add adatper check for initializing d3d11 device. Also add D3D11 flag for MfxSession creation

Author: taste1981

talk/owt/sdk/base/win/msdkvideobase.cc

@@ -29,6 +29,7 @@ static bool isValidPluginUID(const mfxPluginUID* uid) {
   return (AreGuidsEqual(uid, &MFX_PLUGINID_HEVCD_HW) ||
           AreGuidsEqual(uid, &MFX_PLUGINID_HEVCE_HW) ||
           AreGuidsEqual(uid, &MFX_PLUGINID_VP8D_HW) ||
+          AreGuidsEqual(uid, &MFX_PLUGINID_VP9D_HW) ||
           AreGuidsEqual(uid, &MFX_PLUGINID_HEVCE_GACC));
 }
 
@@ -68,9 +69,11 @@ MSDKFactory* MSDKFactory::Get() {
   return singleton;
 }
 
-MFXVideoSession* MSDKFactory::InternalCreateSession() {
+MFXVideoSession* MSDKFactory::InternalCreateSession(bool use_d3d11) {
   mfxStatus sts = MFX_ERR_NONE;
   mfxIMPL impl = MFX_IMPL_HARDWARE_ANY;
+  if (use_d3d11)
+    impl |= MFX_IMPL_VIA_D3D11;
   mfxVersion version = {{3, 1}};
 
   MFXVideoSession* session = new MFXVideoSession();
@@ -87,11 +90,11 @@ MFXVideoSession* MSDKFactory::InternalCreateSession() {
   return session;
 }
 
-MFXVideoSession* MSDKFactory::CreateSession() {
+MFXVideoSession* MSDKFactory::CreateSession(bool use_d3d11) {
   mfxStatus sts = MFX_ERR_NONE;
   MFXVideoSession* session = nullptr;
 
-  session = InternalCreateSession();
+  session = InternalCreateSession(use_d3d11);
 
   if (!session) {
     return nullptr;

talk/owt/sdk/base/win/msdkvideobase.h

@@ -31,7 +31,7 @@ class MSDKFactory {
 
   static MSDKFactory* Get();
 
-  MFXVideoSession* CreateSession();
+  MFXVideoSession* CreateSession(bool use_d3d11 = true);
 
   void DestroySession(MFXVideoSession* session);
 
@@ -99,7 +99,7 @@ class MSDKFactory {
  protected:
   MSDKFactory();
   bool Init();
-  MFXVideoSession* InternalCreateSession();
+  MFXVideoSession* InternalCreateSession(bool use_d3d11 = true);
 
  private:
   static MSDKFactory* singleton;

talk/owt/sdk/base/win/msdkvideodecoder.cc

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "msdkvideobase.h"
+#include "mfxadapter.h"
 #include "talk/owt/sdk/base/nativehandlebuffer.h"
 #include "talk/owt/sdk/base/win/d3d11_allocator.h"
 #include "talk/owt/sdk/base/win/d3dnativeframe.h"
@@ -67,15 +68,53 @@ void MSDKVideoDecoder::CheckOnCodecThread() {
 
 bool MSDKVideoDecoder::CreateD3D11Device() {
   HRESULT hr = S_OK;
-  UINT create_flag = D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
 
   static D3D_FEATURE_LEVEL feature_levels[] = {
       D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1,
       D3D_FEATURE_LEVEL_10_1};
   D3D_FEATURE_LEVEL feature_levels_out;
 
+  mfxU8 headers[] = {0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0xE0, 0x0A, 0x96,
+                     0x52, 0x85, 0x89, 0xC8, 0x00, 0x00, 0x00, 0x01, 0x68,
+                     0xC9, 0x23, 0xC8, 0x00, 0x00, 0x00, 0x01, 0x09, 0x10};
+  mfxBitstream bs = {};
+  bs.Data = headers;
+  bs.DataLength = bs.MaxLength = sizeof(headers);
+
+  mfxStatus sts = MFX_ERR_NONE;
+  mfxU32 num_adapters;
+  sts = MFXQueryAdaptersNumber(&num_adapters);
+
+  if (sts != MFX_ERR_NONE)
+    return false;
+
+  std::vector<mfxAdapterInfo> display_data(num_adapters);
+  mfxAdaptersInfo adapters = {display_data.data(), mfxU32(display_data.size()),
+                              0u};
+  sts = MFXQueryAdaptersDecode(&bs, MFX_CODEC_AVC, &adapters);
+  if (sts != MFX_ERR_NONE) {
+    RTC_LOG(LS_ERROR) << "Failed to query adapter with hardware acceleration";
+    return false;
+  }
+  mfxU32 adapter_idx = adapters.Adapters[0].Number;
+
+  hr = CreateDXGIFactory(__uuidof(IDXGIFactory2), (void**)(&m_pDXGIFactory));
+  if (FAILED(hr)) {
+    RTC_LOG(LS_ERROR)
+        << "Failed to create dxgi factory for adatper enumeration.";
+    return false;
+  }
+
+  hr = m_pDXGIFactory->EnumAdapters(adapter_idx, &m_pAdapter);
+  if (FAILED(hr)) {
+    RTC_LOG(LS_ERROR) << "Failed to enum adapter for specified adapter index.";
+    return false;
+  }
+
+  // On DG1 this setting driver type to hardware will result-in device
+  // creation failure.
   hr = D3D11CreateDevice(
-      nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, create_flag, feature_levels,
+      m_pAdapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr, 0, feature_levels,
       sizeof(feature_levels) / sizeof(feature_levels[0]), D3D11_SDK_VERSION,
       &d3d11_device, &feature_levels_out, &d3d11_device_context);
   if (FAILED(hr)) {
@@ -173,9 +212,9 @@ int32_t MSDKVideoDecoder::InitDecodeOnCodecThread() {
       codec_id = MFX_CODEC_AV1;
     }
 
-    if (!factory->LoadDecoderPlugin(codec_id, m_mfxSession, &m_pluginID)) {
-      return WEBRTC_VIDEO_CODEC_ERROR;
-    }
+    //if (!factory->LoadDecoderPlugin(codec_id, m_mfxSession, &m_pluginID)) {
+    //  return WEBRTC_VIDEO_CODEC_ERROR;
+    //}
 
     if (!CreateD3D11Device()) {
       return WEBRTC_VIDEO_CODEC_ERROR;
@@ -256,6 +295,8 @@ int32_t MSDKVideoDecoder::Decode(
         return WEBRTC_VIDEO_CODEC_ERROR;
       }
       nSurfNum = MSDK_MAX(request.NumFrameSuggested, 1);
+
+      request.Type |= MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
       sts = m_pMFXAllocator->Alloc(m_pMFXAllocator->pthis, &request,
                                    &m_mfxResponse);
       if (MFX_ERR_NONE != sts) {
@@ -275,6 +316,19 @@ int32_t MSDKVideoDecoder::Decode(
         MSDK_MEMCPY_VAR(m_pInputSurfaces[i].Info, &(request.Info),
                         sizeof(mfxFrameInfo));
         m_pInputSurfaces[i].Data.MemId = m_mfxResponse.mids[i];
+        m_pInputSurfaces[i].Data.MemType = request.Type;
+      }
+
+      if (!m_mfxVideoParams.mfx.FrameInfo.FrameRateExtN ||
+          m_mfxVideoParams.mfx.FrameInfo.FrameRateExtD) {
+        m_mfxVideoParams.mfx.FrameInfo.FrameRateExtN = 30;
+        m_mfxVideoParams.mfx.FrameInfo.FrameRateExtD = 1;
+      }
+
+      if (!m_mfxVideoParams.mfx.FrameInfo.AspectRatioH ||
+          !m_mfxVideoParams.mfx.FrameInfo.AspectRatioW) {
+        m_mfxVideoParams.mfx.FrameInfo.AspectRatioH = 1;
+        m_mfxVideoParams.mfx.FrameInfo.AspectRatioW = 1;
       }
       // Finally we're done with all configurations and we're OK to init the
       // decoder.
@@ -316,12 +370,15 @@ int32_t MSDKVideoDecoder::Decode(
     if (sts == MFX_ERR_NONE && syncp != nullptr) {
       sts = m_mfxSession->SyncOperation(syncp, MSDK_DEC_WAIT_INTERVAL);
       if (sts >= MFX_ERR_NONE) {
-        mfxHDLPair* dxMemId = (mfxHDLPair*)pOutputSurface->Data.MemId;
-
+        mfxMemId dxMemId = pOutputSurface->Data.MemId;
+        mfxHDLPair pair = {nullptr};
+        // Maybe we should also send the allocator as part of the frame
+        // handle for locking/unlocking purpose.
+        m_pMFXAllocator->GetFrameHDL(dxMemId, (mfxHDL*)&pair);
         if (callback_) {
           surface_handle->d3d11_device = d3d11_device.p;
           surface_handle->texture =
-              reinterpret_cast<ID3D11Texture2D*>(dxMemId->first);
+              reinterpret_cast<ID3D11Texture2D*>(pair.first);
           // Texture_array_index not used when decoding with MSDK.
           surface_handle->texture_array_index = 0;
           D3D11_TEXTURE2D_DESC texture_desc;

talk/owt/sdk/base/win/msdkvideodecoder.h

@@ -7,6 +7,7 @@
 #include <codecapi.h>
 #include <combaseapi.h>
 #include <d3d11.h>
+#include <dxgi1_2.h>
 #include <dxva2api.h>
 #include <memory>
 #include <utility>
@@ -93,6 +94,8 @@ class MSDKVideoDecoder : public webrtc::VideoDecoder {
     CComPtr<ID3D11DeviceContext> d3d11_device_context;
     CComPtr<ID3D11VideoDevice> d3d11_video_device;
     CComPtr<ID3D11VideoContext> d3d11_video_context;
+    CComQIPtr<IDXGIAdapter> m_pAdapter;
+    CComPtr<IDXGIFactory2> m_pDXGIFactory;
     // Store current decoded frame.
     std::unique_ptr<D3D11ImageHandle> surface_handle;
 

talk/owt/sdk/base/win/msdkvideodecoderfactory.cc

@@ -80,8 +80,10 @@ std::unique_ptr<webrtc::VideoDecoder> MSDKVideoDecoderFactory::CreateVideoDecode
     else if (codec == webrtc::kVideoCodecVP9)
       vp9_hw = true;
 #ifndef DISABLE_H265
-    else if (codec == webrtc::kVideoCodecH265)
+    else if (codec == webrtc::kVideoCodecH265) {
       h265_hw = true;
+      RTC_LOG(LS_ERROR) << "Enabling hardware hevc.";
+    }
 #endif
   }
   if (absl::EqualsIgnoreCase(format.name, cricket::kVp9CodecName) && !vp9_hw) {
@@ -98,7 +100,8 @@ std::unique_ptr<webrtc::VideoDecoder> MSDKVideoDecoderFactory::CreateVideoDecode
 #ifndef DISABLE_H265
   // This should not happen.
   else if (absl::EqualsIgnoreCase(format.name, cricket::kH265CodecName) && !h265_hw) {
-    return nullptr;
+    RTC_LOG(LS_ERROR) << "Returning null hevc encoder.";
+    //return nullptr;
   }
 #endif
 
@@ -108,7 +111,7 @@ std::unique_ptr<webrtc::VideoDecoder> MSDKVideoDecoderFactory::CreateVideoDecode
  std::vector<webrtc::SdpVideoFormat> MSDKVideoDecoderFactory::GetSupportedFormats()
     const {
   std::vector<webrtc::SdpVideoFormat> supported_codecs;
-  //supported_codecs.push_back(webrtc::SdpVideoFormat(cricket::kVp8CodecName));
+  supported_codecs.push_back(webrtc::SdpVideoFormat(cricket::kVp8CodecName));
   for (const webrtc::SdpVideoFormat& format : webrtc::SupportedVP9Codecs())
     supported_codecs.push_back(format);
   for (const webrtc::SdpVideoFormat& format : owt::base::CodecUtils::SupportedH264Codecs())