Möglichkeiten zur Reduzierung des Speicherübertragungsaufwands in OpenGL ES 2.0 / OpenGL 2.1 mit EGL 1.4 zum Rendern von ⇐ C++

[Anonymous]

Ich bin ziemlich früh in den Versuch, einige Bildmanipulationsaufgaben auf einem kopflosen eingebetteten Gerät zu erledigen, das Linux mit einer Mali 400 -GPU ausgeführt wird. Dies unterstützt OpenGL ES 2.0 durch einen offiziellen Treiber und möglicherweise einen meist vollständigen OpenGL 2.1 durch einen inoffiziellen Lima -Treiber.

Code: Select all

MONO8

/

Code: Select all

LUMINANCE

) Textur, führen Sie das Shader -Programm aus, das in eine andere Textur gerendert, und lesen Sie das dann für die Verwendung mit Glreadpixels aus. Ich kann einen vollständigeren Code veröffentlichen, wenn er jemandem helfen würde, aber im Moment zeige ich nur die relevanten Teile des Setups, um Unordnung zu vermeiden (alles hübsche Standard, denke ich): < /p>

Code: Select all

// Setup code:
display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(display, &major, &minor);
const EGLint configAttributes[] = {
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_NONE
};
eglChooseConfig(display, configAttributes, &config, 1, &numConfigs)
const EGLint pbufferAttributes[] = {
EGL_WIDTH, 1920,
EGL_HEIGHT, 1200,
EGL_NONE
};
surface = eglCreatePbufferSurface(display, config, pbufferAttributes);
const EGLint contextAttributes[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttributes);
eglMakeCurrent(display, surface, surface, context);

... Setup shaders, VBOs, etc ...

// Texture used to load image
glGenTextures(1, &textureID);
glBindTexture(GL_TEXTURE_2D, textureID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
unsigned char* data = (unsigned char*)malloc(1920 * 1200 * sizeof(unsigned char));
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 1920, 1200, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data); // Bind to dummy data at first, check if we can remove this
glBindBuffer(GL_ARRAY_BUFFER, VBOVertices);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);

// Texture used to render into
GLuint framebuffer;
glGenFramebuffers(1, &framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1920, 1200, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureID);
< /code>
// LATER: In main loop
auto start = std::chrono::steady_clock::now(); // Start timer for image loading
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 1920, 1200, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, image.img); // Load current image into texture from before
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureID);
glUniform1i(glGetUniformLocation(shaderProgram, "texture1"), 0);
auto text_loaded = std::chrono::steady_clock::now(); // Texture is loaded, end timer for image loading
glUseProgram(shaderProgram);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glFinish();
auto gl_finished = std::chrono::steady_clock::now(); // All rendering should be done when glFinish returns?
glReadPixels(0, 0, 1920, 1200, GL_RGBA, GL_UNSIGNED_BYTE, preprocessed_img_buf);
auto end = std::chrono::steady_clock::now(); // End timer for readout
// This is needed to get back into MONO8 format
for (int i = 0; i < 1920 * 1200; i++){
processed_img_buf[i] = preprocessed_img_buf[i * 4];
}
// Print frame times
auto text_loaded_time = std::chrono::duration_cast(text_loaded - start).count();
auto frame_render_time = std::chrono::duration_cast(gl_finished - text_loaded).count();
auto frame_readout_time = std::chrono::duration_cast(end - gl_finished).count();
< /code>
Versuch, mit dem obigen Code einen losen Benchmark zu erhalten.  Ich sehe Zeit, dass ich kaum glauben kann: < /p>
Image loading time: 7148 us
Render time: 85720 us
Readout time: 158734 us
Total frame time: 251602 us

Image loading time: 4797 us
Render time: 85841 us
Readout time: 152563 us
Total frame time: 243201 us

Image loading time: 6018 us
Render time: 85757 us
Readout time: 158420 us
Total frame time: 250195 us

Ich habe mich in diese erwarteten Glreadpixel verlangt, aber nicht doppelt so hoch wie 10 fps als 10 fps (vorausgesetzt, ich bin auf ziemlich vernünftige Weise Benchmarking). Dies lässt mich glauben, dass ich etwas anderes falsch mache, aber alles, was ich ausprobiert habe, scheint auf irgendeine Weise nicht unterstützt zu werden: /> [*] Versuchte mit GL_LUMINANCE Format auf Glreadpixel , nur um festzustellen, dass es mit dieser Funktion aus den Dokumenten nicht unterstützt wird, nur GL_RGB , gl_RGBA , GL_ALPHA sollen verwendet werden. redundante Daten und das Aufrufen von Glreadpixel mit GL_ALPHA , aber trotz der Dokumente wurde ich mit einem ungültigen OP -Fehler getroffen (vielleicht habe ich etwas früher falsch konfigurierte, damit dies geschah?) Für diese (meistens Format/Anwendungsfall/Mangel an Unterstützung)
Ich habe EGL -Bilder angesehen, bin aber schrecklich verwirrt von ihnen und möchte den Teil meines Codes nicht brechen, der zu funktionieren scheint, wie ich es erwarte, und aus dem, was ich sagen kann. Da kann ich dies optimaler machen, wenn ich beschrieben habe?
Wie würde diese Kombination aus Optionen/Setup aussehen? Ich bin in dieses Gefühl gekommen, dass es machbar war, und jetzt bezweifle ich, ob diese GPU ohne größere Zeitinvestition für mich nützlich sein kann. Ist das der Fall oder bin ich ein paar Umzüge von einer vernünftigen Frame -Zeit entfernt? Ist das möglich und würde es sogar helfen, oder überschätze ich die Kraft des Mali 400 und es sollte nie beabsichtigt, 1920x1200 zu fahren? tun. Ich habe die Fahrerentwicklung sehr wenig getan, und keiner bei GPU>