1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef GPU_COMMAND_BUFFER_SERVICE_SHARED_IMAGE_D3D_IMAGE_BACKING_FACTORY_H_
#define GPU_COMMAND_BUFFER_SERVICE_SHARED_IMAGE_D3D_IMAGE_BACKING_FACTORY_H_
#include <windows.h>
#include <d3d11.h>
#include <d3d12.h>
#include <dxgi1_2.h>
#include <wrl/client.h>
#include <memory>
#include <optional>
#include "gpu/command_buffer/common/shared_image_usage.h"
#include "gpu/command_buffer/service/shared_image/shared_image_backing_factory.h"
#include "gpu/command_buffer/service/shared_image/shared_image_format_service_utils.h"
#include "gpu/config/gpu_driver_bug_workarounds.h"
#include "gpu/gpu_gles2_export.h"
#include "third_party/skia/include/core/SkColor.h"
namespace gfx {
class Size;
class ColorSpace;
} // namespace gfx
namespace gpu {
class DXGISharedHandleManager;
class SharedImageBacking;
struct Mailbox;
class GPU_GLES2_EXPORT D3DImageBackingFactory
: public SharedImageBackingFactory {
public:
D3DImageBackingFactory(
Microsoft::WRL::ComPtr<ID3D11Device> d3d11_device,
scoped_refptr<DXGISharedHandleManager> dxgi_shared_handle_manager,
const GLFormatCaps& gl_format_caps,
const GpuDriverBugWorkarounds& workarounds = GpuDriverBugWorkarounds());
D3DImageBackingFactory(const D3DImageBackingFactory&) = delete;
D3DImageBackingFactory& operator=(const D3DImageBackingFactory&) = delete;
~D3DImageBackingFactory() override;
// Returns true if D3D shared images are supported and this factory should be
// used. Generally this means Skia-GL, passthrough decoder, and ANGLE-D3D11.
static bool IsD3DSharedImageSupported(ID3D11Device* d3d11_device,
const GpuPreferences& gpu_preferences);
// Returns true if DXGI swap chain shared images for overlays are supported.
static bool IsSwapChainSupported(const GpuPreferences& gpu_preferences);
// Clears the current back buffer to |color| on the immediate context.
static bool ClearBackBufferToColor(IDXGISwapChain1* swap_chain,
const SkColor4f& color);
struct GPU_GLES2_EXPORT SwapChainBackings {
SwapChainBackings(std::unique_ptr<SharedImageBacking> front_buffer,
std::unique_ptr<SharedImageBacking> back_buffer);
SwapChainBackings(const SwapChainBackings&) = delete;
SwapChainBackings& operator=(const SwapChainBackings&) = delete;
~SwapChainBackings();
SwapChainBackings(SwapChainBackings&&);
SwapChainBackings& operator=(SwapChainBackings&&);
std::unique_ptr<SharedImageBacking> front_buffer;
std::unique_ptr<SharedImageBacking> back_buffer;
};
// Creates IDXGI Swap Chain and exposes front and back buffers as Shared Image
// mailboxes.
SwapChainBackings CreateSwapChain(const Mailbox& front_buffer_mailbox,
const Mailbox& back_buffer_mailbox,
viz::SharedImageFormat format,
const gfx::Size& size,
const gfx::ColorSpace& color_space,
GrSurfaceOrigin surface_origin,
SkAlphaType alpha_type,
gpu::SharedImageUsageSet usage);
std::unique_ptr<SharedImageBacking> CreateSharedImage(
const Mailbox& mailbox,
viz::SharedImageFormat format,
SurfaceHandle surface_handle,
const gfx::Size& size,
const gfx::ColorSpace& color_space,
GrSurfaceOrigin surface_origin,
SkAlphaType alpha_type,
SharedImageUsageSet usage,
std::string debug_label,
bool is_thread_safe) override;
std::unique_ptr<SharedImageBacking> CreateSharedImage(
const Mailbox& mailbox,
viz::SharedImageFormat format,
const gfx::Size& size,
const gfx::ColorSpace& color_space,
GrSurfaceOrigin surface_origin,
SkAlphaType alpha_type,
SharedImageUsageSet usage,
std::string debug_label,
bool is_thread_safe,
base::span<const uint8_t> pixel_data) override;
std::unique_ptr<SharedImageBacking> CreateSharedImage(
const Mailbox& mailbox,
viz::SharedImageFormat format,
const gfx::Size& size,
const gfx::ColorSpace& color_space,
GrSurfaceOrigin surface_origin,
SkAlphaType alpha_type,
SharedImageUsageSet usage,
std::string debug_label,
bool is_thread_safe,
gfx::GpuMemoryBufferHandle handle) override;
bool IsSupported(SharedImageUsageSet usage,
viz::SharedImageFormat format,
const gfx::Size& size,
bool thread_safe,
gfx::GpuMemoryBufferType gmb_type,
GrContextType gr_context_type,
base::span<const uint8_t> pixel_data) override;
SharedImageBackingType GetBackingType() override;
Microsoft::WRL::ComPtr<ID3D11Device> GetDeviceForTesting() const {
return d3d11_device_;
}
private:
std::unique_ptr<SharedImageBacking> CreateSharedBufferD3D12(
const Mailbox& mailbox,
const gfx::Size& size,
const gfx::ColorSpace& color_space,
GrSurfaceOrigin surface_origin,
SkAlphaType alpha_type,
SharedImageUsageSet usage,
std::string debug_label);
bool SupportsBGRA8UnormStorage();
// D3D11 device used for creating textures. This is also Skia's D3D11 device.
// Can be different from |angle_d3d11_device_| when using Graphite.
Microsoft::WRL::ComPtr<ID3D11Device> d3d11_device_;
// A D3D12 device is currently used for creation of buffer resources to be
// used with WebNN and WebGPU.
Microsoft::WRL::ComPtr<ID3D12Device> d3d12_device_;
std::optional<bool> supports_bgra8unorm_storage_;
scoped_refptr<DXGISharedHandleManager> dxgi_shared_handle_manager_;
// D3D11 device used by ANGLE. Can be different from |d3d11_device_| when
// using Graphite.
Microsoft::WRL::ComPtr<ID3D11Device> angle_d3d11_device_;
// Stores the maximum size dimension supported by an nv12 texture.
int max_nv12_dim_supported_ = 0;
// Stores whether NV12 format is supported by the D3D device.
bool d3d11_supports_nv12_;
// Capabilities needed for getting the correct GL format for creating GL
// textures.
const GLFormatCaps gl_format_caps_;
// True if using UpdateSubresource1() in UploadFromMemory() is allowed.
const bool use_update_subresource1_;
};
} // namespace gpu
#endif // GPU_COMMAND_BUFFER_SERVICE_SHARED_IMAGE_D3D_IMAGE_BACKING_FACTORY_H_
|
