← Back to branch summary

~ubuntu-branches/ubuntu/wily/kwin/wily-proposed

« back to all changes in this revision

Viewing changes to abstract_egl_backend.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2015-08-10 23:16:37 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20150810231637-5zb2tstjkez93hml
Tags: 4:5.3.95-0ubuntu1
new upstream beta release

Show diffs side-by-side

added added

removed removed

Lines of Context:
abstract_egl_backend.cpp
68
68
    cleanupGL();
69
69
    doneCurrent();
70
70
    eglDestroyContext(m_display, m_context);
71
 
    eglDestroySurface(m_display, m_surface);
 
71
    cleanupSurfaces();
72
72
    eglTerminate(m_display);
73
73
    eglReleaseThread();
74
74
}
75
75
 
 
76
void AbstractEglBackend::cleanupSurfaces()
 
77
{
 
78
    if (m_surface != EGL_NO_SURFACE) {
 
79
        eglDestroySurface(m_display, m_surface);
 
80
    }
 
81
}
 
82
 
76
83
bool AbstractEglBackend::initEglAPI()
77
84
{
78
85
    EGLint major, minor;
137
144
        if (!eglBindWaylandDisplayWL(eglDisplay(), *(WaylandServer::self()->display()))) {
138
145
            eglUnbindWaylandDisplayWL = nullptr;
139
146
            eglQueryWaylandBufferWL = nullptr;
 
147
        } else {
 
148
            waylandServer()->display()->setEglDisplay(eglDisplay());
140
149
        }
141
150
    }
142
151
#endif
263
272
        return;
264
273
    }
265
274
    // shm fallback
266
 
    if (GLPlatform::instance()->isGLES()) {
267
 
        // FIXME
268
 
        return;
269
 
    }
270
275
    const QImage &image = buffer->data();
271
276
    if (image.isNull()) {
272
277
        return;
276
281
    const QRegion &damage = pixmap->toplevel()->damage();
277
282
 
278
283
    // TODO: this should be shared with GLTexture::update
279
 
    const QImage im = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
280
 
    for (const QRect &rect : damage.rects()) {
281
 
        glTexSubImage2D(m_target, 0, rect.x(), rect.y(), rect.width(), rect.height(),
282
 
                        GL_BGRA, GL_UNSIGNED_BYTE, im.copy(rect).bits());
 
284
    if (GLPlatform::instance()->isGLES()) {
 
285
        if (s_supportsARGB32 && (image.format() == QImage::Format_ARGB32 || image.format() == QImage::Format_ARGB32_Premultiplied)) {
 
286
            const QImage im = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
 
287
            for (const QRect &rect : damage.rects()) {
 
288
                glTexSubImage2D(m_target, 0, rect.x(), rect.y(), rect.width(), rect.height(),
 
289
                                GL_BGRA_EXT, GL_UNSIGNED_BYTE, im.copy(rect).bits());
 
290
            }
 
291
        } else {
 
292
            const QImage im = image.convertToFormat(QImage::Format_RGBA8888_Premultiplied);
 
293
            for (const QRect &rect : damage.rects()) {
 
294
                glTexSubImage2D(m_target, 0, rect.x(), rect.y(), rect.width(), rect.height(),
 
295
                                GL_RGBA, GL_UNSIGNED_BYTE, im.copy(rect).bits());
 
296
            }
 
297
        }
 
298
    } else {
 
299
        const QImage im = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
 
300
        for (const QRect &rect : damage.rects()) {
 
301
            glTexSubImage2D(m_target, 0, rect.x(), rect.y(), rect.width(), rect.height(),
 
302
                            GL_BGRA, GL_UNSIGNED_BYTE, im.copy(rect).bits());
 
303
        }
283
304
    }
284
305
    q->unbind();
285
306
#endif
288
309
#if HAVE_WAYLAND
289
310
bool AbstractEglTexture::loadShmTexture(const QPointer< KWayland::Server::BufferInterface > &buffer)
290
311
{
291
 
    if (GLPlatform::instance()->isGLES()) {
292
 
        // FIXME
293
 
        return false;
294
 
    }
295
312
    const QImage &image = buffer->data();
296
313
    if (image.isNull()) {
297
314
        return false;
316
333
    default:
317
334
        return false;
318
335
    }
319
 
    glTexImage2D(m_target, 0, format, size.width(), size.height(), 0,
320
 
                 GL_BGRA, GL_UNSIGNED_BYTE, image.bits());
 
336
    if (GLPlatform::instance()->isGLES()) {
 
337
        if (s_supportsARGB32 && format == GL_RGBA8) {
 
338
            const QImage im = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
 
339
            glTexImage2D(m_target, 0, GL_BGRA_EXT, im.width(), im.height(),
 
340
                         0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, im.bits());
 
341
        } else {
 
342
            const QImage im = image.convertToFormat(QImage::Format_RGBA8888_Premultiplied);
 
343
            glTexImage2D(m_target, 0, GL_RGBA, im.width(), im.height(),
 
344
                         0, GL_RGBA, GL_UNSIGNED_BYTE, im.bits());
 
345
        }
 
346
    } else {
 
347
        glTexImage2D(m_target, 0, format, size.width(), size.height(), 0,
 
348
                    GL_BGRA, GL_UNSIGNED_BYTE, image.bits());
 
349
    }
321
350
 
322
351
    q->unbind();
323
352
    q->setYInverted(true);
353
382
 
354
383
EGLImageKHR AbstractEglTexture::attach(const QPointer< KWayland::Server::BufferInterface > &buffer)
355
384
{
356
 
    EGLint format, width, height, yInverted;
 
385
    EGLint format, yInverted;
357
386
    eglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_TEXTURE_FORMAT, &format);
358
387
    if (format != EGL_TEXTURE_RGB && format != EGL_TEXTURE_RGBA) {
359
388
        qCDebug(KWIN_CORE) << "Unsupported texture format: " << format;
360
389
        return EGL_NO_IMAGE_KHR;
361
390
    }
362
 
    eglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_WAYLAND_Y_INVERTED_WL, &yInverted);
363
 
    eglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_WIDTH, &width);
364
 
    eglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_HEIGHT, &height);
 
391
    if (!eglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_WAYLAND_Y_INVERTED_WL, &yInverted)) {
 
392
        // if EGL_WAYLAND_Y_INVERTED_WL is not supported wl_buffer should be treated as if value were EGL_TRUE
 
393
        yInverted = EGL_TRUE;
 
394
    }
365
395
 
366
396
    const EGLint attribs[] = {
367
397
        EGL_WAYLAND_PLANE_WL, 0,
371
401
                                      (EGLClientBuffer)buffer->resource(), attribs);
372
402
    if (image != EGL_NO_IMAGE_KHR) {
373
403
        glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
374
 
        m_size = QSize(width, height);
 
404
        m_size = buffer->size();
375
405
        updateMatrix();
376
406
        q->setYInverted(yInverted);
377
407
    }