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
|
#include <mbgl/platform/default/headless_view.hpp>
#include <mbgl/platform/default/headless_display.hpp>
#include <cassert>
#include <cstring>
namespace mbgl {
HeadlessView::HeadlessView(float pixelRatio_, uint16_t width, uint16_t height)
: display(std::make_shared<HeadlessDisplay>()), pixelRatio(pixelRatio_) {
resize(width, height);
}
HeadlessView::HeadlessView(std::shared_ptr<HeadlessDisplay> display_,
float pixelRatio_,
uint16_t width,
uint16_t height)
: display(std::move(display_)), pixelRatio(pixelRatio_) {
resize(width, height);
}
HeadlessView::~HeadlessView() {
activate();
clearBuffers();
deactivate();
destroyContext();
}
void HeadlessView::loadExtensions() {
if (extensionsLoaded) {
return;
}
gl::InitializeExtensions(initializeExtension);
extensionsLoaded = true;
}
bool HeadlessView::isActive() const {
return std::this_thread::get_id() == thread;
}
void HeadlessView::resize(const uint16_t width, const uint16_t height) {
if(dimensions[0] == width &&
dimensions[1] == height) {
return;
}
dimensions = {{ width, height }};
needsResize = true;
}
PremultipliedImage HeadlessView::readStillImage() {
assert(isActive());
const unsigned int w = dimensions[0] * pixelRatio;
const unsigned int h = dimensions[1] * pixelRatio;
PremultipliedImage image { w, h };
MBGL_CHECK_ERROR(glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, image.data.get()));
const auto stride = image.stride();
auto tmp = std::make_unique<uint8_t[]>(stride);
uint8_t* rgba = image.data.get();
for (int i = 0, j = h - 1; i < j; i++, j--) {
std::memcpy(tmp.get(), rgba + i * stride, stride);
std::memcpy(rgba + i * stride, rgba + j * stride, stride);
std::memcpy(rgba + j * stride, tmp.get(), stride);
}
return image;
}
void HeadlessView::notify() {
// no-op
}
float HeadlessView::getPixelRatio() const {
return pixelRatio;
}
std::array<uint16_t, 2> HeadlessView::getSize() const {
return dimensions;
}
std::array<uint16_t, 2> HeadlessView::getFramebufferSize() const {
return {{ static_cast<uint16_t>(dimensions[0] * pixelRatio),
static_cast<uint16_t>(dimensions[1] * pixelRatio) }};
}
void HeadlessView::activate() {
if (thread != std::thread::id()) {
throw std::runtime_error("OpenGL context was already current");
}
thread = std::this_thread::get_id();
if (!glContext) {
if (!display) {
throw std::runtime_error("Display is not set");
}
createContext();
}
activateContext();
loadExtensions();
}
void HeadlessView::deactivate() {
if (thread == std::thread::id()) {
throw std::runtime_error("OpenGL context was not current");
}
thread = std::thread::id();
deactivateContext();
}
void HeadlessView::invalidate() {
// no-op
}
void HeadlessView::beforeRender() {
if (needsResize) {
clearBuffers();
resizeFramebuffer();
needsResize = false;
}
}
void HeadlessView::afterRender() {
// no-op
}
} // namespace mbgl
|
