DeviceManagerDx.h - mozsearch

Enable keyboard shortcuts

/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_gfx_thebes_DeviceManagerDx_h

#define mozilla_gfx_thebes_DeviceManagerDx_h

#include <set>

#include <vector>

#include "gfxPlatform.h"

#include "gfxTelemetry.h"

#include "gfxTypes.h"

#include "mozilla/Maybe.h"

#include "mozilla/Mutex.h"

#include "mozilla/RefPtr.h"

#include "mozilla/StaticPtr.h"

#include "mozilla/gfx/GraphicsMessages.h"

#include "nsTArray.h"

#include "nsWindowsHelpers.h"

#include <windows.h>

#include <objbase.h>

#include <d3d11.h>

#include <dxgi.h>

#include <dxgi1_6.h>

// This header is available in the June 2010 SDK and in the Win8 SDK

#include <d3dcommon.h>

// Win 8.0 SDK types we'll need when building using older sdks.

#if !defined(D3D_FEATURE_LEVEL_11_1)  // defined in the 8.0 SDK only

#  define D3D_FEATURE_LEVEL_11_1 static_cast<D3D_FEATURE_LEVEL>(0xb100)

#  define D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION 2048

#  define D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION 4096

#endif

struct ID3D11Device;

struct IDCompositionDevice2;

struct IDirectDraw7;

namespace mozilla {

class ScopedGfxFeatureReporter;

namespace layers {

class DeviceAttachmentsD3D11;

}  // namespace layers

namespace gfx {

class FeatureState;

class DeviceManagerDx final {

 public:

  static void Init();

  static void Shutdown();

  DeviceManagerDx();

  ~DeviceManagerDx();

  static DeviceManagerDx* Get() { return sInstance; }

  enum class DeviceFlag {

    isHardwareWebRenderInUse,

    disableDeviceReuse,

};

  using DeviceFlagSet = EnumSet<DeviceFlag, uint8_t>;

  RefPtr<ID3D11Device> GetCompositorDevice();

  RefPtr<ID3D11Device> GetContentDevice();

  RefPtr<ID3D11Device> GetCanvasDevice();

  RefPtr<ID3D11Device> GetImageDevice();

  RefPtr<IDCompositionDevice2> GetDirectCompositionDevice();

  RefPtr<ID3D11Device> GetVRDevice();

  RefPtr<ID3D11Device> CreateDecoderDevice(DeviceFlagSet aFlags);

  RefPtr<ID3D11Device> CreateMediaEngineDevice();

  IDirectDraw7* GetDirectDraw();

  unsigned GetCompositorFeatureLevel() const;

  bool TextureSharingWorks();

  bool IsWARP();

  bool CanUseNV12();

  bool CanUseP010();

  bool CanUseP016();

  bool CanUseDComp();

  // Returns true if we can create a texture with

  // D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX and also

  // upload texture data during the CreateTexture2D

  // call. This crashes on some devices, so we might

  // need to avoid it.

  bool CanInitializeKeyedMutexTextures();

  // Enumerate and return all outputs on the current adapter.

  nsTArray<DXGI_OUTPUT_DESC1> EnumerateOutputs();

  // find the IDXGIOutput with a description.Monitor matching

  // 'monitor'; returns false if not found or some error occurred.

  bool GetOutputFromMonitor(HMONITOR monitor, RefPtr<IDXGIOutput>* aOutOutput);

  void PostUpdateMonitorInfo();

  void UpdateMonitorInfo();

  bool SystemHDREnabled();

  bool WindowHDREnabled(HWND aWindow);

  bool MonitorHDREnabled(HMONITOR aMonitor);

  // Check if the current adapter supports hardware stretching

  void CheckHardwareStretchingSupport(HwStretchingSupport& aRv);

  bool CreateCompositorDevices();

  void CreateContentDevices();

  void CreateDirectCompositionDevice();

  bool CreateCanvasDevice();

  static HANDLE CreateDCompSurfaceHandle();

  void GetCompositorDevices(

      RefPtr<ID3D11Device>* aOutDevice,

      RefPtr<layers::DeviceAttachmentsD3D11>* aOutAttachments);

  void ImportDeviceInfo(const D3D11DeviceStatus& aDeviceStatus);

  // Returns whether the device info was exported.

  bool ExportDeviceInfo(D3D11DeviceStatus* aOut);

  void ResetDevices();

  void InitializeDirectDraw();

  // Reset and reacquire the devices if a reset has happened.

  // Returns whether a reset occurred not whether reacquiring

  // was successful.

  bool MaybeResetAndReacquireDevices();

  // Device reset helpers.

  bool HasDeviceReset(DeviceResetReason* aOutReason = nullptr);

  // Note: these set the cached device reset reason, which will be picked up

  // on the next frame.

  void ForceDeviceReset(ForcedDeviceResetReason aReason);

 private:

  void ResetDevicesLocked() MOZ_REQUIRES(mDeviceLock);

  // Device reset helpers.

  bool HasDeviceResetLocked(DeviceResetReason* aOutReason = nullptr)

      MOZ_REQUIRES(mDeviceLock);

  // Pre-load any compositor resources that are expensive, and are needed when

  // we attempt to create a compositor.

  static void PreloadAttachmentsOnCompositorThread();

  already_AddRefed<IDXGIAdapter1> GetDXGIAdapter();

  IDXGIAdapter1* GetDXGIAdapterLocked() MOZ_REQUIRES(mDeviceLock);

  void DisableD3D11AfterCrash();

  bool CreateCompositorDevicesLocked() MOZ_REQUIRES(mDeviceLock);

  void CreateContentDevicesLocked() MOZ_REQUIRES(mDeviceLock);

  void CreateDirectCompositionDeviceLocked() MOZ_REQUIRES(mDeviceLock);

  bool CreateCanvasDeviceLocked() MOZ_REQUIRES(mDeviceLock);

  void CreateCompositorDevice(mozilla::gfx::FeatureState& d3d11)

      MOZ_REQUIRES(mDeviceLock);

  bool CreateCompositorDeviceHelper(mozilla::gfx::FeatureState& aD3d11,

                                    IDXGIAdapter1* aAdapter,

                                    bool aAttemptVideoSupport,

                                    RefPtr<ID3D11Device>& aOutDevice)

      MOZ_REQUIRES(mDeviceLock);

  void CreateWARPCompositorDevice() MOZ_REQUIRES(mDeviceLock);

  bool CreateVRDevice() MOZ_REQUIRES(mDeviceLock);

  mozilla::gfx::FeatureStatus CreateContentDevice() MOZ_REQUIRES(mDeviceLock);

  bool CreateDevice(IDXGIAdapter* aAdapter, D3D_DRIVER_TYPE aDriverType,

                    UINT aFlags, HRESULT& aResOut,

                    RefPtr<ID3D11Device>& aOutDevice) MOZ_REQUIRES(mDeviceLock);

  bool ContentAdapterIsParentAdapter(ID3D11Device* device)

      MOZ_REQUIRES(mDeviceLock);

  bool LoadD3D11();

  bool LoadDcomp();

  void ReleaseD3D11() MOZ_REQUIRES(mDeviceLock);

  // Call GetDeviceRemovedReason on each device until one returns

  // a failure.

  bool GetAnyDeviceRemovedReason(DeviceResetReason* aOutReason)

      MOZ_REQUIRES(mDeviceLock);

 private:

  static StaticAutoPtr<DeviceManagerDx> sInstance;

  // This is assigned during device creation. Afterwards, it is released if

  // devices failed, and "forgotten" if devices succeeded (meaning, we leak

  // the ref and unassign the module).

  nsModuleHandle mD3D11Module;

  nsModuleHandle mDcompModule;

  mutable mozilla::Mutex mDeviceLock;

  nsTArray<D3D_FEATURE_LEVEL> mFeatureLevels MOZ_GUARDED_BY(mDeviceLock);

  RefPtr<IDXGIAdapter1> mAdapter MOZ_GUARDED_BY(mDeviceLock);

  RefPtr<IDXGIFactory1> mFactory MOZ_GUARDED_BY(mDeviceLock);

  RefPtr<ID3D11Device> mCompositorDevice MOZ_GUARDED_BY(mDeviceLock);

  RefPtr<ID3D11Device> mContentDevice MOZ_GUARDED_BY(mDeviceLock);

  RefPtr<ID3D11Device> mCanvasDevice MOZ_GUARDED_BY(mDeviceLock);

  RefPtr<ID3D11Device> mImageDevice MOZ_GUARDED_BY(mDeviceLock);

  RefPtr<ID3D11Device> mVRDevice MOZ_GUARDED_BY(mDeviceLock);

  RefPtr<ID3D11Device> mDecoderDevice MOZ_GUARDED_BY(mDeviceLock);

  RefPtr<IDCompositionDevice2> mDirectCompositionDevice

      MOZ_GUARDED_BY(mDeviceLock);

  RefPtr<layers::DeviceAttachmentsD3D11> mCompositorAttachments

      MOZ_GUARDED_BY(mDeviceLock);

  bool mCompositorDeviceSupportsVideo MOZ_GUARDED_BY(mDeviceLock);

  Maybe<D3D11DeviceStatus> mDeviceStatus MOZ_GUARDED_BY(mDeviceLock);

  Maybe<DeviceResetReason> mDeviceResetReason MOZ_GUARDED_BY(mDeviceLock);

  RefPtr<Runnable> mUpdateMonitorInfoRunnable MOZ_GUARDED_BY(mDeviceLock);

  Maybe<bool> mSystemHdrEnabled MOZ_GUARDED_BY(mDeviceLock);

  std::set<HMONITOR> mHdrMonitors MOZ_GUARDED_BY(mDeviceLock);

  nsModuleHandle mDirectDrawDLL;

  RefPtr<IDirectDraw7> mDirectDraw;

};

}  // namespace gfx

}  // namespace mozilla

#endif  // mozilla_gfx_thebes_DeviceManagerDx_h