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
|
#include <mbgl/platform/default/headless_display.hpp>
#include <mbgl/platform/default/headless_view.hpp>
#include <mbgl/util/stopwatch.hpp>
#include <cassert>
#include <cstring>
namespace mbgl {
HeadlessView::HeadlessView(float pixelRatio_, uint16_t width, uint16_t height)
: display(std::make_shared<HeadlessDisplay>())
, pixelRatio(pixelRatio_)
, dimensions({{ width, height }})
, needsResize(true) {
}
HeadlessView::HeadlessView(std::shared_ptr<HeadlessDisplay> display_,
float pixelRatio_,
uint16_t width,
uint16_t height)
: display(std::move(display_))
, pixelRatio(pixelRatio_)
, dimensions({{ width, height }})
, needsResize(true) {
}
HeadlessView::~HeadlessView() {
activate();
clearBuffers();
deactivate();
destroyContext();
}
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() {
util::stopwatch stopwatch("readStillImage", EventSeverity::Info, Event::General);
assert(active);
const unsigned int w = dimensions[0] * pixelRatio;
const unsigned int h = dimensions[1] * pixelRatio;
PremultipliedImage image { w, h };
GLuint bufferId;
MBGL_CHECK_ERROR(glGenBuffers(1, &bufferId));
MBGL_CHECK_ERROR(glBindBuffer(GL_PIXEL_PACK_BUFFER, bufferId));
MBGL_CHECK_ERROR(glBufferData(GL_PIXEL_PACK_BUFFER, h * image.stride(), 0, GL_STREAM_READ));
{
util::stopwatch stopwatch2("glReadPixels", EventSeverity::Info, Event::General);
MBGL_CHECK_ERROR(glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, 0));
}
// map the PBO to process its data by CPU
GLubyte* ptr = (GLubyte*)glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY);
if (ptr) {
const int stride = image.stride();
auto tmp = std::make_unique<uint8_t[]>(stride);
uint8_t* rgba = image.data.get();
{
util::stopwatch stopwatch3("memcpy", EventSeverity::Info, Event::General);
for (unsigned int i = 0, j = h - 1; i < h; i++, j--) {
std::memcpy(rgba + i * stride, ptr + j * stride, stride);
}
}
MBGL_CHECK_ERROR(glUnmapBuffer(GL_PIXEL_PACK_BUFFER));
} else {
throw std::runtime_error(std::string("Could not map buffer on return from read pixels."));
}
MBGL_CHECK_ERROR(glDeleteBuffers(1, &bufferId));
// back to conventional pixel operation
MBGL_CHECK_ERROR(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0));
return image;
}
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() {
active = true;
if (!glContext) {
if (!display) {
throw std::runtime_error("Display is not set");
}
createContext();
}
activateContext();
if (!extensionsLoaded) {
gl::InitializeExtensions(initializeExtension);
extensionsLoaded = true;
}
if (needsResize) {
clearBuffers();
resizeFramebuffer();
needsResize = false;
}
}
void HeadlessView::deactivate() {
deactivateContext();
active = false;
}
void HeadlessView::invalidate() {
assert(false);
}
void HeadlessView::notifyMapChange(MapChange change) {
if (mapChangeCallback) {
mapChangeCallback(change);
}
}
} // namespace mbgl
|
