f26eeb9706
Currently, the OpenGLBackend and the QPainterBackend have hooks to indicate the start and the end of compositing cycle, but in both cases, the hooks have different names. This change fixes that inconsistency.
628 lines
19 KiB
C++
628 lines
19 KiB
C++
/*
|
|
KWin - the KDE window manager
|
|
This file is part of the KDE project.
|
|
|
|
SPDX-FileCopyrightText: 2015 Martin Gräßlin <mgraesslin@kde.org>
|
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
*/
|
|
#include "egl_gbm_backend.h"
|
|
// kwin
|
|
#include "composite.h"
|
|
#include "drm_backend.h"
|
|
#include "drm_output.h"
|
|
#include "gbm_surface.h"
|
|
#include "logging.h"
|
|
#include "options.h"
|
|
#include "screens.h"
|
|
#include "drm_gpu.h"
|
|
// kwin libs
|
|
#include <kwinglplatform.h>
|
|
#include <kwineglimagetexture.h>
|
|
// system
|
|
#include <gbm.h>
|
|
|
|
namespace KWin
|
|
{
|
|
|
|
EglGbmBackend::EglGbmBackend(DrmBackend *drmBackend, DrmGpu *gpu)
|
|
: AbstractEglBackend()
|
|
, m_backend(drmBackend)
|
|
, m_gpu(gpu)
|
|
{
|
|
// Egl is always direct rendering.
|
|
setIsDirectRendering(true);
|
|
setSyncsToVBlank(true);
|
|
connect(m_gpu, &DrmGpu::outputEnabled, this, &EglGbmBackend::createOutput);
|
|
connect(m_gpu, &DrmGpu::outputDisabled, this, &EglGbmBackend::removeOutput);
|
|
}
|
|
|
|
EglGbmBackend::~EglGbmBackend()
|
|
{
|
|
cleanup();
|
|
}
|
|
|
|
void EglGbmBackend::cleanupSurfaces()
|
|
{
|
|
for (auto it = m_outputs.begin(); it != m_outputs.end(); ++it) {
|
|
cleanupOutput(*it);
|
|
}
|
|
m_outputs.clear();
|
|
}
|
|
|
|
void EglGbmBackend::cleanupFramebuffer(Output &output)
|
|
{
|
|
if (!output.render.framebuffer) {
|
|
return;
|
|
}
|
|
glDeleteTextures(1, &output.render.texture);
|
|
output.render.texture = 0;
|
|
glDeleteFramebuffers(1, &output.render.framebuffer);
|
|
output.render.framebuffer = 0;
|
|
}
|
|
|
|
void EglGbmBackend::cleanupOutput(Output &output)
|
|
{
|
|
cleanupFramebuffer(output);
|
|
output.output->releaseGbm();
|
|
|
|
if (output.eglSurface != EGL_NO_SURFACE) {
|
|
eglDestroySurface(eglDisplay(), output.eglSurface);
|
|
}
|
|
}
|
|
|
|
bool EglGbmBackend::initializeEgl()
|
|
{
|
|
initClientExtensions();
|
|
EGLDisplay display = m_gpu->eglDisplay();
|
|
|
|
// Use eglGetPlatformDisplayEXT() to get the display pointer
|
|
// if the implementation supports it.
|
|
if (display == EGL_NO_DISPLAY) {
|
|
const bool hasMesaGBM = hasClientExtension(QByteArrayLiteral("EGL_MESA_platform_gbm"));
|
|
const bool hasKHRGBM = hasClientExtension(QByteArrayLiteral("EGL_KHR_platform_gbm"));
|
|
const GLenum platform = hasMesaGBM ? EGL_PLATFORM_GBM_MESA : EGL_PLATFORM_GBM_KHR;
|
|
|
|
if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base")) ||
|
|
(!hasMesaGBM && !hasKHRGBM)) {
|
|
setFailed("Missing one or more extensions between EGL_EXT_platform_base, "
|
|
"EGL_MESA_platform_gbm, EGL_KHR_platform_gbm");
|
|
return false;
|
|
}
|
|
|
|
auto device = gbm_create_device(m_gpu->fd());
|
|
if (!device) {
|
|
setFailed("Could not create gbm device");
|
|
return false;
|
|
}
|
|
m_gpu->setGbmDevice(device);
|
|
|
|
display = eglGetPlatformDisplayEXT(platform, device, nullptr);
|
|
m_gpu->setEglDisplay(display);
|
|
}
|
|
|
|
if (display == EGL_NO_DISPLAY) {
|
|
return false;
|
|
}
|
|
setEglDisplay(display);
|
|
return initEglAPI();
|
|
}
|
|
|
|
void EglGbmBackend::init()
|
|
{
|
|
if (!initializeEgl()) {
|
|
setFailed("Could not initialize egl");
|
|
return;
|
|
}
|
|
if (!initRenderingContext()) {
|
|
setFailed("Could not initialize rendering context");
|
|
return;
|
|
}
|
|
|
|
initKWinGL();
|
|
initBufferAge();
|
|
initWayland();
|
|
}
|
|
|
|
bool EglGbmBackend::initRenderingContext()
|
|
{
|
|
initBufferConfigs();
|
|
if (!createContext()) {
|
|
return false;
|
|
}
|
|
|
|
const auto outputs = m_backend->drmOutputs();
|
|
|
|
for (DrmOutput *drmOutput: outputs) {
|
|
createOutput(drmOutput);
|
|
}
|
|
|
|
if (m_outputs.isEmpty()) {
|
|
qCCritical(KWIN_DRM) << "Create Window Surfaces failed";
|
|
return false;
|
|
}
|
|
|
|
// Set our first surface as the one for the abstract backend, just to make it happy.
|
|
setSurface(m_outputs.first().eglSurface);
|
|
|
|
return makeContextCurrent(m_outputs.first());
|
|
}
|
|
|
|
std::shared_ptr<GbmSurface> EglGbmBackend::createGbmSurface(const QSize &size) const
|
|
{
|
|
auto gbmSurface = std::make_shared<GbmSurface>(m_gpu->gbmDevice(),
|
|
size.width(), size.height(),
|
|
GBM_FORMAT_XRGB8888,
|
|
GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
|
|
if (!gbmSurface) {
|
|
qCCritical(KWIN_DRM) << "Creating GBM surface failed";
|
|
return nullptr;
|
|
}
|
|
return gbmSurface;
|
|
}
|
|
|
|
EGLSurface EglGbmBackend::createEglSurface(std::shared_ptr<GbmSurface> gbmSurface) const
|
|
{
|
|
auto eglSurface = eglCreatePlatformWindowSurfaceEXT(eglDisplay(), config(),
|
|
(void *)(gbmSurface->surface()), nullptr);
|
|
if (eglSurface == EGL_NO_SURFACE) {
|
|
qCCritical(KWIN_DRM) << "Creating EGL surface failed";
|
|
return EGL_NO_SURFACE;
|
|
}
|
|
return eglSurface;
|
|
}
|
|
|
|
bool EglGbmBackend::resetOutput(Output &output, DrmOutput *drmOutput)
|
|
{
|
|
output.output = drmOutput;
|
|
const QSize size = drmOutput->hardwareTransforms() ? drmOutput->pixelSize() :
|
|
drmOutput->modeSize();
|
|
|
|
auto gbmSurface = createGbmSurface(size);
|
|
if (!gbmSurface) {
|
|
return false;
|
|
}
|
|
auto eglSurface = createEglSurface(gbmSurface);
|
|
if (eglSurface == EGL_NO_SURFACE) {
|
|
return false;
|
|
}
|
|
|
|
// destroy previous surface
|
|
if (output.eglSurface != EGL_NO_SURFACE) {
|
|
if (surface() == output.eglSurface) {
|
|
setSurface(eglSurface);
|
|
}
|
|
eglDestroySurface(eglDisplay(), output.eglSurface);
|
|
}
|
|
output.eglSurface = eglSurface;
|
|
output.gbmSurface = gbmSurface;
|
|
|
|
resetFramebuffer(output);
|
|
return true;
|
|
}
|
|
|
|
void EglGbmBackend::createOutput(DrmOutput *drmOutput)
|
|
{
|
|
Output newOutput;
|
|
if (resetOutput(newOutput, drmOutput)) {
|
|
connect(drmOutput, &DrmOutput::modeChanged, this,
|
|
[drmOutput, this] {
|
|
auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
|
|
[drmOutput] (const auto &output) {
|
|
return output.output == drmOutput;
|
|
}
|
|
);
|
|
if (it == m_outputs.end()) {
|
|
return;
|
|
}
|
|
resetOutput(*it, drmOutput);
|
|
}
|
|
);
|
|
m_outputs << newOutput;
|
|
}
|
|
}
|
|
|
|
void EglGbmBackend::removeOutput(DrmOutput *drmOutput)
|
|
{
|
|
auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
|
|
[drmOutput] (const Output &output) {
|
|
return output.output == drmOutput;
|
|
}
|
|
);
|
|
if (it == m_outputs.end()) {
|
|
return;
|
|
}
|
|
|
|
cleanupOutput(*it);
|
|
m_outputs.erase(it);
|
|
}
|
|
|
|
const float vertices[] = {
|
|
-1.0f, 1.0f,
|
|
-1.0f, -1.0f,
|
|
1.0f, -1.0f,
|
|
|
|
-1.0f, 1.0f,
|
|
1.0f, -1.0f,
|
|
1.0f, 1.0f,
|
|
};
|
|
|
|
const float texCoords[] = {
|
|
0.0f, 1.0f,
|
|
0.0f, 0.0f,
|
|
1.0f, 0.0f,
|
|
|
|
0.0f, 1.0f,
|
|
1.0f, 0.0f,
|
|
1.0f, 1.0f
|
|
};
|
|
|
|
bool EglGbmBackend::resetFramebuffer(Output &output)
|
|
{
|
|
cleanupFramebuffer(output);
|
|
|
|
if (output.output->hardwareTransforms()) {
|
|
// No need for an extra render target.
|
|
return true;
|
|
}
|
|
|
|
makeContextCurrent(output);
|
|
|
|
glGenFramebuffers(1, &output.render.framebuffer);
|
|
glBindFramebuffer(GL_FRAMEBUFFER, output.render.framebuffer);
|
|
GLRenderTarget::setKWinFramebuffer(output.render.framebuffer);
|
|
|
|
glGenTextures(1, &output.render.texture);
|
|
glBindTexture(GL_TEXTURE_2D, output.render.texture);
|
|
|
|
const QSize texSize = output.output->pixelSize();
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texSize.width(), texSize.height(),
|
|
0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
|
|
output.render.texture, 0);
|
|
|
|
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
|
|
qCWarning(KWIN_DRM) << "Error: framebuffer not complete";
|
|
return false;
|
|
}
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
GLRenderTarget::setKWinFramebuffer(0);
|
|
return true;
|
|
}
|
|
|
|
void EglGbmBackend::initRenderTarget(Output &output)
|
|
{
|
|
if (output.render.vbo) {
|
|
// Already initialized.
|
|
return;
|
|
}
|
|
std::shared_ptr<GLVertexBuffer> vbo(new GLVertexBuffer(KWin::GLVertexBuffer::Static));
|
|
vbo->setData(6, 2, vertices, texCoords);
|
|
output.render.vbo = vbo;
|
|
}
|
|
|
|
void EglGbmBackend::renderFramebufferToSurface(Output &output)
|
|
{
|
|
if (!output.render.framebuffer) {
|
|
// No additional render target.
|
|
return;
|
|
}
|
|
initRenderTarget(output);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
GLRenderTarget::setKWinFramebuffer(0);
|
|
|
|
const auto size = output.output->modeSize();
|
|
glViewport(0, 0, size.width(), size.height());
|
|
|
|
auto shader = ShaderManager::instance()->pushShader(ShaderTrait::MapTexture);
|
|
|
|
QMatrix4x4 mvpMatrix;
|
|
|
|
const DrmOutput *drmOutput = output.output;
|
|
switch (drmOutput->transform()) {
|
|
case DrmOutput::Transform::Normal:
|
|
case DrmOutput::Transform::Flipped:
|
|
break;
|
|
case DrmOutput::Transform::Rotated90:
|
|
case DrmOutput::Transform::Flipped90:
|
|
mvpMatrix.rotate(90, 0, 0, 1);
|
|
break;
|
|
case DrmOutput::Transform::Rotated180:
|
|
case DrmOutput::Transform::Flipped180:
|
|
mvpMatrix.rotate(180, 0, 0, 1);
|
|
break;
|
|
case DrmOutput::Transform::Rotated270:
|
|
case DrmOutput::Transform::Flipped270:
|
|
mvpMatrix.rotate(270, 0, 0, 1);
|
|
break;
|
|
}
|
|
switch (drmOutput->transform()) {
|
|
case DrmOutput::Transform::Flipped:
|
|
case DrmOutput::Transform::Flipped90:
|
|
case DrmOutput::Transform::Flipped180:
|
|
case DrmOutput::Transform::Flipped270:
|
|
mvpMatrix.scale(-1, 1);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
shader->setUniform(GLShader::ModelViewProjectionMatrix, mvpMatrix);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, output.render.texture);
|
|
output.render.vbo->render(GL_TRIANGLES);
|
|
ShaderManager::instance()->popShader();
|
|
}
|
|
|
|
void EglGbmBackend::prepareRenderFramebuffer(const Output &output) const
|
|
{
|
|
// When render.framebuffer is 0 we may just reset to the screen framebuffer.
|
|
glBindFramebuffer(GL_FRAMEBUFFER, output.render.framebuffer);
|
|
GLRenderTarget::setKWinFramebuffer(output.render.framebuffer);
|
|
}
|
|
|
|
bool EglGbmBackend::makeContextCurrent(const Output &output) const
|
|
{
|
|
const EGLSurface surface = output.eglSurface;
|
|
if (surface == EGL_NO_SURFACE) {
|
|
return false;
|
|
}
|
|
if (eglMakeCurrent(eglDisplay(), surface, surface, context()) == EGL_FALSE) {
|
|
qCCritical(KWIN_DRM) << "Make Context Current failed" << eglGetError();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool EglGbmBackend::initBufferConfigs()
|
|
{
|
|
const EGLint config_attribs[] = {
|
|
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
|
|
EGL_RED_SIZE, 1,
|
|
EGL_GREEN_SIZE, 1,
|
|
EGL_BLUE_SIZE, 1,
|
|
EGL_ALPHA_SIZE, 0,
|
|
EGL_RENDERABLE_TYPE, isOpenGLES() ? EGL_OPENGL_ES2_BIT : EGL_OPENGL_BIT,
|
|
EGL_CONFIG_CAVEAT, EGL_NONE,
|
|
EGL_NONE,
|
|
};
|
|
|
|
EGLint count;
|
|
EGLConfig configs[1024];
|
|
if (!eglChooseConfig(eglDisplay(), config_attribs, configs,
|
|
sizeof(configs) / sizeof(EGLConfig),
|
|
&count)) {
|
|
qCCritical(KWIN_DRM) << "choose config failed";
|
|
return false;
|
|
}
|
|
|
|
qCDebug(KWIN_DRM) << "EGL buffer configs count:" << count;
|
|
|
|
// Loop through all configs, choosing the first one that has suitable format.
|
|
for (EGLint i = 0; i < count; i++) {
|
|
EGLint gbmFormat;
|
|
// Query some configuration parameters, to show in debug log.
|
|
eglGetConfigAttrib(eglDisplay(), configs[i], EGL_NATIVE_VISUAL_ID, &gbmFormat);
|
|
|
|
if (KWIN_DRM().isDebugEnabled()) {
|
|
// GBM formats are declared as FOURCC code (integer from ASCII chars, so use this fact).
|
|
char gbmFormatStr[sizeof(EGLint) + 1] = {0};
|
|
memcpy(gbmFormatStr, &gbmFormat, sizeof(EGLint));
|
|
|
|
// Query number of bits for color channel.
|
|
EGLint blueSize, redSize, greenSize, alphaSize;
|
|
eglGetConfigAttrib(eglDisplay(), configs[i], EGL_RED_SIZE, &redSize);
|
|
eglGetConfigAttrib(eglDisplay(), configs[i], EGL_GREEN_SIZE, &greenSize);
|
|
eglGetConfigAttrib(eglDisplay(), configs[i], EGL_BLUE_SIZE, &blueSize);
|
|
eglGetConfigAttrib(eglDisplay(), configs[i], EGL_ALPHA_SIZE, &alphaSize);
|
|
qCDebug(KWIN_DRM) << " EGL config #" << i << " has GBM FOURCC format:" << gbmFormatStr
|
|
<< "; color sizes (RGBA order):"
|
|
<< redSize << greenSize << blueSize << alphaSize;
|
|
}
|
|
|
|
if ((gbmFormat == GBM_FORMAT_XRGB8888) || (gbmFormat == GBM_FORMAT_ARGB8888)) {
|
|
setConfig(configs[i]);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
qCCritical(KWIN_DRM) << "Choosing EGL config did not return a suitable config. There were"
|
|
<< count << "configs.";
|
|
return false;
|
|
}
|
|
|
|
void EglGbmBackend::present()
|
|
{
|
|
Q_UNREACHABLE();
|
|
// Not in use. This backend does per-screen rendering.
|
|
}
|
|
|
|
static QVector<EGLint> regionToRects(const QRegion ®ion, AbstractWaylandOutput *output)
|
|
{
|
|
const int height = output->modeSize().height();
|
|
|
|
const QMatrix4x4 matrix = DrmOutput::logicalToNativeMatrix(output->geometry(),
|
|
output->scale(),
|
|
output->transform());
|
|
|
|
QVector<EGLint> rects;
|
|
rects.reserve(region.rectCount() * 4);
|
|
for (const QRect &_rect : region) {
|
|
const QRect rect = matrix.mapRect(_rect);
|
|
|
|
rects << rect.left();
|
|
rects << height - (rect.y() + rect.height());
|
|
rects << rect.width();
|
|
rects << rect.height();
|
|
}
|
|
return rects;
|
|
}
|
|
|
|
void EglGbmBackend::aboutToStartPainting(int screenId, const QRegion &damagedRegion)
|
|
{
|
|
Q_ASSERT_X(screenId != -1, "aboutToStartPainting", "not using per screen rendering");
|
|
const Output &output = m_outputs.at(screenId);
|
|
if (output.bufferAge > 0 && !damagedRegion.isEmpty() && supportsPartialUpdate()) {
|
|
const QRegion region = damagedRegion & output.output->geometry();
|
|
|
|
QVector<EGLint> rects = regionToRects(region, output.output);
|
|
const bool correct = eglSetDamageRegionKHR(eglDisplay(), output.eglSurface,
|
|
rects.data(), rects.count()/4);
|
|
if (!correct) {
|
|
qCWarning(KWIN_DRM) << "failed eglSetDamageRegionKHR" << eglGetError();
|
|
}
|
|
}
|
|
}
|
|
|
|
void EglGbmBackend::presentOnOutput(Output &output, const QRegion &damagedRegion)
|
|
{
|
|
if (supportsSwapBuffersWithDamage()) {
|
|
QVector<EGLint> rects = regionToRects(output.damageHistory.constFirst(), output.output);
|
|
eglSwapBuffersWithDamageEXT(eglDisplay(), output.eglSurface,
|
|
rects.data(), rects.count()/4);
|
|
} else {
|
|
eglSwapBuffers(eglDisplay(), output.eglSurface);
|
|
}
|
|
output.buffer = new DrmSurfaceBuffer(m_gpu->fd(), output.gbmSurface);
|
|
|
|
Q_EMIT output.output->outputChange(damagedRegion);
|
|
m_backend->present(output.buffer, output.output);
|
|
|
|
if (supportsBufferAge()) {
|
|
eglQuerySurface(eglDisplay(), output.eglSurface, EGL_BUFFER_AGE_EXT, &output.bufferAge);
|
|
}
|
|
}
|
|
|
|
void EglGbmBackend::screenGeometryChanged(const QSize &size)
|
|
{
|
|
Q_UNUSED(size)
|
|
// TODO, create new buffer?
|
|
}
|
|
|
|
SceneOpenGLTexturePrivate *EglGbmBackend::createBackendTexture(SceneOpenGLTexture *texture)
|
|
{
|
|
return new EglGbmTexture(texture, this);
|
|
}
|
|
|
|
void EglGbmBackend::setViewport(const Output &output) const
|
|
{
|
|
const QSize &overall = screens()->size();
|
|
const QRect &v = output.output->geometry();
|
|
qreal scale = output.output->scale();
|
|
|
|
glViewport(-v.x() * scale, (v.height() - overall.height() + v.y()) * scale,
|
|
overall.width() * scale, overall.height() * scale);
|
|
}
|
|
|
|
QRegion EglGbmBackend::beginFrame(int screenId)
|
|
{
|
|
const Output &output = m_outputs.at(screenId);
|
|
|
|
makeContextCurrent(output);
|
|
prepareRenderFramebuffer(output);
|
|
setViewport(output);
|
|
|
|
if (supportsBufferAge()) {
|
|
QRegion region;
|
|
|
|
// Note: An age of zero means the buffer contents are undefined
|
|
if (output.bufferAge > 0 && output.bufferAge <= output.damageHistory.count()) {
|
|
for (int i = 0; i < output.bufferAge - 1; i++)
|
|
region |= output.damageHistory[i];
|
|
} else {
|
|
region = output.output->geometry();
|
|
}
|
|
|
|
return region;
|
|
}
|
|
return output.output->geometry();
|
|
}
|
|
|
|
void EglGbmBackend::endFrame(int screenId, const QRegion &renderedRegion,
|
|
const QRegion &damagedRegion)
|
|
{
|
|
Output &output = m_outputs[screenId];
|
|
renderFramebufferToSurface(output);
|
|
|
|
const QRegion dirty = damagedRegion.intersected(output.output->geometry());
|
|
if (dirty.isEmpty()) {
|
|
|
|
// If the damaged region of a window is fully occluded, the only
|
|
// rendering done, if any, will have been to repair a reused back
|
|
// buffer, making it identical to the front buffer.
|
|
//
|
|
// In this case we won't post the back buffer. Instead we'll just
|
|
// set the buffer age to 1, so the repaired regions won't be
|
|
// rendered again in the next frame.
|
|
if (!renderedRegion.intersected(output.output->geometry()).isEmpty())
|
|
glFlush();
|
|
|
|
output.bufferAge = 1;
|
|
return;
|
|
}
|
|
presentOnOutput(output, damagedRegion);
|
|
|
|
if (supportsBufferAge()) {
|
|
if (output.damageHistory.count() > 10) {
|
|
output.damageHistory.removeLast();
|
|
}
|
|
output.damageHistory.prepend(dirty);
|
|
}
|
|
}
|
|
|
|
bool EglGbmBackend::usesOverlayWindow() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool EglGbmBackend::perScreenRendering() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
QSharedPointer<GLTexture> EglGbmBackend::textureForOutput(AbstractOutput *abstractOutput) const
|
|
{
|
|
const QVector<KWin::EglGbmBackend::Output>::const_iterator itOutput = std::find_if(m_outputs.begin(), m_outputs.end(),
|
|
[abstractOutput] (const auto &output) {
|
|
return output.output == abstractOutput;
|
|
}
|
|
);
|
|
if (itOutput == m_outputs.end()) {
|
|
return {};
|
|
}
|
|
|
|
DrmOutput *drmOutput = itOutput->output;
|
|
if (!drmOutput->hardwareTransforms()) {
|
|
const auto glTexture = QSharedPointer<KWin::GLTexture>::create(itOutput->render.texture, GL_RGBA8, drmOutput->pixelSize());
|
|
glTexture->setYInverted(true);
|
|
return glTexture;
|
|
}
|
|
|
|
EGLImageKHR image = eglCreateImageKHR(eglDisplay(), nullptr, EGL_NATIVE_PIXMAP_KHR, itOutput->buffer->getBo(), nullptr);
|
|
if (image == EGL_NO_IMAGE_KHR) {
|
|
qCWarning(KWIN_DRM) << "Failed to record frame: Error creating EGLImageKHR - " << glGetError();
|
|
return {};
|
|
}
|
|
|
|
return QSharedPointer<EGLImageTexture>::create(eglDisplay(), image, GL_RGBA8, drmOutput->modeSize());
|
|
}
|
|
|
|
/************************************************
|
|
* EglTexture
|
|
************************************************/
|
|
|
|
EglGbmTexture::EglGbmTexture(KWin::SceneOpenGLTexture *texture, EglGbmBackend *backend)
|
|
: AbstractEglTexture(texture, backend)
|
|
{
|
|
}
|
|
|
|
EglGbmTexture::~EglGbmTexture() = default;
|
|
|
|
}
|