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
|
/*
* Copyright 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <renderengine/RenderEngine.h>
#include "renderengine/ExternalTexture.h"
#include "skia/GaneshVkRenderEngine.h"
#include "skia/GraphiteVkRenderEngine.h"
#include "skia/SkiaGLRenderEngine.h"
#include "threaded/RenderEngineThreaded.h"
#include <cutils/properties.h>
#include <log/log.h>
namespace android {
namespace renderengine {
std::unique_ptr<RenderEngine> RenderEngine::create(const RenderEngineCreationArgs& args) {
threaded::CreateInstanceFactory createInstanceFactory;
ALOGD("%sRenderEngine with %s Backend (%s)", args.threaded == Threaded::YES ? "Threaded " : "",
args.graphicsApi == GraphicsApi::GL ? "SkiaGL" : "SkiaVK",
args.skiaBackend == SkiaBackend::GANESH ? "Ganesh" : "Graphite");
if (args.skiaBackend == SkiaBackend::GRAPHITE) {
createInstanceFactory = [args]() {
return android::renderengine::skia::GraphiteVkRenderEngine::create(args);
};
} else { // GANESH
if (args.graphicsApi == GraphicsApi::VK) {
createInstanceFactory = [args]() {
return android::renderengine::skia::GaneshVkRenderEngine::create(args);
};
} else { // GL
createInstanceFactory = [args]() {
return android::renderengine::skia::SkiaGLRenderEngine::create(args);
};
}
}
if (args.threaded == Threaded::YES) {
return renderengine::threaded::RenderEngineThreaded::create(createInstanceFactory);
} else {
return createInstanceFactory();
}
}
RenderEngine::~RenderEngine() = default;
void RenderEngine::validateInputBufferUsage(const sp<GraphicBuffer>& buffer) {
LOG_ALWAYS_FATAL_IF(!(buffer->getUsage() & GraphicBuffer::USAGE_HW_TEXTURE),
"input buffer not gpu readable");
}
void RenderEngine::validateOutputBufferUsage(const sp<GraphicBuffer>& buffer) {
LOG_ALWAYS_FATAL_IF(!(buffer->getUsage() & GraphicBuffer::USAGE_HW_RENDER),
"output buffer not gpu writeable");
}
ftl::Future<FenceResult> RenderEngine::drawLayers(const DisplaySettings& display,
const std::vector<LayerSettings>& layers,
const std::shared_ptr<ExternalTexture>& buffer,
base::unique_fd&& bufferFence) {
const auto resultPromise = std::make_shared<std::promise<FenceResult>>();
std::future<FenceResult> resultFuture = resultPromise->get_future();
updateProtectedContext(layers, buffer);
drawLayersInternal(std::move(resultPromise), display, layers, buffer, std::move(bufferFence));
return resultFuture;
}
void RenderEngine::updateProtectedContext(const std::vector<LayerSettings>& layers,
const std::shared_ptr<ExternalTexture>& buffer) {
const bool needsProtectedContext =
(buffer && (buffer->getUsage() & GRALLOC_USAGE_PROTECTED)) ||
std::any_of(layers.begin(), layers.end(), [](const LayerSettings& layer) {
const std::shared_ptr<ExternalTexture>& buffer = layer.source.buffer.buffer;
return buffer && (buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
});
useProtectedContext(needsProtectedContext);
}
} // namespace renderengine
} // namespace android
|