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
|
// Copyright 2018 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_AHARDWAREBUFFER_IMAGE_BACKING_FACTORY_H_
#define GPU_COMMAND_BUFFER_SERVICE_SHARED_IMAGE_AHARDWAREBUFFER_IMAGE_BACKING_FACTORY_H_
#include "base/containers/flat_map.h"
#include "gpu/command_buffer/common/shared_image_usage.h"
#include "gpu/command_buffer/service/gles2_cmd_validation.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/gpu_gles2_export.h"
#include "ui/gl/gl_bindings.h"
namespace gfx {
class Size;
class ColorSpace;
} // namespace gfx
namespace viz {
class VulkanContextProvider;
}
namespace gpu {
namespace gles2 {
class FeatureInfo;
} // namespace gles2
class SharedImageBacking;
struct Mailbox;
// Implementation of SharedImageBackingFactory that produces AHardwareBuffer
// backed SharedImages. This is meant to be used on Android only.
class GPU_GLES2_EXPORT AHardwareBufferImageBackingFactory
: public SharedImageBackingFactory {
public:
explicit AHardwareBufferImageBackingFactory(
const gles2::FeatureInfo* feature_info,
const GpuPreferences& gpu_preferences,
const scoped_refptr<viz::VulkanContextProvider>& vulkan_context_provider);
AHardwareBufferImageBackingFactory(
const AHardwareBufferImageBackingFactory&) = delete;
AHardwareBufferImageBackingFactory& operator=(
const AHardwareBufferImageBackingFactory&) = delete;
~AHardwareBufferImageBackingFactory() override;
// SharedImageBackingFactory implementation.
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;
bool IsFormatSupported(viz::SharedImageFormat format);
private:
struct FormatInfo {
FormatInfo();
~FormatInfo();
unsigned int ahb_format = 0;
// Whether this format can be used to create a GL texture from the AHB.
bool gl_supported = false;
// GL internal_format/format/type triplet.
GLuint internal_format = 0;
GLenum gl_format = 0;
GLenum gl_type = 0;
};
// Constructs and returns a FormatInfo corresponding to `format`, which must
// be a supported format.
static FormatInfo FormatInfoForSupportedFormat(
viz::SharedImageFormat format,
const gles2::Validators* validators,
const GLFormatCaps& gl_format_caps);
bool ValidateUsage(SharedImageUsageSet usage,
const gfx::Size& size,
viz::SharedImageFormat format) const;
bool CanImportGpuMemoryBuffer(gfx::GpuMemoryBufferType memory_buffer_type);
std::unique_ptr<SharedImageBacking> MakeBacking(
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);
const FormatInfo& GetFormatInfo(viz::SharedImageFormat format) const {
auto iter = format_infos_.find(format);
CHECK(iter != format_infos_.end());
return iter->second;
}
scoped_refptr<viz::VulkanContextProvider> vulkan_context_provider_;
base::flat_map<viz::SharedImageFormat, FormatInfo> format_infos_;
// Used to limit the max size of AHardwareBuffer.
int32_t max_gl_texture_size_ = 0;
const bool use_passthrough_;
const GLFormatCaps gl_format_caps_;
};
} // namespace gpu
#endif // GPU_COMMAND_BUFFER_SERVICE_SHARED_IMAGE_AHARDWAREBUFFER_IMAGE_BACKING_FACTORY_H_
|
